Determine if this is the superclass of some other named class.

@param otherClassName The name of the class to compare against
@return true if 'this' a superclass of another named class
327426
public boolean isSuperClass(String otherClassName) {
      if (getClassWeAreModelling().getName().equals(otherClassName)) {
         return true;
      } else if (superClazz != null) {
         return superClazz.isSuperClass(otherClassName);
      } else {
         return false;
      }
   }
894008
public boolean exists(String className) {
		if(this.classLoader!=null) {
			if(exists(className, this.classLoader)) {
				LOG.debug("class {} found using class specific class loader", className);
				return true;
			}
			return false;
		}
		if(existsWithDefaultClassLoader(className)) {
			LOG.debug("class {} found using default class loader", className);
			return true;
		}
		if(exists(className, Thread.currentThread().getContextClassLoader())) {
			LOG.debug("class {} found using class loader of current thread", className);
			return true;
		}
		if(exists(className, getClass().getClassLoader())) {
			LOG.debug("class {} found using class loader of current class", className);
			return true;
		}
		return false;
	}
99153
public boolean isSuperClassOf(final OClass iClass) {
    OClass cls = iClass;
    while (cls != null) {
      if (cls.getName().equals(name))
        return true;
      cls = cls.getSuperClass();
    }
    return false;
  }
39276
private function isValidObjectClass($className)
    {
        //====================================================================//
        // Safety Check => Object Type is String
        if (!is_string($className)) {
            return "Object Type is Not a String";
        }
        //====================================================================//
        // Safety Check => Class Exists
        if (!class_exists($className)) {
            return "Object Class Not Found";
        }
        //====================================================================//
        // Safety Check => Class Extends
        if (!is_subclass_of($className, AbstractObject::class)) {
            return "Object Class MUST extends ".AbstractObject::class;
        }

        return true;
    }
453483
public boolean hasClass(String name) {
        byte[] b = classesFound.get(name);
        Boolean found = b == null ? null : b.length > 0;
        if (found != null)
            return found;

        try {
            // try dynamic jar assets
            String path = name.replace('.', '/') + ".class";
            b = findInJarAssets(path);
            // try the file system
            if (b == null)
                b = findInFileSystem(path);
        }
        catch (Exception ex) {
            logger.severeException(ex.getMessage(),  ex);
        }
        found = b != null;
        classesFound.put(name, found ? b : new byte[0]);
        return found;
    }
195965
public static boolean isNotScanClass(String className) {
        String block = BASIC_PACKAGE_PREFIX_LIST.stream().filter(prefix -> className.startsWith(prefix)).findAny().orElse(null);
        return block != null;
    }
1208003
private boolean isWithinSubtree(X500Name other) {
        if (this == other) {
            return true;
        }
        if (other == null) {
            return false;
        }
        if (other.names.length == 0) {
            return true;
        }
        if (this.names.length == 0) {
            return false;
        }
        if (names.length < other.names.length) {
            return false;
        }
        for (int i = 0; i < other.names.length; i++) {
            if (!names[i].equals(other.names[i])) {
                return false;
            }
        }
        return true;
    }
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);
	}
117240
def has_name?( other, ns=nil )
      if ns
        return (namespace() == ns and name() == other)
      elsif other.include? ":"
        return fully_expanded_name == other
      else
        return name == other
      end
    end
844260
public static boolean verifyClass(String className){
        try {
            Class<?> cl = Class.forName(className);
            cl.newInstance();
            return true;
        }
        catch (Exception ex) {
          logger.severeException("ApplicationContext: verifyClass(): General Exception occurred: " + ex.getMessage(), ex);
          return false;
        }
    }
415340
public static boolean isPrimitiveClassName(String className)
	{
		return className.equalsIgnoreCase("boolean") //$NON-NLS-1$
				|| className.equalsIgnoreCase("byte") //$NON-NLS-1$
				|| className.equalsIgnoreCase("char") //$NON-NLS-1$
				|| className.equalsIgnoreCase("short") //$NON-NLS-1$
				|| className.equalsIgnoreCase("int") //$NON-NLS-1$
				|| className.equalsIgnoreCase("long") //$NON-NLS-1$
				|| className.equalsIgnoreCase("float") //$NON-NLS-1$
				|| className.equalsIgnoreCase("double") //$NON-NLS-1$
				|| className.equalsIgnoreCase("string"); //$NON-NLS-1$
	}
1184356
public static boolean hasSuperclass(Class<?> clazz, String superClassName) {
		List<Type> hierarchy = new ArrayList<>();
		getTypeHierarchy(hierarchy, clazz, Object.class);
		for (Type t : hierarchy) {
			if (isClassType(t) && typeToClass(t).getName().equals(superClassName)) {
				return true;
			}
		}
		return false;
	}
581914
static boolean isClassExpression(Node n) {
    return n.isClass() && (!isNamedClass(n) || !isDeclarationParent(n.getParent()));
  }
479087
public static boolean methodEquals( Method method, Method other){
	    
		if ((method.getDeclaringClass().equals( other.getDeclaringClass()))
	    && (method.getName().equals( other.getName()))) {
	        if (!method.getReturnType().equals(other.getReturnType()))
	            return false;
	        
	        Class<?>[] params1 = method.getParameterTypes();
	        Class<?>[] params2 = other.getParameterTypes();
	        if (params1.length == params2.length) {
	            for (int i = 0; i < params1.length; i++) {
	            if (params1[i] != params2[i])
	                return false;
	            }
	            return true;
	        }
	    }
	    return false;
	}
947646
public boolean isMetBy(LocalProperties other) {
		if (this.ordering != null) {
			// we demand an ordering
			return other.getOrdering() != null && this.ordering.isMetBy(other.getOrdering());
		} else if (this.groupedFields != null) {
			// check if the other fields are unique
			if (other.getGroupedFields() != null && other.getGroupedFields().isValidUnorderedPrefix(this.groupedFields)) {
				return true;
			} else  {
				return other.areFieldsUnique(this.groupedFields);
			}
		} else {
			return true;
		}
	}
198992
public function isClassAbstract($className)
    {
        $className = $this->prepareClassReflectionForUsage($className);
        return isset($this->classReflectionData[$className][self::DATA_CLASS_ABSTRACT]);
    }
1145477
def _is_possible_subclass(self, subtype, supertype):
        
        subparams = getattr(subtype, "__parameters__", None)
        if subparams is None:
            return issubclass(subtype, supertype)  # a non-generic actual type
        # It is surprisingly difficult to ignore the type variables in a
        # subclass check. We therefore compare __name__ (along mro) only.
        # This can produce false positives in principle.
        # (previous "nullify __parameters__" logic deleted 2016-01-24 14:52)
        for subtype_super in subtype.mro():
            if subtype_super.__name__ == supertype.__name__:
                # squeeze your thumbs this is not just by accident
                return True  # TODO: ensure __parameters__ are compatible
        return False