Internal used! Register sub-classes of specified class when mapping class to
multiple joined tables is used. Normally this method is called by the {@link ClassDescriptor}
itself.

@param cld The {@link ClassDescriptor} of the class to register.
497712
protected void registerSuperClassMultipleJoinedTables(ClassDescriptor cld)
    {
        /*
        arminw: Sadly, we can't map to sub class-descriptor, because it's not guaranteed
        that they exist when this method is called. Thus we map the class instance instead
        of the class-descriptor.
        */
        if(cld.getBaseClass() != null)
        {
            try
            {
                Class superClass = ClassHelper.getClass(cld.getBaseClass());
                Class currentClass = cld.getClassOfObject();
                synchronized(descriptorTable)
                {
                    List subClasses = (List) superClassMultipleJoinedTablesMap.get(superClass);
                    if(subClasses == null)
                    {
                        subClasses = new ArrayList();
                        superClassMultipleJoinedTablesMap.put(superClass,  subClasses);
                    }
                    if(!subClasses.contains(currentClass))
                    {
                        if(log.isDebugEnabled())
                        {
                            log.debug("(MultipleJoinedTables): Register sub-class '" + currentClass
                                    + "' for class '" + superClass);
                        }
                        subClasses.add(currentClass);
                    }
                }
            }
            catch(Exception e)
            {
                throw new MetadataException("Can't register super class '" + cld.getBaseClass()
                        + "' for class-descriptor: " + cld, e);
            }
        }
    }
294605
def register(self, cls, instance):
        
        if not issubclass(cls, DropletInterface):
            raise TypeError('Given class is not a NAZInterface subclass: %s'
                            % cls)

        if not isinstance(instance, cls):
            raise TypeError('Given instance does not implement the class: %s'
                            % instance)

        if instance.name in self.INSTANCES_BY_NAME:
            if self.INSTANCES_BY_NAME[instance.name] != instance:
                raise ValueError('Given name is registered '
                                 'by other instance: %s' % instance.name)

        self.INSTANCES_BY_INTERFACE[cls].add(instance)
        self.INSTANCES_BY_NAME[instance.name] = instance
419548
public static void initializeClass(Class clazz) {
		try {
			Class.forName(clazz.getName(), true, Thread.currentThread().getContextClassLoader());
		}
		catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}
603859
public static Class<? extends IHelpSet> register(Class<? extends IHelpSet> clazz, String formats) {
        for (String type : formats.split("\\,")) {
            instance.map.put(type, clazz);
        }
        
        return clazz;
    }
667263
private static String firstFoundTableName(PersistenceBroker brokerForClass, ClassDescriptor cld)
    {
        String name = null;
        if (!cld.isInterface() && cld.getFullTableName() != null)
        {
            return cld.getFullTableName();
        }
        if (cld.isExtent())
        {
            Collection extentClasses = cld.getExtentClasses();
            for (Iterator iterator = extentClasses.iterator(); iterator.hasNext();)
            {
                name = firstFoundTableName(brokerForClass, brokerForClass.getClassDescriptor((Class) iterator.next()));
                // System.out.println("## " + cld.getClassNameOfObject()+" - name: "+name);
                if (name != null) break;
            }
        }
        return name;
    }
278701
public static final void registerNodeDataInstance(
			Class<? extends NodeData> clazz) {
		try {
			@SuppressWarnings("unused")
			NodeData test = clazz.newInstance();
			ndImpl = clazz;
		} catch (InstantiationException e) {
			throw new RuntimeException("NodeData implemenation ("
					+ clazz.getName() + ") doesn't provide sole constructor", e);
		} catch (IllegalAccessException e) {
			throw new RuntimeException("NodeData implementation ("
					+ clazz.getName() + ") is not accesible", e);
		}

	}
1055046
public void register(Class<? extends Controller>... controllerClasses) {
        for (Class<? extends Controller> controllerClass : controllerClasses) {
            register(controllerClass);
        }
    }
