Set the super class.

@param iSuperClass
Super class as OClass instance
@return the object itself.
517474
public OClass setSuperClass(final OClass iSuperClass) {
    getDatabase().checkSecurity(ODatabaseSecurityResources.SCHEMA, ORole.PERMISSION_UPDATE);
    final String cmd = String.format("alter class %s superclass %s", name, iSuperClass.getName());
    getDatabase().command(new OCommandSQL(cmd)).execute();
    setSuperClassInternal(iSuperClass);
    return this;
  }
87393
public <T> T toObject(Class<T> toClass) {
		return (T) toObject(toClass, null, null);
	}
881626
def _get_class(self, superclass, namespace=None,
                   local_only=False, include_qualifiers=True,
                   include_classorigin=True):
        
        return self.GetClass(superclass,
                             namespace=namespace,
                             local_only=local_only,
                             include_qualifiers=include_qualifiers,
                             include_classorigin=include_classorigin)
910311
public static Set<Class<?>> getAllSuperTypes(final Class<?> cls) {
        final Set<Class<?>> superTypesFound = new LinkedHashSet<>();

        getAllSuperTypes(cls, superTypesFound);

        return superTypesFound;
    }
812597
public void setProxyClass(Class newProxyClass)
    {
        proxyClass = newProxyClass;
        if (proxyClass == null)
        {
            setProxyClassName(null);
        }
        else
        {
            proxyClassName = proxyClass.getName();
        }
    }
627647
def get_superclass(self, class_):
        
        if not class_.is_loaded or class_.superclass_name is None:
            return None
        return self.get_class(class_.superclass_name)
157969
public static Set<Class<?>> commonSuperclasses(Iterable<Class<?>> classes) {
        Iterator<Class<?>> it = classes.iterator();
        if (!it.hasNext()) {
            return Collections.emptySet();
        }
        // begin with set from first hierarchy
        Set<Class<?>> result = getSuperclasses(it.next());
        // remove non-superclasses of remaining
        while (it.hasNext()) {
            Class<?> c = it.next();
            Iterator<Class<?>> resultIt = result.iterator();
            while (resultIt.hasNext()) {
                Class<?> sup = resultIt.next();
                if (!sup.isAssignableFrom(c)) {
                    resultIt.remove();
                }
            }
        }
        return result;
    }
1247913
function findSuper(methodName, childObject) {
	var object = childObject;
	while (object[methodName] === childObject[methodName]) {
		object = object.constructor.__super__;

		if (!object) {
			throw new Error('Class has no super method for', methodName, '. Remove the _super call to the non-existent method');
		}
	}
	return object;
}
889742
public void setPropertiesClass(Class<?> propertiesClass) {
        Validate.notNull(propertiesClass);
        setProperty(SOABaseProperty.PROPERTIES_CLASS, propertiesClass.getName());
    }
1136958
public OSchemaHelper oClass(String className, String... superClasses)
	{
		return oClass(className, false, superClasses);
	}
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;
	}
892030
@Override
    <T> Class<T> loadClass(final Class<T> superclassOrInterfaceType) {
        final Class<?> type = getType();
        if (!superclassOrInterfaceType.isAssignableFrom(type)) {
            throw new IllegalArgumentException(
                    "Primitive class " + baseType + " cannot be cast to " + superclassOrInterfaceType.getName());
        }
        @SuppressWarnings("unchecked")
        final Class<T> classT = (Class<T>) type;
        return classT;
    }
949128
function(C, SuperC) {
		C.$super = null; // what's this?
		C.$subclasses = [];
		C.$superclass = SuperC || null;
		C.$recurring = SuperC ?
			gui.Object.copy(SuperC.$recurring) : Object.create(null);
		if (SuperC) {
			SuperC.$subclasses.push(C);
		}
		return C;
	}
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
416708
public ClassDescriptor getSuperClassDescriptor()
    {
        if (!m_superCldSet)
        {
            if(getBaseClass() != null)
            {
                m_superCld = getRepository().getDescriptorFor(getBaseClass());
                if(m_superCld.isAbstract() || m_superCld.isInterface())
                {
                    throw new MetadataException("Super class mapping only work for real class, but declared super class" +
                            " is an interface or is abstract. Declared class: " + m_superCld.getClassNameOfObject());
                }
            }
            m_superCldSet = true;
        }

        return m_superCld;
    }
427084
public NominalTypeBuilder superClass() {
    FunctionType ctor = instance.getSuperClassConstructor();
    if (ctor == null) {
      return null;
    }
    return new NominalTypeBuilder(ctor, ctor.getInstanceType());
  }
613152
private JavaClass getSuperclass(JavaClass javaClass) {
    try {
      return javaClass.getSuperClass();
    } catch (ClassNotFoundException e) {
      bugReporter.reportMissingClass(e);
      return null;
    }
  }