Answer a list of types of this CompoundObjectType.
@param noAbstractTypes if true, no abstract types and no interfaces are answered,
else all types of the CompoundObjectType are answered.
@return a list of java Classes
432762
public List<Class<?>> getTypes(boolean noAbstractTypes) {
		List<Class<?>> typeList = new ArrayList<Class<?>>();
		this.addType(typeList, noAbstractTypes);
		return typeList;
	}
1264086
private static Class<?>[] getTypes(Object[] arguments) {
        Class<?>[] classes = new Class<?>[arguments.length];
        for (int i = 0; i < arguments.length; i++) {
            classes[i] = getType(arguments[i]);
        }
        return classes;
    }
970937
public Iterator getAllBaseTypes()
    {
        ArrayList baseTypes = new ArrayList();

        baseTypes.addAll(_directBaseTypes.values());

        for (int idx = baseTypes.size() - 1; idx >= 0; idx--)
        {
            ClassDescriptorDef curClassDef = (ClassDescriptorDef)baseTypes.get(idx);

            for (Iterator it = curClassDef.getDirectBaseTypes(); it.hasNext();)
            {
                ClassDescriptorDef curBaseTypeDef = (ClassDescriptorDef)it.next();

                if (!baseTypes.contains(curBaseTypeDef))
                {
                    baseTypes.add(0, curBaseTypeDef);
                    idx++;
                }
            }
        }
        return baseTypes.iterator();
    }
214167
public List<Type> constructorGenericTypes() {
        return constructorGenerics.isEmpty()
                ? Collections.<Type>emptyList() : new ArrayList<Type>(constructorGenerics.values());
    }
128938
public Set<ClassDescriptor> getDirectSubtypes(ClassDescriptor classDescriptor) throws ClassNotFoundException {

        ClassVertex startVertex = resolveClassVertex(classDescriptor);

        Set<ClassDescriptor> result = new HashSet<>();
        Iterator<InheritanceEdge> i = graph.incomingEdgeIterator(startVertex);
        while (i.hasNext()) {
            InheritanceEdge edge = i.next();
            result.add(edge.getSource().getClassDescriptor());
        }

        return result;
    }
866060
public List<Attribute.TypeCompound> getRawTypeAttributes() {
        return (metadata == null)
                ? List.<Attribute.TypeCompound>nil()
                : metadata.getTypeAttributes();
    }
974978
public List<TypedDependency> typedDependencies(boolean includeExtras) {
    List<TypedDependency> deps = includeExtras ? allTypedDependencies
                                                       : typedDependencies;
    correctDependencies(deps);
    return deps;
  }
768878
@SuppressWarnings("unchecked")
	 Class<?>[] getAllInterfacesAndClasses ( Class<?>[] classes ) 
    {
        if(0 == classes.length ) 
        {
            return classes;
        }
        else 
        {
            List<Class<?>> extendedClasses = new ArrayList<Class<?>>();
            // all interfaces hierarchy
            for (Class<?> clazz: classes) {
            	if (clazz != null) 
            	{
            		Class<?>[] interfaces = clazz.getInterfaces();
	                if (interfaces != null)
	                {
	                	extendedClasses.addAll(Arrays.asList(interfaces));
	                }
	                Class<?> superclass = clazz.getSuperclass();
	                if (superclass != null && superclass != Object.class)
	                {
	                	extendedClasses.addAll(Arrays.asList(superclass));
	                }
            	}
            }
            
            //Class::getInterfaces() gets only interfaces/classes implemented/extended directly by a given class.
            //We need to walk the whole way up the tree.
            return (Class[]) ArrayUtils.addAll( classes, getAllInterfacesAndClasses( extendedClasses.toArray(new Class[extendedClasses.size()])));
        }
    }
1209593
public static Class[] getImplementorClasses( Class interfaceType )
    {
        String interfaceName = interfaceType.getName();
        ArrayList/*< Class >*/ classes = new ArrayList/*< Class >*/();
        ClassLoader classLoader = getClassLoader();
        
        try
        {
            Enumeration e = classLoader.getResources( "META-INF/services/" + interfaceName );
            
            while ( e.hasMoreElements() )
            {
                URL url = ( URL ) e.nextElement();
                
                if ( _log.isTraceEnabled() )
                {
                    _log.trace( "Found implementor entry for interface " + interfaceName + " at " + url );
                }
                
                InputStream is = null;
                String className = null;
                
                try
                {
                    is = url.openStream();
                    BufferedReader reader = new BufferedReader( new InputStreamReader( is ) );
                    className = reader.readLine().trim();
                    Class implementorClass = loadImplementorClass( className, interfaceType, classLoader );
                    if ( implementorClass != null ) classes.add( implementorClass );
                }
                catch ( IOException ioe )
                {
                    _log.error( "Could not read implementor class entry at + " + url );
                }
                finally
                {
                    if ( is != null ) is.close();
                }
            }
        }
        catch ( IOException e )
        {
            _log.error( "Could not discover implementors for " + interfaceName, e );
        }
        
        return ( Class[] ) classes.toArray( new Class[0] );
    }
