Java ClassDescriptor.isAbstract方法代码示例

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private void buildManyToManyReferences(ClassDescriptor cd, CollectionDescriptor collectionDescriptor,
                                        Object keys[], Vector columns)
 {
     if(cd.isAbstract() || cd.isInterface())
     {
logger.debug( "Skip foreign key build for MtoM, found abstract base class or interface " + cd.getClassNameOfObject() );
         return;
     }
     StringBuffer buffer = new StringBuffer(256);
     buildForeignKeyHeader(cd.getFullTableName(), buffer);

     for (int i = 0; i < keys.length; i++) {
         String columnName = (String) keys[i];

         FieldDescriptor foreignColumn = cd.getPkFields()[i];
         String foreignColumnName = foreignColumn.getPersistentField().getName();
         buildReferenceForColumn(buffer, columnName, foreignColumnName);
         FieldDescriptor fieldDescriptor = (FieldDescriptor)foreignColumn.clone();
         fieldDescriptor.setColumnName(columnName);
         columns.add(fieldDescriptor);
     }
     buffer.append("        </foreign-key>\n");

     addReferenceToTable(collectionDescriptor.getIndirectionTable(), buffer.toString());
 }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public void buildConstraintsMap() {
    Iterator classDescriptorIterators = this.repository.iterator();
    while (classDescriptorIterators.hasNext()) {
        ClassDescriptor cd = (ClassDescriptor) classDescriptorIterators.next();
        if(cd.isAbstract() || cd.isInterface())
        {
logger.debug( "Skip constraint build for abstract class/ interface " + cd.getClassNameOfObject() );
        }
        else
        {
            buildConstraints(cd);
            buildOneToOneConstraints(cd);
        }
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private void buildForeignKey(ClassDescriptor foreignClassDescriptor, Vector foreignKeyIndices, ClassDescriptor classDescriptor) {

        if(classDescriptor.isAbstract() || classDescriptor.isInterface())
        {
			logger.debug( "Skip foreign key build, found abstract base class or interface " + classDescriptor.getClassNameOfObject() );
            return;
        }
        StringBuffer buffer = new StringBuffer(256);
        buildForeignKeyHeader(foreignClassDescriptor.getFullTableName(), buffer);

        for (int i = 0; i < foreignKeyIndices.size(); i++) {
            String columnName = null;
            Object obj = foreignKeyIndices.get(i);

            if (obj instanceof Integer)
            {
                int foreignKeyIndex = ((Integer) obj).intValue();
                columnName = classDescriptor.getFieldDescriptorByIndex(foreignKeyIndex).getColumnName();
            }
            else
            {
                    FieldDescriptor fld = classDescriptor.getFieldDescriptorByName((String) obj);
                    if(fld == null)
                    {
						logger.debug( "FieldDescriptor for foreign key parameter \n" + obj + " was not found in ClassDescriptor \n" + classDescriptor );
                    }
                    else columnName = fld.getColumnName();
            }

            FieldDescriptor foreignColumn = foreignClassDescriptor.getPkFields()[i];
            String foreignColumnName = foreignColumn.getColumnName();
            buildReferenceForColumn(buffer, columnName, foreignColumnName);
        }
        buffer.append("        </foreign-key>\n");
        addReferenceToTable(classDescriptor.getFullTableName(), buffer.toString());
    }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public void buildStandardTables() {
    Iterator classDescriptorIterators = this.repository.iterator();
    while (classDescriptorIterators.hasNext()) {
        ClassDescriptor cd = (ClassDescriptor) classDescriptorIterators.next();
        if(cd.isAbstract() || cd.isInterface())
        {
            System.out.println("Skip table build for abstract base class / interface called "+cd.getClassNameOfObject());
        }
        else
        {
            buildStandardTable(cd);
        }
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
TableAlias(ClassDescriptor aCld, String anAlias, boolean lookForExtents, List hints)
     {
         this.cld = aCld;
         this.table = aCld.getFullTableName();
         this.alias = anAlias;
         boolean useHintsOnExtents = false;

         // BRJ: store alias map of in enclosing class
setTableAliasForClassDescriptor(aCld, this);

         //LEANDRO: use hints
         if (hints != null && hints.size() > 0)
         {
             useHintsOnExtents = true;
         }

         logger.debug("TableAlias(): using hints ? " + useHintsOnExtents);

         // BRJ : build alias for extents, only one per Table
         if (lookForExtents)
         {
             ClassDescriptor[] extCLDs = (ClassDescriptor[]) aCld.getRepository().getAllConcreteSubclassDescriptors(
                     aCld).toArray(new ClassDescriptor[0]);

             ClassDescriptor extCd;
             Class extClass;
             String extTable;
             Map extMap = new HashMap(); // only one Alias per Table
             int firstNonAbstractExtentIndex = 0;

             for (int i = 0; i < extCLDs.length; i++)
             {
                 extCd = extCLDs[i];
                 extClass = extCd.getClassOfObject();
                 if (useHintsOnExtents && (!hints.contains(extClass)))
                 {
                     //LEANDRO: don't include this class
                     logger.debug("Skipping class [" + extClass + "] from extents List");
                     firstNonAbstractExtentIndex++;
                     continue;
                 }
                 extTable = extCd.getFullTableName();

                 // BRJ : Use the first non abstract extent
                 // if the main cld is abstract
                 //logger.debug("cld abstract["+aCld.isAbstract()+"] i["+i+"] index ["+firtsNonAbstractExtentIndex+"]");
                 if (aCld.isAbstract() && i == firstNonAbstractExtentIndex)
                 {
                     this.cld = extCd;
                     this.table = extTable;
                 }
                 else
                 {
                     // Add a new extent entry only if the table of the extent
                     // does not match the table of the 'base' class.
                     if (extMap.get(extTable) == null && !extTable.equals(table))
                     {
                         extMap.put(extTable, new TableAlias(extCd, anAlias + "E" + i, false, hints));
                     }
                 }
             }
             extents.addAll(extMap.values());
         }

         if (cld == null)
         {
             throw new PersistenceBrokerSQLException("Table is NULL for alias: " + alias);
         }
     }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Search down all extent classes and return max of all found
 * PK values.
 */
public static long getMaxId(PersistenceBroker brokerForClass, Class topLevel, FieldDescriptor original) throws PersistenceBrokerException
{
    long max = 0;
    long tmp;
    ClassDescriptor cld = brokerForClass.getClassDescriptor(topLevel);

    // if class is not an interface / not abstract we have to search its directly mapped table
    if (!cld.isInterface() && !cld.isAbstract())
    {
        tmp = getMaxIdForClass(brokerForClass, cld, original);
        if (tmp > max)
        {
            max = tmp;
        }
    }
    // if class is an extent we have to search through its subclasses
    if (cld.isExtent())
    {
        Vector extentClasses = cld.getExtentClasses();
        for (int i = 0; i < extentClasses.size(); i++)
        {
            Class extentClass = (Class) extentClasses.get(i);
            if (cld.getClassOfObject().equals(extentClass))
            {
                throw new PersistenceBrokerException("Circular extent in " + extentClass +
                        ", please check the repository");
            }
            else
            {
                // fix by Mark Rowell
                // Call recursive
                tmp = getMaxId(brokerForClass, extentClass, original);
            }
            if (tmp > max)
            {
                max = tmp;
            }
        }
    }
    return max;
}