Determines whether the given array only contains unbounded type variables or Object.class.

@param types the given array of types
@return true if and only if the given array only contains unbounded type variables or Object.class
423980
public static boolean isArrayOfUnboundedTypeVariablesOrObjects(Type[] types) {
        for (Type type : types) {
            if (Object.class.equals(type)) {
                continue;
            }
            if (type instanceof TypeVariable<?>) {
                Type[] bounds = ((TypeVariable<?>) type).getBounds();
                if (bounds == null || bounds.length == 0 || (bounds.length == 1 && Object.class.equals(bounds[0]))) {
                    continue;
                }
            }
            return false;
        }
        return true;
    }
194703
public static boolean arrayFilter(String type) {

        int lastIndex = type.lastIndexOf(ARRAY_PREFIX);
        if (lastIndex == -1) {
            return false;
        }

        String arrayType = type.substring(lastIndex + 1);

        return nameFilter(arrayType);
    }
292801
@SuppressWarnings("unused")
	private static void checkAndCoSort(int[] positions, Class<?>[] types) {
		if (positions.length != types.length) {
			throw new IllegalArgumentException("The positions and types must be of the same length");
		}
		
		TreeMap<Integer, Class<?>> map = new TreeMap<Integer, Class<?>>();
		
		for (int i = 0; i < positions.length; i++) {
			if (positions[i] < 0) {
				throw new IllegalArgumentException("The field " + " (" + positions[i] + ") is invalid.");
			}
			if (types[i] == null) {
				throw new IllegalArgumentException("The type " + i + " is invalid (null)");
			}
			
			if (map.containsKey(positions[i])) {
				throw new IllegalArgumentException("The position " + positions[i] + " occurs multiple times.");
			}
			
			map.put(positions[i], types[i]);
		}
		
		int i = 0;
		for (Map.Entry<Integer, Class<?>> entry : map.entrySet()) {
			positions[i] = entry.getKey();
			types[i] = entry.getValue();
			i++;
		}
	}
562849
public static function isTypesOf(array $array, array $types) : bool
    {
        if (!self::isTypeOf($types, 'string')) {
            return false;
        }

        $types = array_map(function ($type) {
            return DataTypes::guessFromAlias($type);
        }, $types);

        if (array_diff($types, DataTypes::TYPES)) {
            return false;
        }

        foreach ($array as $item) {
            if (!in_array(gettype($item), $types, true)) {
                return false;
            }
        }

        return true;
    }
135721
public static boolean mightContainsProperties(Class<?> type) {
    return type != Object.class
        && type != String.class
        && type != Date.class
        && type != Calendar.class
        && !Primitives.isPrimitive(type)
        && !Iterables.isIterable(type)
        && !Types.isGroovyType(type);
  }
289115
public static boolean isPrimitiveArray(Class<?> type) {
        logger.entering(type);
        checkArgument(type != null, "Type cannot be null.");
        logger.exiting(PRIMITIVE_ARRAY_TYPES.contains(type));
        return PRIMITIVE_ARRAY_TYPES.contains(type);
    }
739900
public static boolean isArray(TypeRef type) {

        if (type instanceof ClassRef) {
            return ((ClassRef)type).getDimensions() > 0;
        } else if (type instanceof PrimitiveRef) {
            return ((PrimitiveRef)type).getDimensions() > 0;
        } else if (type instanceof TypeParamRef) {
            return ((TypeParamRef)type).getDimensions() > 0;
        } else {
            return false;
        }
    }
85607
@SuppressWarnings("unchecked")
   public static boolean typesMatch(Class<?>[] c1, Class[] c2) {
      if (c1.length != c2.length) {
         return false;
      }
      for (int i = 0; i < c1.length; i++) {
         if (!inSameHierarchy(c1[i], c2[i]) && !isConvertible(c1[i], c2[i])) {
            return false;
         }
      }
      return true;
   }
1217243
public static boolean isClassOrInterface(Type type) {
    if (!(type instanceof Class)) {
      return false;
    }

    Class clazz = (Class) type;
    return !clazz.isPrimitive() && !clazz.isAnnotation() && !clazz.isArray() && !clazz.isEnum()
        && !clazz.isAnonymousClass();
  }
59751
public static boolean isIntrospectable(final Class<?> type) {
        return !isEnumType(type)
                && !isArrayType(type)
                && !(isCollectionType(type) && isJdkBuiltIn(type))
                && !(isMapType(type) && isJdkBuiltIn(type));
    }
1008758
function isTypedArray( v ) {
	var i;
	v = typeName( v );
	for ( i = 0; i < NAMES.length; i++ ) {
		if ( NAMES[ i ] === v ) {
			return true;
		}
	}
	return false;
}
616609
@SuppressWarnings("rawtypes")
    public boolean useReferences(Class type) {
        return !Util.isWrapperClass(type) && !type.equals(String.class) && !type.equals(Date.class) && !type.equals(BigDecimal.class) && !type.equals(BigInteger.class);
    }
351485
public boolean isSameTypes(List<Type> ts, List<Type> ss) {
        return isSameTypes(ts, ss, false);
    }
434470
public static boolean isListClass(Class<?> type) {
        if (type.isPrimitive() || type.isEnum()) {
            return false;
        }
        return type.equals(List.class);
    }
1138249
public static boolean isMultiValue(final Class<?> iType) {
    return (iType.isArray() || Collection.class.isAssignableFrom(iType) || Map.class.isAssignableFrom(iType));
  }
830789
private static boolean checkCollectionMembers(Collection<?> c, Class<?> type) {
        for (Object element : c) {
            if (element != null && !type.isInstance(element)) {
                return false;
            }
        }
        return true;
    }
846998
public boolean isArray(Type t) {
        while (t.hasTag(WILDCARD))
            t = wildUpperBound(t);
        return t.hasTag(ARRAY);
    }