/*******************************************************************************
* Copyright (c) 1998, 2015 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 05/16/2008-1.0M8 Guy Pelletier
* - 218084: Implement metadata merging functionality between mapping file
* 05/23/2008-1.0M8 Guy Pelletier
* - 211330: Add attributes-complete support to the EclipseLink-ORM.XML Schema
* 07/22/2008-1.1 Guy Pelletier
* - 237315: Support converters on attribute mappings in the eclipselink orm.xml schema
* 08/27/2008-1.1 Guy Pelletier
* - 211329: Add sequencing on non-id attribute(s) support to the EclipseLink-ORM.XML Schema
* 09/23/2008-1.1 Guy Pelletier
* - 241651: JPA 2.0 Access Type support
* 02/06/2009-2.0 Guy Pelletier
* - 248293: JPA 2.0 Element Collections (part 2)
* 02/25/2009-2.0 Guy Pelletier
* - 265359: JPA 2.0 Element Collections - Metadata processing portions
* 03/27/2009-2.0 Guy Pelletier
* - 241413: JPA 2.0 Add EclipseLink support for Map type attributes
* 04/03/2009-2.0 Guy Pelletier
* - 241413: JPA 2.0 Add EclipseLink support for Map type attributes
* 06/09/2009-2.0 Guy Pelletier
* - 249037: JPA 2.0 persisting list item index
* 06/16/2009-2.0 Guy Pelletier
* - 277039: JPA 2.0 Cache Usage Settings
* 11/06/2009-2.0 Guy Pelletier
* - 286317: UniqueConstraint xml element is changing (plus couple other fixes, see bug)
* 12/2/2009-2.1 Guy Pelletier
* - 296289: Add current annotation metadata support on mapped superclasses to EclipseLink-ORM.XML Schema
* 12/18/2009-2.1 Guy Pelletier
* - 211323: Add class extractor support to the EclipseLink-ORM.XML Schema
* 01/19/2010-2.1 Guy Pelletier
* - 211322: Add fetch-group(s) support to the EclipseLink-ORM.XML Schema
* 03/08/2010-2.1 Guy Pelletier
* - 303632: Add attribute-type for mapping attributes to EclipseLink-ORM
* 04/09/2010-2.1 Guy Pelletier
* - 307050: Add defaults for access methods of a VIRTUAL access type
* 04/27/2010-2.1 Guy Pelletier
* - 309856: MappedSuperclasses from XML are not being initialized properly
* 05/04/2010-2.1 Guy Pelletier
* - 309373: Add parent class attribute to EclipseLink-ORM
* 09/16/2010-2.2 Guy Pelletier
* - 283028: Add support for letting an @Embeddable extend a @MappedSuperclass
* 10/15/2010-2.2 Guy Pelletier
* - 322008: Improve usability of additional criteria applied to queries at the session/EM
* 10/28/2010-2.2 Guy Pelletier
* - 3223850: Primary key metadata issues
* 01/25/2011-2.3 Guy Pelletier
* - 333913: @OrderBy and <order-by/> without arguments should order by primary
* 03/24/2011-2.3 Guy Pelletier
* - 337323: Multi-tenant with shared schema support (part 1)
* 03/28/2011-2.3 Guy Pelletier
* - 341152: From XML cache interceptor and query redirector metadata don't support package specification
* 03/24/2011-2.3 Guy Pelletier
* - 337323: Multi-tenant with shared schema support (part 8)
* 07/03/2011-2.3.1 Guy Pelletier
* - 348756: m_cascadeOnDelete boolean should be changed to Boolean
* 08/18/2011-2.3.1 Guy Pelletier
* - 355093: Add new 'includeCriteria' flag to Multitenant metadata
* 02/08/2012-2.4 Guy Pelletier
* - 350487: JPA 2.1 Specification defined support for Stored Procedure Calls
* 14/05/2012-2.4 Guy Pelletier
* - 376603: Provide for table per tenant support for multitenant applications
* * 30/05/2012-2.4 Guy Pelletier
* - 354678: Temp classloader is still being used during metadata processing
* 10/09/2012-2.5 Guy Pelletier
* - 374688: JPA 2.1 Converter support
* 10/25/2012-2.5 Guy Pelletier
* - 3746888: JPA 2.1 Converter support
* 11/19/2012-2.5 Guy Pelletier
* - 389090: JPA 2.1 DDL Generation Support (foreign key metadata support)
* 11/22/2012-2.5 Guy Pelletier
* - 389090: JPA 2.1 DDL Generation Support (index metadata support)
* 01/23/2013-2.5 Guy Pelletier
* - 350487: JPA 2.1 Specification defined support for Stored Procedure Calls
* 02/13/2013-2.5 Guy Pelletier
* - 397772: JPA 2.1 Entity Graph Support (XML support)
* 02/20/2013-2.5 Guy Pelletier
* - 389090: JPA 2.1 DDL Generation Support (foreign key metadata support)
*******************************************************************************/
package org.eclipse.persistence.internal.jpa.metadata.xml;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.PropertyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EmbeddableAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EntityAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.MappedSuperclassAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.XMLAttributes;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicCollectionAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicMapAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ElementCollectionAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.EmbeddedAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.EmbeddedIdAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ManyToManyAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ManyToOneAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.OneToManyAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.OneToOneAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.TransformationAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.TransientAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VariableOneToOneAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VersionAccessor;
import org.eclipse.persistence.internal.jpa.metadata.sop.SerializedObjectPolicyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.structures.ArrayAccessor;
import org.eclipse.persistence.internal.jpa.metadata.additionalcriteria.AdditionalCriteriaMetadata;
import org.eclipse.persistence.internal.jpa.metadata.cache.CacheIndexMetadata;
import org.eclipse.persistence.internal.jpa.metadata.cache.CacheInterceptorMetadata;
import org.eclipse.persistence.internal.jpa.metadata.cache.CacheMetadata;
import org.eclipse.persistence.internal.jpa.metadata.cache.TimeOfDayMetadata;
import org.eclipse.persistence.internal.jpa.metadata.changetracking.ChangeTrackingMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.AssociationOverrideMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.AttributeOverrideMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.ColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.DiscriminatorClassMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.DiscriminatorColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.FieldMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.ForeignKeyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.JoinColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.JoinFieldMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.OrderColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.PrimaryKeyForeignKeyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.PrimaryKeyJoinColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.PrimaryKeyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.TenantDiscriminatorColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.ConversionValueMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.ConvertMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.ConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.EnumeratedMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.LobMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.MixedConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.ObjectTypeConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.SerializedConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.StructConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.TemporalMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.TypeConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.copypolicy.CustomCopyPolicyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.copypolicy.InstantiationCopyPolicyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.copypolicy.CloneCopyPolicyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.graphs.NamedAttributeNodeMetadata;
import org.eclipse.persistence.internal.jpa.metadata.graphs.NamedEntityGraphMetadata;
import org.eclipse.persistence.internal.jpa.metadata.graphs.NamedSubgraphMetadata;
import org.eclipse.persistence.internal.jpa.metadata.inheritance.InheritanceMetadata;
import org.eclipse.persistence.internal.jpa.metadata.listeners.EntityListenerMetadata;
import org.eclipse.persistence.internal.jpa.metadata.locking.OptimisticLockingMetadata;
import org.eclipse.persistence.internal.jpa.metadata.mappings.AccessMethodsMetadata;
import org.eclipse.persistence.internal.jpa.metadata.mappings.BatchFetchMetadata;
import org.eclipse.persistence.internal.jpa.metadata.mappings.CascadeMetadata;
import org.eclipse.persistence.internal.jpa.metadata.mappings.MapKeyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.mappings.OrderByMetadata;
import org.eclipse.persistence.internal.jpa.metadata.mappings.ReturnInsertMetadata;
import org.eclipse.persistence.internal.jpa.metadata.multitenant.MultitenantMetadata;
import org.eclipse.persistence.internal.jpa.metadata.multitenant.TenantTableDiscriminatorMetadata;
import org.eclipse.persistence.internal.jpa.metadata.nosql.NoSqlMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.HashPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.PartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.PinnedPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.RangePartitionMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.RangePartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.ReplicationPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.RoundRobinPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.UnionPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.ValuePartitionMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.ValuePartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.ColumnResultMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.ConstructorResultMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.EntityResultMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.FetchAttributeMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.FetchGroupMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.FieldResultMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedNativeQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredProcedureQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedStoredFunctionQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedStoredProcedureQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.OracleArrayTypeMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.OracleObjectTypeMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLParameterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLRecordMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLTableMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.QueryHintMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.QueryRedirectorsMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.SQLResultSetMappingMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.StoredProcedureParameterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.sequencing.GeneratedValueMetadata;
import org.eclipse.persistence.internal.jpa.metadata.sequencing.SequenceGeneratorMetadata;
import org.eclipse.persistence.internal.jpa.metadata.sequencing.TableGeneratorMetadata;
import org.eclipse.persistence.internal.jpa.metadata.sequencing.UuidGeneratorMetadata;
import org.eclipse.persistence.internal.jpa.metadata.structures.StructMetadata;
import org.eclipse.persistence.internal.jpa.metadata.structures.StructureAccessor;
import org.eclipse.persistence.internal.jpa.metadata.tables.CollectionTableMetadata;
import org.eclipse.persistence.internal.jpa.metadata.tables.IndexMetadata;
import org.eclipse.persistence.internal.jpa.metadata.tables.JoinTableMetadata;
import org.eclipse.persistence.internal.jpa.metadata.tables.SecondaryTableMetadata;
import org.eclipse.persistence.internal.jpa.metadata.tables.TableMetadata;
import org.eclipse.persistence.internal.jpa.metadata.tables.UniqueConstraintMetadata;
import org.eclipse.persistence.internal.jpa.metadata.transformers.ReadTransformerMetadata;
import org.eclipse.persistence.internal.jpa.metadata.transformers.WriteTransformerMetadata;
import org.eclipse.persistence.oxm.NamespaceResolver;
import org.eclipse.persistence.oxm.XMLDescriptor;
import org.eclipse.persistence.oxm.XMLLogin;
import org.eclipse.persistence.oxm.mappings.XMLCompositeCollectionMapping;
import org.eclipse.persistence.oxm.mappings.XMLCompositeDirectCollectionMapping;
import org.eclipse.persistence.oxm.mappings.XMLCompositeObjectMapping;
import org.eclipse.persistence.oxm.mappings.XMLDirectMapping;
import org.eclipse.persistence.oxm.mappings.nullpolicy.IsSetNullPolicy;
import org.eclipse.persistence.oxm.mappings.nullpolicy.XMLNullRepresentationType;
import org.eclipse.persistence.oxm.platform.DOMPlatform;
import org.eclipse.persistence.oxm.schema.XMLSchemaClassPathReference;
/**
* INTERNAL:
* EclipseLink ORM mapping file OX mapping project.
*
* Key notes:
* - Elements mappings (per descriptor) must remain in order of definition in
* XML. This ensure on any write out the elements will be written in a valid
* order (to be read back in and validated correctly).
* - Attribute mappings (per descriptor) can be in any order (but recommended
* to keep them in order of definition in XML as well)
* - methods should be preserved in alphabetical order.
* - Individual mappings should be built within get methods and used within
* individual descriptor build methods.
*
* @author Guy Pelletier
*/
public class XMLEntityMappingsMappingProject extends org.eclipse.persistence.sessions.Project {
public XMLEntityMappingsMappingProject(String ormNamespace, String xsdLocation) {
setName("MetadataMappingProject");
addDescriptor(buildEntityMappingsDescriptor(xsdLocation));
addDescriptor(buildPersistenceUnitMetadataDescriptor());
addDescriptor(buildPersistenceUnitDefaultsDescriptor());
addDescriptor(buildEntityDescriptor());
addDescriptor(buildEmbeddableDescriptor());
addDescriptor(buildMappedSuperclassDescriptor());
addDescriptor(buildInheritanceDescriptor());
addDescriptor(buildTableDescriptor());
addDescriptor(buildIndexDescriptor());
addDescriptor(buildSecondaryTableDescriptor());
addDescriptor(buildUniqueConstraintDescriptor());
addDescriptor(buildAttributesDescriptor());
addDescriptor(buildEntityListenerDescriptor());
addDescriptor(buildPrimaryKeyDescriptor());
addDescriptor(buildOptimisticLockingDescriptor());
addDescriptor(buildCacheDescriptor());
addDescriptor(buildCacheInterceptorDescriptor());
addDescriptor(buildCacheIndexDescriptor());
addDescriptor(buildFetchAttributeDescriptor());
addDescriptor(buildFetchGroupDescriptor());
addDescriptor(buildTimeOfDayDescriptor());
addDescriptor(buildColumnDescriptor());
addDescriptor(buildOrderColumnDescriptor());
addDescriptor(buildOrderByDescriptor());
addDescriptor(buildJoinColumnDescriptor());
addDescriptor(buildForeignKeyDescriptor());
addDescriptor(buildPrimaryKeyJoinColumnDescriptor());
addDescriptor(buildPrimaryKeyForeignKeyDescriptor());
addDescriptor(buildAccessMethodsDescriptor());
addDescriptor(buildAssociationOverrideDescriptor());
addDescriptor(buildAttributeOverrideDescriptor());
addDescriptor(buildDiscriminatorColumnDescriptor());
addDescriptor(buildDiscriminatorClassDescriptor());
addDescriptor(buildAdditionalCriteriaDescriptor());
addDescriptor(buildMultitenantDescriptor());
addDescriptor(buildTenantDiscriminatorColumnDescriptor());
addDescriptor(buildTenantTableDiscriminatorDescriptor());
addDescriptor(buildNamedQueryDescriptor());
addDescriptor(buildNamedNativeQueryDescriptor());
addDescriptor(buildSqlResultSetMappingDescriptor());
addDescriptor(buildQueryHintDescriptor());
addDescriptor(buildEntityResultDescriptor());
addDescriptor(buildFieldResultDescriptor());
addDescriptor(buildColumnResultDescriptor());
addDescriptor(buildConstructorResultDescriptor());
addDescriptor(buildDefaultRedirectorsDescriptor());
addDescriptor(buildNamedEntityGraphDescriptor());
addDescriptor(buildNamedAttributeNodeDescriptor());
addDescriptor(buildNamedSubgraphDescriptor());
addDescriptor(buildSerializedObjectPolicyDescriptor());
addDescriptor(buildNamedStoredProcedureQueryDescriptor());
addDescriptor(buildNamedStoredFunctionQueryDescriptor());
addDescriptor(buildStoredProcedureParameterDescriptor());
addDescriptor(buildNamedPLSQLStoredProcedureQueryDescriptor());
addDescriptor(buildNamedPLSQLStoredFunctionQueryDescriptor());
addDescriptor(buildOracleObjectTypeDescriptor());
addDescriptor(buildOracleArrayTypeDescriptor());
addDescriptor(buildPLSQLRecordDescriptor());
addDescriptor(buildPLSQLTableDescriptor());
addDescriptor(buildPLSQLParameterDescriptor());
addDescriptor(buildArrayDescriptor());
addDescriptor(buildStructureDescriptor());
addDescriptor(buildStructDescriptor());
addDescriptor(buildIdDescriptor());
addDescriptor(buildEmbeddedIdDescriptor());
addDescriptor(buildTransientDescriptor());
addDescriptor(buildVersionDescriptor());
addDescriptor(buildBasicDescriptor());
addDescriptor(buildReturnInsertDescriptor());
addDescriptor(buildCascadeTypeDescriptor());
addDescriptor(buildManyToOneDescriptor());
addDescriptor(buildOneToOneDescriptor());
addDescriptor(buildOneToManyDescriptor());
addDescriptor(buildManyToManyDescriptor());
addDescriptor(buildJoinTableDescriptor());
addDescriptor(buildEmbeddedDescriptor());
addDescriptor(buildElementCollectionDescriptor());
addDescriptor(buildCollectionTableDescriptor());
addDescriptor(buildBasicCollectionDescriptor());
addDescriptor(buildBasicMapDescriptor());
addDescriptor(buildVariableOneToOneDescriptor());
addDescriptor(buildMapKeyDescriptor());
addDescriptor(buildBatchFetchDescriptor());
addDescriptor(buildGeneratedValueDescriptor());
addDescriptor(buildSequenceGeneratorDescriptor());
addDescriptor(buildTableGeneratorDescriptor());
addDescriptor(buildUuidGeneratorDescriptor());
addDescriptor(buildLobDescriptor());
addDescriptor(buildTemporalDescriptor());
addDescriptor(buildEnumeratedDescriptor());
addDescriptor(buildConvertDescriptor());
addDescriptor(buildConverterDescriptor());
addDescriptor(buildMixedConverterDescriptor());
addDescriptor(buildTypeConverterDescriptor());
addDescriptor(buildSerializedConverterDescriptor());
addDescriptor(buildObjectTypeConverterDescriptor());
addDescriptor(buildConversionValueDescriptor());
addDescriptor(buildStructConverterDescriptor());
addDescriptor(buildChangeTrackingDescriptor());
addDescriptor(buildReadTransformerDescriptor());
addDescriptor(buildWriteTransformerDescriptor());
addDescriptor(buildTransformationDescriptor());
addDescriptor(buildCustomCopyPolicyDescriptor());
addDescriptor(buildCloneCopyPolicyDescriptor());
addDescriptor(buildInstantiationCopyPolicyDescriptor());
addDescriptor(buildPartitioningDescriptor());
addDescriptor(buildReplicationPartitioningDescriptor());
addDescriptor(buildRoundRobinPartitioningDescriptor());
addDescriptor(buildRangePartitioningDescriptor());
addDescriptor(buildRangePartitionDescriptor());
addDescriptor(buildValuePartitioningDescriptor());
addDescriptor(buildValuePartitionDescriptor());
addDescriptor(buildHashPartitioningDescriptor());
addDescriptor(buildUnionPartitioningDescriptor());
addDescriptor(buildPinnedPartitioningDescriptor());
addDescriptor(buildPropertyDescriptor());
addDescriptor(buildNoSqlDescriptor());
addDescriptor(buildFieldDescriptor());
addDescriptor(buildJoinFieldDescriptor());
// Set the name spaces on all descriptors.
NamespaceResolver namespaceResolver = new NamespaceResolver();
namespaceResolver.put("xsi", "http://www.w3.org/2001/XMLSchema-instance");
//namespaceResolver.put("xsd", "http://www.w3.org/2001/XMLSchema");
namespaceResolver.put("orm", ormNamespace);
for (ClassDescriptor descriptor : getDescriptors().values()) {
((XMLDescriptor)descriptor).setNamespaceResolver(namespaceResolver);
}
XMLLogin xmlLogin = new XMLLogin();
DOMPlatform platform = new DOMPlatform();
xmlLogin.setDatasourcePlatform(platform);
this.setDatasourceLogin(xmlLogin);
}
protected void addConverterMappings(ClassDescriptor descriptor) {
descriptor.addMapping(getConverterMapping());
descriptor.addMapping(getTypeConverterMapping());
descriptor.addMapping(getObjectTypeConverterMapping());
descriptor.addMapping(getSerializedConverterMapping());
descriptor.addMapping(getStructConverterMapping());
}
/**
* INTERNAL:
* XSD: access-methods
*/
protected ClassDescriptor buildAccessMethodsDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(AccessMethodsMetadata.class);
XMLDirectMapping getMethodMapping = new XMLDirectMapping();
getMethodMapping.setAttributeName("m_getMethodName");
getMethodMapping.setGetMethodName("getGetMethodName");
getMethodMapping.setSetMethodName("setGetMethodName");
getMethodMapping.setXPath("@get-method");
descriptor.addMapping(getMethodMapping);
XMLDirectMapping setMethodMapping = new XMLDirectMapping();
setMethodMapping.setAttributeName("m_setMethodName");
setMethodMapping.setGetMethodName("getSetMethodName");
setMethodMapping.setSetMethodName("setSetMethodName");
setMethodMapping.setXPath("@set-method");
descriptor.addMapping(setMethodMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: additional-criteria
*/
protected ClassDescriptor buildAdditionalCriteriaDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(AdditionalCriteriaMetadata.class);
// Element mappings - must remain in order of definition in XML.
XMLDirectMapping criteriaMapping = new XMLDirectMapping();
criteriaMapping.setAttributeName("m_criteria");
criteriaMapping.setGetMethodName("getCriteria");
criteriaMapping.setSetMethodName("setCriteria");
criteriaMapping.setXPath("orm:criteria");
descriptor.addMapping(criteriaMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: association-override
*/
protected ClassDescriptor buildAssociationOverrideDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(AssociationOverrideMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getJoinColumnMapping());
descriptor.addMapping(getForeignKeyMapping());
descriptor.addMapping(getJoinTableMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: attribute-override
*/
protected ClassDescriptor buildAttributeOverrideDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(AttributeOverrideMetadata.class);
descriptor.addMapping(getColumnMapping());
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: attributes
*/
protected ClassDescriptor buildAttributesDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(XMLAttributes.class);
// Element mappings - must remain in order of definition in XML.
XMLCompositeObjectMapping embeddedIdMapping = new XMLCompositeObjectMapping();
embeddedIdMapping.setAttributeName("m_embeddedId");
embeddedIdMapping.setGetMethodName("getEmbeddedId");
embeddedIdMapping.setSetMethodName("setEmbeddedId");
embeddedIdMapping.setReferenceClass(EmbeddedIdAccessor.class);
embeddedIdMapping.setXPath("orm:embedded-id");
descriptor.addMapping(embeddedIdMapping);
XMLCompositeCollectionMapping idsMapping = new XMLCompositeCollectionMapping();
idsMapping.setAttributeName("m_ids");
idsMapping.setGetMethodName("getIds");
idsMapping.setSetMethodName("setIds");
idsMapping.setReferenceClass(IdAccessor.class);
idsMapping.setXPath("orm:id");
descriptor.addMapping(idsMapping);
XMLCompositeCollectionMapping basicsMapping = new XMLCompositeCollectionMapping();
basicsMapping.setAttributeName("m_basics");
basicsMapping.setGetMethodName("getBasics");
basicsMapping.setSetMethodName("setBasics");
basicsMapping.setReferenceClass(BasicAccessor.class);
basicsMapping.setXPath("orm:basic");
descriptor.addMapping(basicsMapping);
XMLCompositeCollectionMapping basicCollectionsMapping = new XMLCompositeCollectionMapping();
basicCollectionsMapping.setAttributeName("m_basicCollections");
basicCollectionsMapping.setGetMethodName("getBasicCollections");
basicCollectionsMapping.setSetMethodName("setBasicCollections");
basicCollectionsMapping.setReferenceClass(BasicCollectionAccessor.class);
basicCollectionsMapping.setXPath("orm:basic-collection");
descriptor.addMapping(basicCollectionsMapping);
XMLCompositeCollectionMapping basicMapsMapping = new XMLCompositeCollectionMapping();
basicMapsMapping.setAttributeName("m_basicMaps");
basicMapsMapping.setGetMethodName("getBasicMaps");
basicMapsMapping.setSetMethodName("setBasicMaps");
basicMapsMapping.setReferenceClass(BasicMapAccessor.class);
basicMapsMapping.setXPath("orm:basic-map");
descriptor.addMapping(basicMapsMapping);
XMLCompositeCollectionMapping versionsMapping = new XMLCompositeCollectionMapping();
versionsMapping.setAttributeName("m_versions");
versionsMapping.setGetMethodName("getVersions");
versionsMapping.setSetMethodName("setVersions");
versionsMapping.setReferenceClass(VersionAccessor.class);
versionsMapping.setXPath("orm:version");
descriptor.addMapping(versionsMapping);
XMLCompositeCollectionMapping manyToOnesMapping = new XMLCompositeCollectionMapping();
manyToOnesMapping.setAttributeName("m_manyToOnes");
manyToOnesMapping.setGetMethodName("getManyToOnes");
manyToOnesMapping.setSetMethodName("setManyToOnes");
manyToOnesMapping.setReferenceClass(ManyToOneAccessor.class);
manyToOnesMapping.setXPath("orm:many-to-one");
descriptor.addMapping(manyToOnesMapping);
XMLCompositeCollectionMapping oneToManysMapping = new XMLCompositeCollectionMapping();
oneToManysMapping.setAttributeName("m_oneToManys");
oneToManysMapping.setGetMethodName("getOneToManys");
oneToManysMapping.setSetMethodName("setOneToManys");
oneToManysMapping.setReferenceClass(OneToManyAccessor.class);
oneToManysMapping.setXPath("orm:one-to-many");
descriptor.addMapping(oneToManysMapping);
XMLCompositeCollectionMapping oneToOnesMapping = new XMLCompositeCollectionMapping();
oneToOnesMapping.setAttributeName("m_oneToOnes");
oneToOnesMapping.setGetMethodName("getOneToOnes");
oneToOnesMapping.setSetMethodName("setOneToOnes");
oneToOnesMapping.setReferenceClass(OneToOneAccessor.class);
oneToOnesMapping.setXPath("orm:one-to-one");
descriptor.addMapping(oneToOnesMapping);
XMLCompositeCollectionMapping variableOneToOnesMapping = new XMLCompositeCollectionMapping();
variableOneToOnesMapping.setAttributeName("m_variableOneToOnes");
variableOneToOnesMapping.setGetMethodName("getVariableOneToOnes");
variableOneToOnesMapping.setSetMethodName("setVariableOneToOnes");
variableOneToOnesMapping.setReferenceClass(VariableOneToOneAccessor.class);
variableOneToOnesMapping.setXPath("orm:variable-one-to-one");
descriptor.addMapping(variableOneToOnesMapping);
XMLCompositeCollectionMapping manyToManysMapping = new XMLCompositeCollectionMapping();
manyToManysMapping.setAttributeName("m_manyToManys");
manyToManysMapping.setGetMethodName("getManyToManys");
manyToManysMapping.setSetMethodName("setManyToManys");
manyToManysMapping.setReferenceClass(ManyToManyAccessor.class);
manyToManysMapping.setXPath("orm:many-to-many");
descriptor.addMapping(manyToManysMapping);
XMLCompositeCollectionMapping elementCollectionsMapping = new XMLCompositeCollectionMapping();
elementCollectionsMapping.setAttributeName("m_elementCollections");
elementCollectionsMapping.setGetMethodName("getElementCollections");
elementCollectionsMapping.setSetMethodName("setElementCollections");
elementCollectionsMapping.setReferenceClass(ElementCollectionAccessor.class);
elementCollectionsMapping.setXPath("orm:element-collection");
descriptor.addMapping(elementCollectionsMapping);
XMLCompositeCollectionMapping embeddedsMapping = new XMLCompositeCollectionMapping();
embeddedsMapping.setAttributeName("m_embeddeds");
embeddedsMapping.setGetMethodName("getEmbeddeds");
embeddedsMapping.setSetMethodName("setEmbeddeds");
embeddedsMapping.setReferenceClass(EmbeddedAccessor.class);
embeddedsMapping.setXPath("orm:embedded");
descriptor.addMapping(embeddedsMapping);
XMLCompositeCollectionMapping transformationsMapping = new XMLCompositeCollectionMapping();
transformationsMapping.setAttributeName("m_transformations");
transformationsMapping.setGetMethodName("getTransformations");
transformationsMapping.setSetMethodName("setTransformations");
transformationsMapping.setReferenceClass(TransformationAccessor.class);
transformationsMapping.setXPath("orm:transformation");
descriptor.addMapping(transformationsMapping);
XMLCompositeCollectionMapping transientsMapping = new XMLCompositeCollectionMapping();
transientsMapping.setAttributeName("m_transients");
transientsMapping.setGetMethodName("getTransients");
transientsMapping.setSetMethodName("setTransients");
transientsMapping.setReferenceClass(TransientAccessor.class);
transientsMapping.setXPath("orm:transient");
descriptor.addMapping(transientsMapping);
XMLCompositeCollectionMapping structsMapping = new XMLCompositeCollectionMapping();
structsMapping.setAttributeName("m_structures");
structsMapping.setGetMethodName("getStructures");
structsMapping.setSetMethodName("setStructures");
structsMapping.setReferenceClass(StructureAccessor.class);
structsMapping.setXPath("orm:structure");
descriptor.addMapping(structsMapping);
XMLCompositeCollectionMapping arrayMapping = new XMLCompositeCollectionMapping();
arrayMapping.setAttributeName("m_arrays");
arrayMapping.setGetMethodName("getArrays");
arrayMapping.setSetMethodName("setArrays");
arrayMapping.setReferenceClass(ArrayAccessor.class);
arrayMapping.setXPath("orm:array");
descriptor.addMapping(arrayMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: basic-collection
*/
protected ClassDescriptor buildBasicCollectionDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(BasicCollectionAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getValueColumnMapping());
descriptor.addMapping(getConvertMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getCollectionTableMapping());
descriptor.addMapping(getCascadeOnDeleteMapping());
descriptor.addMapping(getJoinFetchMapping());
descriptor.addMapping(getBatchFetchMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getNonCacheableMapping());
// Attribute Mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: basic
*/
protected ClassDescriptor buildBasicDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(BasicAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnMapping());
descriptor.addMapping(getFieldMapping());
descriptor.addMapping(getIndexMapping());
descriptor.addMapping(getCacheIndexMapping());
descriptor.addMapping(getGeneratedValueMapping());
descriptor.addMapping(getLobMapping());
descriptor.addMapping(getTemporalMapping());
descriptor.addMapping(getEnumeratedMapping());
descriptor.addMapping(getConvertMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getTableGeneratorMapping());
descriptor.addMapping(getSequenceGeneratorMapping());
descriptor.addMapping(getUuidGeneratorMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getReturnInsertMapping());
descriptor.addMapping(getReturnUpdateMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getOptionalAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMutableAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: basic-map
*/
protected ClassDescriptor buildBasicMapDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(BasicMapAccessor.class);
// Element mappings - must remain in order of definition in XML.
XMLCompositeObjectMapping keyColumnMapping = new XMLCompositeObjectMapping();
keyColumnMapping.setAttributeName("m_keyColumn");
keyColumnMapping.setGetMethodName("getKeyColumn");
keyColumnMapping.setSetMethodName("setKeyColumn");
keyColumnMapping.setReferenceClass(ColumnMetadata.class);
keyColumnMapping.setXPath("orm:key-column");
descriptor.addMapping(keyColumnMapping);
XMLDirectMapping keyConverterMapping = new XMLDirectMapping();
keyConverterMapping.setAttributeName("m_keyConverter");
keyConverterMapping.setGetMethodName("getKeyConverter");
keyConverterMapping.setSetMethodName("setKeyConverter");
keyConverterMapping.setXPath("orm:key-converter/text()");
descriptor.addMapping(keyConverterMapping);
descriptor.addMapping(getValueColumnMapping());
XMLDirectMapping valueConverterMapping = new XMLDirectMapping();
valueConverterMapping.setAttributeName("m_valueConverter");
valueConverterMapping.setGetMethodName("getValueConverter");
valueConverterMapping.setSetMethodName("setValueConverter");
valueConverterMapping.setXPath("orm:value-converter/text()");
descriptor.addMapping(valueConverterMapping);
addConverterMappings(descriptor);
descriptor.addMapping(getCollectionTableMapping());
descriptor.addMapping(getCascadeOnDeleteMapping());
descriptor.addMapping(getJoinFetchMapping());
descriptor.addMapping(getBatchFetchMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getNonCacheableMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: batch-fetch
*/
protected ClassDescriptor buildBatchFetchDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(BatchFetchMetadata.class);
descriptor.addMapping(getTypeAttributeMapping());
descriptor.addMapping(getSizeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: cache
*/
protected ClassDescriptor buildCacheDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(CacheMetadata.class);
XMLDirectMapping expiryMapping = new XMLDirectMapping();
expiryMapping.setAttributeName("m_expiry");
expiryMapping.setGetMethodName("getExpiry");
expiryMapping.setSetMethodName("setExpiry");
expiryMapping.setXPath("orm:expiry/text()");
descriptor.addMapping(expiryMapping);
XMLCompositeObjectMapping expiryTimeOfDayMapping = new XMLCompositeObjectMapping();
expiryTimeOfDayMapping.setAttributeName("m_expiryTimeOfDay");
expiryTimeOfDayMapping.setGetMethodName("getExpiryTimeOfDay");
expiryTimeOfDayMapping.setSetMethodName("setExpiryTimeOfDay");
expiryTimeOfDayMapping.setReferenceClass(TimeOfDayMetadata.class);
expiryTimeOfDayMapping.setXPath("orm:time-of-day");
descriptor.addMapping(expiryTimeOfDayMapping);
descriptor.addMapping(getSizeAttributeMapping());
XMLDirectMapping sharedMapping = new XMLDirectMapping();
sharedMapping.setAttributeName("m_shared");
sharedMapping.setGetMethodName("getShared");
sharedMapping.setSetMethodName("setShared");
sharedMapping.setXPath("@shared");
descriptor.addMapping(sharedMapping);
XMLDirectMapping isolationMapping = new XMLDirectMapping();
isolationMapping.setAttributeName("m_isolation");
isolationMapping.setGetMethodName("getIsolation");
isolationMapping.setSetMethodName("setIsolation");
isolationMapping.setXPath("@isolation");
descriptor.addMapping(isolationMapping);
descriptor.addMapping(getTypeAttributeMapping());
XMLDirectMapping alwaysRefreshMapping = new XMLDirectMapping();
alwaysRefreshMapping.setAttributeName("m_alwaysRefresh");
alwaysRefreshMapping.setGetMethodName("getAlwaysRefresh");
alwaysRefreshMapping.setSetMethodName("setAlwaysRefresh");
alwaysRefreshMapping.setXPath("@always-refresh");
descriptor.addMapping(alwaysRefreshMapping);
XMLDirectMapping refreshOnlyIfNewerMapping = new XMLDirectMapping();
refreshOnlyIfNewerMapping.setAttributeName("m_refreshOnlyIfNewer");
refreshOnlyIfNewerMapping.setGetMethodName("getRefreshOnlyIfNewer");
refreshOnlyIfNewerMapping.setSetMethodName("setRefreshOnlyIfNewer");
refreshOnlyIfNewerMapping.setXPath("@refresh-only-if-newer");
descriptor.addMapping(refreshOnlyIfNewerMapping);
XMLDirectMapping disableHitsMapping = new XMLDirectMapping();
disableHitsMapping.setAttributeName("m_disableHits");
disableHitsMapping.setGetMethodName("getDisableHits");
disableHitsMapping.setSetMethodName("setDisableHits");
disableHitsMapping.setXPath("@disable-hits");
descriptor.addMapping(disableHitsMapping);
XMLDirectMapping coordinationTypeMapping = new XMLDirectMapping();
coordinationTypeMapping.setAttributeName("m_coordinationType");
coordinationTypeMapping.setGetMethodName("getCoordinationType");
coordinationTypeMapping.setSetMethodName("setCoordinationType");
coordinationTypeMapping.setXPath("@coordination-type");
descriptor.addMapping(coordinationTypeMapping);
XMLDirectMapping databaseChangeNotificationTypeMapping = new XMLDirectMapping();
databaseChangeNotificationTypeMapping.setAttributeName("m_databaseChangeNotificationType");
databaseChangeNotificationTypeMapping.setGetMethodName("getDatabaseChangeNotificationType");
databaseChangeNotificationTypeMapping.setSetMethodName("setDatabaseChangeNotificationType");
databaseChangeNotificationTypeMapping.setXPath("@databaseChangeNotification-type");
descriptor.addMapping(databaseChangeNotificationTypeMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: cache-interceptor
*/
protected ClassDescriptor buildCacheInterceptorDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(CacheInterceptorMetadata.class);
XMLDirectMapping interceptorClassName = new XMLDirectMapping();
interceptorClassName.setAttributeName("m_interceptorClassName");
interceptorClassName.setGetMethodName("getInterceptorClassName");
interceptorClassName.setSetMethodName("setInterceptorClassName");
interceptorClassName.setXPath("@class");
descriptor.addMapping(interceptorClassName);
return descriptor;
}
/**
* INTERNAL:
* XSD: cascade-type
*/
protected ClassDescriptor buildCascadeTypeDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(CascadeMetadata.class);
XMLDirectMapping cascadeAllMapping = new XMLDirectMapping();
cascadeAllMapping.setAttributeName("m_cascadeAll");
cascadeAllMapping.setGetMethodName("getCascadeAll");
cascadeAllMapping.setSetMethodName("setCascadeAll");
cascadeAllMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy cascadeAllPolicy = new IsSetNullPolicy("isCascadeAll");
cascadeAllPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
cascadeAllMapping.setNullPolicy(cascadeAllPolicy);
cascadeAllMapping.setXPath("orm:cascade-all");
descriptor.addMapping(cascadeAllMapping);
descriptor.addMapping(getCascadePersistMapping());
XMLDirectMapping cascadeMergeMapping = new XMLDirectMapping();
cascadeMergeMapping.setAttributeName("m_cascadeMerge");
cascadeMergeMapping.setGetMethodName("getCascadeMerge");
cascadeMergeMapping.setSetMethodName("setCascadeMerge");
cascadeMergeMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy cascadeMergePolicy = new IsSetNullPolicy("isCascadeMerge");
cascadeMergePolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
cascadeMergeMapping.setNullPolicy(cascadeMergePolicy);
cascadeMergeMapping.setXPath("orm:cascade-merge");
descriptor.addMapping(cascadeMergeMapping);
XMLDirectMapping cascadeRemoveMapping = new XMLDirectMapping();
cascadeRemoveMapping.setAttributeName("m_cascadeRemove");
cascadeRemoveMapping.setGetMethodName("getCascadeRemove");
cascadeRemoveMapping.setSetMethodName("setCascadeRemove");
cascadeRemoveMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy cascadeRemovePolicy = new IsSetNullPolicy("isCascadeRemove");
cascadeRemovePolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
cascadeRemoveMapping.setNullPolicy(cascadeRemovePolicy);
cascadeRemoveMapping.setXPath("orm:cascade-remove");
descriptor.addMapping(cascadeRemoveMapping);
XMLDirectMapping cascadeRefreshMapping = new XMLDirectMapping();
cascadeRefreshMapping.setAttributeName("m_cascadeRefresh");
cascadeRefreshMapping.setGetMethodName("getCascadeRefresh");
cascadeRefreshMapping.setSetMethodName("setCascadeRefresh");
cascadeRefreshMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy cascadeRefreshPolicy = new IsSetNullPolicy("isCascadeRefresh");
cascadeRefreshPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
cascadeRefreshMapping.setNullPolicy(cascadeRefreshPolicy);
cascadeRefreshMapping.setXPath("orm:cascade-refresh");
descriptor.addMapping(cascadeRefreshMapping);
XMLDirectMapping cascadeDetachMapping = new XMLDirectMapping();
cascadeDetachMapping.setAttributeName("m_cascadeDetach");
cascadeDetachMapping.setGetMethodName("getCascadeDetach");
cascadeDetachMapping.setSetMethodName("setCascadeDetach");
cascadeDetachMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy cascadeDetachPolicy = new IsSetNullPolicy("isCascadeDetach");
cascadeDetachPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
cascadeDetachMapping.setNullPolicy(cascadeDetachPolicy);
cascadeDetachMapping.setXPath("orm:cascade-detach");
descriptor.addMapping(cascadeDetachMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: change-tracking
*/
protected ClassDescriptor buildChangeTrackingDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ChangeTrackingMetadata.class);
descriptor.addMapping(getTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: clone-copy-policy
*/
protected ClassDescriptor buildCloneCopyPolicyDescriptor(){
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(CloneCopyPolicyMetadata.class);
XMLDirectMapping methodMapping = new XMLDirectMapping();
methodMapping.setAttributeName("methodName");
methodMapping.setGetMethodName("getMethodName");
methodMapping.setSetMethodName("setMethodName");
methodMapping.setXPath("@method");
descriptor.addMapping(methodMapping);
XMLDirectMapping workingCopyMethodMapping = new XMLDirectMapping();
workingCopyMethodMapping.setAttributeName("workingCopyMethodName");
workingCopyMethodMapping.setGetMethodName("getWorkingCopyMethodName");
workingCopyMethodMapping.setSetMethodName("setWorkingCopyMethodName");
workingCopyMethodMapping.setXPath("@working-copy-method");
descriptor.addMapping(workingCopyMethodMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: collection-table
*/
protected ClassDescriptor buildCollectionTableDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(CollectionTableMetadata.class);
// In a JPA 2.0 specification, join columns will be specified. In an
// EclipseLink specification, primary key join columns will be
// specified. We therefore map both since the metadata object is built
// to handle one or the other. XML will restrict the ability to set
// both so this is not a problem.
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getJoinColumnMapping());
descriptor.addMapping(getForeignKeyMapping());
descriptor.addMapping(getPrimaryKeyJoinColumnMapping());
descriptor.addMapping(getUniqueConstraintMapping());
descriptor.addMapping(getIndexesMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getCatalogAttributeMapping());
descriptor.addMapping(getSchemaAttributeMapping());
descriptor.addMapping(getCreationSuffixAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: column
*/
protected ClassDescriptor buildColumnDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ColumnMetadata.class);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getUniqueAttributeMapping());
descriptor.addMapping(getNullableAttributeMapping());
descriptor.addMapping(getInsertableAttributeMapping());
descriptor.addMapping(getUpdatableAttributeMapping());
descriptor.addMapping(getColumnDefinitionAttributeMapping());
descriptor.addMapping(getTableAttributeMapping());
descriptor.addMapping(getLengthAttributeMapping());
descriptor.addMapping(getPrecisionAttributeMapping());
descriptor.addMapping(getScaleAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: column-result
*/
protected ClassDescriptor buildColumnResultDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ColumnResultMetadata.class);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getClassTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: column-result
*/
protected ClassDescriptor buildConstructorResultDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ConstructorResultMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getConstructorColumnMapping());
// Attribute mappings.
descriptor.addMapping(getTargetClassAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: conversion-value
*/
protected ClassDescriptor buildConversionValueDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ConversionValueMetadata.class);
XMLDirectMapping dataValueMapping = new XMLDirectMapping();
dataValueMapping.setAttributeName("m_dataValue");
dataValueMapping.setGetMethodName("getDataValue");
dataValueMapping.setSetMethodName("setDataValue");
dataValueMapping.setXPath("@data-value");
descriptor.addMapping(dataValueMapping);
XMLDirectMapping objectValueMapping = new XMLDirectMapping();
objectValueMapping.setAttributeName("m_objectValue");
objectValueMapping.setGetMethodName("getObjectValue");
objectValueMapping.setSetMethodName("setObjectValue");
objectValueMapping.setXPath("@object-value");
descriptor.addMapping(objectValueMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: convert
*/
protected ClassDescriptor buildConvertDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ConvertMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getTextMapping());
// Attribute mappings
descriptor.addMapping(getConverterAttributeMapping());
descriptor.addMapping(getAttributeNameAttributeMapping());
descriptor.addMapping(getDisableConversionAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: converter
*/
protected ClassDescriptor buildConverterDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ConverterMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getClassAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: copy-policy
*/
protected ClassDescriptor buildCustomCopyPolicyDescriptor(){
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(CustomCopyPolicyMetadata.class);
XMLDirectMapping classMapping = new XMLDirectMapping();
classMapping.setAttributeName("copyPolicyClassName");
classMapping.setGetMethodName("getCopyPolicyClassName");
classMapping.setSetMethodName("setCopyPolicyClassName");
classMapping.setXPath("@class");
descriptor.addMapping(classMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: cache-interceptor
*/
protected ClassDescriptor buildDefaultRedirectorsDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(QueryRedirectorsMetadata.class);
XMLDirectMapping allQueries = new XMLDirectMapping();
allQueries.setAttributeName("defaultQueryRedirectorName");
allQueries.setGetMethodName("getDefaultQueryRedirectorName");
allQueries.setSetMethodName("setDefaultQueryRedirectorName");
allQueries.setXPath("@all-queries");
descriptor.addMapping(allQueries);
XMLDirectMapping readAllQuery = new XMLDirectMapping();
readAllQuery.setAttributeName("defaultReadAllQueryRedirectorName");
readAllQuery.setGetMethodName("getDefaultReadAllQueryRedirectorName");
readAllQuery.setSetMethodName("setDefaultReadAllQueryRedirectorName");
readAllQuery.setXPath("@read-all");
descriptor.addMapping(readAllQuery);
XMLDirectMapping readObjectQuery = new XMLDirectMapping();
readObjectQuery.setAttributeName("defaultReadObjectQueryRedirectorName");
readObjectQuery.setGetMethodName("getDefaultReadObjectQueryRedirectorName");
readObjectQuery.setSetMethodName("setDefaultReadObjectQueryRedirectorName");
readObjectQuery.setXPath("@read-object");
descriptor.addMapping(readObjectQuery);
XMLDirectMapping reportQuery = new XMLDirectMapping();
reportQuery.setAttributeName("defaultReportQueryRedirectorName");
reportQuery.setGetMethodName("getDefaultReportQueryRedirectorName");
reportQuery.setSetMethodName("setDefaultReportQueryRedirectorName");
reportQuery.setXPath("@report");
descriptor.addMapping(reportQuery);
XMLDirectMapping updateQuery = new XMLDirectMapping();
updateQuery.setAttributeName("defaultUpdateObjectQueryRedirectorName");
updateQuery.setGetMethodName("getDefaultUpdateObjectQueryRedirectorName");
updateQuery.setSetMethodName("setDefaultUpdateObjectQueryRedirectorName");
updateQuery.setXPath("@update");
descriptor.addMapping(updateQuery);
XMLDirectMapping insertQuery = new XMLDirectMapping();
insertQuery.setAttributeName("defaultInsertObjectQueryRedirectorName");
insertQuery.setGetMethodName("getDefaultInsertObjectQueryRedirectorName");
insertQuery.setSetMethodName("setDefaultInsertObjectQueryRedirectorName");
insertQuery.setXPath("@insert");
descriptor.addMapping(insertQuery);
XMLDirectMapping deleteQuery = new XMLDirectMapping();
deleteQuery.setAttributeName("defaultDeleteObjectQueryRedirectorName");
deleteQuery.setGetMethodName("getDefaultDeleteObjectQueryRedirectorName");
deleteQuery.setSetMethodName("setDefaultDeleteObjectQueryRedirectorName");
deleteQuery.setXPath("@delete");
descriptor.addMapping(deleteQuery);
return descriptor;
}
/**
* INTERNAL:
* XSD: discriminator-class
*/
protected ClassDescriptor buildDiscriminatorClassDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(DiscriminatorClassMetadata.class);
XMLDirectMapping discriminatorMapping = new XMLDirectMapping();
discriminatorMapping.setAttributeName("m_discriminator");
discriminatorMapping.setGetMethodName("getDiscriminator");
discriminatorMapping.setSetMethodName("setDiscriminator");
discriminatorMapping.setXPath("@discriminator");
descriptor.addMapping(discriminatorMapping);
descriptor.addMapping(getValueAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: discriminator-column
*/
protected ClassDescriptor buildDiscriminatorColumnDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(DiscriminatorColumnMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getDiscriminatorTypeAttributeMapping());
descriptor.addMapping(getColumnDefinitionAttributeMapping());
descriptor.addMapping(getLengthAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: element-collection
*/
protected ClassDescriptor buildElementCollectionDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ElementCollectionAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getOrderByMapping());
descriptor.addMapping(getOrderColumnMapping());
descriptor.addMapping(getMapKeyMapping());
descriptor.addMapping(getMapKeyClassMapping());
descriptor.addMapping(getMapKeyTemporalMapping());
descriptor.addMapping(getMapKeyEnumeratedMapping());
descriptor.addMapping(getMapKeyAttributeOverrideMapping());
descriptor.addMapping(getMapKeyConvertMapping());
descriptor.addMapping(getMapKeyAssociationOverrideMapping());
descriptor.addMapping(getMapKeyColumnMapping());
descriptor.addMapping(getMapKeyJoinColumnMapping());
descriptor.addMapping(getMapKeyForeignKeyMapping());
descriptor.addMapping(getColumnMapping());
descriptor.addMapping(getTemporalMapping());
descriptor.addMapping(getEnumeratedMapping());
descriptor.addMapping(getLobMapping());
descriptor.addMapping(getConvertMapping());
descriptor.addMapping(getAttributeOverrideMapping());
descriptor.addMapping(getAssociationOverrideMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getCollectionTableMapping());
descriptor.addMapping(getFieldMapping());
descriptor.addMapping(getCascadeOnDeleteMapping());
descriptor.addMapping(getJoinFetchMapping());
descriptor.addMapping(getBatchFetchMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getNonCacheableMapping());
descriptor.addMapping(getDeleteAllMapping());
descriptor.addMapping(getPartitioningMapping());
descriptor.addMapping(getReplicationPartitioningMapping());
descriptor.addMapping(getRoundRobinPartitioningMapping());
descriptor.addMapping(getPinnedPartitioningMapping());
descriptor.addMapping(getRangePartitioningMapping());
descriptor.addMapping(getValuePartitioningMapping());
descriptor.addMapping(getHashPartitioningMapping());
descriptor.addMapping(getUnionPartitioningMapping());
descriptor.addMapping(getPartitionedMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getTargetClassAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
descriptor.addMapping(getCompositeMemberAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: array
*/
protected ClassDescriptor buildArrayDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ArrayAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnMapping());
descriptor.addMapping(getTemporalMapping());
descriptor.addMapping(getEnumeratedMapping());
descriptor.addMapping(getLobMapping());
descriptor.addMapping(getConvertMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getTargetClassAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
descriptor.addMapping(getDatabaseTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: embeddable
*/
protected ClassDescriptor buildEmbeddableDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(EmbeddableAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getDescriptionMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getCustomizerMapping());
descriptor.addMapping(getChangeTrackingMapping());
descriptor.addMapping(getStructMapping());
descriptor.addMapping(getNoSqlMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getCustomCopyPolicyMapping());
descriptor.addMapping(getInstantiationCopyPolicyMapping());
descriptor.addMapping(getCloneCopyPolicyMapping());
descriptor.addMapping(getOracleObjectTypeMapping());
descriptor.addMapping(getOracleArrayTypeMapping());
descriptor.addMapping(getPLSQLRecordMapping());
descriptor.addMapping(getPLSQLTableMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAttributeOverrideMapping());
descriptor.addMapping(getAssociationOverrideMapping());
descriptor.addMapping(getAttributesMapping());
// Attribute mappings.
descriptor.addMapping(getClassAttributeMapping());
descriptor.addMapping(getParentClassAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMetadataCompleteAttributeMapping());
descriptor.addMapping(getExcludeDefaultMappingsAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: embedded
*/
protected ClassDescriptor buildEmbeddedDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(EmbeddedAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getAttributeOverrideMapping());
descriptor.addMapping(getAssociationOverrideMapping());
descriptor.addMapping(getConvertMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getFieldMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: structure
*/
protected ClassDescriptor buildStructureDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(StructureAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
descriptor.addMapping(getTargetClassAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: embedded-id
*/
protected ClassDescriptor buildEmbeddedIdDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(EmbeddedIdAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getAttributeOverrideMapping());
descriptor.addMapping(getAssociationOverrideMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: entity
*/
protected ClassDescriptor buildEntityDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(EntityAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getDescriptionMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getMultitenantMapping());
descriptor.addMapping(getAdditionalCriteriaMapping());
descriptor.addMapping(getCustomizerMapping());
descriptor.addMapping(getChangeTrackingMapping());
XMLCompositeObjectMapping tableMapping = new XMLCompositeObjectMapping();
tableMapping.setAttributeName("m_table");
tableMapping.setGetMethodName("getTable");
tableMapping.setSetMethodName("setTable");
tableMapping.setReferenceClass(TableMetadata.class);
tableMapping.setXPath("orm:table");
descriptor.addMapping(tableMapping);
XMLCompositeCollectionMapping secondaryTablesMapping = new XMLCompositeCollectionMapping();
secondaryTablesMapping.setAttributeName("m_secondaryTables");
secondaryTablesMapping.setGetMethodName("getSecondaryTables");
secondaryTablesMapping.setSetMethodName("setSecondaryTables");
secondaryTablesMapping.setReferenceClass(SecondaryTableMetadata.class);
secondaryTablesMapping.setXPath("orm:secondary-table");
descriptor.addMapping(secondaryTablesMapping);
descriptor.addMapping(getStructMapping());
descriptor.addMapping(getNoSqlMapping());
descriptor.addMapping(getPrimaryKeyJoinColumnMapping());
descriptor.addMapping(getPrimaryKeyForeignKeyMapping());
descriptor.addMapping(getCascadeOnDeleteMapping());
descriptor.addMapping(getIndexesMapping());
descriptor.addMapping(getIdClassMapping());
descriptor.addMapping(getPrimaryKeyMapping());
XMLCompositeObjectMapping inheritanceMapping = new XMLCompositeObjectMapping();
inheritanceMapping.setAttributeName("m_inheritance");
inheritanceMapping.setGetMethodName("getInheritance");
inheritanceMapping.setSetMethodName("setInheritance");
inheritanceMapping.setReferenceClass(InheritanceMetadata.class);
inheritanceMapping.setXPath("orm:inheritance");
descriptor.addMapping(inheritanceMapping);
XMLDirectMapping discriminatorValueMapping = new XMLDirectMapping();
discriminatorValueMapping.setAttributeName("m_discriminatorValue");
discriminatorValueMapping.setGetMethodName("getDiscriminatorValue");
discriminatorValueMapping.setSetMethodName("setDiscriminatorValue");
discriminatorValueMapping.setXPath("orm:discriminator-value/text()");
descriptor.addMapping(discriminatorValueMapping);
descriptor.addMapping(getDiscriminatorColumnMapping());
descriptor.addMapping(getClassExtractorMapping());
descriptor.addMapping(getOptimisticLockingMapping());
descriptor.addMapping(getCacheMapping());
descriptor.addMapping(getCacheInterceptorMapping());
descriptor.addMapping(getCacheIndexesMapping());
descriptor.addMapping(getFetchGroupMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getCustomCopyPolicyMapping());
descriptor.addMapping(getInstantiationCopyPolicyMapping());
descriptor.addMapping(getCloneCopyPolicyMapping());
descriptor.addMapping(getSerializedObjectPolicyMapping());
descriptor.addMapping(getSequenceGeneratorMapping());
descriptor.addMapping(getTableGeneratorMapping());
descriptor.addMapping(getUuidGeneratorMapping());
descriptor.addMapping(getPartitioningMapping());
descriptor.addMapping(getReplicationPartitioningMapping());
descriptor.addMapping(getRoundRobinPartitioningMapping());
descriptor.addMapping(getPinnedPartitioningMapping());
descriptor.addMapping(getRangePartitioningMapping());
descriptor.addMapping(getValuePartitioningMapping());
descriptor.addMapping(getHashPartitioningMapping());
descriptor.addMapping(getUnionPartitioningMapping());
descriptor.addMapping(getPartitionedMapping());
descriptor.addMapping(getNamedQueryMapping());
descriptor.addMapping(getNamedNativeQueryMapping());
descriptor.addMapping(getNamedStoredProcedureQueryMapping());
descriptor.addMapping(getNamedStoredFunctionQueryMapping());
descriptor.addMapping(getNamedPLSQLStoredProcedureQueryMapping());
descriptor.addMapping(getNamedPLSQLStoredFunctionQueryMapping());
descriptor.addMapping(getOracleObjectTypeMapping());
descriptor.addMapping(getOracleArrayTypeMapping());
descriptor.addMapping(getPLSQLRecordMapping());
descriptor.addMapping(getPLSQLTableMapping());
descriptor.addMapping(getResultSetMappingMapping());
descriptor.addMapping(getQueryRedirectorsMapping());
descriptor.addMapping(getExcludeDefaultListenersMapping());
descriptor.addMapping(getExcludeSuperclassListenersMapping());
descriptor.addMapping(getEntityListenersMapping());
descriptor.addMapping(getPrePeristMapping());
descriptor.addMapping(getPostPeristMapping());
descriptor.addMapping(getPreRemoveMapping());
descriptor.addMapping(getPostRemoveMapping());
descriptor.addMapping(getPreUpdateMapping());
descriptor.addMapping(getPostUpdateMapping());
descriptor.addMapping(getPostLoadMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAttributeOverrideMapping());
descriptor.addMapping(getAssociationOverrideMapping());
descriptor.addMapping(getConvertMapping());
descriptor.addMapping(getNamedEntityGraphMapping());
descriptor.addMapping(getAttributesMapping());
// Attribute mappings.
XMLDirectMapping nameMapping = new XMLDirectMapping();
nameMapping.setAttributeName("m_entityName");
nameMapping.setGetMethodName("getEntityName");
nameMapping.setSetMethodName("setEntityName");
nameMapping.setXPath("@name");
descriptor.addMapping(nameMapping);
descriptor.addMapping(getClassAttributeMapping());
descriptor.addMapping(getParentClassAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getCacheableAttributeMapping());
descriptor.addMapping(getMetadataCompleteAttributeMapping());
descriptor.addMapping(getExcludeDefaultMappingsAttributeMapping());
descriptor.addMapping(getReadOnlyAttributeMapping());
descriptor.addMapping(getExistenceCheckingAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: entity-listener
*/
protected ClassDescriptor buildEntityListenerDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(EntityListenerMetadata.class);
descriptor.addMapping(getPrePeristMapping());
descriptor.addMapping(getPostPeristMapping());
descriptor.addMapping(getPreRemoveMapping());
descriptor.addMapping(getPostRemoveMapping());
descriptor.addMapping(getPreUpdateMapping());
descriptor.addMapping(getPostUpdateMapping());
descriptor.addMapping(getPostLoadMapping());
descriptor.addMapping(getClassAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: entity-mappings
*/
protected ClassDescriptor buildEntityMappingsDescriptor(String xsdLocation) {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setDefaultRootElement("orm:entity-mappings");
descriptor.setJavaClass(XMLEntityMappings.class);
descriptor.setSchemaReference(new XMLSchemaClassPathReference(xsdLocation));
descriptor.addMapping(getDescriptionMapping());
XMLCompositeObjectMapping persistenceUnitMetadataMapping = new XMLCompositeObjectMapping();
persistenceUnitMetadataMapping.setAttributeName("m_persistenceUnitMetadata");
persistenceUnitMetadataMapping.setGetMethodName("getPersistenceUnitMetadata");
persistenceUnitMetadataMapping.setSetMethodName("setPersistenceUnitMetadata");
persistenceUnitMetadataMapping.setReferenceClass(XMLPersistenceUnitMetadata.class);
persistenceUnitMetadataMapping.setXPath("orm:persistence-unit-metadata");
descriptor.addMapping(persistenceUnitMetadataMapping);
XMLDirectMapping packageMapping = new XMLDirectMapping();
packageMapping.setAttributeName("m_package");
packageMapping.setGetMethodName("getPackage");
packageMapping.setSetMethodName("setPackage");
packageMapping.setXPath("orm:package/text()");
descriptor.addMapping(packageMapping);
descriptor.addMapping(getSchemaMapping());
descriptor.addMapping(getCatalogMapping());
descriptor.addMapping(getAccessMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getTenantDiscriminatorColumnsMapping());
descriptor.addMapping(getMixedConverterMapping());
descriptor.addMapping(getTypeConverterMapping());
descriptor.addMapping(getObjectTypeConverterMapping());
descriptor.addMapping(getSerializedConverterMapping());
descriptor.addMapping(getStructConverterMapping());
XMLCompositeCollectionMapping sequenceGeneratorsMapping = new XMLCompositeCollectionMapping();
sequenceGeneratorsMapping.setAttributeName("m_sequenceGenerators");
sequenceGeneratorsMapping.setGetMethodName("getSequenceGenerators");
sequenceGeneratorsMapping.setSetMethodName("setSequenceGenerators");
sequenceGeneratorsMapping.setReferenceClass(SequenceGeneratorMetadata.class);
sequenceGeneratorsMapping.setXPath("orm:sequence-generator");
descriptor.addMapping(sequenceGeneratorsMapping);
XMLCompositeCollectionMapping tableGeneratorsMapping = new XMLCompositeCollectionMapping();
tableGeneratorsMapping.setAttributeName("m_tableGenerators");
tableGeneratorsMapping.setGetMethodName("getTableGenerators");
tableGeneratorsMapping.setSetMethodName("setTableGenerators");
tableGeneratorsMapping.setReferenceClass(TableGeneratorMetadata.class);
tableGeneratorsMapping.setXPath("orm:table-generator");
descriptor.addMapping(tableGeneratorsMapping);
XMLCompositeCollectionMapping uuidGeneratorsMapping = new XMLCompositeCollectionMapping();
uuidGeneratorsMapping.setAttributeName("m_uuidGenerators");
uuidGeneratorsMapping.setGetMethodName("getUuidGenerators");
uuidGeneratorsMapping.setSetMethodName("setUuidGenerators");
uuidGeneratorsMapping.setReferenceClass(UuidGeneratorMetadata.class);
uuidGeneratorsMapping.setXPath("orm:uuid-generator");
descriptor.addMapping(uuidGeneratorsMapping);
XMLCompositeCollectionMapping partitioningMapping = new XMLCompositeCollectionMapping();
partitioningMapping.setAttributeName("m_partitioning");
partitioningMapping.setGetMethodName("getPartitioning");
partitioningMapping.setSetMethodName("setPartitioning");
partitioningMapping.setReferenceClass(PartitioningMetadata.class);
partitioningMapping.setXPath("orm:partitioning");
descriptor.addMapping(partitioningMapping);
partitioningMapping = new XMLCompositeCollectionMapping();
partitioningMapping.setAttributeName("m_replicationPartitioning");
partitioningMapping.setGetMethodName("getReplicationPartitioning");
partitioningMapping.setSetMethodName("setReplicationPartitioning");
partitioningMapping.setReferenceClass(ReplicationPartitioningMetadata.class);
partitioningMapping.setXPath("orm:replication-partitioning");
descriptor.addMapping(partitioningMapping);
partitioningMapping = new XMLCompositeCollectionMapping();
partitioningMapping.setAttributeName("m_roundRobinPartitioning");
partitioningMapping.setGetMethodName("getRoundRobinPartitioning");
partitioningMapping.setSetMethodName("setRoundRobinPartitioning");
partitioningMapping.setReferenceClass(RoundRobinPartitioningMetadata.class);
partitioningMapping.setXPath("orm:round-robin-partitioning");
descriptor.addMapping(partitioningMapping);
partitioningMapping = new XMLCompositeCollectionMapping();
partitioningMapping.setAttributeName("m_pinnedPartitioning");
partitioningMapping.setGetMethodName("getPinnedPartitioning");
partitioningMapping.setSetMethodName("setPinnedPartitioning");
partitioningMapping.setReferenceClass(PinnedPartitioningMetadata.class);
partitioningMapping.setXPath("orm:pinned-partitioning");
descriptor.addMapping(partitioningMapping);
partitioningMapping = new XMLCompositeCollectionMapping();
partitioningMapping.setAttributeName("m_rangePartitioning");
partitioningMapping.setGetMethodName("getRangePartitioning");
partitioningMapping.setSetMethodName("setRangePartitioning");
partitioningMapping.setReferenceClass(RangePartitioningMetadata.class);
partitioningMapping.setXPath("orm:range-partitioning");
descriptor.addMapping(partitioningMapping);
partitioningMapping = new XMLCompositeCollectionMapping();
partitioningMapping.setAttributeName("m_valuePartitioning");
partitioningMapping.setGetMethodName("getValuePartitioning");
partitioningMapping.setSetMethodName("setValuePartitioning");
partitioningMapping.setReferenceClass(ValuePartitioningMetadata.class);
partitioningMapping.setXPath("orm:value-partitioning");
descriptor.addMapping(partitioningMapping);
partitioningMapping = new XMLCompositeCollectionMapping();
partitioningMapping.setAttributeName("m_hashPartitioning");
partitioningMapping.setGetMethodName("getHashPartitioning");
partitioningMapping.setSetMethodName("setHashPartitioning");
partitioningMapping.setReferenceClass(HashPartitioningMetadata.class);
partitioningMapping.setXPath("orm:hash-partitioning");
descriptor.addMapping(partitioningMapping);
partitioningMapping = new XMLCompositeCollectionMapping();
partitioningMapping.setAttributeName("m_unionPartitioning");
partitioningMapping.setGetMethodName("getUnionPartitioning");
partitioningMapping.setSetMethodName("setUnionPartitioning");
partitioningMapping.setReferenceClass(UnionPartitioningMetadata.class);
partitioningMapping.setXPath("orm:union-partitioning");
descriptor.addMapping(partitioningMapping);
descriptor.addMapping(getNamedQueryMapping());
descriptor.addMapping(getNamedNativeQueryMapping());
descriptor.addMapping(getNamedStoredProcedureQueryMapping());
descriptor.addMapping(getNamedStoredFunctionQueryMapping());
descriptor.addMapping(getNamedPLSQLStoredProcedureQueryMapping());
descriptor.addMapping(getNamedPLSQLStoredFunctionQueryMapping());
descriptor.addMapping(getOracleObjectTypeMapping());
descriptor.addMapping(getOracleArrayTypeMapping());
descriptor.addMapping(getPLSQLRecordMapping());
descriptor.addMapping(getPLSQLTableMapping());
descriptor.addMapping(getResultSetMappingMapping());
XMLCompositeCollectionMapping mappedSuperclassMapping = new XMLCompositeCollectionMapping();
mappedSuperclassMapping.setAttributeName("m_mappedSuperclasses");
mappedSuperclassMapping.setGetMethodName("getMappedSuperclasses");
mappedSuperclassMapping.setSetMethodName("setMappedSuperclasses");
mappedSuperclassMapping.setReferenceClass(MappedSuperclassAccessor.class);
mappedSuperclassMapping.setXPath("orm:mapped-superclass");
descriptor.addMapping(mappedSuperclassMapping);
XMLCompositeCollectionMapping entityMapping = new XMLCompositeCollectionMapping();
entityMapping.setAttributeName("m_entities");
entityMapping.setGetMethodName("getEntities");
entityMapping.setSetMethodName("setEntities");
entityMapping.setReferenceClass(EntityAccessor.class);
entityMapping.setXPath("orm:entity");
descriptor.addMapping(entityMapping);
XMLCompositeCollectionMapping embeddableMapping = new XMLCompositeCollectionMapping();
embeddableMapping.setAttributeName("m_embeddables");
embeddableMapping.setGetMethodName("getEmbeddables");
embeddableMapping.setSetMethodName("setEmbeddables");
embeddableMapping.setReferenceClass(EmbeddableAccessor.class);
embeddableMapping.setXPath("orm:embeddable");
descriptor.addMapping(embeddableMapping);
// What about the version attribute???
XMLDirectMapping versionMapping = new XMLDirectMapping();
versionMapping.setAttributeName("m_version");
versionMapping.setGetMethodName("getVersion");
versionMapping.setSetMethodName("setVersion");
versionMapping.setXPath("@version");
descriptor.addMapping(versionMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: entity-result
*/
protected ClassDescriptor buildEntityResultDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(EntityResultMetadata.class);
XMLCompositeCollectionMapping fieldResultMapping = new XMLCompositeCollectionMapping();
fieldResultMapping.setAttributeName("m_fieldResults");
fieldResultMapping.setGetMethodName("getFieldResults");
fieldResultMapping.setSetMethodName("setFieldResults");
fieldResultMapping.setReferenceClass(FieldResultMetadata.class);
fieldResultMapping.setXPath("orm:field-result");
descriptor.addMapping(fieldResultMapping);
XMLDirectMapping entityClassMapping = new XMLDirectMapping();
entityClassMapping.setAttributeName("m_entityClassName");
entityClassMapping.setGetMethodName("getEntityClassName");
entityClassMapping.setSetMethodName("setEntityClassName");
entityClassMapping.setXPath("@entity-class");
descriptor.addMapping(entityClassMapping);
XMLDirectMapping discriminatorColumnMapping = new XMLDirectMapping();
discriminatorColumnMapping.setAttributeName("m_discriminatorColumn");
discriminatorColumnMapping.setGetMethodName("getDiscriminatorColumn");
discriminatorColumnMapping.setSetMethodName("setDiscriminatorColumn");
discriminatorColumnMapping.setXPath("@discriminator-column");
descriptor.addMapping(discriminatorColumnMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: enumerated
*/
protected ClassDescriptor buildEnumeratedDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(EnumeratedMetadata.class);
XMLDirectMapping enumeratedMapping = new XMLDirectMapping();
enumeratedMapping.setAttributeName("m_enumeratedType");
enumeratedMapping.setGetMethodName("getEnumeratedType");
enumeratedMapping.setSetMethodName("setEnumeratedType");
enumeratedMapping.setXPath("text()");
descriptor.addMapping(enumeratedMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: fetch-attribute
*/
protected ClassDescriptor buildFetchAttributeDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(FetchAttributeMetadata.class);
// Element mappings - must remain in order of definition in XML.
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: fetch-group
*/
protected ClassDescriptor buildFetchGroupDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(FetchGroupMetadata.class);
// Element mappings - must remain in order of definition in XML.
XMLCompositeCollectionMapping attributesMapping = new XMLCompositeCollectionMapping();
attributesMapping.setAttributeName("m_fetchAttributes");
attributesMapping.setGetMethodName("getFetchAttributes");
attributesMapping.setSetMethodName("setFetchAttributes");
attributesMapping.setReferenceClass(FetchAttributeMetadata.class);
attributesMapping.setXPath("orm:attribute");
descriptor.addMapping(attributesMapping);
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
XMLDirectMapping loadMapping = new XMLDirectMapping();
loadMapping.setAttributeName("m_load");
loadMapping.setGetMethodName("getLoad");
loadMapping.setSetMethodName("setLoad");
loadMapping.setXPath("@load");
descriptor.addMapping(loadMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: field
*/
protected ClassDescriptor buildFieldDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(FieldMetadata.class);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: field-result
*/
protected ClassDescriptor buildFieldResultDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(FieldResultMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getColumnAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: foreign-key
*/
protected ClassDescriptor buildForeignKeyDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ForeignKeyMetadata.class);
// Element mappings - must remain in order of definition in XML.
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getForeignKeyDefinitionAttributeMapping());
descriptor.addMapping(getConstraintModeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: generated-value
*/
protected ClassDescriptor buildGeneratedValueDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(GeneratedValueMetadata.class);
XMLDirectMapping strategyMapping = new XMLDirectMapping();
strategyMapping.setAttributeName("m_strategy");
strategyMapping.setGetMethodName("getStrategy");
strategyMapping.setSetMethodName("setStrategy");
strategyMapping.setXPath("@strategy");
descriptor.addMapping(strategyMapping);
XMLDirectMapping generatorMapping = new XMLDirectMapping();
generatorMapping.setAttributeName("m_generator");
generatorMapping.setGetMethodName("getGenerator");
generatorMapping.setSetMethodName("setGenerator");
generatorMapping.setXPath("@generator");
descriptor.addMapping(generatorMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: hash-partitioning
*/
protected ClassDescriptor buildHashPartitioningDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(HashPartitioningMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getUnionUnpartitionableQueriesAttributeMapping());
descriptor.addMapping(getPartitionColumnMapping());
descriptor.addMapping(getConnectionPoolsMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: id
*/
protected ClassDescriptor buildIdDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(IdAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnMapping());
descriptor.addMapping(getFieldMapping());
descriptor.addMapping(getIndexMapping());
descriptor.addMapping(getCacheIndexMapping());
descriptor.addMapping(getGeneratedValueMapping());
descriptor.addMapping(getTemporalMapping());
descriptor.addMapping(getEnumeratedMapping());
descriptor.addMapping(getConvertMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getTableGeneratorMapping());
descriptor.addMapping(getSequenceGeneratorMapping());
descriptor.addMapping(getUuidGeneratorMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMutableAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: index
*/
protected ClassDescriptor buildIndexDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(IndexMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnNamesMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getTableAttributeMapping());
descriptor.addMapping(getCatalogAttributeMapping());
descriptor.addMapping(getSchemaAttributeMapping());
descriptor.addMapping(getColumnListAttributeMapping());
descriptor.addMapping(getUniqueAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: cache-index
*/
protected ClassDescriptor buildCacheIndexDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(CacheIndexMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnNamesMapping());
// Attribute mappings.
XMLDirectMapping updateableMapping = new XMLDirectMapping();
updateableMapping.setAttributeName("updateable");
updateableMapping.setGetMethodName("getUpdateable");
updateableMapping.setSetMethodName("setUpdateable");
updateableMapping.setXPath("@updateable");
descriptor.addMapping(updateableMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: inheritance
*/
protected ClassDescriptor buildInheritanceDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(InheritanceMetadata.class);
XMLDirectMapping strategyMapping = new XMLDirectMapping();
strategyMapping.setAttributeName("m_strategy");
strategyMapping.setGetMethodName("getStrategy");
strategyMapping.setSetMethodName("setStrategy");
strategyMapping.setXPath("@strategy");
descriptor.addMapping(strategyMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: instantiation-copy-policy
*/
protected ClassDescriptor buildInstantiationCopyPolicyDescriptor(){
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(InstantiationCopyPolicyMetadata.class);
return descriptor;
}
/**
* INTERNAL:
* XSD: join-column
*/
protected ClassDescriptor buildJoinColumnDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(JoinColumnMetadata.class);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getReferencedColumnNameMapping());
descriptor.addMapping(getUniqueAttributeMapping());
descriptor.addMapping(getNullableAttributeMapping());
descriptor.addMapping(getInsertableAttributeMapping());
descriptor.addMapping(getUpdatableAttributeMapping());
descriptor.addMapping(getColumnDefinitionAttributeMapping());
descriptor.addMapping(getTableAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: join-field
*/
protected ClassDescriptor buildJoinFieldDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(JoinFieldMetadata.class);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
XMLDirectMapping referencedFieldNameMapping = new XMLDirectMapping();
referencedFieldNameMapping.setAttributeName("m_referencedColumnName");
referencedFieldNameMapping.setGetMethodName("getReferencedColumnName");
referencedFieldNameMapping.setSetMethodName("setReferencedColumnName");
referencedFieldNameMapping.setXPath("@referenced-field-name");
descriptor.addMapping(referencedFieldNameMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: join-table
*/
protected ClassDescriptor buildJoinTableDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(JoinTableMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getJoinColumnMapping());
descriptor.addMapping(getForeignKeyMapping());
descriptor.addMapping(getInverseJoinColumnMapping());
descriptor.addMapping(getInverseForeignKeyMapping());
descriptor.addMapping(getUniqueConstraintMapping());
descriptor.addMapping(getIndexesMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getCatalogAttributeMapping());
descriptor.addMapping(getSchemaAttributeMapping());
descriptor.addMapping(getCreationSuffixAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: lob
*/
protected ClassDescriptor buildLobDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(LobMetadata.class);
return descriptor;
}
/**
* INTERNAL:
* XSD: many-to-many
*/
protected ClassDescriptor buildManyToManyDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ManyToManyAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getOrderByMapping());
descriptor.addMapping(getOrderColumnMapping());
descriptor.addMapping(getMapKeyMapping());
descriptor.addMapping(getMapKeyClassMapping());
descriptor.addMapping(getMapKeyTemporalMapping());
descriptor.addMapping(getMapKeyEnumeratedMapping());
descriptor.addMapping(getMapKeyAttributeOverrideMapping());
descriptor.addMapping(getMapKeyConvertMapping());
descriptor.addMapping(getMapKeyAssociationOverrideMapping());
descriptor.addMapping(getMapKeyColumnMapping());
descriptor.addMapping(getMapKeyJoinColumnMapping());
descriptor.addMapping(getMapKeyForeignKeyMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getJoinTableMapping());
descriptor.addMapping(getJoinFieldMapping());
descriptor.addMapping(getCascadeMapping());
descriptor.addMapping(getCascadeOnDeleteMapping());
descriptor.addMapping(getJoinFetchMapping());
descriptor.addMapping(getBatchFetchMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getNonCacheableMapping());
descriptor.addMapping(getPartitioningMapping());
descriptor.addMapping(getReplicationPartitioningMapping());
descriptor.addMapping(getRoundRobinPartitioningMapping());
descriptor.addMapping(getPinnedPartitioningMapping());
descriptor.addMapping(getRangePartitioningMapping());
descriptor.addMapping(getValuePartitioningMapping());
descriptor.addMapping(getHashPartitioningMapping());
descriptor.addMapping(getUnionPartitioningMapping());
descriptor.addMapping(getPartitionedMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getTargetEntityAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMappedByAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: many-to-one
*/
protected ClassDescriptor buildManyToOneDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ManyToOneAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getPrimaryKeyJoinColumnMapping());
descriptor.addMapping(getPrimaryKeyForeignKeyMapping());
descriptor.addMapping(getJoinColumnMapping());
descriptor.addMapping(getForeignKeyMapping());
descriptor.addMapping(getJoinTableMapping());
descriptor.addMapping(getJoinFieldMapping());
descriptor.addMapping(getCascadeMapping());
descriptor.addMapping(getJoinFetchMapping());
descriptor.addMapping(getBatchFetchMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getNonCacheableMapping());
descriptor.addMapping(getPartitioningMapping());
descriptor.addMapping(getReplicationPartitioningMapping());
descriptor.addMapping(getRoundRobinPartitioningMapping());
descriptor.addMapping(getPinnedPartitioningMapping());
descriptor.addMapping(getRangePartitioningMapping());
descriptor.addMapping(getValuePartitioningMapping());
descriptor.addMapping(getHashPartitioningMapping());
descriptor.addMapping(getUnionPartitioningMapping());
descriptor.addMapping(getPartitionedMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getTargetEntityAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getOptionalAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMapsIdAttributeMapping());
descriptor.addMapping(getIdAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: map-key
*/
protected ClassDescriptor buildMapKeyDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(MapKeyMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: mapped-superclass
*/
protected ClassDescriptor buildMappedSuperclassDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(MappedSuperclassAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getDescriptionMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getMultitenantMapping());
descriptor.addMapping(getAdditionalCriteriaMapping());
descriptor.addMapping(getCustomizerMapping());
descriptor.addMapping(getChangeTrackingMapping());
descriptor.addMapping(getIdClassMapping());
descriptor.addMapping(getPrimaryKeyMapping());
descriptor.addMapping(getOptimisticLockingMapping());
descriptor.addMapping(getCacheMapping());
descriptor.addMapping(getCacheIndexesMapping());
descriptor.addMapping(getCacheInterceptorMapping());
descriptor.addMapping(getFetchGroupMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getCustomCopyPolicyMapping());
descriptor.addMapping(getInstantiationCopyPolicyMapping());
descriptor.addMapping(getCloneCopyPolicyMapping());
descriptor.addMapping(getSerializedObjectPolicyMapping());
descriptor.addMapping(getSequenceGeneratorMapping());
descriptor.addMapping(getTableGeneratorMapping());
descriptor.addMapping(getUuidGeneratorMapping());
descriptor.addMapping(getPartitioningMapping());
descriptor.addMapping(getReplicationPartitioningMapping());
descriptor.addMapping(getRoundRobinPartitioningMapping());
descriptor.addMapping(getPinnedPartitioningMapping());
descriptor.addMapping(getRangePartitioningMapping());
descriptor.addMapping(getValuePartitioningMapping());
descriptor.addMapping(getHashPartitioningMapping());
descriptor.addMapping(getUnionPartitioningMapping());
descriptor.addMapping(getPartitionedMapping());
descriptor.addMapping(getNamedQueryMapping());
descriptor.addMapping(getNamedNativeQueryMapping());
descriptor.addMapping(getNamedStoredProcedureQueryMapping());
descriptor.addMapping(getNamedStoredFunctionQueryMapping());
descriptor.addMapping(getNamedPLSQLStoredProcedureQueryMapping());
descriptor.addMapping(getNamedPLSQLStoredFunctionQueryMapping());
descriptor.addMapping(getOracleObjectTypeMapping());
descriptor.addMapping(getOracleArrayTypeMapping());
descriptor.addMapping(getPLSQLRecordMapping());
descriptor.addMapping(getPLSQLTableMapping());
descriptor.addMapping(getResultSetMappingMapping());
descriptor.addMapping(getQueryRedirectorsMapping());
descriptor.addMapping(getExcludeDefaultListenersMapping());
descriptor.addMapping(getExcludeSuperclassListenersMapping());
descriptor.addMapping(getEntityListenersMapping());
descriptor.addMapping(getPrePeristMapping());
descriptor.addMapping(getPostPeristMapping());
descriptor.addMapping(getPreRemoveMapping());
descriptor.addMapping(getPostRemoveMapping());
descriptor.addMapping(getPreUpdateMapping());
descriptor.addMapping(getPostUpdateMapping());
descriptor.addMapping(getPostLoadMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAttributeOverrideMapping());
descriptor.addMapping(getAssociationOverrideMapping());
descriptor.addMapping(getAttributesMapping());
// Attribute mappings.
descriptor.addMapping(getClassAttributeMapping());
descriptor.addMapping(getParentClassAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getCacheableAttributeMapping());
descriptor.addMapping(getMetadataCompleteAttributeMapping());
descriptor.addMapping(getExcludeDefaultMappingsAttributeMapping());
descriptor.addMapping(getReadOnlyAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: converter
*/
protected ClassDescriptor buildMixedConverterDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(MixedConverterMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getClassAttributeMapping());
descriptor.addMapping(getAutoApplyAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: multi-tenant
*/
protected ClassDescriptor buildMultitenantDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(MultitenantMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getTenantDiscriminatorColumnsMapping());
descriptor.addMapping(getTenantTableDiscriminatorMapping());
// Attribute mappings.
descriptor.addMapping(getTypeAttributeMapping());
descriptor.addMapping(getIncludeCriteriaAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: named-attribute-node
*/
protected ClassDescriptor buildNamedAttributeNodeDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedAttributeNodeMetadata.class);
// Element mappings - must remain in order of definition in XML.
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getSubgraphAttributeMapping());
descriptor.addMapping(getKeySubgraphAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: named-entity-graph
*/
protected ClassDescriptor buildNamedEntityGraphDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedEntityGraphMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getNamedAttributeNodeMapping());
descriptor.addMapping(getSubgraphMapping());
descriptor.addMapping(getSubclassSubgraphMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getIncludeAllAttributesAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: named-native-query
*/
protected ClassDescriptor buildNamedNativeQueryDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedNativeQueryMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getQueryMapping());
descriptor.addMapping(getHintMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getResultClassAttributeMapping());
descriptor.addMapping(getResultSetMappingAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: named-plsql-stored-function-query
*/
protected ClassDescriptor buildNamedPLSQLStoredFunctionQueryDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedPLSQLStoredFunctionQueryMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getHintMapping());
descriptor.addMapping(getPLSQLParametersMapping());
XMLCompositeObjectMapping returnParameterMapping = new XMLCompositeObjectMapping();
returnParameterMapping.setAttributeName("m_returnParameter");
returnParameterMapping.setGetMethodName("getReturnParameter");
returnParameterMapping.setSetMethodName("setReturnParameter");
returnParameterMapping.setReferenceClass(PLSQLParameterMetadata.class);
returnParameterMapping.setXPath("orm:return-parameter");
descriptor.addMapping(returnParameterMapping);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getResultClassAttributeMapping());
descriptor.addMapping(getResultSetMappingAttributeMapping());
descriptor.addMapping(getFunctionNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: named-plsql-stored-procedure-query
*/
protected ClassDescriptor buildNamedPLSQLStoredProcedureQueryDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedPLSQLStoredProcedureQueryMetadata.class);
descriptor.addMapping(getHintMapping());
descriptor.addMapping(getPLSQLParametersMapping());
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getResultClassAttributeMapping());
descriptor.addMapping(getResultSetMappingAttributeMapping());
descriptor.addMapping(getProcedureNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: named-query
*/
protected ClassDescriptor buildNamedQueryDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedQueryMetadata.class);
descriptor.addMapping(getQueryMapping());
descriptor.addMapping(getHintMapping());
descriptor.addMapping(getLockModeMapping());
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: named-stored-function-query
*/
protected ClassDescriptor buildNamedStoredFunctionQueryDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedStoredFunctionQueryMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getHintMapping());
descriptor.addMapping(getParametersMapping());
XMLCompositeObjectMapping returnParameterMapping = new XMLCompositeObjectMapping();
returnParameterMapping.setAttributeName("m_returnParameter");
returnParameterMapping.setGetMethodName("getReturnParameter");
returnParameterMapping.setSetMethodName("setReturnParameter");
returnParameterMapping.setReferenceClass(StoredProcedureParameterMetadata.class);
returnParameterMapping.setXPath("orm:return-parameter");
descriptor.addMapping(returnParameterMapping);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getResultSetMappingAttributeMapping());
descriptor.addMapping(getFunctionNameAttributeMapping());
descriptor.addMapping(getCallByIndexAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: named-stored-procedure-query
*/
protected ClassDescriptor buildNamedStoredProcedureQueryDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedStoredProcedureQueryMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getResultClasses());
descriptor.addMapping(getResultSetMappings());
descriptor.addMapping(getHintMapping());
descriptor.addMapping(getParametersMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getResultClassAttributeMapping());
descriptor.addMapping(getResultSetMappingAttributeMapping());
descriptor.addMapping(getProcedureNameAttributeMapping());
descriptor.addMapping(getCallByIndexAttributeMapping());
XMLDirectMapping returnsResultSetMapping = new XMLDirectMapping();
returnsResultSetMapping.setAttributeName("m_returnsResultSet");
returnsResultSetMapping.setGetMethodName("getReturnsResultSet");
returnsResultSetMapping.setSetMethodName("setReturnsResultSet");
returnsResultSetMapping.setXPath("@returns-result-set");
descriptor.addMapping(returnsResultSetMapping);
XMLDirectMapping multipleResultSetsMapping = new XMLDirectMapping();
multipleResultSetsMapping.setAttributeName("m_multipleResultSets");
multipleResultSetsMapping.setGetMethodName("getMultipleResultSets");
multipleResultSetsMapping.setSetMethodName("setMultipleResultSets");
multipleResultSetsMapping.setXPath("@multiple-result-sets");
descriptor.addMapping(multipleResultSetsMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: named-subgraph
*/
protected ClassDescriptor buildNamedSubgraphDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NamedSubgraphMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getNamedAttributeNodeMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getClassTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: no-sql
*/
protected ClassDescriptor buildNoSqlDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(NoSqlMetadata.class);
// Attribute mappings.
XMLDirectMapping dataTypeMapping = new XMLDirectMapping();
dataTypeMapping.setAttributeName("m_dataType");
dataTypeMapping.setGetMethodName("getDataType");
dataTypeMapping.setSetMethodName("setDataType");
dataTypeMapping.setXPath("@data-type");
descriptor.addMapping(dataTypeMapping);
XMLDirectMapping dataFormatMapping = new XMLDirectMapping();
dataFormatMapping.setAttributeName("m_dataFormat");
dataFormatMapping.setGetMethodName("getDataFormat");
dataFormatMapping.setSetMethodName("setDataFormat");
dataFormatMapping.setXPath("@data-format");
descriptor.addMapping(dataFormatMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: object-type-converter
*/
protected ClassDescriptor buildObjectTypeConverterDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ObjectTypeConverterMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getDataTypeAttributeMapping());
descriptor.addMapping(getObjectTypeAttributeMapping());
XMLCompositeCollectionMapping conversionValuesMapping = new XMLCompositeCollectionMapping();
conversionValuesMapping.setAttributeName("m_conversionValues");
conversionValuesMapping.setGetMethodName("getConversionValues");
conversionValuesMapping.setSetMethodName("setConversionValues");
conversionValuesMapping.setReferenceClass(ConversionValueMetadata.class);
conversionValuesMapping.setXPath("orm:conversion-value");
descriptor.addMapping(conversionValuesMapping);
XMLDirectMapping defaultObjectMapping = new XMLDirectMapping();
defaultObjectMapping.setAttributeName("m_defaultObjectValue");
defaultObjectMapping.setGetMethodName("getDefaultObjectValue");
defaultObjectMapping.setSetMethodName("setDefaultObjectValue");
defaultObjectMapping.setXPath("orm:default-object-value");
descriptor.addMapping(defaultObjectMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: one-to-many
*/
protected ClassDescriptor buildOneToManyDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(OneToManyAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getOrderByMapping());
descriptor.addMapping(getOrderColumnMapping());
descriptor.addMapping(getMapKeyMapping());
descriptor.addMapping(getMapKeyClassMapping());
descriptor.addMapping(getMapKeyTemporalMapping());
descriptor.addMapping(getMapKeyEnumeratedMapping());
descriptor.addMapping(getMapKeyAttributeOverrideMapping());
descriptor.addMapping(getMapKeyConvertMapping());
descriptor.addMapping(getMapKeyAssociationOverrideMapping());
descriptor.addMapping(getMapKeyColumnMapping());
descriptor.addMapping(getMapKeyJoinColumnMapping());
descriptor.addMapping(getMapKeyForeignKeyMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getJoinTableMapping());
descriptor.addMapping(getJoinColumnMapping());
descriptor.addMapping(getForeignKeyMapping());
descriptor.addMapping(getJoinFieldMapping());
descriptor.addMapping(getCascadeMapping());
descriptor.addMapping(getCascadeOnDeleteMapping());
descriptor.addMapping(getPrivateOwnedMapping());
descriptor.addMapping(getJoinFetchMapping());
descriptor.addMapping(getBatchFetchMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getNonCacheableMapping());
descriptor.addMapping(getDeleteAllMapping());
descriptor.addMapping(getPartitioningMapping());
descriptor.addMapping(getReplicationPartitioningMapping());
descriptor.addMapping(getRoundRobinPartitioningMapping());
descriptor.addMapping(getPinnedPartitioningMapping());
descriptor.addMapping(getRangePartitioningMapping());
descriptor.addMapping(getValuePartitioningMapping());
descriptor.addMapping(getHashPartitioningMapping());
descriptor.addMapping(getUnionPartitioningMapping());
descriptor.addMapping(getPartitionedMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getTargetEntityAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMappedByAttributeMapping());
descriptor.addMapping(getOrphanRemovalAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: one-to-one
*/
protected ClassDescriptor buildOneToOneDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(OneToOneAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getPrimaryKeyJoinColumnMapping());
descriptor.addMapping(getPrimaryKeyForeignKeyMapping());
descriptor.addMapping(getJoinColumnMapping());
descriptor.addMapping(getForeignKeyMapping());
descriptor.addMapping(getJoinTableMapping());
descriptor.addMapping(getJoinFieldMapping());
descriptor.addMapping(getCascadeMapping());
descriptor.addMapping(getCascadeOnDeleteMapping());
descriptor.addMapping(getPrivateOwnedMapping());
descriptor.addMapping(getJoinFetchMapping());
descriptor.addMapping(getBatchFetchMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getNonCacheableMapping());
descriptor.addMapping(getPartitioningMapping());
descriptor.addMapping(getReplicationPartitioningMapping());
descriptor.addMapping(getRoundRobinPartitioningMapping());
descriptor.addMapping(getPinnedPartitioningMapping());
descriptor.addMapping(getRangePartitioningMapping());
descriptor.addMapping(getValuePartitioningMapping());
descriptor.addMapping(getHashPartitioningMapping());
descriptor.addMapping(getUnionPartitioningMapping());
descriptor.addMapping(getPartitionedMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getTargetEntityAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getOptionalAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMappedByAttributeMapping());
descriptor.addMapping(getOrphanRemovalAttributeMapping());
descriptor.addMapping(getMapsIdAttributeMapping());
descriptor.addMapping(getIdAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: optimistic-locking
*/
protected ClassDescriptor buildOptimisticLockingDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(OptimisticLockingMetadata.class);
// Element mappings - must remain in order of definition in XML.
XMLCompositeCollectionMapping selectedColumnsMapping = new XMLCompositeCollectionMapping();
selectedColumnsMapping.setAttributeName("m_selectedColumns");
selectedColumnsMapping.setGetMethodName("getSelectedColumns");
selectedColumnsMapping.setSetMethodName("setSelectedColumns");
selectedColumnsMapping.setReferenceClass(ColumnMetadata.class);
selectedColumnsMapping.setXPath("orm:selected-column");
descriptor.addMapping(selectedColumnsMapping);
// Attribute mappings.
descriptor.addMapping(getTypeAttributeMapping());
XMLDirectMapping cascadeMapping = new XMLDirectMapping();
cascadeMapping.setAttributeName("m_cascade");
cascadeMapping.setGetMethodName("getCascade");
cascadeMapping.setSetMethodName("setCascade");
cascadeMapping.setXPath("@cascade");
descriptor.addMapping(cascadeMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: order-by
*/
protected ClassDescriptor buildOrderByDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(OrderByMetadata.class);
descriptor.addMapping(getValueMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: order-column
*/
protected ClassDescriptor buildOrderColumnDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(OrderColumnMetadata.class);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getNullableAttributeMapping());
descriptor.addMapping(getInsertableAttributeMapping());
descriptor.addMapping(getUpdatableAttributeMapping());
descriptor.addMapping(getColumnDefinitionAttributeMapping());
XMLDirectMapping correctionTypeMapping = new XMLDirectMapping();
correctionTypeMapping.setAttributeName("m_correctionType");
correctionTypeMapping.setGetMethodName("getCorrectionType");
correctionTypeMapping.setSetMethodName("setCorrectionType");
correctionTypeMapping.setXPath("@correction-type");
descriptor.addMapping(correctionTypeMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: partitioning
*/
protected ClassDescriptor buildPartitioningDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PartitioningMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getClassAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: persistence-unit-defaults
*/
protected ClassDescriptor buildPersistenceUnitDefaultsDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(XMLPersistenceUnitDefaults.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getSchemaMapping());
descriptor.addMapping(getCatalogMapping());
XMLDirectMapping delimitedIdentifiersMapping = new XMLDirectMapping();
delimitedIdentifiersMapping.setAttributeName("m_delimitedIdentifiers");
delimitedIdentifiersMapping.setGetMethodName("getDelimitedIdentifiers");
delimitedIdentifiersMapping.setSetMethodName("setDelimitedIdentifiers");
delimitedIdentifiersMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy delimitedIdentifiersPolicy = new IsSetNullPolicy("isDelimitedIdentifiers");
delimitedIdentifiersPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
delimitedIdentifiersMapping.setNullPolicy(delimitedIdentifiersPolicy);
delimitedIdentifiersMapping.setXPath("orm:delimited-identifiers");
descriptor.addMapping(delimitedIdentifiersMapping);
descriptor.addMapping(getAccessMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getCascadePersistMapping());
descriptor.addMapping(getTenantDiscriminatorColumnsMapping());
descriptor.addMapping(getEntityListenersMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: persistence-unit-metadata
*/
protected ClassDescriptor buildPersistenceUnitMetadataDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(XMLPersistenceUnitMetadata.class);
XMLDirectMapping xmlMappingMetadataCompleteMapping = new XMLDirectMapping();
xmlMappingMetadataCompleteMapping.setAttributeName("m_xmlMappingMetadataComplete");
xmlMappingMetadataCompleteMapping.setGetMethodName("getXMLMappingMetadataComplete");
xmlMappingMetadataCompleteMapping.setSetMethodName("setXMLMappingMetadataComplete");
xmlMappingMetadataCompleteMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy xmlMappingMetadataCompletePolicy = new IsSetNullPolicy("isXMLMappingMetadataComplete");
xmlMappingMetadataCompletePolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
xmlMappingMetadataCompleteMapping.setNullPolicy(xmlMappingMetadataCompletePolicy);
xmlMappingMetadataCompleteMapping.setXPath("orm:xml-mapping-metadata-complete");
descriptor.addMapping(xmlMappingMetadataCompleteMapping);
XMLDirectMapping excludeDefaultMappingsMapping = new XMLDirectMapping();
excludeDefaultMappingsMapping.setAttributeName("m_excludeDefaultMappings");
excludeDefaultMappingsMapping.setGetMethodName("getExcludeDefaultMappings");
excludeDefaultMappingsMapping.setSetMethodName("setExcludeDefaultMappings");
excludeDefaultMappingsMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy excludeDefaultMappingsPolicy = new IsSetNullPolicy("excludeDefaultMappings");
excludeDefaultMappingsPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
excludeDefaultMappingsMapping.setNullPolicy(excludeDefaultMappingsPolicy);
excludeDefaultMappingsMapping.setXPath("orm:exclude-default-mappings");
descriptor.addMapping(excludeDefaultMappingsMapping);
XMLCompositeObjectMapping persistenceUnitDefaultsMapping = new XMLCompositeObjectMapping();
persistenceUnitDefaultsMapping.setAttributeName("m_persistenceUnitDefaults");
persistenceUnitDefaultsMapping.setGetMethodName("getPersistenceUnitDefaults");
persistenceUnitDefaultsMapping.setSetMethodName("setPersistenceUnitDefaults");
persistenceUnitDefaultsMapping.setReferenceClass(XMLPersistenceUnitDefaults.class);
persistenceUnitDefaultsMapping.setXPath("orm:persistence-unit-defaults");
descriptor.addMapping(persistenceUnitDefaultsMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: pinned-partitioning
*/
protected ClassDescriptor buildPinnedPartitioningDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PinnedPartitioningMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getConnectionPoolAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: plsql-parameter
*/
protected ClassDescriptor buildPLSQLParameterDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PLSQLParameterMetadata.class);
// Attribute mappings.
descriptor.addMapping(getDirectionAttributeMapping());
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getQueryParameterAttributeMapping());
descriptor.addMapping(getOptionalAttributeMapping());
descriptor.addMapping(getDatabaseTypeAttributeMapping());
descriptor.addMapping(getLengthAttributeMapping());
descriptor.addMapping(getPrecisionAttributeMapping());
descriptor.addMapping(getScaleAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: oracle-object
*/
protected ClassDescriptor buildOracleObjectTypeDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(OracleObjectTypeMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getFieldsMapping());
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getJavaTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: oracle-array
*/
protected ClassDescriptor buildOracleArrayTypeDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(OracleArrayTypeMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getJavaTypeAttributeMapping());
descriptor.addMapping(getNestedTypeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: plsql-record
*/
protected ClassDescriptor buildPLSQLRecordDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PLSQLRecordMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getFieldsMapping());
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getCompatibleTypeAttributeMapping());
descriptor.addMapping(getJavaTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: plsql-table
*/
protected ClassDescriptor buildPLSQLTableDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PLSQLTableMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getCompatibleTypeAttributeMapping());
descriptor.addMapping(getJavaTypeAttributeMapping());
descriptor.addMapping(getNestedTypeMapping());
XMLDirectMapping isNestedTableMapping = new XMLDirectMapping();
isNestedTableMapping.setAttributeName("isNestedTable");
isNestedTableMapping.setGetMethodName("getNestedTable");
isNestedTableMapping.setSetMethodName("setNestedTable");
isNestedTableMapping.setXPath("@nested-table");
descriptor.addMapping(isNestedTableMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: primary-key
*/
protected ClassDescriptor buildPrimaryKeyDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PrimaryKeyMetadata.class);
// Element mappings - must remain in order of definition in XML.
XMLCompositeCollectionMapping columnsMapping = new XMLCompositeCollectionMapping();
columnsMapping.setAttributeName("m_columns");
columnsMapping.setReferenceClass(ColumnMetadata.class);
columnsMapping.setGetMethodName("getColumns");
columnsMapping.setSetMethodName("setColumns");
columnsMapping.setXPath("orm:column");
descriptor.addMapping(columnsMapping);
// Attribute mappings.
XMLDirectMapping validationMapping = new XMLDirectMapping();
validationMapping.setAttributeName("m_validation");
validationMapping.setGetMethodName("getValidation");
validationMapping.setSetMethodName("setValidation");
validationMapping.setXPath("@validation");
descriptor.addMapping(validationMapping);
XMLDirectMapping cacheKeyMapping = new XMLDirectMapping();
cacheKeyMapping.setAttributeName("m_cacheKeyType");
cacheKeyMapping.setGetMethodName("getCacheKeyType");
cacheKeyMapping.setSetMethodName("setCacheKeyType");
cacheKeyMapping.setXPath("@cache-key-type");
descriptor.addMapping(cacheKeyMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: primary-key-foreign-key
*/
protected ClassDescriptor buildPrimaryKeyForeignKeyDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PrimaryKeyForeignKeyMetadata.class);
// Element mappings - must remain in order of definition in XML.
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getForeignKeyDefinitionAttributeMapping());
descriptor.addMapping(getConstraintModeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: primary-key-join-column
*/
protected ClassDescriptor buildPrimaryKeyJoinColumnDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PrimaryKeyJoinColumnMetadata.class);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getReferencedColumnNameMapping());
descriptor.addMapping(getColumnDefinitionAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: property
*/
protected ClassDescriptor buildPropertyDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(PropertyMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getValueAttributeMapping());
XMLDirectMapping valueTypeMapping = new XMLDirectMapping();
valueTypeMapping.setAttributeName("m_valueTypeName");
valueTypeMapping.setGetMethodName("getValueTypeName");
valueTypeMapping.setSetMethodName("setValueTypeName");
valueTypeMapping.setXPath("@value-type");
descriptor.addMapping(valueTypeMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: query-hint
*/
protected ClassDescriptor buildQueryHintDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(QueryHintMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getValueAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: range-partition
*/
protected ClassDescriptor buildRangePartitionDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(RangePartitionMetadata.class);
// Element mappings - must remain in order of definition in XML.
// none currently ...
// Attribute mappings
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("startValue");
mapping.setGetMethodName("getStartValue");
mapping.setSetMethodName("setStartValue");
mapping.setXPath("@start-value");
descriptor.addMapping(mapping);
mapping = new XMLDirectMapping();
mapping.setAttributeName("endValue");
mapping.setGetMethodName("getEndValue");
mapping.setSetMethodName("setEndValue");
mapping.setXPath("@end-value");
descriptor.addMapping(mapping);
descriptor.addMapping(getConnectionPoolAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: range-partitioning
*/
protected ClassDescriptor buildRangePartitioningDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(RangePartitioningMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getPartitionColumnMapping());
descriptor.addMapping(getRangePartitionMapping());
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getUnionUnpartitionableQueriesAttributeMapping());
descriptor.addMapping(getPartitionValueTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: read-transformer
*/
protected ClassDescriptor buildReadTransformerDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ReadTransformerMetadata.class);
descriptor.addMapping(getTransformerClassAttributeMapping());
descriptor.addMapping(getMethodAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: replication-partitioning
*/
protected ClassDescriptor buildReplicationPartitioningDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ReplicationPartitioningMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getConnectionPoolsMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: return-insert
*/
protected ClassDescriptor buildReturnInsertDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ReturnInsertMetadata.class);
XMLDirectMapping returnOnlyMapping = new XMLDirectMapping();
returnOnlyMapping.setAttributeName("m_returnOnly");
returnOnlyMapping.setGetMethodName("getReturnOnly");
returnOnlyMapping.setSetMethodName("setReturnOnly");
returnOnlyMapping.setXPath("@return-only");
descriptor.addMapping(returnOnlyMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: round-robin-partitioning
*/
protected ClassDescriptor buildRoundRobinPartitioningDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(RoundRobinPartitioningMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getReplicateWritesMapping());
descriptor.addMapping(getConnectionPoolsMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: table
*/
protected ClassDescriptor buildSecondaryTableDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(SecondaryTableMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getPrimaryKeyJoinColumnMapping());
descriptor.addMapping(getPrimaryKeyForeignKeyMapping());
descriptor.addMapping(getUniqueConstraintMapping());
descriptor.addMapping(getIndexesMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getCatalogAttributeMapping());
descriptor.addMapping(getSchemaAttributeMapping());
descriptor.addMapping(getCreationSuffixAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: sequence-generator
*/
protected ClassDescriptor buildSequenceGeneratorDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(SequenceGeneratorMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
XMLDirectMapping sequenceNameMapping = new XMLDirectMapping();
sequenceNameMapping.setAttributeName("m_sequenceName");
sequenceNameMapping.setGetMethodName("getSequenceName");
sequenceNameMapping.setSetMethodName("setSequenceName");
sequenceNameMapping.setXPath("@sequence-name");
descriptor.addMapping(sequenceNameMapping);
descriptor.addMapping(getCatalogAttributeMapping());
descriptor.addMapping(getSchemaAttributeMapping());
descriptor.addMapping(getInitialValueAttributeMapping());
descriptor.addMapping(getAllocationSizeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: SerializedObjectPolicy
*/
protected ClassDescriptor buildSerializedObjectPolicyDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(SerializedObjectPolicyMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnMapping());
// Attribute mappings.
descriptor.addMapping(getClassAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: sql-result-set-mapping
*/
protected ClassDescriptor buildSqlResultSetMappingDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(SQLResultSetMappingMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getEntityResultMapping());
descriptor.addMapping(getConstructorResultMapping());
descriptor.addMapping(getColumnResultMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: procedure-parameter
*/
protected ClassDescriptor buildStoredProcedureParameterDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(StoredProcedureParameterMetadata.class);
// Element mappings - must remain in order of definition in XML.
// Attribute mappings.
descriptor.addMapping(getDirectionAttributeMapping());
descriptor.addMapping(getModeAttributeMapping());
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getQueryParameterAttributeMapping());
descriptor.addMapping(getOptionalAttributeMapping());
descriptor.addMapping(getTypeNameAttributeMapping());
descriptor.addMapping(getClassTypeAttributeMapping());
XMLDirectMapping jdbcTypeMapping = new XMLDirectMapping();
jdbcTypeMapping.setAttributeName("m_jdbcType");
jdbcTypeMapping.setGetMethodName("getJdbcType");
jdbcTypeMapping.setSetMethodName("setJdbcType");
jdbcTypeMapping.setXPath("@jdbc-type");
descriptor.addMapping(jdbcTypeMapping);
XMLDirectMapping jdbcTypeNameMapping = new XMLDirectMapping();
jdbcTypeNameMapping.setAttributeName("m_jdbcTypeName");
jdbcTypeNameMapping.setGetMethodName("getJdbcTypeName");
jdbcTypeNameMapping.setSetMethodName("setJdbcTypeName");
jdbcTypeNameMapping.setXPath("@jdbc-type-name");
descriptor.addMapping(jdbcTypeNameMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: struct-converter
*/
protected ClassDescriptor buildStructConverterDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(StructConverterMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
XMLDirectMapping converterMapping = new XMLDirectMapping();
converterMapping.setAttributeName("m_converter");
converterMapping.setGetMethodName("getConverter");
converterMapping.setSetMethodName("setConverter");
converterMapping.setXPath("@converter");
descriptor.addMapping(converterMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: table
*/
protected ClassDescriptor buildTableDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TableMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getUniqueConstraintMapping());
descriptor.addMapping(getIndexesMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getCatalogAttributeMapping());
descriptor.addMapping(getSchemaAttributeMapping());
descriptor.addMapping(getCreationSuffixAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: struct
*/
protected ClassDescriptor buildStructDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(StructMetadata.class);
// Element mappings - must remain in order of definition in XML.
XMLCompositeDirectCollectionMapping fieldsMapping = new XMLCompositeDirectCollectionMapping();
fieldsMapping.setAttributeName("m_fields");
fieldsMapping.setGetMethodName("getFields");
fieldsMapping.setSetMethodName("setFields");
fieldsMapping.setXPath("orm:field");
descriptor.addMapping(fieldsMapping);
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: table-generator
*/
protected ClassDescriptor buildTableGeneratorDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TableGeneratorMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getUniqueConstraintMapping());
descriptor.addMapping(getIndexesMapping());
// Attribute mappings.
XMLDirectMapping nameMapping = new XMLDirectMapping();
nameMapping.setAttributeName("m_generatorName");
nameMapping.setGetMethodName("getGeneratorName");
nameMapping.setSetMethodName("setGeneratorName");
nameMapping.setXPath("@name");
descriptor.addMapping(nameMapping);
XMLDirectMapping tableMapping = new XMLDirectMapping();
tableMapping.setAttributeName("m_name");
tableMapping.setGetMethodName("getName");
tableMapping.setSetMethodName("setName");
tableMapping.setXPath("@table");
descriptor.addMapping(tableMapping);
descriptor.addMapping(getCatalogAttributeMapping());
descriptor.addMapping(getSchemaAttributeMapping());
descriptor.addMapping(getCreationSuffixAttributeMapping());
XMLDirectMapping pkColumnNameMapping = new XMLDirectMapping();
pkColumnNameMapping.setAttributeName("m_pkColumnName");
pkColumnNameMapping.setGetMethodName("getPkColumnName");
pkColumnNameMapping.setSetMethodName("setPkColumnName");
pkColumnNameMapping.setXPath("@pk-column-name");
descriptor.addMapping(pkColumnNameMapping);
XMLDirectMapping valueColumnNameMapping = new XMLDirectMapping();
valueColumnNameMapping.setAttributeName("m_valueColumnName");
valueColumnNameMapping.setGetMethodName("getValueColumnName");
valueColumnNameMapping.setSetMethodName("setValueColumnName");
valueColumnNameMapping.setXPath("@value-column-name");
descriptor.addMapping(valueColumnNameMapping);
XMLDirectMapping pkColumnValueMapping = new XMLDirectMapping();
pkColumnValueMapping.setAttributeName("m_pkColumnValue");
pkColumnValueMapping.setGetMethodName("getPkColumnValue");
pkColumnValueMapping.setSetMethodName("setPkColumnValue");
pkColumnValueMapping.setXPath("@pk-column-value");
descriptor.addMapping(pkColumnValueMapping);
descriptor.addMapping(getInitialValueAttributeMapping());
descriptor.addMapping(getAllocationSizeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: temporal
*/
protected ClassDescriptor buildTemporalDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TemporalMetadata.class);
XMLDirectMapping temporalMapping = new XMLDirectMapping();
temporalMapping.setAttributeName("m_temporalType");
temporalMapping.setGetMethodName("getTemporalType");
temporalMapping.setSetMethodName("setTemporalType");
temporalMapping.setXPath("text()");
descriptor.addMapping(temporalMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: tenant-discriminator-column
*/
protected ClassDescriptor buildTenantDiscriminatorColumnDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TenantDiscriminatorColumnMetadata.class);
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getContextPropertyAttributeMapping());
descriptor.addMapping(getDiscriminatorTypeAttributeMapping());
descriptor.addMapping(getColumnDefinitionAttributeMapping());
descriptor.addMapping(getTableAttributeMapping());
descriptor.addMapping(getLengthAttributeMapping());
descriptor.addMapping(getPrimaryKeyAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: tenant-table-discriminator
*/
protected ClassDescriptor buildTenantTableDiscriminatorDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TenantTableDiscriminatorMetadata.class);
// Attribute mappings
descriptor.addMapping(getContextPropertyAttributeMapping());
descriptor.addMapping(getTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: time-of-day
*/
protected ClassDescriptor buildTimeOfDayDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TimeOfDayMetadata.class);
XMLDirectMapping hourMapping = new XMLDirectMapping();
hourMapping.setAttributeName("m_hour");
hourMapping.setGetMethodName("getHour");
hourMapping.setSetMethodName("setHour");
hourMapping.setXPath("@hour");
descriptor.addMapping(hourMapping);
XMLDirectMapping minuteMapping = new XMLDirectMapping();
minuteMapping.setAttributeName("m_minute");
minuteMapping.setGetMethodName("getMinute");
minuteMapping.setSetMethodName("setMinute");
minuteMapping.setXPath("@minute");
descriptor.addMapping(minuteMapping);
XMLDirectMapping secondMapping = new XMLDirectMapping();
secondMapping.setAttributeName("m_second");
secondMapping.setGetMethodName("getSecond");
secondMapping.setSetMethodName("setSecond");
secondMapping.setXPath("@second");
descriptor.addMapping(secondMapping);
XMLDirectMapping millisecondMapping = new XMLDirectMapping();
millisecondMapping.setAttributeName("m_millisecond");
millisecondMapping.setGetMethodName("getMillisecond");
millisecondMapping.setSetMethodName("setMillisecond");
millisecondMapping.setXPath("@millisecond");
descriptor.addMapping(millisecondMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: transformation
*/
protected ClassDescriptor buildTransformationDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TransformationAccessor.class);
// Element mappings - must remain in order of definition in XML.
XMLCompositeObjectMapping readTransformerMapping = new XMLCompositeObjectMapping();
readTransformerMapping.setAttributeName("m_readTransformer");
readTransformerMapping.setGetMethodName("getReadTransformer");
readTransformerMapping.setSetMethodName("setReadTransformer");
readTransformerMapping.setReferenceClass(ReadTransformerMetadata.class);
readTransformerMapping.setXPath("orm:read-transformer");
descriptor.addMapping(readTransformerMapping);
XMLCompositeCollectionMapping writeTransformersMapping = new XMLCompositeCollectionMapping();
writeTransformersMapping.setAttributeName("m_writeTransformers");
writeTransformersMapping.setGetMethodName("getWriteTransformers");
writeTransformersMapping.setSetMethodName("setWriteTransformers");
writeTransformersMapping.setReferenceClass(WriteTransformerMetadata.class);
writeTransformersMapping.setXPath("orm:write-transformer");
descriptor.addMapping(writeTransformersMapping);
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getOptionalAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMutableAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: transient
*/
protected ClassDescriptor buildTransientDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TransientAccessor.class);
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: type-converter
*/
protected ClassDescriptor buildTypeConverterDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(TypeConverterMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getDataTypeAttributeMapping());
descriptor.addMapping(getObjectTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: type-converter
*/
protected ClassDescriptor buildSerializedConverterDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(SerializedConverterMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getClassAttributeMapping());
XMLDirectMapping packageMapping = new XMLDirectMapping();
packageMapping.setAttributeName("m_serializerPackage");
packageMapping.setGetMethodName("getSerializerPackage");
packageMapping.setSetMethodName("setSerializerPackage");
packageMapping.setXPath("@serializer-package");
descriptor.addMapping(packageMapping);
return descriptor;
}
/**
* INTERNAL:
* XSD: union-partitioning
*/
protected ClassDescriptor buildUnionPartitioningDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(UnionPartitioningMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getReplicateWritesMapping());
descriptor.addMapping(getConnectionPoolsMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: unique-constraint
*/
protected ClassDescriptor buildUniqueConstraintDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(UniqueConstraintMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnNamesMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: uuid-generator
*/
protected ClassDescriptor buildUuidGeneratorDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(UuidGeneratorMetadata.class);
descriptor.addMapping(getNameAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: value-partition
*/
protected ClassDescriptor buildValuePartitionDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ValuePartitionMetadata.class);
// Element mappings - must remain in order of definition in XML.
// none currently ...
// Attribute mappings
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("value");
mapping.setGetMethodName("getValue");
mapping.setSetMethodName("setValue");
mapping.setXPath("@value");
descriptor.addMapping(mapping);
descriptor.addMapping(getConnectionPoolAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: value-partitioning
*/
protected ClassDescriptor buildValuePartitioningDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(ValuePartitioningMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getPartitionColumnMapping());
descriptor.addMapping(getValuePartitionMapping());
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getUnionUnpartitionableQueriesAttributeMapping());
descriptor.addMapping(getDefaultConnectionPoolAttributeMapping());
descriptor.addMapping(getPartitionValueTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: variable-one-to-one
*/
protected ClassDescriptor buildVariableOneToOneDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(VariableOneToOneAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getCascadeMapping());
descriptor.addMapping(getDiscriminatorColumnMapping());
descriptor.addMapping(getDiscriminatorClassMapping());
descriptor.addMapping(getJoinColumnMapping());
descriptor.addMapping(getPrivateOwnedMapping());
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
descriptor.addMapping(getNonCacheableMapping());
descriptor.addMapping(getPartitioningMapping());
descriptor.addMapping(getReplicationPartitioningMapping());
descriptor.addMapping(getRoundRobinPartitioningMapping());
descriptor.addMapping(getPinnedPartitioningMapping());
descriptor.addMapping(getRangePartitioningMapping());
descriptor.addMapping(getValuePartitioningMapping());
descriptor.addMapping(getHashPartitioningMapping());
descriptor.addMapping(getUnionPartitioningMapping());
descriptor.addMapping(getPartitionedMapping());
// Attribute mappings.
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getTargetInterfaceAttributeMapping());
descriptor.addMapping(getFetchAttributeMapping());
descriptor.addMapping(getOptionalAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getOrphanRemovalAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: version
*/
protected ClassDescriptor buildVersionDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(VersionAccessor.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnMapping());
descriptor.addMapping(getTemporalMapping());
descriptor.addMapping(getConvertMapping());
addConverterMappings(descriptor);
descriptor.addMapping(getPropertyMapping());
descriptor.addMapping(getAccessMethodsMapping());
// Attribute mappings
descriptor.addMapping(getNameAttributeMapping());
descriptor.addMapping(getAccessAttributeMapping());
descriptor.addMapping(getMutableAttributeMapping());
descriptor.addMapping(getAttributeTypeAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
* XSD: write-transformer
*/
protected ClassDescriptor buildWriteTransformerDescriptor() {
XMLDescriptor descriptor = new XMLDescriptor();
descriptor.setJavaClass(WriteTransformerMetadata.class);
// Element mappings - must remain in order of definition in XML.
descriptor.addMapping(getColumnMapping());
// Attribute mappings.
descriptor.addMapping(getTransformerClassAttributeMapping());
descriptor.addMapping(getMethodAttributeMapping());
return descriptor;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getAccessAttributeMapping() {
XMLDirectMapping accessMapping = new XMLDirectMapping();
accessMapping.setAttributeName("m_access");
accessMapping.setGetMethodName("getAccess");
accessMapping.setSetMethodName("setAccess");
accessMapping.setXPath("@access");
return accessMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getAccessMapping() {
XMLDirectMapping accessMapping = new XMLDirectMapping();
accessMapping.setAttributeName("m_access");
accessMapping.setGetMethodName("getAccess");
accessMapping.setSetMethodName("setAccess");
accessMapping.setXPath("orm:access/text()");
return accessMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getAccessMethodsMapping() {
XMLCompositeObjectMapping accessMethodsMapping = new XMLCompositeObjectMapping();
accessMethodsMapping.setAttributeName("m_accessMethods");
accessMethodsMapping.setGetMethodName("getAccessMethods");
accessMethodsMapping.setSetMethodName("setAccessMethods");
accessMethodsMapping.setReferenceClass(AccessMethodsMetadata.class);
accessMethodsMapping.setXPath("orm:access-methods");
return accessMethodsMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getAdditionalCriteriaMapping() {
XMLCompositeObjectMapping additionalCriteriaMapping = new XMLCompositeObjectMapping();
additionalCriteriaMapping.setAttributeName("m_additionalCriteria");
additionalCriteriaMapping.setGetMethodName("getAdditionalCriteria");
additionalCriteriaMapping.setSetMethodName("setAdditionalCriteria");
additionalCriteriaMapping.setReferenceClass(AdditionalCriteriaMetadata.class);
additionalCriteriaMapping.setXPath("orm:additional-criteria");
return additionalCriteriaMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getAllocationSizeAttributeMapping() {
XMLDirectMapping allocationSizeMapping = new XMLDirectMapping();
allocationSizeMapping.setAttributeName("m_allocationSize");
allocationSizeMapping.setGetMethodName("getAllocationSize");
allocationSizeMapping.setSetMethodName("setAllocationSize");
allocationSizeMapping.setXPath("@allocation-size");
return allocationSizeMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getAssociationOverrideMapping() {
XMLCompositeCollectionMapping associationOverridesMapping = new XMLCompositeCollectionMapping();
associationOverridesMapping.setAttributeName("m_associationOverrides");
associationOverridesMapping.setGetMethodName("getAssociationOverrides");
associationOverridesMapping.setSetMethodName("setAssociationOverrides");
associationOverridesMapping.setReferenceClass(AssociationOverrideMetadata.class);
associationOverridesMapping.setXPath("orm:association-override");
return associationOverridesMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getAttributeNameAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_attributeName");
mapping.setGetMethodName("getAttributeName");
mapping.setSetMethodName("setAttributeName");
mapping.setXPath("@attribute-name");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getAttributeOverrideMapping() {
XMLCompositeCollectionMapping attributeOverridesMapping = new XMLCompositeCollectionMapping();
attributeOverridesMapping.setAttributeName("m_attributeOverrides");
attributeOverridesMapping.setGetMethodName("getAttributeOverrides");
attributeOverridesMapping.setSetMethodName("setAttributeOverrides");
attributeOverridesMapping.setReferenceClass(AttributeOverrideMetadata.class);
attributeOverridesMapping.setXPath("orm:attribute-override");
return attributeOverridesMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getAttributesMapping() {
XMLCompositeObjectMapping attributesMapping = new XMLCompositeObjectMapping();
attributesMapping.setAttributeName("m_attributes");
attributesMapping.setGetMethodName("getAttributes");
attributesMapping.setSetMethodName("setAttributes");
attributesMapping.setReferenceClass(XMLAttributes.class);
attributesMapping.setXPath("orm:attributes");
return attributesMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getAttributeTypeAttributeMapping() {
XMLDirectMapping attributeTypeMapping = new XMLDirectMapping();
attributeTypeMapping.setAttributeName("m_attributeType");
attributeTypeMapping.setGetMethodName("getAttributeType");
attributeTypeMapping.setSetMethodName("setAttributeType");
attributeTypeMapping.setXPath("@attribute-type");
return attributeTypeMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getAutoApplyAttributeMapping() {
XMLDirectMapping nameMapping = new XMLDirectMapping();
nameMapping.setAttributeName("m_autoApply");
nameMapping.setGetMethodName("getAutoApply");
nameMapping.setSetMethodName("setAutoApply");
nameMapping.setXPath("@auto-apply");
return nameMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getBatchFetchMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_batchFetch");
mapping.setGetMethodName("getBatchFetch");
mapping.setSetMethodName("setBatchFetch");
mapping.setReferenceClass(BatchFetchMetadata.class);
mapping.setXPath("orm:batch-fetch");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCacheableAttributeMapping() {
XMLDirectMapping cacheableMapping = new XMLDirectMapping();
cacheableMapping.setAttributeName("m_cacheable");
cacheableMapping.setGetMethodName("getCacheable");
cacheableMapping.setSetMethodName("setCacheable");
cacheableMapping.setXPath("@cacheable");
return cacheableMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getCacheInterceptorMapping() {
XMLCompositeObjectMapping cacheMapping = new XMLCompositeObjectMapping();
cacheMapping.setAttributeName("m_cacheInterceptor");
cacheMapping.setGetMethodName("getCacheInterceptor");
cacheMapping.setSetMethodName("setCacheInterceptor");
cacheMapping.setReferenceClass(CacheInterceptorMetadata.class);
cacheMapping.setXPath("orm:cache-interceptor");
return cacheMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getCacheMapping() {
XMLCompositeObjectMapping cacheMapping = new XMLCompositeObjectMapping();
cacheMapping.setAttributeName("m_cache");
cacheMapping.setGetMethodName("getCache");
cacheMapping.setSetMethodName("setCache");
cacheMapping.setReferenceClass(CacheMetadata.class);
cacheMapping.setXPath("orm:cache");
return cacheMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCallByIndexAttributeMapping() {
XMLDirectMapping callByIndexMapping = new XMLDirectMapping();
callByIndexMapping.setAttributeName("m_callByIndex");
callByIndexMapping.setGetMethodName("getCallByIndex");
callByIndexMapping.setSetMethodName("setCallByIndex");
callByIndexMapping.setXPath("@call-by-index");
return callByIndexMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getCascadeMapping() {
XMLCompositeObjectMapping cascadeMapping = new XMLCompositeObjectMapping();
cascadeMapping.setAttributeName("m_cascade");
cascadeMapping.setGetMethodName("getCascade");
cascadeMapping.setSetMethodName("setCascade");
cascadeMapping.setReferenceClass(CascadeMetadata.class);
cascadeMapping.setXPath("orm:cascade");
return cascadeMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCascadeOnDeleteMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_cascadeOnDelete");
mapping.setGetMethodName("getCascadeOnDelete");
mapping.setSetMethodName("setCascadeOnDelete");
// Cascade on delete is not mapped as an empty type, rather a boolean.
mapping.setXPath("orm:cascade-on-delete/text()");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCascadePersistMapping() {
XMLDirectMapping cascadePersistMapping = new XMLDirectMapping();
cascadePersistMapping.setAttributeName("m_cascadePersist");
cascadePersistMapping.setGetMethodName("getCascadePersist");
cascadePersistMapping.setSetMethodName("setCascadePersist");
//cascadePersistMapping.setAttributeClassification(String.class);
cascadePersistMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy cascadePersistPolicy = new IsSetNullPolicy("isCascadePersist");
cascadePersistPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
cascadePersistMapping.setNullPolicy(cascadePersistPolicy);
cascadePersistMapping.setXPath("orm:cascade-persist");
return cascadePersistMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCatalogAttributeMapping() {
XMLDirectMapping catalogMapping = new XMLDirectMapping();
catalogMapping.setAttributeName("m_catalog");
catalogMapping.setGetMethodName("getCatalog");
catalogMapping.setSetMethodName("setCatalog");
catalogMapping.setXPath("@catalog");
return catalogMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCatalogMapping() {
XMLDirectMapping catalogMapping = new XMLDirectMapping();
catalogMapping.setAttributeName("m_catalog");
catalogMapping.setGetMethodName("getCatalog");
catalogMapping.setSetMethodName("setCatalog");
catalogMapping.setXPath("orm:catalog/text()");
return catalogMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getChangeTrackingMapping() {
XMLCompositeObjectMapping changeTrackingMapping = new XMLCompositeObjectMapping();
changeTrackingMapping.setAttributeName("m_changeTracking");
changeTrackingMapping.setGetMethodName("getChangeTracking");
changeTrackingMapping.setSetMethodName("setChangeTracking");
changeTrackingMapping.setReferenceClass(ChangeTrackingMetadata.class);
changeTrackingMapping.setXPath("orm:change-tracking");
return changeTrackingMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getClassAttributeMapping() {
XMLDirectMapping classMapping = new XMLDirectMapping();
classMapping.setAttributeName("m_className");
classMapping.setGetMethodName("getClassName");
classMapping.setSetMethodName("setClassName");
classMapping.setXPath("@class");
return classMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getClassExtractorMapping() {
XMLDirectMapping classExtractorMapping = new XMLDirectMapping();
classExtractorMapping.setAttributeName("m_classExtractorName");
classExtractorMapping.setGetMethodName("getClassExtractorName");
classExtractorMapping.setSetMethodName("setClassExtractorName");
classExtractorMapping.setXPath("orm:class-extractor/@class");
return classExtractorMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getClassTypeAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_typeName");
mapping.setGetMethodName("getTypeName");
mapping.setSetMethodName("setTypeName");
mapping.setXPath("@class");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getCloneCopyPolicyMapping() {
XMLCompositeObjectMapping columnMapping = new XMLCompositeObjectMapping();
columnMapping.setAttributeName("m_cloneCopyPolicy");
columnMapping.setGetMethodName("getCloneCopyPolicy");
columnMapping.setSetMethodName("setCloneCopyPolicy");
columnMapping.setReferenceClass(CloneCopyPolicyMetadata.class);
columnMapping.setXPath("orm:clone-copy-policy");
return columnMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getCollectionTableMapping() {
XMLCompositeObjectMapping collectionTableMapping = new XMLCompositeObjectMapping();
collectionTableMapping.setAttributeName("m_collectionTable");
collectionTableMapping.setGetMethodName("getCollectionTable");
collectionTableMapping.setSetMethodName("setCollectionTable");
collectionTableMapping.setReferenceClass(CollectionTableMetadata.class);
collectionTableMapping.setXPath("orm:collection-table");
return collectionTableMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getColumnAttributeMapping() {
XMLDirectMapping columnMapping = new XMLDirectMapping();
columnMapping.setAttributeName("m_column");
columnMapping.setGetMethodName("getColumn");
columnMapping.setSetMethodName("setColumn");
columnMapping.setXPath("@column");
return columnMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getColumnDefinitionAttributeMapping() {
XMLDirectMapping columnDefinitionMapping = new XMLDirectMapping();
columnDefinitionMapping.setAttributeName("m_columnDefinition");
columnDefinitionMapping.setGetMethodName("getColumnDefinition");
columnDefinitionMapping.setSetMethodName("setColumnDefinition");
columnDefinitionMapping.setXPath("@column-definition");
return columnDefinitionMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getColumnListAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_columnList");
mapping.setGetMethodName("getColumnList");
mapping.setSetMethodName("setColumnList");
mapping.setXPath("@column-list");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getColumnMapping() {
XMLCompositeObjectMapping columnMapping = new XMLCompositeObjectMapping();
columnMapping.setAttributeName("m_column");
columnMapping.setGetMethodName("getColumn");
columnMapping.setSetMethodName("setColumn");
columnMapping.setReferenceClass(ColumnMetadata.class);
columnMapping.setXPath("orm:column");
return columnMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getFieldMapping() {
XMLCompositeObjectMapping columnMapping = new XMLCompositeObjectMapping();
columnMapping.setAttributeName("m_field");
columnMapping.setGetMethodName("getField");
columnMapping.setSetMethodName("setField");
columnMapping.setReferenceClass(FieldMetadata.class);
columnMapping.setXPath("orm:field");
return columnMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getForeignKeyMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_foreignKey");
mapping.setGetMethodName("getForeignKey");
mapping.setSetMethodName("setForeignKey");
mapping.setReferenceClass(ForeignKeyMetadata.class);
mapping.setXPath("orm:foreign-key");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getForeignKeyDefinitionAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_foreignKeyDefinition");
mapping.setGetMethodName("getForeignKeyDefinition");
mapping.setSetMethodName("setForeignKeyDefinition");
mapping.setXPath("@foreign-key-definition");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeDirectCollectionMapping getColumnNamesMapping() {
XMLCompositeDirectCollectionMapping columnNamesMapping = new XMLCompositeDirectCollectionMapping();
columnNamesMapping.setAttributeName("m_columnNames");
columnNamesMapping.setGetMethodName("getColumnNames");
columnNamesMapping.setSetMethodName("setColumnNames");
columnNamesMapping.setXPath("orm:column-name");
return columnNamesMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getColumnResultMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_columnResults");
mapping.setGetMethodName("getColumnResults");
mapping.setSetMethodName("setColumnResults");
mapping.setReferenceClass(ColumnResultMetadata.class);
mapping.setXPath("orm:column-result");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCompatibleTypeAttributeMapping() {
XMLDirectMapping typeMapping = new XMLDirectMapping();
typeMapping.setAttributeName("compatibleType");
typeMapping.setGetMethodName("getCompatibleType");
typeMapping.setSetMethodName("setCompatibleType");
typeMapping.setXPath("@compatible-type");
return typeMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCompositeMemberAttributeMapping() {
XMLDirectMapping attributeTypeMapping = new XMLDirectMapping();
attributeTypeMapping.setAttributeName("m_compositeMember");
attributeTypeMapping.setGetMethodName("getCompositeMember");
attributeTypeMapping.setSetMethodName("setCompositeMember");
attributeTypeMapping.setXPath("@composite-member");
return attributeTypeMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getConnectionPoolAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("connectionPool");
mapping.setGetMethodName("getConnectionPool");
mapping.setSetMethodName("setConnectionPool");
mapping.setXPath("@connection-pool");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeDirectCollectionMapping getConnectionPoolsMapping() {
XMLCompositeDirectCollectionMapping mapping = new XMLCompositeDirectCollectionMapping();
mapping.setAttributeName("connectionPools");
mapping.setGetMethodName("getConnectionPools");
mapping.setSetMethodName("setConnectionPools");
mapping.setXPath("orm:connection-pool");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getConstraintModeAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_constraintMode");
mapping.setGetMethodName("getConstraintMode");
mapping.setSetMethodName("setConstraintMode");
mapping.setXPath("@constraint-mode");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getConstructorColumnMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_columnResults");
mapping.setGetMethodName("getColumnResults");
mapping.setSetMethodName("setColumnResults");
mapping.setReferenceClass(ColumnResultMetadata.class);
mapping.setXPath("orm:column");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getConstructorResultMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_constructorResults");
mapping.setGetMethodName("getConstructorResults");
mapping.setSetMethodName("setConstructorResults");
mapping.setReferenceClass(ConstructorResultMetadata.class);
mapping.setXPath("orm:constructor-result");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getContextPropertyAttributeMapping() {
XMLDirectMapping contextPropertyMapping = new XMLDirectMapping();
contextPropertyMapping.setAttributeName("m_contextProperty");
contextPropertyMapping.setGetMethodName("getContextProperty");
contextPropertyMapping.setSetMethodName("setContextProperty");
contextPropertyMapping.setXPath("@context-property");
return contextPropertyMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getConverterAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_converterClassName");
mapping.setGetMethodName("getConverterClassName");
mapping.setSetMethodName("setConverterClassName");
mapping.setXPath("@converter");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getConverterMapping() {
XMLCompositeCollectionMapping convertersMapping = new XMLCompositeCollectionMapping();
convertersMapping.setAttributeName("m_converters");
convertersMapping.setGetMethodName("getConverters");
convertersMapping.setSetMethodName("setConverters");
convertersMapping.setReferenceClass(ConverterMetadata.class);
convertersMapping.setXPath("orm:converter");
return convertersMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getConvertMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_converts");
mapping.setGetMethodName("getConverts");
mapping.setSetMethodName("setConverts");
mapping.setReferenceClass(ConvertMetadata.class);
mapping.setXPath("orm:convert");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCreationSuffixAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_creationSuffix");
mapping.setGetMethodName("getCreationSuffix");
mapping.setSetMethodName("setCreationSuffix");
mapping.setXPath("@creation-suffix");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getCustomCopyPolicyMapping() {
XMLCompositeObjectMapping columnMapping = new XMLCompositeObjectMapping();
columnMapping.setAttributeName("m_customCopyPolicy");
columnMapping.setGetMethodName("getCustomCopyPolicy");
columnMapping.setSetMethodName("setCustomCopyPolicy");
columnMapping.setReferenceClass(CustomCopyPolicyMetadata.class);
columnMapping.setXPath("orm:copy-policy");
return columnMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getCustomizerMapping() {
XMLDirectMapping customizerMapping = new XMLDirectMapping();
customizerMapping.setAttributeName("m_customizerClassName");
customizerMapping.setGetMethodName("getCustomizerClassName");
customizerMapping.setSetMethodName("setCustomizerClassName");
customizerMapping.setXPath("orm:customizer/@class");
return customizerMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getDatabaseTypeAttributeMapping() {
XMLDirectMapping typeMapping = new XMLDirectMapping();
typeMapping.setAttributeName("m_databaseType");
typeMapping.setGetMethodName("getDatabaseType");
typeMapping.setSetMethodName("setDatabaseType");
typeMapping.setXPath("@database-type");
return typeMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getDataTypeAttributeMapping() {
XMLDirectMapping dataTypeMapping = new XMLDirectMapping();
dataTypeMapping.setAttributeName("m_dataTypeName");
dataTypeMapping.setGetMethodName("getDataTypeName");
dataTypeMapping.setSetMethodName("setDataTypeName");
dataTypeMapping.setXPath("@data-type");
return dataTypeMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getDefaultConnectionPoolAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("defaultConnectionPool");
mapping.setGetMethodName("getDefaultConnectionPool");
mapping.setSetMethodName("setDefaultConnectionPool");
mapping.setXPath("@default-connection-pool");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getDeleteAllMapping() {
XMLDirectMapping deleteAllMapping = new XMLDirectMapping();
deleteAllMapping.setAttributeName("m_deleteAll");
deleteAllMapping.setGetMethodName("getDeleteAll");
deleteAllMapping.setSetMethodName("setDeleteAll");
deleteAllMapping.setXPath("orm:delete-all");
deleteAllMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy deleteAllPolicy = new IsSetNullPolicy("isDeleteAll");
deleteAllPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
deleteAllMapping.setNullPolicy(deleteAllPolicy);
return deleteAllMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getDescriptionMapping() {
XMLDirectMapping descriptionMapping = new XMLDirectMapping();
descriptionMapping.setAttributeName("m_description");
descriptionMapping.setGetMethodName("getDescription");
descriptionMapping.setSetMethodName("setDescription");
descriptionMapping.setXPath("orm:description/text()");
return descriptionMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getDirectionAttributeMapping() {
XMLDirectMapping directionMapping = new XMLDirectMapping();
directionMapping.setAttributeName("m_direction");
directionMapping.setGetMethodName("getDirection");
directionMapping.setSetMethodName("setDirection");
directionMapping.setXPath("@direction");
return directionMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getDisableConversionAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_disableConversion");
mapping.setGetMethodName("getDisableConversion");
mapping.setSetMethodName("setDisableConversion");
mapping.setXPath("@disable-conversion");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getDiscriminatorClassMapping() {
XMLCompositeCollectionMapping discriminatorClassMapping = new XMLCompositeCollectionMapping();
discriminatorClassMapping.setAttributeName("m_discriminatorClasses");
discriminatorClassMapping.setGetMethodName("getDiscriminatorClasses");
discriminatorClassMapping.setSetMethodName("setDiscriminatorClasses");
discriminatorClassMapping.setReferenceClass(DiscriminatorClassMetadata.class);
discriminatorClassMapping.setXPath("orm:discriminator-class");
return discriminatorClassMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getDiscriminatorColumnMapping() {
XMLCompositeObjectMapping discriminatorColumnMapping = new XMLCompositeObjectMapping();
discriminatorColumnMapping.setAttributeName("m_discriminatorColumn");
discriminatorColumnMapping.setGetMethodName("getDiscriminatorColumn");
discriminatorColumnMapping.setSetMethodName("setDiscriminatorColumn");
discriminatorColumnMapping.setReferenceClass(DiscriminatorColumnMetadata.class);
discriminatorColumnMapping.setXPath("orm:discriminator-column");
return discriminatorColumnMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getDiscriminatorTypeAttributeMapping() {
XMLDirectMapping discriminatorTypeMapping = new XMLDirectMapping();
discriminatorTypeMapping.setAttributeName("m_discriminatorType");
discriminatorTypeMapping.setGetMethodName("getDiscriminatorType");
discriminatorTypeMapping.setSetMethodName("setDiscriminatorType");
discriminatorTypeMapping.setXPath("@discriminator-type");
return discriminatorTypeMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getEntityListenersMapping() {
XMLCompositeCollectionMapping entityListenersMapping = new XMLCompositeCollectionMapping();
entityListenersMapping.setAttributeName("m_entityListeners");
entityListenersMapping.setGetMethodName("getEntityListeners");
entityListenersMapping.setSetMethodName("setEntityListeners");
entityListenersMapping.setReferenceClass(EntityListenerMetadata.class);
entityListenersMapping.setXPath("orm:entity-listeners/orm:entity-listener");
return entityListenersMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getEntityResultMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_entityResults");
mapping.setGetMethodName("getEntityResults");
mapping.setSetMethodName("setEntityResults");
mapping.setReferenceClass(EntityResultMetadata.class);
mapping.setXPath("orm:entity-result");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getEnumeratedMapping() {
XMLCompositeObjectMapping enumeratedMapping = new XMLCompositeObjectMapping();
enumeratedMapping.setAttributeName("m_enumerated");
enumeratedMapping.setGetMethodName("getEnumerated");
enumeratedMapping.setSetMethodName("setEnumerated");
enumeratedMapping.setReferenceClass(EnumeratedMetadata.class);
enumeratedMapping.setXPath("orm:enumerated");
return enumeratedMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getExcludeDefaultListenersMapping() {
XMLDirectMapping excludeDefaultListenersMapping = new XMLDirectMapping();
excludeDefaultListenersMapping.setAttributeName("m_excludeDefaultListeners");
excludeDefaultListenersMapping.setGetMethodName("getExcludeDefaultListeners");
excludeDefaultListenersMapping.setSetMethodName("setExcludeDefaultListeners");
excludeDefaultListenersMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy excludeDefaultListenersPolicy = new IsSetNullPolicy("excludeDefaultListeners");
excludeDefaultListenersPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
excludeDefaultListenersMapping.setNullPolicy(excludeDefaultListenersPolicy);
excludeDefaultListenersMapping.setXPath("orm:exclude-default-listeners");
return excludeDefaultListenersMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getExcludeDefaultMappingsAttributeMapping() {
XMLDirectMapping excludeDefaultMappingsMapping = new XMLDirectMapping();
excludeDefaultMappingsMapping.setAttributeName("m_excludeDefaultMappings");
excludeDefaultMappingsMapping.setGetMethodName("getExcludeDefaultMappings");
excludeDefaultMappingsMapping.setSetMethodName("setExcludeDefaultMappings");
excludeDefaultMappingsMapping.setXPath("@exclude-default-mappings");
return excludeDefaultMappingsMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getExcludeSuperclassListenersMapping() {
XMLDirectMapping excludeSuperclassListenersMapping = new XMLDirectMapping();
excludeSuperclassListenersMapping.setAttributeName("m_excludeSuperclassListeners");
excludeSuperclassListenersMapping.setGetMethodName("getExcludeSuperclassListeners");
excludeSuperclassListenersMapping.setSetMethodName("setExcludeSuperclassListeners");
excludeSuperclassListenersMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy excludeSuperclassListenersPolicy = new IsSetNullPolicy("excludeSuperclassListeners");
excludeSuperclassListenersPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
excludeSuperclassListenersMapping.setNullPolicy(excludeSuperclassListenersPolicy);
excludeSuperclassListenersMapping.setXPath("orm:exclude-superclass-listeners");
return excludeSuperclassListenersMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getExistenceCheckingAttributeMapping() {
XMLDirectMapping existenceCheckingMapping = new XMLDirectMapping();
existenceCheckingMapping.setAttributeName("m_existenceChecking");
existenceCheckingMapping.setGetMethodName("getExistenceChecking");
existenceCheckingMapping.setSetMethodName("setExistenceChecking");
existenceCheckingMapping.setXPath("@existence-checking");
return existenceCheckingMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getFetchAttributeMapping() {
XMLDirectMapping fetchMapping = new XMLDirectMapping();
fetchMapping.setAttributeName("m_fetch");
fetchMapping.setGetMethodName("getFetch");
fetchMapping.setSetMethodName("setFetch");
fetchMapping.setXPath("@fetch");
return fetchMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getFetchGroupMapping() {
XMLCompositeCollectionMapping fetchGroupMapping = new XMLCompositeCollectionMapping();
fetchGroupMapping.setAttributeName("m_fetchGroups");
fetchGroupMapping.setGetMethodName("getFetchGroups");
fetchGroupMapping.setSetMethodName("setFetchGroups");
fetchGroupMapping.setReferenceClass(FetchGroupMetadata.class);
fetchGroupMapping.setXPath("orm:fetch-group");
return fetchGroupMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getFieldsMapping() {
XMLCompositeCollectionMapping fieldsMapping = new XMLCompositeCollectionMapping();
fieldsMapping.setAttributeName("fields");
fieldsMapping.setGetMethodName("getFields");
fieldsMapping.setSetMethodName("setFields");
fieldsMapping.setReferenceClass(PLSQLParameterMetadata.class);
fieldsMapping.setXPath("orm:field");
return fieldsMapping;
}
/**
* INTERNAL:
* NOTE: Internally we re-use the procedure name attribute to store the
* function name.
*/
protected XMLDirectMapping getFunctionNameAttributeMapping() {
XMLDirectMapping procedureNameMapping = new XMLDirectMapping();
procedureNameMapping.setAttributeName("m_procedureName");
procedureNameMapping.setGetMethodName("getProcedureName");
procedureNameMapping.setSetMethodName("setProcedureName");
procedureNameMapping.setXPath("@function-name");
return procedureNameMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getGeneratedValueMapping() {
XMLCompositeObjectMapping generatedValueMapping = new XMLCompositeObjectMapping();
generatedValueMapping.setAttributeName("m_generatedValue");
generatedValueMapping.setGetMethodName("getGeneratedValue");
generatedValueMapping.setSetMethodName("setGeneratedValue");
generatedValueMapping.setReferenceClass(GeneratedValueMetadata.class);
generatedValueMapping.setXPath("orm:generated-value");
return generatedValueMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getHashPartitioningMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_hashPartitioning");
mapping.setGetMethodName("getHashPartitioning");
mapping.setSetMethodName("setHashPartitioning");
mapping.setReferenceClass(HashPartitioningMetadata.class);
mapping.setXPath("orm:hash-partitioning");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getHintMapping() {
XMLCompositeCollectionMapping hintMapping = new XMLCompositeCollectionMapping();
hintMapping.setAttributeName("m_hints");
hintMapping.setGetMethodName("getHints");
hintMapping.setSetMethodName("setHints");
hintMapping.setReferenceClass(QueryHintMetadata.class);
hintMapping.setXPath("orm:hint");
return hintMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getIdAttributeMapping() {
XMLDirectMapping mappedByMapping = new XMLDirectMapping();
mappedByMapping.setAttributeName("m_id");
mappedByMapping.setGetMethodName("getId");
mappedByMapping.setSetMethodName("setId");
mappedByMapping.setXPath("@id");
return mappedByMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getIdClassMapping() {
XMLDirectMapping idClassMapping = new XMLDirectMapping();
idClassMapping.setAttributeName("m_idClassName");
idClassMapping.setGetMethodName("getIdClassName");
idClassMapping.setSetMethodName("setIdClassName");
idClassMapping.setXPath("orm:id-class/@class");
return idClassMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getIncludeAllAttributesAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_includeAllAttributes");
mapping.setGetMethodName("getIncludeAllAttributes");
mapping.setSetMethodName("setIncludeAllAttributes");
mapping.setXPath("@include-all-attributes");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getIncludeCriteriaAttributeMapping() {
XMLDirectMapping includeCriteriaMapping = new XMLDirectMapping();
includeCriteriaMapping.setAttributeName("m_includeCriteria");
includeCriteriaMapping.setGetMethodName("getIncludeCriteria");
includeCriteriaMapping.setSetMethodName("setIncludeCriteria");
includeCriteriaMapping.setXPath("@include-criteria");
return includeCriteriaMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getIndexesMapping() {
XMLCompositeCollectionMapping indexesMapping = new XMLCompositeCollectionMapping();
indexesMapping.setAttributeName("m_indexes");
indexesMapping.setGetMethodName("getIndexes");
indexesMapping.setSetMethodName("setIndexes");
indexesMapping.setReferenceClass(IndexMetadata.class);
indexesMapping.setXPath("orm:index");
return indexesMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getCacheIndexesMapping() {
XMLCompositeCollectionMapping indexesMapping = new XMLCompositeCollectionMapping();
indexesMapping.setAttributeName("m_cacheIndexes");
indexesMapping.setGetMethodName("getCacheIndexes");
indexesMapping.setSetMethodName("setCacheIndexes");
indexesMapping.setReferenceClass(CacheIndexMetadata.class);
indexesMapping.setXPath("orm:cache-index");
return indexesMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getIndexMapping() {
XMLCompositeObjectMapping indexMapping = new XMLCompositeObjectMapping();
indexMapping.setAttributeName("m_index");
indexMapping.setGetMethodName("getIndex");
indexMapping.setSetMethodName("setIndex");
indexMapping.setReferenceClass(IndexMetadata.class);
indexMapping.setXPath("orm:index");
return indexMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getCacheIndexMapping() {
XMLCompositeObjectMapping indexMapping = new XMLCompositeObjectMapping();
indexMapping.setAttributeName("m_cacheIndex");
indexMapping.setGetMethodName("getCacheIndex");
indexMapping.setSetMethodName("setCacheIndex");
indexMapping.setReferenceClass(CacheIndexMetadata.class);
indexMapping.setXPath("orm:cache-index");
return indexMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getInitialValueAttributeMapping() {
XMLDirectMapping initialValueMapping = new XMLDirectMapping();
initialValueMapping.setAttributeName("m_initialValue");
initialValueMapping.setGetMethodName("getInitialValue");
initialValueMapping.setSetMethodName("setInitialValue");
initialValueMapping.setXPath("@initial-value");
return initialValueMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getInsertableAttributeMapping() {
XMLDirectMapping insertableMapping = new XMLDirectMapping();
insertableMapping.setAttributeName("m_insertable");
insertableMapping.setGetMethodName("getInsertable");
insertableMapping.setSetMethodName("setInsertable");
insertableMapping.setXPath("@insertable");
return insertableMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getInstantiationCopyPolicyMapping() {
XMLCompositeObjectMapping columnMapping = new XMLCompositeObjectMapping();
columnMapping.setAttributeName("m_instantiationCopyPolicy");
columnMapping.setGetMethodName("getInstantiationCopyPolicy");
columnMapping.setSetMethodName("setInstantiationCopyPolicy");
columnMapping.setReferenceClass(InstantiationCopyPolicyMetadata.class);
columnMapping.setXPath("orm:instantiation-copy-policy");
return columnMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getInverseForeignKeyMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_inverseForeignKey");
mapping.setGetMethodName("getInverseForeignKey");
mapping.setSetMethodName("setInverseForeignKey");
mapping.setReferenceClass(ForeignKeyMetadata.class);
mapping.setXPath("orm:inverse-foreign-key");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getInverseJoinColumnMapping() {
XMLCompositeCollectionMapping joinColumnMapping = new XMLCompositeCollectionMapping();
joinColumnMapping.setAttributeName("m_inverseJoinColumns");
joinColumnMapping.setGetMethodName("getInverseJoinColumns");
joinColumnMapping.setSetMethodName("setInverseJoinColumns");
joinColumnMapping.setReferenceClass(JoinColumnMetadata.class);
joinColumnMapping.setXPath("orm:inverse-join-column");
return joinColumnMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getJavaTypeAttributeMapping() {
XMLDirectMapping javaTypeMapping = new XMLDirectMapping();
javaTypeMapping.setAttributeName("javaType");
javaTypeMapping.setGetMethodName("getJavaType");
javaTypeMapping.setSetMethodName("setJavaType");
javaTypeMapping.setXPath("@java-type");
return javaTypeMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getJoinColumnMapping() {
XMLCompositeCollectionMapping joinColumnMapping = new XMLCompositeCollectionMapping();
joinColumnMapping.setAttributeName("m_joinColumns");
joinColumnMapping.setGetMethodName("getJoinColumns");
joinColumnMapping.setSetMethodName("setJoinColumns");
joinColumnMapping.setReferenceClass(JoinColumnMetadata.class);
joinColumnMapping.setXPath("orm:join-column");
return joinColumnMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getJoinFieldMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_joinFields");
mapping.setGetMethodName("getJoinFields");
mapping.setSetMethodName("setJoinFields");
mapping.setReferenceClass(JoinFieldMetadata.class);
mapping.setXPath("orm:join-field");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getJoinFetchMapping() {
XMLDirectMapping joinFetchMapping = new XMLDirectMapping();
joinFetchMapping.setAttributeName("m_joinFetch");
joinFetchMapping.setGetMethodName("getJoinFetch");
joinFetchMapping.setSetMethodName("setJoinFetch");
joinFetchMapping.setXPath("orm:join-fetch/text()");
return joinFetchMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getJoinTableMapping() {
XMLCompositeObjectMapping joinTableMapping = new XMLCompositeObjectMapping();
joinTableMapping.setAttributeName("m_joinTable");
joinTableMapping.setGetMethodName("getJoinTable");
joinTableMapping.setSetMethodName("setJoinTable");
joinTableMapping.setReferenceClass(JoinTableMetadata.class);
joinTableMapping.setXPath("orm:join-table");
return joinTableMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getKeySubgraphAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_keySubgraph");
mapping.setGetMethodName("getKeySubgraph");
mapping.setSetMethodName("setKeySubgraph");
mapping.setXPath("@key-subgraph");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getLengthAttributeMapping() {
XMLDirectMapping lengthMapping = new XMLDirectMapping();
lengthMapping.setAttributeName("m_length");
lengthMapping.setGetMethodName("getLength");
lengthMapping.setSetMethodName("setLength");
lengthMapping.setXPath("@length");
return lengthMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getLobMapping() {
XMLCompositeObjectMapping lobMapping = new XMLCompositeObjectMapping();
lobMapping.setAttributeName("m_lob");
lobMapping.setGetMethodName("getLob");
lobMapping.setSetMethodName("setLob");
lobMapping.setReferenceClass(LobMetadata.class);
lobMapping.setXPath("orm:lob");
return lobMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getLockModeMapping() {
XMLDirectMapping lockModeMapping = new XMLDirectMapping();
lockModeMapping.setAttributeName("m_lockMode");
lockModeMapping.setGetMethodName("getLockMode");
lockModeMapping.setSetMethodName("setLockMode");
lockModeMapping.setXPath("orm:lock-mode");
return lockModeMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getMapKeyAssociationOverrideMapping() {
XMLCompositeCollectionMapping associationOverridesMapping = new XMLCompositeCollectionMapping();
associationOverridesMapping.setAttributeName("m_mapKeyAssociationOverrides");
associationOverridesMapping.setGetMethodName("getMapKeyAssociationOverrides");
associationOverridesMapping.setSetMethodName("setMapKeyAssociationOverrides");
associationOverridesMapping.setReferenceClass(AssociationOverrideMetadata.class);
associationOverridesMapping.setXPath("orm:map-key-association-override");
return associationOverridesMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getMapKeyAttributeOverrideMapping() {
XMLCompositeCollectionMapping attributeOverridesMapping = new XMLCompositeCollectionMapping();
attributeOverridesMapping.setAttributeName("m_mapKeyAttributeOverrides");
attributeOverridesMapping.setGetMethodName("getMapKeyAttributeOverrides");
attributeOverridesMapping.setSetMethodName("setMapKeyAttributeOverrides");
attributeOverridesMapping.setReferenceClass(AttributeOverrideMetadata.class);
attributeOverridesMapping.setXPath("orm:map-key-attribute-override");
return attributeOverridesMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getMapKeyClassMapping() {
XMLDirectMapping mapKeyClassMapping = new XMLDirectMapping();
mapKeyClassMapping.setAttributeName("m_mapKeyClassName");
mapKeyClassMapping.setGetMethodName("getMapKeyClassName");
mapKeyClassMapping.setSetMethodName("setMapKeyClassName");
mapKeyClassMapping.setXPath("orm:map-key-class/@class");
return mapKeyClassMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getMapKeyColumnMapping() {
XMLCompositeObjectMapping mapKeyColumnMapping = new XMLCompositeObjectMapping();
mapKeyColumnMapping.setAttributeName("m_mapKeyColumn");
mapKeyColumnMapping.setGetMethodName("getMapKeyColumn");
mapKeyColumnMapping.setSetMethodName("setMapKeyColumn");
mapKeyColumnMapping.setReferenceClass(ColumnMetadata.class);
mapKeyColumnMapping.setXPath("orm:map-key-column");
return mapKeyColumnMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getMapKeyConvertMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_mapKeyConverts");
mapping.setGetMethodName("getMapKeyConverts");
mapping.setSetMethodName("setMapKeyConverts");
mapping.setReferenceClass(ConvertMetadata.class);
mapping.setXPath("orm:map-key-convert");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getMapKeyEnumeratedMapping() {
XMLCompositeObjectMapping mapKeyEnumeratedMapping = new XMLCompositeObjectMapping();
mapKeyEnumeratedMapping.setAttributeName("m_mapKeyEnumerated");
mapKeyEnumeratedMapping.setGetMethodName("getMapKeyEnumerated");
mapKeyEnumeratedMapping.setSetMethodName("setMapKeyEnumerated");
mapKeyEnumeratedMapping.setReferenceClass(EnumeratedMetadata.class);
mapKeyEnumeratedMapping.setXPath("orm:map-key-enumerated");
return mapKeyEnumeratedMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getMapKeyForeignKeyMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_mapKeyForeignKey");
mapping.setGetMethodName("getMapKeyForeignKey");
mapping.setSetMethodName("setMapKeyForeignKey");
mapping.setReferenceClass(ForeignKeyMetadata.class);
mapping.setXPath("orm:map-key-foreign-key");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getMapKeyJoinColumnMapping() {
XMLCompositeCollectionMapping mapKeyJoinColumnMapping = new XMLCompositeCollectionMapping();
mapKeyJoinColumnMapping.setAttributeName("m_mapKeyJoinColumns");
mapKeyJoinColumnMapping.setGetMethodName("getMapKeyJoinColumns");
mapKeyJoinColumnMapping.setSetMethodName("setMapKeyJoinColumns");
mapKeyJoinColumnMapping.setReferenceClass(JoinColumnMetadata.class);
mapKeyJoinColumnMapping.setXPath("orm:map-key-join-column");
return mapKeyJoinColumnMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getMapKeyMapping() {
XMLCompositeObjectMapping mapKeyMapping = new XMLCompositeObjectMapping();
mapKeyMapping.setAttributeName("m_mapKey");
mapKeyMapping.setGetMethodName("getMapKey");
mapKeyMapping.setSetMethodName("setMapKey");
mapKeyMapping.setReferenceClass(MapKeyMetadata.class);
mapKeyMapping.setXPath("orm:map-key");
return mapKeyMapping;
}
/**
* INTERNAL
*/
protected XMLCompositeObjectMapping getMapKeyTemporalMapping() {
XMLCompositeObjectMapping mapKeyTemporalMapping = new XMLCompositeObjectMapping();
mapKeyTemporalMapping.setAttributeName("m_mapKeyTemporal");
mapKeyTemporalMapping.setGetMethodName("getMapKeyTemporal");
mapKeyTemporalMapping.setSetMethodName("setMapKeyTemporal");
mapKeyTemporalMapping.setReferenceClass(TemporalMetadata.class);
mapKeyTemporalMapping.setXPath("orm:map-key-temporal");
return mapKeyTemporalMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getMappedByAttributeMapping() {
XMLDirectMapping mappedByMapping = new XMLDirectMapping();
mappedByMapping.setAttributeName("m_mappedBy");
mappedByMapping.setGetMethodName("getMappedBy");
mappedByMapping.setSetMethodName("setMappedBy");
mappedByMapping.setXPath("@mapped-by");
return mappedByMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getMapsIdAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_mapsId");
mapping.setGetMethodName("getMapsId");
mapping.setSetMethodName("setMapsId");
mapping.setXPath("@maps-id");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getMetadataCompleteAttributeMapping() {
XMLDirectMapping metadataCompleteMapping = new XMLDirectMapping();
metadataCompleteMapping.setAttributeName("m_metadataComplete");
metadataCompleteMapping.setGetMethodName("getMetadataComplete");
metadataCompleteMapping.setSetMethodName("setMetadataComplete");
metadataCompleteMapping.setXPath("@metadata-complete");
return metadataCompleteMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getMethodAttributeMapping() {
XMLDirectMapping methodMapping = new XMLDirectMapping();
methodMapping.setAttributeName("m_method");
methodMapping.setGetMethodName("getMethod");
methodMapping.setSetMethodName("setMethod");
methodMapping.setXPath("@method");
return methodMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getMixedConverterMapping() {
XMLCompositeCollectionMapping convertersMapping = new XMLCompositeCollectionMapping();
convertersMapping.setAttributeName("m_mixedConverters");
convertersMapping.setGetMethodName("getMixedConverters");
convertersMapping.setSetMethodName("setMixedConverters");
convertersMapping.setReferenceClass(MixedConverterMetadata.class);
convertersMapping.setXPath("orm:converter");
return convertersMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getModeAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_mode");
mapping.setGetMethodName("getMode");
mapping.setSetMethodName("setMode");
mapping.setXPath("@mode");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getMultitenantMapping() {
XMLCompositeObjectMapping multitenantMapping = new XMLCompositeObjectMapping();
multitenantMapping.setAttributeName("m_multitenant");
multitenantMapping.setGetMethodName("getMultitenant");
multitenantMapping.setSetMethodName("setMultitenant");
multitenantMapping.setReferenceClass(MultitenantMetadata.class);
multitenantMapping.setXPath("orm:multitenant");
return multitenantMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getMutableAttributeMapping() {
XMLDirectMapping mutableMapping = new XMLDirectMapping();
mutableMapping.setAttributeName("m_mutable");
mutableMapping.setGetMethodName("getMutable");
mutableMapping.setSetMethodName("setMutable");
mutableMapping.setXPath("@mutable");
return mutableMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getNameAttributeMapping() {
XMLDirectMapping nameMapping = new XMLDirectMapping();
nameMapping.setAttributeName("m_name");
nameMapping.setGetMethodName("getName");
nameMapping.setSetMethodName("setName");
nameMapping.setXPath("@name");
return nameMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getNamedAttributeNodeMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_namedAttributeNodes");
mapping.setGetMethodName("getNamedAttributeNodes");
mapping.setSetMethodName("setNamedAttributeNodes");
mapping.setReferenceClass(NamedAttributeNodeMetadata.class);
mapping.setXPath("orm:named-attribute-node");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getNamedEntityGraphMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_namedEntityGraphs");
mapping.setGetMethodName("getNamedEntityGraphs");
mapping.setSetMethodName("setNamedEntityGraphs");
mapping.setReferenceClass(NamedEntityGraphMetadata.class);
mapping.setXPath("orm:named-entity-graph");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getNamedNativeQueryMapping() {
XMLCompositeCollectionMapping namedNativeQueryMapping = new XMLCompositeCollectionMapping();
namedNativeQueryMapping.setAttributeName("m_namedNativeQueries");
namedNativeQueryMapping.setGetMethodName("getNamedNativeQueries");
namedNativeQueryMapping.setSetMethodName("setNamedNativeQueries");
namedNativeQueryMapping.setReferenceClass(NamedNativeQueryMetadata.class);
namedNativeQueryMapping.setXPath("orm:named-native-query");
return namedNativeQueryMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getNamedPLSQLStoredFunctionQueryMapping() {
XMLCompositeCollectionMapping namedStoredFunctionQueryMapping = new XMLCompositeCollectionMapping();
namedStoredFunctionQueryMapping.setAttributeName("m_namedPLSQLStoredFunctionQueries");
namedStoredFunctionQueryMapping.setGetMethodName("getNamedPLSQLStoredFunctionQueries");
namedStoredFunctionQueryMapping.setSetMethodName("setNamedPLSQLStoredFunctionQueries");
namedStoredFunctionQueryMapping.setReferenceClass(NamedPLSQLStoredFunctionQueryMetadata.class);
namedStoredFunctionQueryMapping.setXPath("orm:named-plsql-stored-function-query");
return namedStoredFunctionQueryMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getNamedPLSQLStoredProcedureQueryMapping() {
XMLCompositeCollectionMapping namedStoredFunctionQueryMapping = new XMLCompositeCollectionMapping();
namedStoredFunctionQueryMapping.setAttributeName("m_namedPLSQLStoredProcedureQueries");
namedStoredFunctionQueryMapping.setGetMethodName("getNamedPLSQLStoredProcedureQueries");
namedStoredFunctionQueryMapping.setSetMethodName("setNamedPLSQLStoredProcedureQueries");
namedStoredFunctionQueryMapping.setReferenceClass(NamedPLSQLStoredProcedureQueryMetadata.class);
namedStoredFunctionQueryMapping.setXPath("orm:named-plsql-stored-procedure-query");
return namedStoredFunctionQueryMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getNamedQueryMapping() {
XMLCompositeCollectionMapping namedQueryMapping = new XMLCompositeCollectionMapping();
namedQueryMapping.setAttributeName("m_namedQueries");
namedQueryMapping.setGetMethodName("getNamedQueries");
namedQueryMapping.setSetMethodName("setNamedQueries");
namedQueryMapping.setReferenceClass(NamedQueryMetadata.class);
namedQueryMapping.setXPath("orm:named-query");
return namedQueryMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getNamedStoredFunctionQueryMapping() {
XMLCompositeCollectionMapping namedStoredFunctionQueryMapping = new XMLCompositeCollectionMapping();
namedStoredFunctionQueryMapping.setAttributeName("m_namedStoredFunctionQueries");
namedStoredFunctionQueryMapping.setGetMethodName("getNamedStoredFunctionQueries");
namedStoredFunctionQueryMapping.setSetMethodName("setNamedStoredFunctionQueries");
namedStoredFunctionQueryMapping.setReferenceClass(NamedStoredFunctionQueryMetadata.class);
namedStoredFunctionQueryMapping.setXPath("orm:named-stored-function-query");
return namedStoredFunctionQueryMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getNamedStoredProcedureQueryMapping() {
XMLCompositeCollectionMapping namedStoredProcedureQueryMapping = new XMLCompositeCollectionMapping();
namedStoredProcedureQueryMapping.setAttributeName("m_namedStoredProcedureQueries");
namedStoredProcedureQueryMapping.setGetMethodName("getNamedStoredProcedureQueries");
namedStoredProcedureQueryMapping.setSetMethodName("setNamedStoredProcedureQueries");
namedStoredProcedureQueryMapping.setReferenceClass(NamedStoredProcedureQueryMetadata.class);
namedStoredProcedureQueryMapping.setXPath("orm:named-stored-procedure-query");
return namedStoredProcedureQueryMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getNestedTypeMapping() {
XMLDirectMapping nestedTypeMapping = new XMLDirectMapping();
nestedTypeMapping.setAttributeName("nestedType");
nestedTypeMapping.setGetMethodName("getNestedType");
nestedTypeMapping.setSetMethodName("setNestedType");
nestedTypeMapping.setXPath("@nested-type");
return nestedTypeMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getNonCacheableMapping() {
XMLDirectMapping noncacheable = new XMLDirectMapping();
noncacheable.setAttributeName("m_nonCacheable");
noncacheable.setGetMethodName("getNonCacheable");
noncacheable.setSetMethodName("setNonCacheable");
noncacheable.setConverter(new EmptyElementConverter());
IsSetNullPolicy cacheablePolicy = new IsSetNullPolicy("isNonCacheable");
cacheablePolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
noncacheable.setNullPolicy(cacheablePolicy);
noncacheable.setXPath("orm:noncacheable");
return noncacheable;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getNoSqlMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_noSql");
mapping.setGetMethodName("getNoSql");
mapping.setSetMethodName("setNoSql");
mapping.setReferenceClass(NoSqlMetadata.class);
mapping.setXPath("orm:no-sql");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getNullableAttributeMapping() {
XMLDirectMapping nullableMapping = new XMLDirectMapping();
nullableMapping.setAttributeName("m_nullable");
nullableMapping.setGetMethodName("getNullable");
nullableMapping.setSetMethodName("setNullable");
nullableMapping.setXPath("@nullable");
return nullableMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getObjectTypeAttributeMapping() {
XMLDirectMapping objectTypeMapping = new XMLDirectMapping();
objectTypeMapping.setAttributeName("m_objectTypeName");
objectTypeMapping.setGetMethodName("getObjectTypeName");
objectTypeMapping.setSetMethodName("setObjectTypeName");
objectTypeMapping.setXPath("@object-type");
return objectTypeMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getObjectTypeConverterMapping() {
XMLCompositeCollectionMapping objectTypeConvertersMapping = new XMLCompositeCollectionMapping();
objectTypeConvertersMapping.setAttributeName("m_objectTypeConverters");
objectTypeConvertersMapping.setGetMethodName("getObjectTypeConverters");
objectTypeConvertersMapping.setSetMethodName("setObjectTypeConverters");
objectTypeConvertersMapping.setReferenceClass(ObjectTypeConverterMetadata.class);
objectTypeConvertersMapping.setXPath("orm:object-type-converter");
return objectTypeConvertersMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getOptimisticLockingMapping() {
XMLCompositeObjectMapping optimisticLockingMapping = new XMLCompositeObjectMapping();
optimisticLockingMapping.setAttributeName("m_optimisticLocking");
optimisticLockingMapping.setGetMethodName("getOptimisticLocking");
optimisticLockingMapping.setSetMethodName("setOptimisticLocking");
optimisticLockingMapping.setReferenceClass(OptimisticLockingMetadata.class);
optimisticLockingMapping.setXPath("orm:optimistic-locking");
return optimisticLockingMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getOptionalAttributeMapping() {
XMLDirectMapping optionalMapping = new XMLDirectMapping();
optionalMapping.setAttributeName("m_optional");
optionalMapping.setGetMethodName("getOptional");
optionalMapping.setSetMethodName("setOptional");
optionalMapping.setXPath("@optional");
return optionalMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getOracleArrayTypeMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_oracleArrayTypes");
mapping.setGetMethodName("getOracleArrayTypes");
mapping.setSetMethodName("setOracleArrayTypes");
mapping.setReferenceClass(OracleArrayTypeMetadata.class);
mapping.setXPath("orm:oracle-array");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getOracleObjectTypeMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_oracleObjectTypes");
mapping.setGetMethodName("getOracleObjectTypes");
mapping.setSetMethodName("setOracleObjectTypes");
mapping.setReferenceClass(OracleObjectTypeMetadata.class);
mapping.setXPath("orm:oracle-object");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getOrderByMapping() {
XMLCompositeObjectMapping orderByMapping = new XMLCompositeObjectMapping();
orderByMapping.setAttributeName("m_orderBy");
orderByMapping.setGetMethodName("getOrderBy");
orderByMapping.setSetMethodName("setOrderBy");
orderByMapping.setReferenceClass(OrderByMetadata.class);
orderByMapping.setXPath("orm:order-by");
return orderByMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getOrderColumnMapping() {
XMLCompositeObjectMapping orderColumnMapping = new XMLCompositeObjectMapping();
orderColumnMapping.setAttributeName("m_orderColumn");
orderColumnMapping.setGetMethodName("getOrderColumn");
orderColumnMapping.setSetMethodName("setOrderColumn");
orderColumnMapping.setReferenceClass(OrderColumnMetadata.class);
orderColumnMapping.setXPath("orm:order-column");
return orderColumnMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getOrphanRemovalAttributeMapping() {
XMLDirectMapping orphanRemovalMapping = new XMLDirectMapping();
orphanRemovalMapping.setAttributeName("m_orphanRemoval");
orphanRemovalMapping.setGetMethodName("getOrphanRemoval");
orphanRemovalMapping.setSetMethodName("setOrphanRemoval");
orphanRemovalMapping.setXPath("@orphan-removal");
return orphanRemovalMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getParametersMapping() {
XMLCompositeCollectionMapping parametersMapping = new XMLCompositeCollectionMapping();
parametersMapping.setAttributeName("m_parameters");
parametersMapping.setGetMethodName("getParameters");
parametersMapping.setSetMethodName("setParameters");
parametersMapping.setReferenceClass(StoredProcedureParameterMetadata.class);
parametersMapping.setXPath("orm:parameter");
return parametersMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getParentClassAttributeMapping() {
XMLDirectMapping parentClassMapping = new XMLDirectMapping();
parentClassMapping.setAttributeName("m_parentClassName");
parentClassMapping.setGetMethodName("getParentClassName");
parentClassMapping.setSetMethodName("setParentClassName");
parentClassMapping.setXPath("@parent-class");
return parentClassMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getRangePartitionMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("partitions");
mapping.setGetMethodName("getPartitions");
mapping.setSetMethodName("setPartitions");
mapping.setReferenceClass(RangePartitionMetadata.class);
mapping.setXPath("orm:partition");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getPartitionColumnMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("partitionColumn");
mapping.setGetMethodName("getPartitionColumn");
mapping.setSetMethodName("setPartitionColumn");
mapping.setReferenceClass(ColumnMetadata.class);
mapping.setXPath("orm:partition-column");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPartitionedMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_partitioned");
mapping.setGetMethodName("getPartitioned");
mapping.setSetMethodName("setPartitioned");
mapping.setXPath("orm:partitioned");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getPartitioningMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_partitioning");
mapping.setGetMethodName("getPartitioning");
mapping.setSetMethodName("setPartitioning");
mapping.setReferenceClass(PartitioningMetadata.class);
mapping.setXPath("orm:partitioning");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPartitionValueTypeAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("partitionValueTypeName");
mapping.setGetMethodName("getPartitionValueTypeName");
mapping.setSetMethodName("setPartitionValueTypeName");
mapping.setXPath("@partition-value-type");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getPinnedPartitioningMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_pinnedPartitioning");
mapping.setGetMethodName("getPinnedPartitioning");
mapping.setSetMethodName("setPinnedPartitioning");
mapping.setReferenceClass(PinnedPartitioningMetadata.class);
mapping.setXPath("orm:pinned-partitioning");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getPLSQLParametersMapping() {
XMLCompositeCollectionMapping parametersMapping = new XMLCompositeCollectionMapping();
parametersMapping.setAttributeName("m_parameters");
parametersMapping.setGetMethodName("getParameters");
parametersMapping.setSetMethodName("setParameters");
parametersMapping.setReferenceClass(PLSQLParameterMetadata.class);
parametersMapping.setXPath("orm:parameter");
return parametersMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getPLSQLRecordMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_plsqlRecords");
mapping.setGetMethodName("getPLSQLRecords");
mapping.setSetMethodName("setPLSQLRecords");
mapping.setReferenceClass(PLSQLRecordMetadata.class);
mapping.setXPath("orm:plsql-record");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getPLSQLTableMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_plsqlTables");
mapping.setGetMethodName("getPLSQLTables");
mapping.setSetMethodName("setPLSQLTables");
mapping.setReferenceClass(PLSQLTableMetadata.class);
mapping.setXPath("orm:plsql-table");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPostLoadMapping() {
XMLDirectMapping postLoadMapping = new XMLDirectMapping();
postLoadMapping.setAttributeName("m_postLoad");
postLoadMapping.setGetMethodName("getPostLoad");
postLoadMapping.setSetMethodName("setPostLoad");
postLoadMapping.setXPath("orm:post-load/@method-name");
return postLoadMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPostPeristMapping() {
XMLDirectMapping postPersistMapping = new XMLDirectMapping();
postPersistMapping.setAttributeName("m_postPersist");
postPersistMapping.setGetMethodName("getPostPersist");
postPersistMapping.setSetMethodName("setPostPersist");
postPersistMapping.setXPath("orm:post-persist/@method-name");
return postPersistMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPostRemoveMapping() {
XMLDirectMapping postRemoveMapping = new XMLDirectMapping();
postRemoveMapping.setAttributeName("m_postRemove");
postRemoveMapping.setGetMethodName("getPostRemove");
postRemoveMapping.setSetMethodName("setPostRemove");
postRemoveMapping.setXPath("orm:post-remove/@method-name");
return postRemoveMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPostUpdateMapping() {
XMLDirectMapping postUpdateMapping = new XMLDirectMapping();
postUpdateMapping.setAttributeName("m_postUpdate");
postUpdateMapping.setGetMethodName("getPostUpdate");
postUpdateMapping.setSetMethodName("setPostUpdate");
postUpdateMapping.setXPath("orm:post-update/@method-name");
return postUpdateMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPrecisionAttributeMapping() {
XMLDirectMapping precisionMapping = new XMLDirectMapping();
precisionMapping.setAttributeName("m_precision");
precisionMapping.setGetMethodName("getPrecision");
precisionMapping.setSetMethodName("setPrecision");
precisionMapping.setXPath("@precision");
return precisionMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPrePeristMapping() {
XMLDirectMapping prePersistMapping = new XMLDirectMapping();
prePersistMapping.setAttributeName("m_prePersist");
prePersistMapping.setGetMethodName("getPrePersist");
prePersistMapping.setSetMethodName("setPrePersist");
prePersistMapping.setXPath("orm:pre-persist/@method-name");
return prePersistMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPreRemoveMapping() {
XMLDirectMapping preRemoveMapping = new XMLDirectMapping();
preRemoveMapping.setAttributeName("m_preRemove");
preRemoveMapping.setGetMethodName("getPreRemove");
preRemoveMapping.setSetMethodName("setPreRemove");
preRemoveMapping.setXPath("orm:pre-remove/@method-name");
return preRemoveMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPreUpdateMapping() {
XMLDirectMapping preUpdateMapping = new XMLDirectMapping();
preUpdateMapping.setAttributeName("m_preUpdate");
preUpdateMapping.setGetMethodName("getPreUpdate");
preUpdateMapping.setSetMethodName("setPreUpdate");
preUpdateMapping.setXPath("orm:pre-update/@method-name");
return preUpdateMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPrimaryKeyAttributeMapping() {
XMLDirectMapping primaryKeyMapping = new XMLDirectMapping();
primaryKeyMapping.setAttributeName("m_primaryKey");
primaryKeyMapping.setGetMethodName("getPrimaryKey");
primaryKeyMapping.setSetMethodName("setPrimaryKey");
primaryKeyMapping.setXPath("@primary-key");
return primaryKeyMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getPrimaryKeyForeignKeyMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_primaryKeyForeignKey");
mapping.setGetMethodName("getPrimaryKeyForeignKey");
mapping.setSetMethodName("setPrimaryKeyForeignKey");
mapping.setReferenceClass(PrimaryKeyForeignKeyMetadata.class);
mapping.setXPath("orm:primary-key-foreign-key");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getPrimaryKeyJoinColumnMapping() {
XMLCompositeCollectionMapping primaryKeyJoinColumnMapping = new XMLCompositeCollectionMapping();
primaryKeyJoinColumnMapping.setAttributeName("m_primaryKeyJoinColumns");
primaryKeyJoinColumnMapping.setGetMethodName("getPrimaryKeyJoinColumns");
primaryKeyJoinColumnMapping.setSetMethodName("setPrimaryKeyJoinColumns");
primaryKeyJoinColumnMapping.setReferenceClass(PrimaryKeyJoinColumnMetadata.class);
primaryKeyJoinColumnMapping.setXPath("orm:primary-key-join-column");
return primaryKeyJoinColumnMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getPrimaryKeyMapping() {
XMLCompositeObjectMapping primaryKeyMapping = new XMLCompositeObjectMapping();
primaryKeyMapping.setAttributeName("m_primaryKey");
primaryKeyMapping.setReferenceClass(PrimaryKeyMetadata.class);
primaryKeyMapping.setXPath("orm:primary-key");
return primaryKeyMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getPrivateOwnedMapping() {
XMLDirectMapping privateOwnedMapping = new XMLDirectMapping();
privateOwnedMapping.setAttributeName("m_privateOwned");
privateOwnedMapping.setGetMethodName("getPrivateOwned");
privateOwnedMapping.setSetMethodName("setPrivateOwned");
privateOwnedMapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy privateOwnedPolicy = new IsSetNullPolicy("isPrivateOwned");
privateOwnedPolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
privateOwnedMapping.setNullPolicy(privateOwnedPolicy);
privateOwnedMapping.setXPath("orm:private-owned");
return privateOwnedMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getProcedureNameAttributeMapping() {
XMLDirectMapping procedureNameMapping = new XMLDirectMapping();
procedureNameMapping.setAttributeName("m_procedureName");
procedureNameMapping.setGetMethodName("getProcedureName");
procedureNameMapping.setSetMethodName("setProcedureName");
procedureNameMapping.setXPath("@procedure-name");
return procedureNameMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getPropertyMapping() {
XMLCompositeCollectionMapping propertyMapping = new XMLCompositeCollectionMapping();
propertyMapping.setAttributeName("m_properties");
propertyMapping.setGetMethodName("getProperties");
propertyMapping.setSetMethodName("setProperties");
propertyMapping.setReferenceClass(PropertyMetadata.class);
propertyMapping.setXPath("orm:property");
return propertyMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getQueryMapping() {
XMLDirectMapping queryMapping = new XMLDirectMapping();
queryMapping.setAttributeName("m_query");
queryMapping.setGetMethodName("getQuery");
queryMapping.setSetMethodName("setQuery");
queryMapping.setXPath("orm:query");
return queryMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getQueryParameterAttributeMapping() {
XMLDirectMapping queryParameterMapping = new XMLDirectMapping();
queryParameterMapping.setAttributeName("m_queryParameter");
queryParameterMapping.setGetMethodName("getQueryParameter");
queryParameterMapping.setSetMethodName("setQueryParameter");
queryParameterMapping.setXPath("@query-parameter");
return queryParameterMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getQueryRedirectorsMapping() {
XMLCompositeObjectMapping redirectorsMapping = new XMLCompositeObjectMapping();
redirectorsMapping.setAttributeName("m_queryRedirectors");
redirectorsMapping.setGetMethodName("getQueryRedirectors");
redirectorsMapping.setSetMethodName("setQueryRedirectors");
redirectorsMapping.setReferenceClass(QueryRedirectorsMetadata.class);
redirectorsMapping.setXPath("orm:query-redirectors");
return redirectorsMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getRangePartitioningMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_rangePartitioning");
mapping.setGetMethodName("getRangePartitioning");
mapping.setSetMethodName("setRangePartitioning");
mapping.setReferenceClass(RangePartitioningMetadata.class);
mapping.setXPath("orm:range-partitioning");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getReadOnlyAttributeMapping() {
XMLDirectMapping readOnlyMapping = new XMLDirectMapping();
readOnlyMapping.setAttributeName("m_readOnly");
readOnlyMapping.setGetMethodName("getReadOnly");
readOnlyMapping.setSetMethodName("setReadOnly");
readOnlyMapping.setXPath("@read-only");
return readOnlyMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getReferencedColumnNameMapping() {
XMLDirectMapping referencedColumnNameMapping = new XMLDirectMapping();
referencedColumnNameMapping.setAttributeName("m_referencedColumnName");
referencedColumnNameMapping.setGetMethodName("getReferencedColumnName");
referencedColumnNameMapping.setSetMethodName("setReferencedColumnName");
referencedColumnNameMapping.setXPath("@referenced-column-name");
return referencedColumnNameMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getReplicateWritesMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("replicateWrites");
mapping.setGetMethodName("getReplicateWrites");
mapping.setSetMethodName("setReplicateWrites");
mapping.setXPath("@replicate-writes");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getReplicationPartitioningMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_replicationPartitioning");
mapping.setGetMethodName("getReplicationPartitioning");
mapping.setSetMethodName("setReplicationPartitioning");
mapping.setReferenceClass(ReplicationPartitioningMetadata.class);
mapping.setXPath("orm:replication-partitioning");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getResultClassAttributeMapping() {
XMLDirectMapping resultClassMapping = new XMLDirectMapping();
resultClassMapping.setAttributeName("m_resultClassName");
resultClassMapping.setGetMethodName("getResultClassName");
resultClassMapping.setSetMethodName("setResultClassName");
resultClassMapping.setXPath("@result-class");
return resultClassMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeDirectCollectionMapping getResultClasses() {
XMLCompositeDirectCollectionMapping mapping = new XMLCompositeDirectCollectionMapping();
mapping.setAttributeName("m_resultClassNames");
mapping.setGetMethodName("getResultClassNames");
mapping.setSetMethodName("setResultClassNames");
mapping.setXPath("orm:result-class");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getResultSetMappingAttributeMapping() {
XMLDirectMapping resultSetMappingMapping = new XMLDirectMapping();
resultSetMappingMapping.setAttributeName("m_resultSetMapping");
resultSetMappingMapping.setGetMethodName("getResultSetMapping");
resultSetMappingMapping.setSetMethodName("setResultSetMapping");
resultSetMappingMapping.setXPath("@result-set-mapping");
return resultSetMappingMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getResultSetMappingMapping() {
XMLCompositeCollectionMapping sqlResultSetMappingMapping = new XMLCompositeCollectionMapping();
sqlResultSetMappingMapping.setAttributeName("m_sqlResultSetMappings");
sqlResultSetMappingMapping.setGetMethodName("getSqlResultSetMappings");
sqlResultSetMappingMapping.setSetMethodName("setSqlResultSetMappings");
sqlResultSetMappingMapping.setReferenceClass(SQLResultSetMappingMetadata.class);
sqlResultSetMappingMapping.setXPath("orm:sql-result-set-mapping");
return sqlResultSetMappingMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeDirectCollectionMapping getResultSetMappings() {
XMLCompositeDirectCollectionMapping mapping = new XMLCompositeDirectCollectionMapping();
mapping.setAttributeName("m_resultSetMappings");
mapping.setGetMethodName("getResultSetMappings");
mapping.setSetMethodName("setResultSetMappings");
mapping.setXPath("orm:result-set-mapping");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getReturnInsertMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_returnInsert");
mapping.setGetMethodName("getReturnInsert");
mapping.setSetMethodName("setReturnInsert");
mapping.setReferenceClass(ReturnInsertMetadata.class);
mapping.setXPath("orm:return-insert");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getReturnUpdateMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_returnUpdate");
mapping.setGetMethodName("getReturnUpdate");
mapping.setSetMethodName("setReturnUpdate");
mapping.setConverter(new EmptyElementConverter());
IsSetNullPolicy returnUpdatePolicy = new IsSetNullPolicy("isReturnUpdate");
returnUpdatePolicy.setMarshalNullRepresentation(XMLNullRepresentationType.EMPTY_NODE);
mapping.setNullPolicy(returnUpdatePolicy);
mapping.setXPath("orm:return-update");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getRoundRobinPartitioningMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_roundRobinPartitioning");
mapping.setGetMethodName("getRoundRobinPartitioning");
mapping.setSetMethodName("setRoundRobinPartitioning");
mapping.setReferenceClass(RoundRobinPartitioningMetadata.class);
mapping.setXPath("orm:round-robin-partitioning");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getScaleAttributeMapping() {
XMLDirectMapping scaleMapping = new XMLDirectMapping();
scaleMapping.setAttributeName("m_scale");
scaleMapping.setGetMethodName("getScale");
scaleMapping.setSetMethodName("setScale");
scaleMapping.setXPath("@scale");
return scaleMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getSchemaAttributeMapping() {
XMLDirectMapping schemaMapping = new XMLDirectMapping();
schemaMapping.setAttributeName("m_schema");
schemaMapping.setGetMethodName("getSchema");
schemaMapping.setSetMethodName("setSchema");
schemaMapping.setXPath("@schema");
return schemaMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getSchemaMapping() {
XMLDirectMapping schemaMapping = new XMLDirectMapping();
schemaMapping.setAttributeName("m_schema");
schemaMapping.setGetMethodName("getSchema");
schemaMapping.setSetMethodName("setSchema");
schemaMapping.setXPath("orm:schema/text()");
return schemaMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getSequenceGeneratorMapping() {
XMLCompositeObjectMapping sequenceGeneratorMapping = new XMLCompositeObjectMapping();
sequenceGeneratorMapping.setAttributeName("m_sequenceGenerator");
sequenceGeneratorMapping.setGetMethodName("getSequenceGenerator");
sequenceGeneratorMapping.setSetMethodName("setSequenceGenerator");
sequenceGeneratorMapping.setReferenceClass(SequenceGeneratorMetadata.class);
sequenceGeneratorMapping.setXPath("orm:sequence-generator");
return sequenceGeneratorMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getSerializedObjectPolicyMapping() {
XMLCompositeObjectMapping serializedObjectPolicyMapping = new XMLCompositeObjectMapping();
serializedObjectPolicyMapping.setAttributeName("m_serializedObjectPolicy");
serializedObjectPolicyMapping.setGetMethodName("getSerializedObjectPolicy");
serializedObjectPolicyMapping.setSetMethodName("setSerializedObjectPolicy");
serializedObjectPolicyMapping.setReferenceClass(SerializedObjectPolicyMetadata.class);
serializedObjectPolicyMapping.setXPath("orm:serialized-object");
return serializedObjectPolicyMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getSizeAttributeMapping() {
XMLDirectMapping sizeMapping = new XMLDirectMapping();
sizeMapping.setAttributeName("m_size");
sizeMapping.setGetMethodName("getSize");
sizeMapping.setSetMethodName("setSize");
sizeMapping.setXPath("@size");
return sizeMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getStructConverterMapping() {
XMLCompositeCollectionMapping structConvertersMapping = new XMLCompositeCollectionMapping();
structConvertersMapping.setAttributeName("m_structConverters");
structConvertersMapping.setGetMethodName("getStructConverters");
structConvertersMapping.setSetMethodName("setStructConverters");
structConvertersMapping.setReferenceClass(StructConverterMetadata.class);
structConvertersMapping.setXPath("orm:struct-converter");
return structConvertersMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getStructMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_struct");
mapping.setGetMethodName("getStruct");
mapping.setSetMethodName("setStruct");
mapping.setReferenceClass(StructMetadata.class);
mapping.setXPath("orm:struct");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getSubclassSubgraphMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_subclassSubgraph");
mapping.setGetMethodName("getSubclassSubgraphs");
mapping.setSetMethodName("setSubclassSubgraphs");
mapping.setReferenceClass(NamedSubgraphMetadata.class);
mapping.setXPath("orm:subclass-subgraph");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getSubgraphAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_subgraph");
mapping.setGetMethodName("getSubgraph");
mapping.setSetMethodName("setSubgraph");
mapping.setXPath("@subgraph");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getSubgraphMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("m_subgraphs");
mapping.setGetMethodName("getSubgraphs");
mapping.setSetMethodName("setSubgraphs");
mapping.setReferenceClass(NamedSubgraphMetadata.class);
mapping.setXPath("orm:subgraph");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getTableAttributeMapping() {
XMLDirectMapping tableMapping = new XMLDirectMapping();
tableMapping.setAttributeName("m_table");
tableMapping.setGetMethodName("getTable");
tableMapping.setSetMethodName("setTable");
tableMapping.setXPath("@table");
return tableMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getTableGeneratorMapping() {
XMLCompositeObjectMapping tableGeneratorMapping = new XMLCompositeObjectMapping();
tableGeneratorMapping.setAttributeName("m_tableGenerator");
tableGeneratorMapping.setGetMethodName("getTableGenerator");
tableGeneratorMapping.setSetMethodName("setTableGenerator");
tableGeneratorMapping.setReferenceClass(TableGeneratorMetadata.class);
tableGeneratorMapping.setXPath("orm:table-generator");
return tableGeneratorMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getTargetClassAttributeMapping() {
XMLDirectMapping targetClassMapping = new XMLDirectMapping();
targetClassMapping.setAttributeName("m_targetClassName");
targetClassMapping.setGetMethodName("getTargetClassName");
targetClassMapping.setSetMethodName("setTargetClassName");
targetClassMapping.setXPath("@target-class");
return targetClassMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getTargetEntityAttributeMapping() {
XMLDirectMapping targetEntityMapping = new XMLDirectMapping();
targetEntityMapping.setAttributeName("m_targetEntityName");
targetEntityMapping.setGetMethodName("getTargetEntityName");
targetEntityMapping.setSetMethodName("setTargetEntityName");
targetEntityMapping.setXPath("@target-entity");
return targetEntityMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getTargetInterfaceAttributeMapping() {
XMLDirectMapping targetInterfaceMapping = new XMLDirectMapping();
targetInterfaceMapping.setAttributeName("m_targetEntityName");
targetInterfaceMapping.setGetMethodName("getTargetEntityName");
targetInterfaceMapping.setSetMethodName("setTargetEntityName");
targetInterfaceMapping.setXPath("@target-interface");
return targetInterfaceMapping;
}
/**
* INTERNAL
*/
protected XMLCompositeObjectMapping getTemporalMapping() {
XMLCompositeObjectMapping temporalMapping = new XMLCompositeObjectMapping();
temporalMapping.setAttributeName("m_temporal");
temporalMapping.setGetMethodName("getTemporal");
temporalMapping.setSetMethodName("setTemporal");
temporalMapping.setReferenceClass(TemporalMetadata.class);
temporalMapping.setXPath("orm:temporal");
return temporalMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getTenantDiscriminatorColumnsMapping() {
XMLCompositeCollectionMapping tenantDiscriminatorsMapping = new XMLCompositeCollectionMapping();
tenantDiscriminatorsMapping.setAttributeName("m_tenantDiscriminatorColumns");
tenantDiscriminatorsMapping.setGetMethodName("getTenantDiscriminatorColumns");
tenantDiscriminatorsMapping.setSetMethodName("setTenantDiscriminatorColumns");
tenantDiscriminatorsMapping.setReferenceClass(TenantDiscriminatorColumnMetadata.class);
tenantDiscriminatorsMapping.setXPath("orm:tenant-discriminator-column");
return tenantDiscriminatorsMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getTenantTableDiscriminatorMapping() {
XMLCompositeObjectMapping tenantTableDiscriminatorMapping = new XMLCompositeObjectMapping();
tenantTableDiscriminatorMapping.setAttributeName("m_tenantTableDiscriminator");
tenantTableDiscriminatorMapping.setGetMethodName("getTenantTableDiscriminator");
tenantTableDiscriminatorMapping.setSetMethodName("setTenantTableDiscriminator");
tenantTableDiscriminatorMapping.setReferenceClass(TenantTableDiscriminatorMetadata.class);
tenantTableDiscriminatorMapping.setXPath("orm:tenant-table-discriminator");
return tenantTableDiscriminatorMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getTextMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_text");
mapping.setGetMethodName("getText");
mapping.setSetMethodName("setText");
mapping.setXPath("text()");
return mapping;
}
/**
* INTERNAL
*/
protected XMLDirectMapping getTransformerClassAttributeMapping() {
XMLDirectMapping transformerClassNameMapping = new XMLDirectMapping();
transformerClassNameMapping.setAttributeName("m_transformerClassName");
transformerClassNameMapping.setGetMethodName("getTransformerClassName");
transformerClassNameMapping.setSetMethodName("setTransformerClassName");
transformerClassNameMapping.setXPath("@transformer-class");
return transformerClassNameMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getTypeAttributeMapping() {
XMLDirectMapping typeMapping = new XMLDirectMapping();
typeMapping.setAttributeName("m_type");
typeMapping.setGetMethodName("getType");
typeMapping.setSetMethodName("setType");
typeMapping.setXPath("@type");
return typeMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getTypeConverterMapping() {
XMLCompositeCollectionMapping typeConvertersMapping = new XMLCompositeCollectionMapping();
typeConvertersMapping.setAttributeName("m_typeConverters");
typeConvertersMapping.setGetMethodName("getTypeConverters");
typeConvertersMapping.setSetMethodName("setTypeConverters");
typeConvertersMapping.setReferenceClass(TypeConverterMetadata.class);
typeConvertersMapping.setXPath("orm:type-converter");
return typeConvertersMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getSerializedConverterMapping() {
XMLCompositeCollectionMapping typeConvertersMapping = new XMLCompositeCollectionMapping();
typeConvertersMapping.setAttributeName("m_serializedConverters");
typeConvertersMapping.setGetMethodName("getSerializedConverters");
typeConvertersMapping.setSetMethodName("setSerializedConverters");
typeConvertersMapping.setReferenceClass(SerializedConverterMetadata.class);
typeConvertersMapping.setXPath("orm:serialized-converter");
return typeConvertersMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getTypeNameAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("m_typeName");
mapping.setGetMethodName("getTypeName");
mapping.setSetMethodName("setTypeName");
mapping.setXPath("@type");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getUnionPartitioningMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_unionPartitioning");
mapping.setGetMethodName("getUnionPartitioning");
mapping.setSetMethodName("setUnionPartitioning");
mapping.setReferenceClass(UnionPartitioningMetadata.class);
mapping.setXPath("orm:union-partitioning");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getUnionUnpartitionableQueriesAttributeMapping() {
XMLDirectMapping mapping = new XMLDirectMapping();
mapping.setAttributeName("unionUnpartitionableQueries");
mapping.setGetMethodName("getUnionUnpartitionableQueries");
mapping.setSetMethodName("setUnionUnpartitionableQueries");
mapping.setXPath("@union-unpartitionable-queries");
return mapping;
}
/**
* INTERNAL
*/
protected XMLDirectMapping getUniqueAttributeMapping() {
XMLDirectMapping uniqueMapping = new XMLDirectMapping();
uniqueMapping.setAttributeName("m_unique");
uniqueMapping.setGetMethodName("getUnique");
uniqueMapping.setSetMethodName("setUnique");
uniqueMapping.setXPath("@unique");
return uniqueMapping;
}
/**
* INTERNAL
*/
protected XMLCompositeCollectionMapping getUniqueConstraintMapping() {
XMLCompositeCollectionMapping uniqueConstraintMapping = new XMLCompositeCollectionMapping();
uniqueConstraintMapping.setAttributeName("m_uniqueConstraints");
uniqueConstraintMapping.setGetMethodName("getUniqueConstraints");
uniqueConstraintMapping.setSetMethodName("setUniqueConstraints");
uniqueConstraintMapping.setReferenceClass(UniqueConstraintMetadata.class);
uniqueConstraintMapping.setXPath("orm:unique-constraint");
return uniqueConstraintMapping;
}
/**
* INTERNAL
*/
protected XMLDirectMapping getUpdatableAttributeMapping() {
XMLDirectMapping updatableMapping = new XMLDirectMapping();
updatableMapping.setAttributeName("m_updatable");
updatableMapping.setGetMethodName("getUpdatable");
updatableMapping.setSetMethodName("setUpdatable");
updatableMapping.setXPath("@updatable");
return updatableMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getUuidGeneratorMapping() {
XMLCompositeObjectMapping uuidGeneratorMapping = new XMLCompositeObjectMapping();
uuidGeneratorMapping.setAttributeName("m_uuidGenerator");
uuidGeneratorMapping.setGetMethodName("getUuidGenerator");
uuidGeneratorMapping.setSetMethodName("setUuidGenerator");
uuidGeneratorMapping.setReferenceClass(UuidGeneratorMetadata.class);
uuidGeneratorMapping.setXPath("orm:uuid-generator");
return uuidGeneratorMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getValueAttributeMapping() {
XMLDirectMapping valueMapping = new XMLDirectMapping();
valueMapping.setAttributeName("m_value");
valueMapping.setGetMethodName("getValue");
valueMapping.setSetMethodName("setValue");
valueMapping.setXPath("@value");
return valueMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getValueColumnMapping() {
XMLCompositeObjectMapping valueColumnMapping = new XMLCompositeObjectMapping();
valueColumnMapping.setAttributeName("m_valueColumn");
valueColumnMapping.setGetMethodName("getValueColumn");
valueColumnMapping.setSetMethodName("setValueColumn");
valueColumnMapping.setReferenceClass(ColumnMetadata.class);
valueColumnMapping.setXPath("orm:value-column");
return valueColumnMapping;
}
/**
* INTERNAL:
*/
protected XMLDirectMapping getValueMapping() {
XMLDirectMapping valueMapping = new XMLDirectMapping();
valueMapping.setAttributeName("m_value");
valueMapping.setGetMethodName("getValue");
valueMapping.setSetMethodName("setValue");
valueMapping.setXPath("text()");
return valueMapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeCollectionMapping getValuePartitionMapping() {
XMLCompositeCollectionMapping mapping = new XMLCompositeCollectionMapping();
mapping.setAttributeName("partitions");
mapping.setGetMethodName("getPartitions");
mapping.setSetMethodName("setPartitions");
mapping.setReferenceClass(ValuePartitionMetadata.class);
mapping.setXPath("orm:partition");
return mapping;
}
/**
* INTERNAL:
*/
protected XMLCompositeObjectMapping getValuePartitioningMapping() {
XMLCompositeObjectMapping mapping = new XMLCompositeObjectMapping();
mapping.setAttributeName("m_valuePartitioning");
mapping.setGetMethodName("getValuePartitioning");
mapping.setSetMethodName("setValuePartitioning");
mapping.setReferenceClass(ValuePartitioningMetadata.class);
mapping.setXPath("orm:value-partitioning");
return mapping;
}
}