222271
private void addTableFor(ClassDescriptorDef classDef)
    {
        String                  name     = classDef.getProperty(PropertyHelper.OJB_PROPERTY_TABLE);
        TableDef                tableDef = getTable(name);
        FieldDescriptorDef      fieldDef;
        ReferenceDescriptorDef  refDef;
        CollectionDescriptorDef collDef;
        ColumnDef               columnDef;
        IndexDef                indexDef;

        if (tableDef == null)
        {
            tableDef = new TableDef(name);
            addTable(tableDef);
        }
        if (classDef.hasProperty(PropertyHelper.OJB_PROPERTY_DOCUMENTATION))
        {
            tableDef.setProperty(PropertyHelper.OJB_PROPERTY_DOCUMENTATION,
                                 classDef.getProperty(PropertyHelper.OJB_PROPERTY_DOCUMENTATION));
        }
        if (classDef.hasProperty(PropertyHelper.OJB_PROPERTY_TABLE_DOCUMENTATION))
        {
            tableDef.setProperty(PropertyHelper.OJB_PROPERTY_TABLE_DOCUMENTATION,
                                 classDef.getProperty(PropertyHelper.OJB_PROPERTY_TABLE_DOCUMENTATION));
        }
        for (Iterator fieldIt = classDef.getFields(); fieldIt.hasNext();)
        {
            fieldDef = (FieldDescriptorDef)fieldIt.next();
            if (fieldDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_IGNORE, false) ||
                fieldDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_VIRTUAL_FIELD, false))
            {
                continue;
            }
            columnDef = addColumnFor(fieldDef, tableDef);
            if (fieldDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_INDEXED, false))
            {
                // add the field to the default index
                indexDef = tableDef.getIndex(null);
                if (indexDef == null)
                {
                    indexDef = new IndexDef(null, false);
                    tableDef.addIndex(indexDef);
                }
                indexDef.addColumn(columnDef.getName());
            }
        }
        for (Iterator refIt = classDef.getReferences(); refIt.hasNext();)
        {
            refDef = (ReferenceDescriptorDef)refIt.next();
            if (!refDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_IGNORE, false))
            {
                addForeignkeys(refDef, tableDef);
            }
        }
        for (Iterator collIt = classDef.getCollections(); collIt.hasNext();)
        {
            collDef = (CollectionDescriptorDef)collIt.next();
            if (!collDef.getBooleanProperty(PropertyHelper.OJB_PROPERTY_IGNORE, false))
            {
                if (collDef.hasProperty(PropertyHelper.OJB_PROPERTY_INDIRECTION_TABLE))
                {
                    addIndirectionTable(collDef);
                }
                else
                {
                    addForeignkeys(collDef, tableDef);
                }
            }
        }
        for (Iterator indexIt = classDef.getIndexDescriptors(); indexIt.hasNext();)
        {
            addIndex((IndexDescriptorDef)indexIt.next(), tableDef);
        }
    }
510130
private static Class registerTypeMapping(WSServer server, Class clazz) {
	java.lang.reflect.Method[] methods = clazz.getMethods();
	java.lang.reflect.Method method;
	Class[] params;
	for (int i = 0; i < methods.length; i++) {
	    method = methods[i];
	    if (method.getDeclaringClass() == clazz) {
		_registerTypeMapping(server, method.getReturnType());
		params = method.getParameterTypes();
		for (int y = 0; y < params.length; y++) {
		    _registerTypeMapping(server, params[y]);
		}
	    }
	}
	return clazz;
    }
1343517
private void catalogClass(JavaClass clz) {
        transactionalMethods = new HashMap<>();
        isEntity = false;
        hasId = false;
        hasGeneratedValue = false;
        hasEagerOneToMany = false;
        hasHCEquals = false;

        for (AnnotationEntry entry : clz.getAnnotationEntries()) {
            if ("Ljavax/persistence/Entity;".equals(entry.getAnnotationType())) {
                isEntity = true;
                break;
            }
        }

        for (Method m : clz.getMethods()) {
            catalogFieldOrMethod(m);

            if (("equals".equals(m.getName()) && SignatureBuilder.SIG_OBJECT_TO_BOOLEAN.equals(m.getSignature()))
                    || (Values.HASHCODE.equals(m.getName()) && SignatureBuilder.SIG_VOID_TO_INT.equals(m.getSignature()))) {
                hasHCEquals = true;
            }
        }

        for (Field f : clz.getFields()) {
            catalogFieldOrMethod(f);
        }
    }
160280
private void addSuperClasses(Integer directSuperClass,
			ClassRecord subClassRecord) {
		if (subClassRecord.superClasses.contains(directSuperClass)) {
			return;
		}
		subClassRecord.superClasses.add(directSuperClass);
		ClassRecord superClassRecord = getClassRecord(directSuperClass);
		if (superClassRecord == null) {
			return;
		}

		for (Integer superClass : superClassRecord.directSuperClasses) {
			addSuperClasses(superClass, subClassRecord);
		}
	}