972761
public static Set<String> getJavaDefaultTypes() {
		if (javaDefaultTypes == null) {
			Set<String> result = new HashSet<String>(125);
			result.add("AbstractMethodError");
			result.add("Appendable");
			result.add("ArithmeticException");
			result.add("ArrayIndexOutOfBoundsException");
			result.add("ArrayStoreException");
			result.add("AssertionError");
			result.add("AutoCloseable");
			result.add("Boolean");
			result.add("BootstrapMethodError");
			result.add("Byte");
			result.add("Character");
			result.add("CharSequence");
			result.add("Class");
			result.add("ClassCastException");
			result.add("ClassCircularityError");
			result.add("ClassFormatError");
			result.add("ClassLoader");
			result.add("ClassNotFoundException");
			result.add("ClassValue");
			result.add("CloneNotSupportedException");
			result.add("Cloneable");
			result.add("Comparable");
			result.add("Compiler");
			result.add("Double");
			result.add("Deprecated");
			result.add("Enum");
			result.add("EnumConstantNotPresentException");
			result.add("Error");
			result.add("Exception");
			result.add("ExceptionInInitializerError");
			result.add("Float");
			result.add("FloatingDecimal");
			result.add("FunctionalInterface");
			result.add("IllegalAccessError");
			result.add("IllegalAccessException");
			result.add("IllegalArgumentException");
			result.add("IllegalCallerException");
			result.add("IllegalMonitorStateException");
			result.add("IllegalStateException");
			result.add("IllegalThreadStateException");
			result.add("IncompatibleClassChangeError");
			result.add("IndexOutOfBoundsException");
			result.add("InheritableThreadLocal");
			result.add("InstantiationError");
			result.add("InstantiationException");
			result.add("Integer");
			result.add("InternalError");
			result.add("InterruptedException");
			result.add("Iterable");
			result.add("LayerInstantiationException");
			result.add("LinkageError");
			result.add("Long");
			result.add("Math");
			result.add("Module");
			result.add("ModuleLayer");
			result.add("NegativeArraySizeException");
			result.add("NoClassDefFoundError");
			result.add("NoSuchFieldError");
			result.add("NoSuchFieldException");
			result.add("NoSuchMethodError");
			result.add("NoSuchMethodException");
			result.add("NullPointerException");
			result.add("Number");
			result.add("NumberFormatException");
			result.add("Object");
			result.add("Override");
			result.add("OutOfMemoryError");
			result.add("Package");
			result.add("Process");
			result.add("ProcessBuilder");
			result.add("Readable");
			result.add("ReflectiveOperationException");
			result.add("Runnable");
			result.add("Runtime");
			result.add("RuntimeException");
			result.add("RuntimePermission");
			result.add("SafeVarargs");
			result.add("SecurityException");
			result.add("SecurityManager");
			result.add("Short");
			result.add("StackOverflowError");
			result.add("StackTraceElement");
			result.add("StackWalker");
			result.add("StrictMath");
			result.add("String");
			result.add("StringBuffer");
			result.add("StringBuilder");
			result.add("StringIndexOutOfBoundsException");
			result.add("SuppressWarnings");
			result.add("System");
			result.add("Thread");
			result.add("ThreadDeath");
			result.add("ThreadGroup");
			result.add("ThreadLocal");
			result.add("Throwable");
			result.add("TypeNotPresentException");
			result.add("UnknownError");
			result.add("UnsatisfiedLinkError");
			result.add("UnsupportedClassVersionError");
			result.add("UnsupportedOperationException");
			result.add("VerifyError");
			result.add("VirtualMachineError");
			result.add("Void");
			result.add("boolean");
			result.add("byte");
			result.add("char");
			result.add("double");
			result.add("float");
			result.add("int");
			result.add("long");
			result.add("short");
			javaDefaultTypes = Collections.unmodifiableSet(result);
		}
		return javaDefaultTypes;
	}
