Hi All,
We've been looking at this for that last day or so and are making
progress towards a full fix. I will let you know when we have something.
-Tom
Marina Vatkina wrote:
>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);
>>>>>>> }
>>>>>>> }
>>>>>>> }
>>>>>>>}
>>>>>>>
>>>>>>>
>>>>>>>