1006005
public SelectStatement getPreparedSelectStatement(Query query, ClassDescriptor cld)
    {
        SelectStatement sql = new SqlSelectStatement(m_platform, cld, query, logger);
        if (logger.isDebugEnabled())
        {
            logger.debug("SQL:" + sql.getStatement());
        }
        return sql;
    }
1358935
public void addClassToId(final Class<?> clazz, final String id) {
        Assert.notNull(clazz, "Class cannot be null");
        Assert.hasText(id, "Alias (id) cannot be null or contain only whitespaces");

        if (classToId.containsKey(clazz)) {
            throw new IllegalArgumentException("Class " + clazz + " has already defined alias (id) " + classToId.get(clazz)
                    + " cannot set another alias " + id);
        }

        if (idToClass.containsKey(id)) {
            throw new IllegalArgumentException("Alias (id) " + id + " is used by another class " + idToClass.get(id)
                    + " and cannot be used by " + clazz);
        }

        classToId.put(clazz, id);
        idToClass.put(id, clazz);
    }
985745
private static Collection getExtentClasses(ClassDescriptor cld)
    {
        /**
         * 1. check if this class has a ojbConcreteClass attribute
         */
        FieldDescriptor fd = cld.getFieldDescriptorByName(ClassDescriptor.OJB_CONCRETE_CLASS);
        Collection classes = new HashSet();  // use same class only once
        if (fd != null)
        {
            classes.add(cld.getClassOfObject().getName());
        }

        /**
         * 2. if this class has extents/is an extent search for all extents
         */
        if (cld.isExtent())
        {
            Vector extentClasses = cld.getExtentClasses();

            /**
             * 3. get all extents for this class
             */
            for (int i = 0; i < extentClasses.size(); i++)
            {
                Class ec = (Class) extentClasses.get(i);
                ClassDescriptor extCld = cld.getRepository().getDescriptorFor(ec);
                classes.addAll(getExtentClasses(extCld));
            }
        }

        return classes;
    }
438570
public static void registerXMLBindingClassForPropGetSetMethod(final Class<?> cls) {
        if (registeredXMLBindingClassList.containsKey(cls)) {
            return;
        }

        synchronized (entityDeclaredPropGetMethodPool) {
            registeredXMLBindingClassList.put(cls, false);

            if (entityDeclaredPropGetMethodPool.containsKey(cls)) {
                entityDeclaredPropGetMethodPool.remove(cls);
                entityDeclaredPropSetMethodPool.remove(cls);

                entityPropFieldPool.remove(cls);
                loadPropGetSetMethodList(cls);
            }
        }
    }
1262228
private void registerServletDescriptor(ServletDescriptor servletDescriptor) {
        try {
            servletDescriptor.register(httpService);
        } catch (RuntimeException e) {
            LOG.error(
                "Registration of ServletDescriptor under mountpoint {} fails with unexpected RuntimeException!",
                servletDescriptor.getAlias(), e);
        } catch (ServletException e) {
            LOG.error(
                "Unable to mount servlet on mount point '{}', either it was already registered under the same alias or the init method throws an exception",
                servletDescriptor.getAlias(), e);
        } catch (NamespaceException e) {
            LOG.error(
                "Unable to mount servlet on mount point '{}', another resource is already bound to this alias",
                servletDescriptor.getAlias(), e);
        }
    }
573227
public static void registerRowKeyProperty(final Class<?> cls, final String rowKeyPropertyName) {
        if (ClassUtil.getPropGetMethod(cls, rowKeyPropertyName) == null || ClassUtil.getPropSetMethod(cls, rowKeyPropertyName) == null) {
            throw new IllegalArgumentException("The specified class: " + ClassUtil.getCanonicalClassName(cls)
                    + " doesn't have getter or setter method for the specified row key propery: " + rowKeyPropertyName);
        }

        final Method setMethod = ClassUtil.getPropSetMethod(cls, rowKeyPropertyName);
        final Class<?> parameterType = setMethod.getParameterTypes()[0];
        Class<?>[] typeArgs = ClassUtil.getTypeArgumentsByMethod(setMethod);

        if (HBaseColumn.class.equals(parameterType) || (typeArgs.length == 1 && typeArgs[0].equals(HBaseColumn.class))
                || (typeArgs.length == 2 && typeArgs[1].equals(HBaseColumn.class))) {
            throw new IllegalArgumentException(
                    "Unsupported row key property type: " + setMethod.toGenericString() + ". The row key property type can't be be HBaseColumn");
        }

        classRowkeySetMethodPool.put(cls, setMethod);
    }