Returns true if the class is the class of an engineering object, returns false if not.
434948
public static Boolean isEngineeringObjectClass(Class<?> clazz) {
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(OpenEngSBForeignKey.class)) {
                return true;
            }
        }
        return false;
    }
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;
  }
978981
def is_backup_class(cls):
    """"""
    return True if (
        isclass(cls) and
        issubclass(cls, Storable) and
        get_mapping(cls, no_mapping_ok=True)
    ) else False
494441
def is_module(obj):
    
    return True if obj and isinstance(obj, ModuleType) or inspect.isclass(obj) else False
371326
def is_classmethod(fn):
    """"""
    # This is True for bound methods
    if not inspect.ismethod(fn):
        return False
    if not hasattr(fn, "__self__"):
        return False
    im_self = fn.__self__
    # This is None for instance methods on classes, but True
    # for instance methods on instances.
    if im_self is None:
        return False
    # This is True for class methods of new- and old-style classes, respectively
    return isinstance(im_self, six.class_types)
846398
def is_instance_or_subclass(val, class_):
    """"""
    try:
        return issubclass(val, class_)
    except TypeError:
        return isinstance(val, class_)
942859
private boolean checkValidClass(Class<?> clazz) {
        return clazz.isAnnotationPresent(Entity.class) || clazz.isAnnotationPresent(MappedSuperclass.class)
            || clazz.isAnnotationPresent(Embeddable.class);

    }
560828
def is_handler_subclass(cls, classnames=("ViewHandler", "APIHandler")):
    """"""
    if isinstance(cls, list):
        return any(is_handler_subclass(c) for c in cls)
    elif isinstance(cls, type):
        return any(c.__name__ in classnames for c in inspect.getmro(cls))
    else:
        raise TypeError(
            "Unexpected type `{}` for class `{}`".format(
                type(cls),
                cls
            )
        )
1271992
public boolean isEqualsInheritedFromObject() {
        ClassAccessor<? super T> i = this;
        while (i.getType() != Object.class) {
            if (i.declaresEquals() && !i.isEqualsAbstract()) {
                return false;
            }
            i = i.getSuperAccessor();
        }
        return true;
    }
133723
def backend_class(self):
        
        if not self.backend:
            return None

        if not self.__backend_class:
            self.__backend_class = self._get_netengine_backend()

        return self.__backend_class
1116437
static boolean isClassType(Element element, Elements elements, Types types) {
    TypeMirror classType = types.getDeclaredType(
        elements.getTypeElement(Class.class.getName()),
        types.getWildcardType(null, null));
    return types.isAssignable(element.asType(), classType);
  }
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
1341017
public static boolean isFloatingPointType(Class pClass) {
        return
                pClass == Float.class ||
                        pClass == Float.TYPE ||
                        pClass == Double.class ||
                        pClass == Double.TYPE;
    }
1175194
public static boolean isClassFile(IJavaElement elt) {
        if (elt == null) {
            return false;
        }
        return elt instanceof IClassFile || elt instanceof ICompilationUnit;

    }
56413
def class_check(vector):
    
    for i in vector:
        if not isinstance(i, type(vector[0])):
            return False
    return True
1342911
def node_is_subclass(cls, *subclass_names):
    """"""
    if not isinstance(cls, (ClassDef, Instance)):
        return False

    # if cls.bases == YES:
    #     return False
    for base_cls in cls.bases:
        try:
            for inf in base_cls.inferred():  # pragma no branch
                if inf.qname() in subclass_names:
                    return True

                if inf != cls and node_is_subclass(  # pragma no branch
                        inf, *subclass_names):
                    # check up the hierarchy in case we are a subclass of
                    # a subclass of a subclass ...
                    return True
        except InferenceError:  # pragma no cover
            continue

    return False
654372
public boolean isMetBy(Class<?> klass) {
    // Classes which aren't capabilities handlers have an assumed
    // set of capabilities
    if (!CapabilitiesHandler.class.isAssignableFrom(klass))
      return isMetBy(NON_HANDLER_CAPABILITIES);

    // Attempt to instantiate an instance of the class
    CapabilitiesHandler instance;
    try {
       instance = (CapabilitiesHandler) klass.newInstance();
    }
    catch (InstantiationException | IllegalAccessException e) {
      throw new RuntimeException("Couldn't instantiate CapabilitiesHandler " +
	klass.getSimpleName(),
	e);
    }

    // Test the instance
    return isMetBy(instance);
  }