Returns a boolean indicating whether the given class is a polymorphic type.
558959
private boolean isPolymorphicType(Class<?> clazz) {
    return polymorphicTypes.stream().anyMatch(polymorphicType -> polymorphicType.getConfigClass() == clazz);
  }
1182616
public static boolean checkValueIsType(Object value, Object name, Class type) {
        if (value != null) {
            if (type.isAssignableFrom(value.getClass())) {
                return true;
            } else {
                throw new RuntimeException("The value argument of '" + name + "' must be of type "
                        + type.getName() + ". Found: " + value.getClass());
            }
        } else {
            return false;
        }
    }
344929
public static boolean isBoolean(TypeRef type) {
        if (type instanceof PrimitiveRef) {
            return Constants.PRIMITIVE_BOOLEAN_REF.equals(type);
        } else if (!(type instanceof ClassRef)) {
            return false;
        } else {
            return Constants.BOOLEAN_REF.equals(type);
        }
    }
1280565
public static boolean isSupportedType(final Class<?> clazz) {
        if (ReflectionUtils.isPropertyType(clazz)) {
            return true;
        }
        if (clazz.isArray() || Map.class.isAssignableFrom(clazz) || Iterable.class.isAssignableFrom(clazz)) {
            Class<?> subType;
            if (clazz.isArray()) {
                subType = clazz.getComponentType();
            } else {
                subType = ReflectionUtils.getParameterizedClass(clazz);
            }

            //get component type, String.class from List<String>
            if (subType != null && subType != Object.class && !ReflectionUtils.isPropertyType(subType)) {
                return false;
            }

            //either no componentType or it is an allowed type
            return true;
        }
        return false;
    }
288760
public static boolean isGeneratedClass(Class<?> type) {
        return null != type && type != GeneratedClass.class
                && GeneratedClass.class.isAssignableFrom(type);
    }
1202855
def is_subclass(obj, cls):
    
    try:
        for i in obj.__bases__:
            if i is cls or isinstance(i, cls):
                return True
        for i in obj.__bases__:
            if isinstance(i, cls):
                return True
    except AttributeError:
        return isinstance(obj.__class__, cls)
    return False
251027
public static boolean isIntCategory(ClassNode type) {
        return  type==byte_TYPE     ||  type==char_TYPE     ||
                type==int_TYPE      ||  type==short_TYPE;
    }
547724
@SuppressWarnings("rawtypes")
	public static boolean isBesicType(Class cls){
		if (cls == null) return false;
		String type = cls.getName();
		return isBasicType(type);
		
	}
965542
public static boolean isDoubleType(Class<?> type) {
        return (type.isPrimitive() && type == float.class) || (type.isPrimitive() && type == double.class)
                || (!type.isPrimitive() && type == Float.class) || (!type.isPrimitive() && type == Double.class);
    }
1177361
def IsPrimitiveType(obj):
   """"""
   return (isinstance(obj, types.bool) or isinstance(obj, types.byte) or
      isinstance(obj, types.short) or isinstance(obj, six.integer_types) or
      isinstance(obj, types.double) or isinstance(obj, types.float) or
      isinstance(obj, six.string_types) or
      isinstance(obj, types.PropertyPath) or
      isinstance(obj, types.ManagedMethod) or
      isinstance(obj, types.datetime) or
      isinstance(obj, types.URI) or isinstance(obj, type))
1058428
public function isInstanceOf( core_kernel_classes_Class $class)
    {
        $returnValue = (bool) false;
        foreach($this->getTypes() as $type){
        	if ($class->equals($type) || $type->isSubClassOf($class)){
        		$returnValue = true;
        		break;
        	}
        }
        return (bool) $returnValue;
    }
766188
public static boolean isNoValueType(Class<?> type) {

        LettuceAssert.notNull(type, "Class must not be null!");

        return findDescriptor(type).map(Descriptor::isNoValue).orElse(false);
    }
396650
def is_class(data):
    

    try:
        with unpack(data) as up:
            magic = up.unpack_struct(_BBBB)

        return magic == JAVA_CLASS_MAGIC

    except UnpackException:
        return False
344256
static boolean isBivariantType(JSType type) {
    ObjectType objType = type.toObjectType();
    return objType != null
        // && objType.isNativeObjectType()
        && BIVARIANT_TYPES.contains(objType.getReferenceName());
  }
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;
   }
1326503
def is_type(type_, *p):
    
    try:
        for i in p:
            if i.type_ != type_:
                return False

        return True
    except:
        pass

    return False
299988
public final static boolean isClassType(final Type type) {
        if (type instanceof Class) return true;
        if (type instanceof WildcardType) return false;
        if (type instanceof TypeVariable) return false;
        if (type instanceof GenericArrayType) return isClassType(((GenericArrayType) type).getGenericComponentType());
        if (!(type instanceof ParameterizedType)) return false; //只能是null了
        final ParameterizedType ptype = (ParameterizedType) type;
        if (ptype.getOwnerType() != null && !isClassType(ptype.getOwnerType())) return false;
        if (!isClassType(ptype.getRawType())) return false;
        for (Type t : ptype.getActualTypeArguments()) {
            if (!isClassType(t)) return false;
        }
        return true;
    }