Get the subclasses of this class, sorted in order of name. Call {@link ClassInfoList#directOnly()} to get
direct subclasses.

@return the list of subclasses of this class, or the empty list if none.
174433
public ClassInfoList getSubclasses() {
        if (getName().equals("java.lang.Object")) {
            // Make an exception for querying all subclasses of java.lang.Object
            return scanResult.getAllClasses();
        } else {
            return new ClassInfoList(
                    this.filterClassInfo(RelType.SUBCLASSES, /* strictWhitelist = */ !isExternalClass),
                    /* sortByName = */ true);
        }
    }
405942
public String[] getSuperclasses() {
    List<String>	result;

    result = new ArrayList<>(m_CacheNames.keySet());
    Collections.sort(result);

    return result.toArray(new String[result.size()]);
  }
455082
def get_recursive_subclasses(cls):
    """"""
    return cls.__subclasses__() + [g for s in cls.__subclasses__() for g in get_recursive_subclasses(s)]
127121
public ClassInfoList getClassInfoRecursive() {
        final Set<ClassInfo> reachableClassInfo = new HashSet<>();
        obtainClassInfoRecursive(reachableClassInfo);
        return new ClassInfoList(reachableClassInfo, /* sortByName = */ true);
    }
1090679
public boolean hasSubtypes(ClassDescriptor classDescriptor) throws ClassNotFoundException {
        Set<ClassDescriptor> subtypes = getDirectSubtypes(classDescriptor);
        if (DEBUG) {
            System.out.println("Direct subtypes of " + classDescriptor + " are " + subtypes);
        }
        return !subtypes.isEmpty();
    }
819644
public List<Class<?>> directSuperclasses(Class<?> c)
    {
        if(c.isPrimitive()) {
            return primitiveSuperclasses(c);
        }
        else if(c.isArray()) {
            return arrayDirectSuperclasses(0, c);
        }
        else {
            Class<?> [] interfaces = c.getInterfaces();
            Class<?> superclass = c.getSuperclass();

            List<Class<?>> classes = new LinkedList<Class<?>>();
            classes.addAll(Arrays.asList(interfaces));
            if(superclass == null) {
                if(interfaces.length == 0 &&
                   c != Object.class)
                    classes.add(Object.class);
            }
            else {
                classes.add(superclass);
            }

            return classes;
        }
    }
925548
public ClassInfoList getStandardClasses() {
        return filter(new ClassInfoFilter() {
            @Override
            public boolean accept(final ClassInfo ci) {
                return ci.isStandardClass();
            }
        });
    }
1154466
protected List<Class<?>> getExtensionClasses() {
		return Lists.<Class<?>> newArrayList(
			ArrayExtensions.class,
			BigDecimalExtensions.class,
			BigIntegerExtensions.class,
			BooleanExtensions.class,
			ByteExtensions.class,
			CharacterExtensions.class,
			CollectionExtensions.class,
			ComparableExtensions.class,
			DoubleExtensions.class,
			FloatExtensions.class,
			FunctionExtensions.class,
			IntegerExtensions.class,
			IterableExtensions.class,
			IteratorExtensions.class,
			ListExtensions.class,
			LongExtensions.class,
			MapExtensions.class,
			ObjectExtensions.class,
			ProcedureExtensions.class,
			ShortExtensions.class,
			StringExtensions.class);
	}
500434
public static List<Method> getAllDeclaredMethods(Class<?> clazz) {
		List<Method> result = new ArrayList<>();
		while (clazz != null) {
			Method[] methods = clazz.getDeclaredMethods();
			Collections.addAll(result, methods);
			clazz = clazz.getSuperclass();
		}
		return result;
	}
559916
public Set<ClassModel> getAllClassDependencies() {
		HashSet<ClassModel> result = new HashSet<>();
		ClassModel.getAllClassDependencies(result, this);
		return result;
	}
441612
public java.util.List<ActiveInstance> getActiveInstances() {
        if (activeInstances == null) {
            activeInstances = new com.amazonaws.internal.SdkInternalList<ActiveInstance>();
        }
        return activeInstances;
    }
1031460
public ClassInfoList getAllClasses() {
        if (closed.get()) {
            throw new IllegalArgumentException("Cannot use a ScanResult after it has been closed");
        }
        if (!scanSpec.enableClassInfo) {
            throw new IllegalArgumentException("Please call ClassGraph#enableClassInfo() before #scan()");
        }
        return ClassInfo.getAllClasses(classNameToClassInfo.values(), scanSpec);
    }
1260766
public JClass []getParameterTypes()
  {
    Class []types = _method.getParameterTypes();

    JClass []jTypes = new JClass[types.length];

    for (int i = 0; i < types.length; i++) {
      jTypes[i] = _loader.forName(types[i].getName());
    }

    return jTypes;
  }
1240767
public String[] getSuperclasses(String cls) {
    List<String>	result;

    result = new ArrayList<>();

    for (String superclass: m_CacheNames.keySet()) {
      if (m_CacheNames.get(superclass).contains(cls))
        result.add(superclass);
    }

    if (result.size() > 1)
      Collections.sort(result);

    return result.toArray(new String[result.size()]);
  }
453461
public Set<ClassDescriptor> getSubtypes(ClassDescriptor classDescriptor) throws ClassNotFoundException {
        Set<ClassDescriptor> result = subtypeSetMap.get(classDescriptor);
        if (result == null) {
            result = computeKnownSubtypes(classDescriptor);
            subtypeSetMap.put(classDescriptor, result);
        }
        return result;
    }
800618
public Iterator getAllExtentClasses()
    {
        ArrayList subTypes = new ArrayList();

        subTypes.addAll(_extents);

        for (int idx = 0; idx < subTypes.size(); idx++)
        {
            ClassDescriptorDef curClassDef = (ClassDescriptorDef)subTypes.get(idx);

            for (Iterator it = curClassDef.getExtentClasses(); it.hasNext();)
            {
                ClassDescriptorDef curSubTypeDef = (ClassDescriptorDef)it.next();

                if (!subTypes.contains(curSubTypeDef))
                {
                    subTypes.add(curSubTypeDef);
                }
            }
        }
        return subTypes.iterator();
    }
623979
private List<ClassInfo> getOverrideOrder() {
        if (overrideOrder == null) {
            overrideOrder = getOverrideOrder(new HashSet<ClassInfo>(), new ArrayList<ClassInfo>());
        }
        return overrideOrder;
    }