190244
public static void getAllInterfaces(Class<?> classObject, ArrayList<Type> interfaces) {
        Type[] superInterfaces = classObject.getGenericInterfaces();
        interfaces.addAll((Arrays.asList(superInterfaces)));

        // for cases where the extended class is defined with a Generic.
        Type tgs = classObject.getGenericSuperclass();
        if (tgs != null) {
            if ((tgs) instanceof ParameterizedType) {
                interfaces.add(tgs);
            }
        }

        if (tc.isDebugEnabled()) {
            Tr.debug(tc, "updated interfaces to: " + interfaces);
        }

        Class<?> superClass = classObject.getSuperclass();
        if (superClass != null) {
            getAllInterfaces(superClass, interfaces);
        }
    }
497825
public static Class[] getClasses(Object[] objs) {
	Class[] cls = new Class[objs.length];
	for (int i = 0; i < objs.length; i++) {
	    if (objs[i] == null) cls[i] = Object.class;
	    else cls[i] = objs[i].getClass();
	}
	return cls;
    }
1103259
private static Type[] getGenericInterfaces(Class<?> cls, Class<?> expectedClass,
                                               Class<?> commonBaseCls) {
        if (Object.class == cls) {
            return emptyType;
        }
        Type[] cachedTypes = getTypes(cls, expectedClass, commonBaseCls);
        if (cachedTypes != null)
            return cachedTypes;
        if (expectedClass != null) {
            Type genericSuperType = cls.getGenericSuperclass();
            if (genericSuperType instanceof ParameterizedType) {
                Class<?> actualType = InjectionUtils.getActualType(genericSuperType);
                if (actualType != null && actualType.isAssignableFrom(expectedClass)) {
                    Type[] tempTypes = new Type[] { genericSuperType };
                    putTypes(cls, expectedClass, commonBaseCls, tempTypes);
                    return tempTypes;
                } else if (commonBaseCls != null && commonBaseCls != Object.class 
                           && commonBaseCls.isAssignableFrom(expectedClass)
                           && commonBaseCls.isAssignableFrom(actualType)
                           || expectedClass.isAssignableFrom(actualType)) {
                    putTypes(cls, expectedClass, commonBaseCls, emptyType);
                    return emptyType;
                }
            }
        }
        Type[] types = cls.getGenericInterfaces();
        if (types.length > 0) {
            putTypes(cls, expectedClass, commonBaseCls, types);
            return types;
        }
        Type[] superGenericTypes = getGenericInterfaces(cls.getSuperclass(), expectedClass, commonBaseCls);
        putTypes(cls, expectedClass, commonBaseCls, superGenericTypes);
        return superGenericTypes;
    }
391698
protected List<TypeName> getExtractedTypes(TypeName permutationType, TypeName paramType) {
    return match(permutationType)
        .when(typeOf(ParameterizedTypeName.class)).get(
            t -> {
              if (isDecomposableBuilder(t.rawType)) {
                return t.typeArguments.subList(1, t.typeArguments.size());
              } else if (t.rawType.equals(MATCH_ANY)) {
                return ImmutableList.of(paramType);
              } else {
                return Collections.<TypeName>emptyList();
              }
            })
        .when(typeOf(TypeVariableName.class)).get(t -> ImmutableList.of())
        .when(typeOf(ClassName.class)).get(t -> ImmutableList.of(paramType))
        .orElse(t -> ImmutableList.of(t))
        .getMatch();
  }
505379
public com.sun.javadoc.Type[] interfaceTypes() {
        //### Cache result here?
        return TypeMaker.getTypes(env, env.types.interfaces(type));
    }
816849
protected List<Map<String, ?>> generatePrimitiveTypes(Set<String> primitiveTypes) {
		final List<Map<String, ?>> list = new ArrayList<>();
		if (!primitiveTypes.isEmpty()) {
			list.add(pattern(it -> {
				it.matches(keywordRegex(primitiveTypes) + "(?:\\s*\\[\\s*\\])*"); //$NON-NLS-1$
				it.style(PRIMITIVE_TYPE_STYLE);
				it.comment("Primitive types"); //$NON-NLS-1$
			}));
		}
		return list;
	}
547724
@SuppressWarnings("rawtypes")
	public static boolean isBesicType(Class cls){
		if (cls == null) return false;
		String type = cls.getName();
		return isBasicType(type);
		
	}