True if the Class is a superclass of the given one.
331187
def superclass(self, klass):
        """"""
        return bool(lib.EnvSuperclassP(self._env, self._cls, klass._cls))
603390
def _is_metaclass(klass, seen=None):
    
    if klass.name == "type":
        return True
    if seen is None:
        seen = set()
    for base in klass.bases:
        try:
            for baseobj in base.infer():
                baseobj_name = baseobj.qname()
                if baseobj_name in seen:
                    continue
                else:
                    seen.add(baseobj_name)
                if isinstance(baseobj, bases.Instance):
                    # not abstract
                    return False
                if baseobj is util.Uninferable:
                    continue
                if baseobj is klass:
                    continue
                if not isinstance(baseobj, ClassDef):
                    continue
                if baseobj._type == "metaclass":
                    return True
                if _is_metaclass(baseobj, seen):
                    return True
        except exceptions.InferenceError:
            continue
    return False
915462
def isinstance(instance, ifaces):
    """"""
    ifaces = _ensure_ifaces_tuple(ifaces)
    for iface in ifaces:

        attributes = (
            attr
            for attr in iface.__abstractmethods__
            if hasattr(getattr(iface, attr), '__iattribute__')
        )
        for attribute in attributes:

            if not hasattr(instance, attribute):

                return False

        if not issubclass(type(instance), ifaces):

            return False

    return True
845052
public static void isAssignable(Class<?> superType, Class<?> subType) throws IllegalArgumentException {
		isAssignable(superType, subType, "{} is not assignable to {})", subType, superType);
	}
868243
public boolean isSubClassOf(final OClass iClass) {
    if (iClass == null)
      return false;

    OClass cls = this;
    while (cls != null) {
      if (cls.getName().equals(iClass.getName()))
        return true;
      cls = cls.getSuperClass();
    }
    return 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
378809
private boolean isMap(Class<?> rawType) {

    // this sucks... is there really no way to work around this in GWT?
    // http://code.google.com/p/google-web-toolkit/issues/detail?id=4663
    if (rawType == Map.class) {
      return true;
    }
    Class<?> superType = rawType;
    while (superType != null) {
      if (superType == AbstractMap.class) {
        return true;
      }
      superType = superType.getSuperclass();
    }
    return false;
  }
991582
public boolean isSubtypeOf(Class<?> clazz) {
		if (isType(clazz)) {
			return true;
		}
		// TODO interfaces don't inherit from non-interfaces, primitives, arrays, object
		// A final type does not have any subtypes
		JvmType type = findType(clazz);
		if (type == null) {
			return false;
		}
		return isSubtypeOf(type);
	}
923802
private static boolean isCompatibleClasses(final Class<?> one, final Class<?> two) {
        return one.isAssignableFrom(two) || two.isAssignableFrom(one);
    }
273024
def _forgiving_issubclass(derived_class, base_class):
    
    return (type(derived_class) is ClassType and \
            type(base_class) is ClassType and \
            issubclass(derived_class, base_class))
491272
private boolean hasSuperclass(Name es6Class) {
    Node decl = es6Class.getDeclaration().getNode();
    Node classNode = NodeUtil.getRValueOfLValue(decl);
    checkState(classNode.isClass(), classNode);
    Node superclass = classNode.getSecondChild();

    return !superclass.isEmpty();
  }
467637
function(cls,superClass) {
    var super_;
    while (lib.type.isFunction(cls.super_)) {
      if (cls.super_ === superClass) {
        super_ = cls.super_;
        break;
      }
      cls = cls.super_;
    }
    return super_;
  }
297152
def is_one_of(obj, types):
    """"""
    for type_ in types:
        if isinstance(obj, type_):
            return True
    return False
914679
def isinstance(self, instance, class_name):
        """"""
        if isinstance(instance, BaseNode):
            klass = self.dynamic_node_classes.get(class_name, None)
            if klass:
                return isinstance(instance, klass)
            # Not an instance of a class in the registry
            return False
        else:
            raise TypeError("This function can only be used for BaseNode objects")
179102
public static function isSubclassOf($class, $parent)
    {
        if (! is_subclass_of($class, $parent)) {
            if (is_object($class)) {
                $class = get_class($class);
            }
            self::isString($class);
            if ($class === $parent) {
                return;
            }
            if (! class_exists($class)) {
                throw new InvalidArgumentException('Class not found: ' . $class);
            }
            throw new InvalidArgumentException('Class ' . $class . ' should extend ' . $parent);
        }
    }
56413
def class_check(vector):
    
    for i in vector:
        if not isinstance(i, type(vector[0])):
            return False
    return True
503978
public static boolean isInstanceOf(Object obj, String classSimpleName) {
    if (obj == null) {
      return false;
    }
    
    Class<?> currentClass = obj.getClass();
    while (currentClass != Object.class) {
      if (currentClass.getSimpleName().equals(classSimpleName)) {
        return true;
      } else {
        currentClass = currentClass.getSuperclass();
      }
    }
    return false;
  }