Check if the passed class is abstract or not. Note: interfaces and
annotations are also considered as abstract whereas arrays are never
abstract.

@param aClass
The class to check.
@return <code>true</code> if the passed class is abstract
481990
public static boolean isAbstractClass (@Nullable final Class <?> aClass)
  {
    // Special case for arrays (see documentation of Class.getModifiers: only
    // final and interface are set, the rest is indeterministic)
    return aClass != null && !aClass.isArray () && Modifier.isAbstract (aClass.getModifiers ());
  }
210706
def abstract(class_):
    
    if not inspect.isclass(class_):
        raise TypeError("@abstract can only be applied to classes")

    abc_meta = None

    # if the class is not already using a metaclass specific to ABC,
    # we need to change that
    class_meta = type(class_)
    if class_meta not in (_ABCMetaclass, _ABCObjectMetaclass):
        # decide what metaclass to use, depending on whether it's a subclass
        # of our universal :class:`Object` or not
        if class_meta is type:
            abc_meta = _ABCMetaclass  # like ABCMeta, but can never instantiate
        elif class_meta is ObjectMetaclass:
            abc_meta = _ABCObjectMetaclass  # ABCMeta mixed with ObjectMetaclass
        else:
            raise ValueError(
                "@abstract cannot be applied to classes with custom metaclass")

    class_.__abstract__ = True
    return metaclass(abc_meta)(class_) if abc_meta else class_
833648
public boolean isToClass(Class<?> toClass) {
        List<DomainClass> domainClasses = reflectionHelper.getAnnotationWithMeta(toClass, DomainClass.class);
        return 0 != domainClasses.size();
    }
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);
  }
873418
@Nullable
  public static Class <?> getPrimitiveWrapperClass (@Nullable final Class <?> aClass)
  {
    if (isPrimitiveWrapperType (aClass))
      return aClass;
    return PRIMITIVE_TO_WRAPPER.get (aClass);
  }
7948
public boolean isAssignableFrom(Class cl)
  {
    if (getName().equals(cl.getName()))
      return true;

    Class []ifc = cl.getInterfaces();

    for (int i = 0; i < ifc.length; i++) {
      if (isAssignableFrom(ifc[i]))
        return true;
    }

    if (cl.getSuperclass() != null)
      return isAssignableFrom(cl.getSuperclass());
    else
      return false;
  }
1209362
public static boolean isInstaneOf(String srcClassName, Class trg) {
	Class clazz = ClassUtil.loadClass(srcClassName, null);
	if (clazz == null) return false;
	return isInstaneOf(clazz, trg);
    }
1200162
private boolean isAssociatedClass(@DottedClassName String calledClass) {
        if (calledClass.equals(parentClassName)) {
            return true;
        }

        if (calledClass.length() <= clsName.length()) {
            return false;
        }
        int innerMarkPos = calledClass.indexOf('$', clsName.length());
        if (innerMarkPos < 0) {
            innerMarkPos = calledClass.indexOf('.', clsName.length());
            if (innerMarkPos < 0) {
                return false;
            }
        }

        String topClass = calledClass.substring(0, innerMarkPos);
        return topClass.equals(clsName) || calledClass.substring(innerMarkPos + 1).startsWith("access");
    }
1011272
def is_abstract(self) -> bool:
        
        meta_value = getattr(self.clsdict.get('Meta'), 'abstract', False)
        return self.clsdict.get(ABSTRACT_ATTR, meta_value) is True
680950
public boolean isDeprecated(Class<?> clazz) {

        // check if class is marked as deprecated
        if (clazz.getAnnotation(Deprecated.class) != null) { 
            return true; 
        }
        
        // check if super class is deprecated
        Class<?> superClass = clazz.getSuperclass();
        if (superClass != null) {
            return isDeprecated(superClass);
        }
        
        // check if interfaces are deprecated
        for (Class<?> iface : clazz.getInterfaces()) {
            return isDeprecated(iface);
        }
        
        // not deprecated
        return false;
    }
683772
public static boolean isInstaneOf(Class src, Class trg) {
	if (src.isArray() && trg.isArray()) {
	    return isInstaneOf(src.getComponentType(), trg.getComponentType());
	}

	if (src == trg) return true;

	// Interface
	if (trg.isInterface()) {
	    return _checkInterfaces(src, trg);
	}
	// Extends

	while (src != null) {
	    if (src == trg) return true;
	    src = src.getSuperclass();
	}
	return trg == Object.class;
    }
931691
public static boolean isVetoed(Class<?> javaClass) {
        if (javaClass.isAnnotationPresent(Vetoed.class)) {
            return true;
        }
        return isPackageVetoed(javaClass.getPackage());
    }
62917
@SuppressWarnings("unchecked")
    private boolean isClassTrivial(ClassTraceInfo info) {
        AnnotationNode trivialAnnotation = getAnnotation(TRIVIAL_TYPE.getDescriptor(), info.classNode.visibleAnnotations);
        if (trivialAnnotation != null) {
            return true;
        }
        return false;
    }
1108026
public static boolean isArray( Class clazz ) {
      return clazz != null
            && (clazz.isArray() || Collection.class.isAssignableFrom( clazz ) || (JSONArray.class.isAssignableFrom( clazz )));
   }
835804
private static boolean checkFieldsWithDataAnnotation(Class<? extends AbstractPlugin> pluginClass) {
        List<Field> dataFields = new ArrayList<>();
        for (Field field : pluginClass.getDeclaredFields()) {
            if (field.isAnnotationPresent(Plugin.Data.class)) {
                dataFields.add(field);
            }
        }
        return shouldHasUniqueValues(dataFields);
    }
947644
public static boolean hasMethodWithAnnotation(Class<?> type,
                                                  Class<? extends Annotation> annotationType,
                                                  boolean checkMetaAnnotations) {
        try {
            do {
                Method[] methods = type.getDeclaredMethods();
                for (Method method : methods) {
                    if (hasAnnotation(method, annotationType, checkMetaAnnotations)) {
                        return true;
                    }
                }
                type = type.getSuperclass();
            } while (type != null);
        } catch (Throwable e) {
            // ignore a class loading issue
        }
        return false;
    }
635505
public boolean hasSupertype(AClassType sclass, PType other)
	{
		return af.createSClassDefinitionAssistant().hasSupertype(sclass.getClassdef(), other);
	}