Java ClassDescriptor.getCollectionDescriptorByName方法代码示例

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Allows to change the <em>cascading delete</em> behavior of the specified reference
 * of the target class while this transaction is in use.
 *
 * @param target The class to change cascading delete behavior of the references.
 * @param referenceField The field name of the 1:1, 1:n or 1:n reference.
 * @param doCascade If <em>true</em> cascading delete is enabled, <em>false</em> disabled.
 */
public void setCascadingDelete(Class target, String referenceField, boolean doCascade)
{
    ClassDescriptor cld = getBroker().getClassDescriptor(target);
    ObjectReferenceDescriptor ord = cld.getObjectReferenceDescriptorByName(referenceField);
    if(ord == null)
    {
        ord = cld.getCollectionDescriptorByName(referenceField);
    }
    if(ord == null)
    {
        throw new CascadeSettingException("Invalid reference field name '" + referenceField
                + "', can't find 1:1, 1:n or m:n relation with that name in " + target);
    }
    runtimeCascadeDeleteMap.put(ord, (doCascade ? Boolean.TRUE : Boolean.FALSE));
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * create either a CollectionPrefetcher or a ReferencePrefetcher
 */ 
public RelationshipPrefetcher createRelationshipPrefetcher(ClassDescriptor anOwnerCld, String aRelationshipName)
{
    ObjectReferenceDescriptor ord;
    
    ord = anOwnerCld.getCollectionDescriptorByName(aRelationshipName);
    if (ord == null)
    {
        ord = anOwnerCld.getObjectReferenceDescriptorByName(aRelationshipName);
        if (ord == null)
        {
            throw new PersistenceBrokerException("Relationship named '" + aRelationshipName
                    + "' not found in owner class " + (anOwnerCld != null ? anOwnerCld.getClassNameOfObject() : null));
        }
    }
    return createRelationshipPrefetcher(ord);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * This method concatenate the main object and the specified reference
 * object (1:1 reference a referenced object, 1:n and m:n reference a
 * collection of referenced objects) by hand. This method is needed when
 * in the reference metadata definitions the auto-xxx setting was disabled.
 * More info see OJB doc.
 *
 * @param obj Object with reference
 * @param attributeName field name of the reference
 * @param reference The referenced object
 * @param insert flag signals insert operation
 * @return true if the specified reference was found and linking was successful
 */
public boolean link(Object obj, String attributeName, Object reference, boolean insert)
{
    ClassDescriptor cld = m_broker.getDescriptorRepository().getDescriptorFor(ProxyHelper.getRealClass(obj));
    ObjectReferenceDescriptor ord;
    boolean match = false;
    // first look for reference then for collection
    ord = cld.getObjectReferenceDescriptorByName(attributeName);
    if (ord != null)
    {
        linkOrUnlinkOneToOne(true, obj, ord, insert);
        match = true;
    }
    else
    {
        CollectionDescriptor cod = cld.getCollectionDescriptorByName(attributeName);
        if (cod != null)
        {
            linkOrUnlinkXToMany(true, obj, cod, insert);
            match = true;
        }
    }
    return match;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
private boolean linkOrUnlink(boolean doLink, Object obj, String attributeName, boolean insert)
{
    boolean match = false;
    ClassDescriptor cld = m_broker.getDescriptorRepository().getDescriptorFor(ProxyHelper.getRealClass(obj));
    ObjectReferenceDescriptor ord;

    // first look for reference then for collection
    ord = cld.getObjectReferenceDescriptorByName(attributeName);
    if (ord != null)
    {
        linkOrUnlinkOneToOne(doLink, obj, ord, insert);
        match = true;
    }
    else
    {
        CollectionDescriptor cod = cld.getCollectionDescriptorByName(attributeName);
        if (cod != null)
        {
            linkOrUnlinkXToMany(doLink, obj, cod, insert);
            match = true;
        }
    }

    return match;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
* retrieve the value of attribute[fieldNum] from the object.
* @return Object the value of attribute[fieldNum]
*/
  Object getValue(int fieldNum)
  {
      String attributeName = getAttributeName(fieldNum);
      ClassDescriptor cld = broker.getClassDescriptor(pc.getClass());
      
      // field could be a primitive typed attribute...
      AttributeDescriptorBase fld = cld.getFieldDescriptorByName(attributeName);
      // field could be a reference attribute...
      if (fld == null) 
      {
	fld = cld.getObjectReferenceDescriptorByName(attributeName);
}
// or it could be a collection attribute:
      if (fld == null) 
      {
	fld = cld.getCollectionDescriptorByName(attributeName);
}        
      Object value = fld.getPersistentField().get(pc);
      return value;
  }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public void changeReferenceSetting(PersistenceBroker broker, Class clazz,
                                           String referenceField, boolean autoRetrieve,
                                           int autoUpdate, int autoDelete, boolean useProxy)
        {
            ClassDescriptor cld = broker.getClassDescriptor(clazz);
            ObjectReferenceDescriptor ref = cld.getCollectionDescriptorByName(referenceField);
            ref = cld.getCollectionDescriptorByName(referenceField);
            if(ref == null) ref = cld.getObjectReferenceDescriptorByName(referenceField);
            if(ref == null)
            {
                throw new OJBRuntimeException("Given field " + referenceField + " does not match a reference in " + clazz);
            }

            prepareSetting(ref, cld, clazz, referenceField);

            ref.setLazy(useProxy);
            ref.setCascadeRetrieve(autoRetrieve);
            ref.setCascadingStore(autoUpdate);
            ref.setCascadingDelete(autoDelete);

//            System.out.println("old settings: " + oldRef.toXML());
//            System.out.println("new settings: " + ref.toXML());
        }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public static boolean isMappedColumn(String clazz, String fieldName, Collection<DescriptorRepository> descriptorRepositories) {
    final ClassDescriptor cd = findClassDescriptor(clazz, descriptorRepositories);
    if (cd != null) {
        return cd.getFieldDescriptorByName(fieldName) != null ||
                cd.getObjectReferenceDescriptorByName(fieldName) != null ||
                cd.getCollectionDescriptorByName(fieldName) != null;
    }
    return false;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
protected void restoreMetadataSettings(PersistenceBroker broker)
        {
            if(oldSettings.size() == 0) return;
            Iterator it = oldSettings.entrySet().iterator();
            Map.Entry entry;
            while(it.hasNext())
            {
                entry =  (Map.Entry) it.next();
                String clazz =  (String) entry.getKey();
                Map fieldMap = (Map) entry.getValue();
                Iterator iter = fieldMap.entrySet().iterator();
                Map.Entry entry2;
                ClassDescriptor cld = broker.getDescriptorRepository().getDescriptorFor(clazz);
                while(iter.hasNext())
                {
                    entry2 = (Map.Entry) iter.next();
                    String oldRefName = (String) entry2.getKey();
                    ObjectReferenceDescriptor oldRef = (ObjectReferenceDescriptor) entry2.getValue();
                    // lookup single object or collection descriptor
                    ObjectReferenceDescriptor ref = cld.getCollectionDescriptorByName(oldRefName);
                    if(ref == null) ref = cld.getObjectReferenceDescriptorByName(oldRefName);

//                    System.out.println("Restoring metadata for " + clazz
//                            + " from " + ref.toXML()
//                            + " === to ===> " + oldRef.toXML());
                    ref.setCascadeRetrieve(oldRef.getCascadeRetrieve());
                    ref.setCascadingStore(oldRef.getCascadingStore());
                    ref.setCascadingDelete(oldRef.getCascadingDelete());
                    ref.setLazy(oldRef.isLazy());
//                    System.out.println("Restore metadata for " + clazz
//                            + " to " + ref.toXML());
                }
            }
            oldSettings.clear();
        }
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public void setUp() throws Exception
{
    super.setUp();
    ClassDescriptor cld = MetadataManager.getInstance().getRepository().getDescriptorFor(ProductGroup.class);
    CollectionDescriptor cod = cld.getCollectionDescriptorByName("allArticlesInGroup");
    oldValue = cod.getCascadingStore();
    // odmg-api need false
    cod.setCascadeStore(false);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
void changeAutoSetting(Class clazz, String referenceField, boolean autoRetrieve, boolean autoUpdate, boolean autoDelete, boolean useProxy)
{
    ClassDescriptor cld = broker.getClassDescriptor(clazz);
    ObjectReferenceDescriptor ref = cld.getCollectionDescriptorByName(referenceField);
    if(ref == null) ref = cld.getObjectReferenceDescriptorByName(referenceField);
    ref.setLazy(useProxy);
    ref.setCascadeRetrieve(autoRetrieve);
    ref.setCascadeStore(autoUpdate);
    ref.setCascadeDelete(autoDelete);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
/**
 * Store m-side and intermediary
 */
public void testStoringWithAutoUpdateFalse1()
{
    ClassDescriptor cld = broker.getClassDescriptor(Paper.class);
    CollectionDescriptor cod = cld.getCollectionDescriptorByName("qualifiers");
    int autoUpdate = cod.getCascadingStore();

    cod.setCascadingStore(ObjectReferenceDescriptor.CASCADE_LINK);

    try
    {
        String now = new Date().toString();
        Paper paper = new Paper();
        paper.setAuthor("Jonny Myers");
        paper.setDate(now);
        Qualifier qual = new Topic();
        qual.setName("qual " + now);
        paper.setQualifiers(Arrays.asList(new Qualifier[] { qual }));
        broker.beginTransaction();
        // TODO: use constraint in DB and fix test
        // store paper and set indirection table, ignore new Qualifier
        // object. Will cause Key Constraint Exception when constraint are set
        broker.store(paper);
        Identity paperId = new Identity(paper, broker);
        broker.commitTransaction();

        broker.clearCache();
        broker.beginTransaction();
        Paper retPaper = (Paper) broker.getObjectByIdentity(paperId);
        assertEquals(0, retPaper.getQualifiers().size());
        broker.commitTransaction();
    }
    finally
    {
        cod.setCascadingStore(autoUpdate);
    }
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
void changeRelationMetadata(String field, boolean autoRetrieve, int autoUpdate, int autoDelete, boolean proxy)
{
    ClassDescriptor cld = broker.getClassDescriptor(Node.class);
    CollectionDescriptor cod = cld.getCollectionDescriptorByName(field);
    cod.setLazy(proxy);
    cod.setCascadeRetrieve(autoRetrieve);
    cod.setCascadingStore(autoUpdate);
    cod.setCascadingDelete(autoDelete);
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
@Override
public boolean isCollectionUpdatable(Class boClass, String collectionName) {
	ClassDescriptor cd = getClassDescriptor(boClass);
	CollectionDescriptor collDesc = cd.getCollectionDescriptorByName(collectionName);
	return collDesc.getCascadingStore() != ObjectReferenceDescriptor.CASCADE_NONE;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
@Override
public boolean hasCollection(Class boClass, String collectionName) {
	ClassDescriptor cd = getClassDescriptor(boClass);
	return cd.getCollectionDescriptorByName(collectionName) != null;
}
 

import org.apache.ojb.broker.metadata.ClassDescriptor; //导入方法依赖的package包/类
public static CollectionDescriptor findCollectionDescriptor(String clazz, String fieldName, Collection<DescriptorRepository> descriptorRepositories) {
    final ClassDescriptor cd = findClassDescriptor(clazz, descriptorRepositories);
    return cd != null ? cd.getCollectionDescriptorByName(fieldName) : null;
}