Hi Sahoo,
Right, and what I can see is the order of operations is different in java SE
and in verifier:
In Java SE, persistence.xml contains list of classes that is being processed.
My fix is done at that time. By the time you create EMF, all is OK.
In verifier, you start with creating EMF, which causes the processing to start.
It hits the ClassDescriptor.initialize much earlier than the previous one, and
something is not set consistently.
HTH,
-marina
Sanjeeb Kumar Sahoo wrote:
> Marina,
>
> When I run "verifier client.jar", I consistently see the exception I
> mentioned in the first email. I have not tried with your fix. In the
> mean time, in a separate email you also confirmed that even with your
> fix in place, when you run verifier, you see the exception that I see.
> You also mentioned the use of java.util.Set. That can probably change
> the order of processing of classes and cause different exceptions to be
> thrown at runtime.
>
> Over all, the issue is not totally fixed.
>
> Thanks,
> Sahoo
>
> Marina Vatkina wrote:
>
>> Tom, Sahoo,
>>
>> I can't reproduce your error message in my environment,
>> but I was getting the original exception (no @Id, etc.)
>> on the latest code (I used trunk but it completely matches
>> the fcs branch).
>>
>> Can you please check if the following change makes any
>> difference on your side:
>>
>> Index:
>> src/java/oracle/toplink/essentials/internal/ejb/cmp3/metadata/MetadataDescriptor.java
>>
>> ===================================================================
>> RCS file:
>> /cvs/glassfish/entity-persistence/src/java/oracle/toplink/essentials/internal/ejb/cmp3/metadata/MetadataDescriptor.java,v
>>
>> retrieving revision 1.12
>> diff -r1.12 MetadataDescriptor.java
>> 987c987
>> < if (hasInheritanceTag(parent) ||
>> m_metadataDescriptors.containsKey(parent)) {
>> ---
>>
>>
>>> if (hasInheritanceTag(parent) ||
>>>
>>
>> m_metadataDescriptors.containsKey(parent) || hasEntityTag(parent)) {
>>
>> I attach the modified file here.
>>
>> thanks,
>> -marina
>>
>>
>> Tom Ware wrote On 04/05/06 06:14,:
>>
>>
>>> Sahoo,
>>>
>>> Thank you for pointing out this issue. We will investigate.
>>>
>>> -Tom
>>>
>>> Marina Vatkina wrote:
>>>
>>>
>>>
>>>
>>>> CC-ing Jerome and Shelly.
>>>>
>>>> -marina
>>>>
>>>> Sanjeeb Kumar Sahoo wrote:
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>> Hi Tom,
>>>>>
>>>>> I tried running the test case for issue #486 on my latest workspace
>>>>> and got following result:
>>>>>
>>>>> Exception [TOPLINK-0] (Oracle TopLink Essentials - 2006.4 (Build
>>>>> 060404)): oracle.toplink.essentials.exceptions.IntegrityException
>>>>> Descriptor Exceptions:
>>>>> ---------------------------------------------------------
>>>>>
>>>>> Exception [TOPLINK-8] (Oracle TopLink Essentials - 2006.4 (Build
>>>>> 060404)): oracle.toplink.essentials.exceptions.DescriptorException
>>>>> Exception Description: The descriptor [RelationalDescriptor(pkg.A
>>>>> --> [DatabaseTable(A)])] has been set to use inheritance, but a
>>>>> class indicator field has not been defined.
>>>>> When using inheritance, a class indicator field or class extraction
>>>>> method must be set.
>>>>> Parent Descriptor: [RelationalDescriptor(pkg.A -->
>>>>> [DatabaseTable(A)])]
>>>>> Descriptor: RelationalDescriptor(pkg.A --> [DatabaseTable(A)])
>>>>>
>>>>> Exception [TOPLINK-8] (Oracle TopLink Essentials - 2006.4 (Build
>>>>> 060404)): oracle.toplink.essentials.exceptions.DescriptorException
>>>>> Exception Description: The descriptor [RelationalDescriptor(pkg.B
>>>>> --> [DatabaseTable(A), DatabaseTable(B)])] has been set to use
>>>>> inheritance, but a class indicator field has not been defined.
>>>>> When using inheritance, a class indicator field or class extraction
>>>>> method must be set.
>>>>> Parent Descriptor: [RelationalDescriptor(pkg.A -->
>>>>> [DatabaseTable(A)])]
>>>>> Descriptor: RelationalDescriptor(pkg.B --> [DatabaseTable(A),
>>>>> DatabaseTable(B)])
>>>>>
>>>>> When I added @Inheritance to pkg.A.class, the errors vanished. I am
>>>>> using the latest workspace. I saw the issue both in the trunk as
>>>>> well as in the 90 branch.
>>>>>
>>>>> Thanks,
>>>>> Sahoo
>>>>>
>>>>> Tom Ware wrote:
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>> Checked into entity-persistence on FCS branch on on Trunk
>>>>>>
>>>>>> Issue number: 486
>>>>>> Obtained from: TopLink
>>>>>> Submitted by: Tom Ware
>>>>>> Reviewed by: TopLink Team
>>>>>>
>>>>>> Fix for GlassFish issue 486
>>>>>>
>>>>>> Tested with QuickLook, entity-persistence tests and
>>>>>> Oracle-internal tests
>>>>>>
>>>>>>
>>>>>> ------------------------------------------------------------------------
>>>>>>
>>>>>>
>>>>>> /*
>>>>>> * The contents of this file are subject to the terms * of the
>>>>>> Common Development and Distribution License * (the "License").
>>>>>> You may not use this file except * in compliance with the License.
>>>>>> * * You can obtain a copy of the license at *
>>>>>> glassfish/bootstrap/legal/CDDLv1.0.txt or *
>>>>>> https://glassfish.dev.java.net/public/CDDLv1.0.html. * See the
>>>>>> License for the specific language governing * permissions and
>>>>>> limitations under the License.
>>>>>> * * When distributing Covered Code, include this CDDL * HEADER
>>>>>> in each file and include the License file at *
>>>>>> glassfish/bootstrap/legal/CDDLv1.0.txt. If applicable, * add the
>>>>>> following below this CDDL HEADER, with the * fields enclosed by
>>>>>> brackets "[]" replaced with your * own identifying information:
>>>>>> Portions Copyright [yyyy] * [name of copyright owner]
>>>>>> */
>>>>>> // Copyright (c) 1998, 2006, Oracle. All rights reserved. package
>>>>>> oracle.toplink.essentials.internal.ejb.cmp3.metadata;
>>>>>>
>>>>>> import java.util.Map;
>>>>>> import java.util.List;
>>>>>> import java.util.Vector;
>>>>>> import java.util.HashMap;
>>>>>> import java.util.Iterator;
>>>>>> import java.util.ArrayList;
>>>>>> import java.util.Collection;
>>>>>>
>>>>>> import oracle.toplink.essentials.mappings.DatabaseMapping;
>>>>>>
>>>>>> import oracle.toplink.essentials.exceptions.ValidationException;
>>>>>>
>>>>>> import oracle.toplink.essentials.descriptors.ClassDescriptor;
>>>>>> import oracle.toplink.essentials.descriptors.VersionLockingPolicy;
>>>>>> import oracle.toplink.essentials.descriptors.RelationalDescriptor;
>>>>>>
>>>>>> import oracle.toplink.essentials.internal.helper.DatabaseField;
>>>>>> import oracle.toplink.essentials.internal.helper.DatabaseTable;
>>>>>> import oracle.toplink.essentials.internal.ejb.cmp3.base.CMP3Policy;
>>>>>>
>>>>>> /**
>>>>>> * Common metatata descriptor for the annotation and xml processors.
>>>>>> * * @author Guy Pelletier, Dave McCann
>>>>>> * @since TopLink EJB 3.0 Reference Implementation
>>>>>> */
>>>>>> public abstract class MetadataDescriptor {
>>>>>> protected ClassDescriptor m_descriptor;
>>>>>> protected Class m_javaClass;
>>>>>> protected Class m_inheritanceRootClass;
>>>>>> protected MetadataDescriptor m_inheritanceRootDmd;
>>>>>> protected boolean m_isInheritanceRoot;
>>>>>> protected boolean m_ignoreIDAnnotations;
>>>>>> protected boolean m_ignoreTableAnnotations;
>>>>>> protected boolean m_ignoreInheritanceAnnotations;
>>>>>> protected boolean m_usesSingleTableInheritanceStrategy;
>>>>>> protected String m_primaryTableName;
>>>>>> protected String m_embeddedIdAttributeName;
>>>>>> protected Map m_accessors;
>>>>>> protected Map m_pkClassIDs;
>>>>>> protected Map m_setMethodNames;
>>>>>> protected Map m_attributeOverrides;
>>>>>> protected Map m_associationOverrides;
>>>>>> protected Map m_manyToManyAccessors;
>>>>>> protected Map m_relationshipAccessors; protected
>>>>>> List m_idAttributeNames;
>>>>>> protected List m_idOrderByAttributeNames;
>>>>>> protected List m_mappedSuperclasses;
>>>>>> protected List m_aggregateDmds;
>>>>>> protected List m_orderByAttributeNames;
>>>>>> /********************* Values set during XML processing
>>>>>> *********************/
>>>>>> // Used to determine if access type was specified for this
>>>>>> entity/descriptor.
>>>>>> protected Boolean m_isXmlPropertyAccess;
>>>>>> // Used to determine if cascade-persist was specified for this
>>>>>> entity/descriptor.
>>>>>> protected Boolean m_isCascadePersistSet;
>>>>>> // By default we don't exclude default listeners unless
>>>>>> explicitly set.
>>>>>> protected boolean m_xmlExcludeDefaultListeners;
>>>>>> // By default we don't exclude superclass listeners unless
>>>>>> explicitely set.
>>>>>> protected boolean m_xmlExcludeSuperclassListeners;
>>>>>> // True is meta-data complete is specified. Ignore annotations
>>>>>> except for defaults.
>>>>>> protected boolean m_ignoreAnnotations;
>>>>>> // Only to be used if the entity is defined in XML and not
>>>>>> annotated.
>>>>>> protected String m_xmlCatalog;
>>>>>> // Only to be used if the entity is defined in XML and not
>>>>>> annotated.
>>>>>> protected String m_xmlSchema;
>>>>>> // List of default listeners to apply to this entity/descriptor
>>>>>> protected List m_defaultListeners;
>>>>>> // Indicates no id element was defined in XML, so the default
>>>>>> (TOPLINKDEFAULTID) was used.
>>>>>> protected boolean m_isDefaultPrimaryKeySet;
>>>>>> // Indicates no table element was defined in XML, so the
>>>>>> default was used.
>>>>>> protected boolean m_isDefaultPrimaryTableSet;
>>>>>> // List of fields which have the default table name set.
>>>>>> protected List m_fieldsWithDefaultPrimaryKeySet;
>>>>>> // List of fields with name in the format, entity/attribute
>>>>>> name + "_" + TOPLINKDEFAULTID
>>>>>> protected List m_fieldsWithComplexDefaultPrimaryKeySet;
>>>>>> // List of fields with name = TOPLINKDEFAULTID
>>>>>> protected List m_fieldsWithDefaultPrimaryTableSet;
>>>>>> /**
>>>>>> * INTERNAL: */
>>>>>> public MetadataDescriptor(Class javaClass) {
>>>>>> init();
>>>>>> m_descriptor = new RelationalDescriptor();
>>>>>> m_descriptor.setExistenceChecking("Check database");
>>>>>> // In case of alias==null, TopLink populates it with short
>>>>>> class name // in desc.getAlias(), which causes descriptor
>>>>>> being added with this // alias to the project
>>>>>> (addDescriptor method) before we have a chance // to set
>>>>>> the desired alias. Setting "" stops default alias generation.
>>>>>> // WIP - fix this code.
>>>>>> m_descriptor.setAlias("");
>>>>>> setJavaClass(javaClass);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Constructor used for wrapping an existing descriptor which
>>>>>> was presumably * loaded from the project xml.
>>>>>> */
>>>>>> public MetadataDescriptor(ClassDescriptor descriptor, Class
>>>>>> javaClass) {
>>>>>> init();
>>>>>> m_descriptor = descriptor;
>>>>>> setJavaClass(javaClass);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Copy constructor. Used for creation of annotations meta
>>>>>> data out of xml * meta data. All the attributes should be
>>>>>> processed.
>>>>>> */
>>>>>> public MetadataDescriptor(MetadataDescriptor md) {
>>>>>> m_descriptor = md.m_descriptor;
>>>>>> m_javaClass = md.m_javaClass;
>>>>>> m_inheritanceRootClass = null;
>>>>>> m_inheritanceRootDmd = null;
>>>>>> m_isInheritanceRoot = md.m_isInheritanceRoot;
>>>>>> m_ignoreIDAnnotations = md.m_ignoreIDAnnotations;
>>>>>> m_ignoreTableAnnotations = md.m_ignoreIDAnnotations;
>>>>>> m_ignoreInheritanceAnnotations =
>>>>>> md.m_ignoreInheritanceAnnotations;
>>>>>> m_usesSingleTableInheritanceStrategy =
>>>>>> md.m_usesSingleTableInheritanceStrategy;
>>>>>>
>>>>>> m_primaryTableName = md.m_primaryTableName;
>>>>>> m_embeddedIdAttributeName = md.m_embeddedIdAttributeName;
>>>>>> m_pkClassIDs = md.m_pkClassIDs;
>>>>>> m_setMethodNames = md.m_setMethodNames;
>>>>>> m_attributeOverrides = md.m_attributeOverrides;
>>>>>> m_associationOverrides = md.m_associationOverrides;
>>>>>> m_accessors = md.m_accessors;
>>>>>> m_manyToManyAccessors = md.m_manyToManyAccessors;
>>>>>> m_relationshipAccessors = md.m_relationshipAccessors;
>>>>>> m_idAttributeNames = md.m_idAttributeNames;
>>>>>> m_idOrderByAttributeNames = md.m_idOrderByAttributeNames;
>>>>>> m_mappedSuperclasses = md.m_mappedSuperclasses;
>>>>>> m_aggregateDmds = md.m_aggregateDmds;
>>>>>> m_orderByAttributeNames = md.m_orderByAttributeNames;
>>>>>> m_isCascadePersistSet = md.m_isCascadePersistSet;
>>>>>> m_xmlExcludeDefaultListeners =
>>>>>> md.m_xmlExcludeDefaultListeners;
>>>>>> m_xmlExcludeSuperclassListeners =
>>>>>> md.m_xmlExcludeSuperclassListeners;
>>>>>> m_ignoreAnnotations = md.m_ignoreAnnotations;
>>>>>> m_defaultListeners = md.m_defaultListeners;
>>>>>> m_xmlCatalog = md.m_xmlCatalog;
>>>>>> m_xmlSchema = md.m_xmlSchema;
>>>>>> m_isDefaultPrimaryKeySet =
>>>>>> md.m_isDefaultPrimaryKeySet;
>>>>>> m_isDefaultPrimaryTableSet = md.m_isDefaultPrimaryTableSet;
>>>>>> m_fieldsWithDefaultPrimaryKeySet =
>>>>>> md.m_fieldsWithDefaultPrimaryKeySet;
>>>>>> m_fieldsWithComplexDefaultPrimaryKeySet =
>>>>>> md.m_fieldsWithComplexDefaultPrimaryKeySet;
>>>>>> m_fieldsWithDefaultPrimaryTableSet =
>>>>>> md.m_fieldsWithDefaultPrimaryTableSet;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addAccessor(MetadataAccessor accessor) {
>>>>>> m_accessors.put(accessor.getAttributeName(), accessor);
>>>>>> if (accessor.isRelationship()) {
>>>>>>
>>>>>> m_relationshipAccessors.put(accessor.getAttributeName(), accessor);
>>>>>> }
>>>>>> // Store ManyToMany relationships so that we may
>>>>>> look at attribute
>>>>>> // names when defaulting join columns for bi and uni
>>>>>> directional M-M's.
>>>>>> if (accessor.isManyToMany()) {
>>>>>>
>>>>>> m_manyToManyAccessors.put(accessor.getReferenceClass(),
>>>>>> accessor); }
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addAggregateDmd(MetadataDescriptor aggregateDmd) {
>>>>>> m_aggregateDmds.add(aggregateDmd);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addAssociationOverride(String attributeName,
>>>>>> Object[] joinColumns) {
>>>>>> m_associationOverrides.put(attributeName, joinColumns);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addAttributeOverride(String attributeName,
>>>>>> DatabaseField field) {
>>>>>> m_attributeOverrides.put(attributeName, field);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addClassIndicator(Class entityClass, String value) {
>>>>>> if (isInheritanceSubclass()) {
>>>>>> getInheritanceRootDmd().addClassIndicator(entityClass,
>>>>>> value); } else {
>>>>>>
>>>>>> m_descriptor.getInheritancePolicy().addClassNameIndicator(entityClass.getName(),
>>>>>> value);
>>>>>> }
>>>>>> }
>>>>>> /** * INTERNAL:
>>>>>> */
>>>>>> public void addDefaultEventListener(MetadataEntityListener
>>>>>> listener) {
>>>>>>
>>>>>> m_descriptor.getEventManager().addDefaultEventListener(listener);
>>>>>> }
>>>>>> /** * INTERNAL:
>>>>>> */
>>>>>> public void addEntityEventListener(MetadataEntityListener
>>>>>> listener) {
>>>>>>
>>>>>> m_descriptor.getEventManager().setEntityEventListener(listener);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void
>>>>>> addEntityListenerEventListener(MetadataEntityListener listener) {
>>>>>>
>>>>>> m_descriptor.getEventManager().addEntityListenerEventListener(listener);
>>>>>>
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addIdAttributeName(String idAttributeName) {
>>>>>> m_idAttributeNames.add(idAttributeName); }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addListener(MetadataEntityListener listener) {
>>>>>> m_descriptor.getEventManager().addListener(listener);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addMapping(DatabaseMapping mapping) {
>>>>>> m_descriptor.addMapping(mapping);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addMultipleTableForeignKeyField(DatabaseField
>>>>>> pkField, DatabaseField fkField) {
>>>>>> m_descriptor.addMultipleTableForeignKeyField(pkField,
>>>>>> fkField);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addMultipleTablePrimaryKeyField(DatabaseField
>>>>>> pkField, DatabaseField fkField) {
>>>>>> m_descriptor.addMultipleTablePrimaryKeyField(pkField,
>>>>>> fkField);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * We store these to validate the primary class when processing
>>>>>> * the entity class.
>>>>>> */
>>>>>> public void addPKClassId(String attributeName, Class type) {
>>>>>> m_pkClassIDs.put(attributeName, type);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addPrimaryKeyField(DatabaseField field) {
>>>>>> m_descriptor.addPrimaryKeyField(field);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addSetMethodName(String getMethodName, String
>>>>>> setMethodName) {
>>>>>> m_setMethodNames.put(getMethodName, setMethodName);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void addTable(DatabaseTable table) {
>>>>>> m_descriptor.addTable(table);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean excludeSuperclassListeners() {
>>>>>> return
>>>>>> m_descriptor.getEventManager().excludeSuperclassListeners();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public MetadataAccessor getAccessorFor(String
>>>>>> fieldOrPropertyName) {
>>>>>> MetadataAccessor accessor = (MetadataAccessor)
>>>>>> m_accessors.get(fieldOrPropertyName);
>>>>>> if (accessor == null) {
>>>>>> return (MetadataAccessor)
>>>>>> m_accessors.get(MetadataHelper.getAttributeNameFromMethodName(fieldOrPropertyName));
>>>>>>
>>>>>> }
>>>>>> return accessor;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public String getAlias() {
>>>>>> return m_descriptor.getAlias();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public Object[] getAssociationOverrideFor(MetadataAccessor
>>>>>> accessor) {
>>>>>> return (Object[])
>>>>>> m_associationOverrides.get(accessor.getAttributeName());
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public DatabaseField getAttributeOverrideFor(MetadataAccessor
>>>>>> accessor) {
>>>>>> return getAttributeOverrideFor(accessor.getAttributeName());
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public DatabaseField getAttributeOverrideFor(String
>>>>>> attributeName) {
>>>>>> return (DatabaseField)
>>>>>> m_attributeOverrides.get(attributeName);
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public DatabaseField getClassIndicatorField() {
>>>>>> if (getInheritanceRootDmd() != null) {
>>>>>> return
>>>>>> getInheritanceRootDmd().getDescriptor().getInheritancePolicy().getClassIndicatorField();
>>>>>>
>>>>>> } else {
>>>>>> if (getDescriptor().hasInheritance()) {
>>>>>> return
>>>>>> getDescriptor().getInheritancePolicy().getClassIndicatorField();
>>>>>> } else {
>>>>>> return null;
>>>>>> }
>>>>>> }
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * A list of default listeners to be applied to this entity if
>>>>>> * shouldExcludeDefaultListeners() is false. The listeners
>>>>>> are of type * MetadataDefaultListener. The
>>>>>> initializeCallbackMethods(ClassLoader) * method must be
>>>>>> called on each listener before adding them to the event *
>>>>>> manager.
>>>>>> */
>>>>>> public List getDefaultListeners() {
>>>>>> if (m_defaultListeners == null) {
>>>>>> m_defaultListeners = new ArrayList();
>>>>>> }
>>>>>> return m_defaultListeners;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * The default table name is the descriptor alias, unless this
>>>>>> descriptor * metadata is an inheritance subclass with a
>>>>>> SINGLE_TABLE strategy. Then * it is the table name of the
>>>>>> root descriptor metadata.
>>>>>> */
>>>>>> public String getDefaultTableName() {
>>>>>> String defaultTableName = getAlias().toUpperCase();
>>>>>> if (isInheritanceSubclass()) { if
>>>>>> (m_inheritanceRootDmd.usesSingleTableInheritanceStrategy()) {
>>>>>> defaultTableName =
>>>>>> m_inheritanceRootDmd.getPrimaryTableName();
>>>>>> }
>>>>>> }
>>>>>> return defaultTableName;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public ClassDescriptor getDescriptor() {
>>>>>> return m_descriptor;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * The value for m_catalog will be one of:
>>>>>> * - persistence unit default
>>>>>> * - entity-mappings default
>>>>>> * - empty string
>>>>>> */
>>>>>> public String getCatalog() {
>>>>>> return m_xmlCatalog;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public String getEmbeddedIdAttributeName() {
>>>>>> return m_embeddedIdAttributeName;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public List getFieldsWithComplexDefaultPrimaryKeySet() {
>>>>>> if (m_fieldsWithComplexDefaultPrimaryKeySet == null) {
>>>>>> m_fieldsWithComplexDefaultPrimaryKeySet = new
>>>>>> ArrayList();
>>>>>> }
>>>>>> return m_fieldsWithComplexDefaultPrimaryKeySet;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public List getFieldsWithDefaultPrimaryKeySet() {
>>>>>> if (m_fieldsWithDefaultPrimaryKeySet == null) {
>>>>>> m_fieldsWithDefaultPrimaryKeySet = new ArrayList();
>>>>>> }
>>>>>> return m_fieldsWithDefaultPrimaryKeySet;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public List getFieldsWithDefaultPrimaryTableSet() {
>>>>>> if (m_fieldsWithDefaultPrimaryTableSet == null) {
>>>>>> m_fieldsWithDefaultPrimaryTableSet = new ArrayList();
>>>>>> }
>>>>>> return m_fieldsWithDefaultPrimaryTableSet;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Return the primary key attribute name for this entity.
>>>>>> */
>>>>>> public String getIdAttributeName() {
>>>>>> if (getIdAttributeNames().isEmpty()) {
>>>>>> if (isInheritanceSubclass()) {
>>>>>> return getInheritanceRootDmd().getIdAttributeName();
>>>>>> } else {
>>>>>> return "";
>>>>>> }
>>>>>> } else {
>>>>>> return (String) getIdAttributeNames().get(0);
>>>>>> }
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Return the id attribute names declared on this descriptor
>>>>>> metadata.
>>>>>> */
>>>>>> public List getIdAttributeNames() {
>>>>>> return m_idAttributeNames;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Return the primary key attribute names for this entity. If
>>>>>> there are no
>>>>>> * id attribute names set then we are either:
>>>>>> * 1) an inheritance subclass, get the id attribute names from
>>>>>> the root
>>>>>> * of the inheritance structure.
>>>>>> * 2) we have an embedded id. Get the id attribute names from
>>>>>> the embedded
>>>>>> * descriptor metadata, which is equal the attribute names
>>>>>> of all the
>>>>>> * direct to field mappings on that descriptor metadata.
>>>>>> Currently does
>>>>>> * not traverse nested embeddables.
>>>>>> */
>>>>>> public List getIdOrderByAttributeNames() {
>>>>>> if (m_idOrderByAttributeNames.isEmpty()) {
>>>>>> if (m_idAttributeNames.isEmpty()) {
>>>>>> if (isInheritanceSubclass()) {
>>>>>> // Get the id attribute names from our root
>>>>>> parent.
>>>>>> m_idOrderByAttributeNames =
>>>>>> m_inheritanceRootDmd.getIdAttributeNames();
>>>>>> } else {
>>>>>> // We must have a composite primary key as a
>>>>>> result of an embedded id.
>>>>>> m_idOrderByAttributeNames =
>>>>>> getAccessorFor(getEmbeddedIdAttributeName()).getReferenceMetadataDescriptor().getOrderByAttributeNames();
>>>>>>
>>>>>> } } else {
>>>>>> m_idOrderByAttributeNames = m_idAttributeNames;
>>>>>> }
>>>>>> }
>>>>>> return m_idOrderByAttributeNames;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public MetadataAccessor getManyToManyAccessor(Class cls) {
>>>>>> return (MetadataAccessor) m_manyToManyAccessors.get(cls);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * This will return the attribute names for all the direct to
>>>>>> field mappings * on this descriptor metadata. This method
>>>>>> will typically be called when an * @Embedded or @EmbeddedId
>>>>>> attribute has been specified in an @OrderBy.
>>>>>> */
>>>>>> public List getOrderByAttributeNames() {
>>>>>> if (m_orderByAttributeNames.isEmpty()) {
>>>>>> for (Iterator mapIt = getMappings().iterator();
>>>>>> mapIt.hasNext(); ) {
>>>>>> DatabaseMapping mapping = (DatabaseMapping)
>>>>>> mapIt.next();
>>>>>> if (mapping.isDirectToFieldMapping()) {
>>>>>>
>>>>>> m_orderByAttributeNames.add(mapping.getAttributeName());
>>>>>> }
>>>>>> }
>>>>>> }
>>>>>> return m_orderByAttributeNames;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * This method assumes that isInheritanceSubclass(HashMap) has
>>>>>> already been * called to determine the inheritance root
>>>>>> class. It returns the root * parent class in an inheritance
>>>>>> hierarchy, null otherwise.
>>>>>> */
>>>>>> public Class getInheritanceRootClass() {
>>>>>> return m_inheritanceRootClass;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL: * Store the descriptor metadata for the root
>>>>>> of our inheritance hierarchy.
>>>>>> */
>>>>>> public MetadataDescriptor getInheritanceRootDmd() {
>>>>>> return m_inheritanceRootDmd;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public Class getJavaClass() {
>>>>>> return m_javaClass;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public DatabaseMapping getMappingForAttributeName(String
>>>>>> attributeName) {
>>>>>> MetadataAccessor accessor = (MetadataAccessor)
>>>>>> getAccessorFor(attributeName);
>>>>>> if (accessor != null) {
>>>>>> // If the accessor is a relationship accessor than it
>>>>>> may or may
>>>>>> // not have been processed yet. Fast track its
>>>>>> processing if it
>>>>>> // needs to be. The process call will do nothing if it
>>>>>> has already
>>>>>> // been processed.
>>>>>> if (accessor.isRelationship()) {
>>>>>> accessor.process();
>>>>>> }
>>>>>> return
>>>>>> m_descriptor.getMappingForAttributeName(attributeName);
>>>>>> }
>>>>>> // We didn't find a mapping on this descriptor,
>>>>>> check our aggregate // descriptors now.
>>>>>> for (Iterator mapIt = m_aggregateDmds.iterator();
>>>>>> mapIt.hasNext(); ) {
>>>>>> MetadataDescriptor aggregateDmd = (MetadataDescriptor)
>>>>>> mapIt.next();
>>>>>> DatabaseMapping mapping =
>>>>>> aggregateDmd.getMappingForAttributeName(attributeName);
>>>>>> if (mapping != null) {
>>>>>> return mapping;
>>>>>> }
>>>>>> }
>>>>>> // We didn't find a mapping on the aggregate
>>>>>> descriptors. If we are an
>>>>>> // inheritance subclass, check for a mapping on the
>>>>>> inheritance root
>>>>>> // descriptor metadata.
>>>>>> if (isInheritanceSubclass()) {
>>>>>> return
>>>>>> getInheritanceRootDmd().getMappingForAttributeName(attributeName);
>>>>>> }
>>>>>> // Found nothing ... return null.
>>>>>> return null;
>>>>>> } /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public List getMappings() {
>>>>>> return m_descriptor.getMappings();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public String getPKClassName() {
>>>>>> String pkClassName = null;
>>>>>> if (m_descriptor.hasCMPPolicy()) {
>>>>>> pkClassName = ((CMP3Policy)
>>>>>> m_descriptor.getCMPPolicy()).getPKClassName(); }
>>>>>> return pkClassName;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Method to return the primary key field for the given
>>>>>> descriptor
>>>>>> * metadata. Assumes there is one and only one.
>>>>>> */
>>>>>> public String getPrimaryKeyFieldName() {
>>>>>> // This must be here for an override feature otherwise it
>>>>>> shouldn't be
>>>>>> // necessary. WIP - investigate.
>>>>>> if (getPrimaryKeyFields() == null ||
>>>>>> !(getPrimaryKeyFields().iterator().hasNext())) {
>>>>>> return "";
>>>>>> }
>>>>>> return
>>>>>> ((DatabaseField)(getPrimaryKeyFields().iterator().next())).getName();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Return the primary key fields for this descriptor metadata.
>>>>>> If this is
>>>>>> * an inheritance subclass and it has no primary key fields,
>>>>>> then grab the * primary key fields from the root.
>>>>>> */
>>>>>> public List getPrimaryKeyFields() {
>>>>>> List primaryKeyFields = m_descriptor.getPrimaryKeyFields();
>>>>>> if (primaryKeyFields.isEmpty() &&
>>>>>> isInheritanceSubclass()) {
>>>>>> primaryKeyFields =
>>>>>> getInheritanceRootDmd().getPrimaryKeyFields();
>>>>>> }
>>>>>> return primaryKeyFields;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public String getPrimaryTableName() {
>>>>>> // Assumes tables have been specified via XML and that the
>>>>>> first
>>>>>> // table is the primary table.
>>>>>> Vector tables = m_descriptor.getTables();
>>>>>> if (m_primaryTableName == null &&
>>>>>> !tables.isEmpty()) {
>>>>>> m_primaryTableName = ((DatabaseTable)
>>>>>> tables.firstElement()).getQualifiedName();
>>>>>> } else if (m_primaryTableName == null && tables.isEmpty()) {
>>>>>> m_primaryTableName = "";
>>>>>> }
>>>>>> return m_primaryTableName;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public Collection getRelationshipAccessors() {
>>>>>> return m_relationshipAccessors.values();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * The value for m_schema will be one of:
>>>>>> * - persistence unit default
>>>>>> * - entity-mappings default
>>>>>> * - empty string
>>>>>> */
>>>>>> public String getSchema() {
>>>>>> return m_xmlSchema;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public String getSetMethodName(String getMethodName) {
>>>>>> return (String) m_setMethodNames.get(getMethodName);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public abstract void
>>>>>> handlePotentialDefaultTableUsage(DatabaseField dbField);
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasAssociationOverrideFor(MetadataAccessor
>>>>>> accessor) {
>>>>>> return
>>>>>> m_associationOverrides.containsKey(accessor.getAttributeName());
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasAttributeOverrideFor(MetadataAccessor
>>>>>> accessor) {
>>>>>> return hasAttributeOverrideFor(accessor.getAttributeName());
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasAttributeOverrideFor(String attributeName) {
>>>>>> return m_attributeOverrides.containsKey(attributeName);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasCompositePrimaryKey() {
>>>>>> return getPrimaryKeyFields().size() > 1 ||
>>>>>> getPKClassName() != null;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasEmbeddedIdAttribute() {
>>>>>> return m_embeddedIdAttributeName != null;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasEntityEventListener() {
>>>>>> return
>>>>>> m_descriptor.getEventManager().hasEntityEventListener();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasEntityListenerEventListeners() {
>>>>>> return
>>>>>> m_descriptor.getEventManager().hasEntityListenerEventListeners();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> protected abstract boolean hasEntityTag(Class cls);
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> protected abstract boolean hasInheritanceTag(Class entityClass);
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasManyToManyAccessorFor(Class cls) {
>>>>>> return m_manyToManyAccessors.containsKey(cls);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> protected abstract boolean hasMappedSuperclassTag(Class cls);
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasMappingForAccessor(MetadataAccessor accessor) {
>>>>>> return
>>>>>> hasMappingForAttributeName(accessor.getAttributeName());
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean hasMappingForAttributeName(String attributeName) {
>>>>>> return
>>>>>> m_descriptor.getMappingForAttributeName(attributeName) != null;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Returns a list of mapped superclasses for this metadata
>>>>>> descriptor.
>>>>>> */
>>>>>> public List getMappedSuperclasses() {
>>>>>> if (m_mappedSuperclasses == null) {
>>>>>> m_mappedSuperclasses = new ArrayList();
>>>>>> Class parent = m_javaClass.getSuperclass();
>>>>>> while (parent != Object.class) {
>>>>>> if (hasMappedSuperclassTag(parent)) {
>>>>>> m_mappedSuperclasses.add(parent);
>>>>>> }
>>>>>> parent = parent.getSuperclass();
>>>>>> }
>>>>>> }
>>>>>> return (ArrayList) m_mappedSuperclasses;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Return true is the descriptor has primary key fields set.
>>>>>> */
>>>>>> public boolean hasPrimaryKeyFields() {
>>>>>> return m_descriptor.getPrimaryKeyFields().size() > 0;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public abstract boolean hasPrimaryKeyJoinColumns();
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean ignoreIDAnnotations() {
>>>>>> return m_ignoreIDAnnotations; }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean ignoreInheritanceAnnotations() {
>>>>>> return m_ignoreInheritanceAnnotations; }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean ignoreTableAnnotations() {
>>>>>> return m_ignoreTableAnnotations; }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> private void init() {
>>>>>> m_isInheritanceRoot = false;
>>>>>> m_ignoreIDAnnotations = false;
>>>>>> m_ignoreTableAnnotations = false;
>>>>>> m_ignoreInheritanceAnnotations = false;
>>>>>> m_pkClassIDs = new HashMap();
>>>>>> m_accessors = new HashMap();
>>>>>> m_setMethodNames = new HashMap();
>>>>>>
>>>>>> m_idAttributeNames = new ArrayList();
>>>>>> m_orderByAttributeNames = new ArrayList();
>>>>>> m_idOrderByAttributeNames = new ArrayList();
>>>>>> m_aggregateDmds = new ArrayList();
>>>>>> m_attributeOverrides = new HashMap();
>>>>>> m_associationOverrides = new HashMap();
>>>>>> m_manyToManyAccessors = new HashMap();
>>>>>> m_relationshipAccessors = new HashMap();
>>>>>> // initialize values set during XML processing
>>>>>> m_isXmlPropertyAccess = null;
>>>>>> m_isCascadePersistSet = null;
>>>>>> m_xmlExcludeDefaultListeners = false;
>>>>>> m_xmlExcludeSuperclassListeners = false;
>>>>>> m_ignoreAnnotations = false;
>>>>>> m_xmlCatalog = "";
>>>>>> m_xmlSchema = "";
>>>>>> m_isDefaultPrimaryKeySet = false;
>>>>>> m_isDefaultPrimaryTableSet = false;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * If "set", indicates that cascade-persist should be applied
>>>>>> to all * relationship mappings for this entity.
>>>>>> */
>>>>>> public boolean isAggregate() {
>>>>>> return m_descriptor.isAggregateDescriptor();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * If "set", indicates that cascade-persist should be applied
>>>>>> to all * relationship mappings for this entity.
>>>>>> */
>>>>>> public Boolean isCascadePersistSet() {
>>>>>> return m_isCascadePersistSet != null;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean isDefaultPrimaryKeySet() {
>>>>>> return m_isDefaultPrimaryKeySet;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean isDefaultPrimaryTableSet() {
>>>>>> return m_isDefaultPrimaryTableSet;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * If "set", indicates that default listeners in the
>>>>>> m_defaultListenerList * list NOT should be applied to the
>>>>>> entity.
>>>>>> */
>>>>>> public boolean isXmlExcludeDefaultListenersSet() {
>>>>>> return m_xmlExcludeDefaultListeners;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * If "set", indicates that superclass listeners should NOT be
>>>>>> applied to * the entity.
>>>>>> */
>>>>>> public boolean isXmlExcludeSuperclassListenersSet() {
>>>>>> return m_xmlExcludeSuperclassListeners;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates that we found an XML field access type for this
>>>>>> metadata
>>>>>> * descriptor.
>>>>>> */
>>>>>> public boolean isXmlFieldAccess() {
>>>>>> return (m_isXmlPropertyAccess != null &&
>>>>>> m_isXmlPropertyAccess.booleanValue() == false);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates that we found an XML property access type for
>>>>>> this metadata
>>>>>> * descriptor.
>>>>>> */
>>>>>> public boolean isXmlPropertyAccess() {
>>>>>> return (m_isXmlPropertyAccess != null &&
>>>>>> m_isXmlPropertyAccess.booleanValue() == true);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Return true is this descriptor metadata is an inheritance
>>>>>> root.
>>>>>> */
>>>>>> public boolean isInheritanceRoot() {
>>>>>> return m_isInheritanceRoot;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Method to determine if the given class is an inheritance
>>>>>> subclass.
>>>>>> */
>>>>>> public boolean isInheritanceSubclass() {
>>>>>> return (getInheritanceRootClass() != null);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Calls to this method should only be made once to determine
>>>>>> if this
>>>>>> * descriptor metadata is part of an inhertiance hierarchy.
>>>>>> Any consecutive
>>>>>> * inquiries should be made through the
>>>>>> isInheritanceSubclass() call.
>>>>>> */
>>>>>> protected boolean isInheritanceSubclass(HashMap
>>>>>> m_metadataDescriptors) {
>>>>>> Class lastParent = null;
>>>>>> Class parent = m_javaClass.getSuperclass();
>>>>>> while (parent != Object.class) {
>>>>>> if (hasInheritanceTag(parent) ||
>>>>>> m_metadataDescriptors.containsKey(parent) || hasEntityTag(parent)) {
>>>>>> lastParent = parent;
>>>>>> }
>>>>>> parent = parent.getSuperclass();
>>>>>> }
>>>>>> // Finally set whatever we found as the
>>>>>> inheritance root class. Which
>>>>>> // may be null.
>>>>>> m_inheritanceRootClass = lastParent;
>>>>>>
>>>>>> return isInheritanceSubclass();
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean pkClassWasNotValidated() {
>>>>>> return ! m_pkClassIDs.isEmpty();
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setAlias(String alias) {
>>>>>> m_descriptor.setAlias(alias);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setCatalog(String xmlCatalog) {
>>>>>> m_xmlCatalog = xmlCatalog;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setClassIndicatorField(DatabaseField field) {
>>>>>>
>>>>>> m_descriptor.getInheritancePolicy().setClassIndicatorField(field);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setDefaultListeners(List defaultListeners) {
>>>>>> m_defaultListeners = defaultListeners;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setDefaultPrimaryKey() {
>>>>>> m_isDefaultPrimaryKeySet = true;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setDefaultPrimaryTable() {
>>>>>> m_isDefaultPrimaryTableSet = true;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setDescriptor(RelationalDescriptor descriptor) {
>>>>>> m_descriptor = descriptor;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setDescriptorIsEmbeddable() {
>>>>>> m_descriptor.descriptorIsAggregate();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setEmbeddedIdAttributeName(String
>>>>>> embeddedIdAttributeName) {
>>>>>> m_embeddedIdAttributeName = embeddedIdAttributeName;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setExcludeDefaultListeners(boolean
>>>>>> excludeDefaultListeners) {
>>>>>>
>>>>>> m_descriptor.getEventManager().setExcludeDefaultListeners(excludeDefaultListeners);
>>>>>>
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setExcludeSuperclassListeners(boolean
>>>>>> excludeSuperclassListeners) {
>>>>>>
>>>>>> m_descriptor.getEventManager().setExcludeSuperclassListeners(excludeSuperclassListeners);
>>>>>>
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setIgnoreFlags() {
>>>>>> m_ignoreInheritanceAnnotations =
>>>>>> m_descriptor.hasInheritance();
>>>>>> m_ignoreTableAnnotations =
>>>>>> m_descriptor.getTableNames().size() > 0;
>>>>>> m_ignoreIDAnnotations =
>>>>>> m_descriptor.getPrimaryKeyFieldNames().size() > 0 &&
>>>>>> !isDefaultPrimaryKeySet();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Store the descriptor metadata for the root of our
>>>>>> inheritance hierarchy.
>>>>>> */
>>>>>> public void setInheritanceRootDmd(MetadataDescriptor
>>>>>> inheritanceRootDmd) {
>>>>>> m_inheritanceRootDmd = inheritanceRootDmd;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Store the java class for the root of our inheritance
>>>>>> hierarchy.
>>>>>> */
>>>>>> public void setInheritanceRootClass(Class rootClass) {
>>>>>> m_inheritanceRootClass = rootClass;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Stored on the root class of an inheritance hierarchy.
>>>>>> */
>>>>>> public void setInheritanceStrategy(String inheritanceStrategy) {
>>>>>> if
>>>>>> (inheritanceStrategy.equals(MetadataConstants.TABLE_PER_CLASS)) {
>>>>>> throw
>>>>>> ValidationException.tablePerClassInheritanceNotSupported(m_javaClass);
>>>>>>
>>>>>> }
>>>>>> m_usesSingleTableInheritanceStrategy =
>>>>>> (inheritanceStrategy.equals(MetadataConstants.SINGLE_TABLE));
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Set this descriptor metadata as an inheritance root.
>>>>>> Because the * inheritance root class may or may not have an
>>>>>> @Inheritance annotation * defined then we need to ensure that
>>>>>> descriptor metadata knows it is.
>>>>>> */
>>>>>> public void setIsInheritanceRoot(boolean isInheritanceRoot) {
>>>>>> m_isInheritanceRoot = isInheritanceRoot;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates that we found an XML field access type for this
>>>>>> metadata
>>>>>> * descriptor.
>>>>>> */
>>>>>> public void setIsXmlFieldAccess() {
>>>>>> m_isXmlPropertyAccess = new Boolean(false);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates that we found an XML property access type for
>>>>>> this metadata
>>>>>> * descriptor.
>>>>>> */
>>>>>> public void setIsXmlPropertyAccess() {
>>>>>> m_isXmlPropertyAccess = new Boolean(true);
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Used to set this descriptors java class. */
>>>>>> public void setJavaClass(Class javaClass) {
>>>>>> m_javaClass = javaClass;
>>>>>> if ((m_javaClass != null) && (m_descriptor != null)){
>>>>>> m_descriptor.setJavaClassName(m_javaClass.getName());
>>>>>> } else if (m_descriptor != null) {
>>>>>> m_descriptor.setJavaClassName(null);
>>>>>> }
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setOptimisticLockingPolicy(DatabaseField field) {
>>>>>> VersionLockingPolicy vlp = new VersionLockingPolicy();
>>>>>> vlp.setWriteLockField(field);
>>>>>> vlp.storeInObject();
>>>>>> m_descriptor.setOptimisticLockingPolicy(vlp);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Should only be called from those descriptor metadata's that
>>>>>> are in
>>>>>> * fact part of an inheritance hierarchy. It figures out the
>>>>>> parent and
>>>>>> * then sets it.
>>>>>> */
>>>>>> public void setParentClass() {
>>>>>> Class parent = m_javaClass.getSuperclass();
>>>>>> while (parent != Object.class) {
>>>>>> if (hasEntityTag(parent)) {
>>>>>> break;
>>>>>> }
>>>>>> parent = parent.getSuperclass();
>>>>>> }
>>>>>> setParentClass(parent);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Set the inheritance parent class for this descriptor metadata.
>>>>>> */
>>>>>> public void setParentClass(Class parent) {
>>>>>>
>>>>>> m_descriptor.getInheritancePolicy().setParentClassName(parent.getName());
>>>>>>
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setPKClass(Class pkClass) {
>>>>>> CMP3Policy policy = new CMP3Policy();
>>>>>> policy.setPrimaryKeyClassName(pkClass.getName());
>>>>>> m_descriptor.setCMPPolicy(policy);
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setPrimaryTable(DatabaseTable primaryTable) {
>>>>>> Vector tables = m_descriptor.getTables();
>>>>>> if (tables != null && !tables.isEmpty()) {
>>>>>> tables.remove(0);
>>>>>> }
>>>>>> tables.add(0, primaryTable);
>>>>>> m_primaryTableName = primaryTable.getQualifiedName();
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setSchema(String xmlSchema) {
>>>>>> m_xmlSchema = xmlSchema;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setSequenceNumberField(DatabaseField field) {
>>>>>> DatabaseField existingField =
>>>>>> m_descriptor.getSequenceNumberField();
>>>>>> if (existingField == null) {
>>>>>> m_descriptor.setSequenceNumberField(field);
>>>>>> } else {
>>>>>> if (!existingField.equals(field)) {
>>>>>> throw
>>>>>> ValidationException.onlyOneGeneratedValueIsAllowed(m_javaClass,
>>>>>> existingField.getQualifiedName(), field.getQualifiedName());
>>>>>> }
>>>>>> }
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public void setSequenceNumberName(String name) {
>>>>>> m_descriptor.setSequenceNumberName(name);
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates that default listeners are NOT to be applied to
>>>>>> the entity.
>>>>>> */
>>>>>> public void setXmlExcludeDefaultListeners(boolean
>>>>>> xmlExcludeDefaultListeners) {
>>>>>> m_xmlExcludeDefaultListeners = xmlExcludeDefaultListeners;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates that superclass listeners are NOT to be applied
>>>>>> to the entity.
>>>>>> */
>>>>>> public void setXmlExcludeSuperclassListeners(boolean
>>>>>> xmlExcludeSuperclassListeners) {
>>>>>> m_xmlExcludeSuperclassListeners =
>>>>>> xmlExcludeSuperclassListeners;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates that all annotations should be ignored, and only
>>>>>> default values * set by the annotations processor.
>>>>>> */
>>>>>> public void setShouldIgnoreAnnotations(boolean
>>>>>> ignoreAnnotations) {
>>>>>> m_ignoreAnnotations = ignoreAnnotations;
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates that cascade-persist should be added to the set
>>>>>> of cascade * values for all relationship mappings.
>>>>>> */
>>>>>> public void setShouldUseCascadePersist() {
>>>>>> m_isCascadePersistSet = true;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Sets the strategy on the descriptor's inheritance policy to
>>>>>> SINGLE_TABLE. * The default is JOINED.
>>>>>> */
>>>>>> public void setSingleTableInheritanceStrategy() {
>>>>>> m_descriptor.getInheritancePolicy().setSingleTableStrategy();
>>>>>> }
>>>>>>
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates whether or not annotations should be ignored,
>>>>>> i.e. only default * values processed.
>>>>>> */
>>>>>> public boolean shouldIgnoreAnnotations() {
>>>>>> return m_ignoreAnnotations;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> */
>>>>>> public boolean usesOptimisticLocking() {
>>>>>> return m_descriptor.usesOptimisticLocking();
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Returns true if this entity uses property access.
>>>>>> */
>>>>>> public abstract boolean usesPropertyAccess();
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * Indicates if the strategy on the descriptor's inheritance
>>>>>> policy is * SINGLE_TABLE or JOINED.
>>>>>> * * @return true if SINGLE_TABLE, false otherwise
>>>>>> */
>>>>>> public boolean usesSingleTableInheritanceStrategy() {
>>>>>> return m_usesSingleTableInheritanceStrategy;
>>>>>> }
>>>>>> /**
>>>>>> * INTERNAL:
>>>>>> * This method is used only to validate id fields that were
>>>>>> found on a
>>>>>> * pk class were also found on the entity.
>>>>>> */
>>>>>> public void validatePKClassId(String attributeName, Class type) {
>>>>>> if (m_pkClassIDs.containsKey(attributeName)) {
>>>>>> Class value = (Class) m_pkClassIDs.get(attributeName);
>>>>>> if (value == type) {
>>>>>> m_pkClassIDs.remove(attributeName);
>>>>>> } else {
>>>>>> throw
>>>>>> ValidationException.invalidCompositePKAttribute(m_javaClass,
>>>>>> getPKClassName(), attributeName, value, type);
>>>>>> }
>>>>>> }
>>>>>> }
>>>>>> }
>>>>>>