Java 类org.hibernate.cache.spi.access.NaturalIdRegionAccessStrategy 实例源码

public UnionSubclassEntityPersister(
        final EntityBinding entityBinding,
        final EntityRegionAccessStrategy cacheAccessStrategy,
        final NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
        final SessionFactoryImplementor factory,
        final Mapping mapping) throws HibernateException {
    super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory );
    // TODO: implement!!! initializing final fields to null to make compiler happy.
    subquery = null;
    tableName = null;
    subclassClosure = null;
    spaces = null;
    subclassSpaces = null;
    discriminatorValue = null;
    discriminatorSQLValue = null;
    constraintOrderedTableNames = null;
    constraintOrderedKeyColumnNames = null;
}

@Override
public NaturalIdRegionAccessStrategy buildAccessStrategy(final AccessType accessType) throws CacheException {
    if (AccessType.READ_ONLY.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new ReadOnlyAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    if (AccessType.NONSTRICT_READ_WRITE.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new NonStrictReadWriteAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    if (AccessType.READ_WRITE.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new ReadWriteAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    throw new CacheException("AccessType \"" + accessType + "\" is not currently supported by Hazelcast.");
}

private static void populateMappingModel(MetadataImplementor mappingMetadata, ExplicitSqmDomainMetamodel domainMetamodel) {
//      final PersisterFactory persisterFactory = getSessionFactory().getServiceRegistry().getService( PersisterFactory.class );
        final PersisterFactory persisterFactory = domainMetamodel.getPersisterFactory();

        for ( final PersistentClass model : mappingMetadata.getEntityBindings() ) {
//          final EntityRegionAccessStrategy accessStrategy = getSessionFactory().getCache().determineEntityRegionAccessStrategy(
//                  model
//          );
            final EntityRegionAccessStrategy accessStrategy = null;

//          final NaturalIdRegionAccessStrategy naturalIdAccessStrategy = getSessionFactory().getCache().determineNaturalIdRegionAccessStrategy(
//                  model
//          );
            final NaturalIdRegionAccessStrategy naturalIdAccessStrategy = null;

            persisterFactory.createEntityPersister(
                    model,
                    accessStrategy,
                    naturalIdAccessStrategy,
                    domainMetamodel
            );
        }

        persisterFactory.finishUp( domainMetamodel );
    }

public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {

        switch (accessType) {

            case READ_ONLY:
                if (metadata.isMutable()) {
                    log.warn("read-only cache configured for mutable entity ["
                            + getName() + "]");
                }
                return new ReadOnlyMemcachedNaturalIdRegionAccessStrategy(this, settings);
            case READ_WRITE:
                return new ReadWriteMemcachedNaturalIdRegionAccessStrategy(this, settings, metadata);
            case NONSTRICT_READ_WRITE:
                return new NonStrictReadWriteMemcachedNaturalIdRegionAccessStrategy(this, settings);
            case TRANSACTIONAL:
                return new TransactionalMemcachedNaturalIdRegionAccessStrategy(this, settings);
            default:
                throw new IllegalArgumentException("unrecognized access strategy type [" + accessType + "]");
        }
    }

@Override
    public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
        switch ( accessType ) {
            case READ_ONLY:
                if ( getCacheDataDescription().isMutable() ) {
                    LOG.warnf( "read-only cache configured for mutable collection [ %s ]", getName() );
                }
                return new ReadOnlyNaturalIdRegionAccessStrategy( this );
            case READ_WRITE:
                 return new ReadWriteNaturalIdRegionAccessStrategy( this );
            case NONSTRICT_READ_WRITE:
                return new NonstrictReadWriteNaturalIdRegionAccessStrategy( this );
            case TRANSACTIONAL:
                return new TransactionalNaturalIdRegionAccessStrategy( this );
//              throw new UnsupportedOperationException( "doesn't support this access strategy" );
            default:
                throw new IllegalArgumentException( "unrecognized access strategy type [" + accessType + "]" );
        }
    }

@Override
@SuppressWarnings( {"unchecked"})
public EntityPersister createEntityPersister(
        PersistentClass metadata,
        EntityRegionAccessStrategy cacheAccessStrategy,
        NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
        SessionFactoryImplementor factory,
        Mapping cfg) {
    Class<? extends EntityPersister> persisterClass = metadata.getEntityPersisterClass();
    if ( persisterClass == null ) {
        persisterClass = serviceRegistry.getService( PersisterClassResolver.class ).getEntityPersisterClass( metadata );
    }
    return create( persisterClass, ENTITY_PERSISTER_CONSTRUCTOR_ARGS, metadata, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, cfg );
}

/**
 * Handle removing cross reference entries for the given natural-id/pk combo
 *
 * @param persister The persister representing the entity type.
 * @param pk The primary key value
 * @param naturalIdValues The natural id value(s)
 * 
 * @return The cached values, if any.  May be different from incoming values.
 */
public Object[] removeNaturalIdCrossReference(EntityPersister persister, Serializable pk, Object[] naturalIdValues) {
    persister = locatePersisterForKey( persister );
    validateNaturalId( persister, naturalIdValues );

    final NaturalIdResolutionCache entityNaturalIdResolutionCache = naturalIdResolutionCacheMap.get( persister );
    Object[] sessionCachedNaturalIdValues = null;
    if ( entityNaturalIdResolutionCache != null ) {
        final CachedNaturalId cachedNaturalId = entityNaturalIdResolutionCache.pkToNaturalIdMap
                .remove( pk );
        if ( cachedNaturalId != null ) {
            entityNaturalIdResolutionCache.naturalIdToPkMap.remove( cachedNaturalId );
            sessionCachedNaturalIdValues = cachedNaturalId.getValues();
        }
    }

    if ( persister.hasNaturalIdCache() ) {
        final NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy = persister
                .getNaturalIdCacheAccessStrategy();
        final NaturalIdCacheKey naturalIdCacheKey = new NaturalIdCacheKey( naturalIdValues, persister, session() );
        naturalIdCacheAccessStrategy.evict( naturalIdCacheKey );

        if ( sessionCachedNaturalIdValues != null
                && !Arrays.equals( sessionCachedNaturalIdValues, naturalIdValues ) ) {
            final NaturalIdCacheKey sessionNaturalIdCacheKey = new NaturalIdCacheKey( sessionCachedNaturalIdValues, persister, session() );
            naturalIdCacheAccessStrategy.evict( sessionNaturalIdCacheKey );
        }
    }

    return sessionCachedNaturalIdValues;
}

@Override
        public void removeSharedNaturalIdCrossReference(EntityPersister persister, Serializable id, Object[] naturalIdValues) {
            if ( !persister.hasNaturalIdentifier() ) {
                // nothing to do
                return;
            }

            if ( ! persister.hasNaturalIdCache() ) {
                // nothing to do
                return;
            }

            // todo : couple of things wrong here:
            //      1) should be using access strategy, not plain evict..
            //      2) should prefer session-cached values if any (requires interaction from removeLocalNaturalIdCrossReference

            persister = locateProperPersister( persister );
            final NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy = persister.getNaturalIdCacheAccessStrategy();
            final NaturalIdCacheKey naturalIdCacheKey = new NaturalIdCacheKey( naturalIdValues, persister, session );
            naturalIdCacheAccessStrategy.evict( naturalIdCacheKey );

//          if ( sessionCachedNaturalIdValues != null
//                  && !Arrays.equals( sessionCachedNaturalIdValues, deletedNaturalIdValues ) ) {
//              final NaturalIdCacheKey sessionNaturalIdCacheKey = new NaturalIdCacheKey( sessionCachedNaturalIdValues, persister, session );
//              naturalIdCacheAccessStrategy.evict( sessionNaturalIdCacheKey );
//          }
        }

/**
 * Performs the process of loading an entity from the configured
 * underlying datasource.
 * 
 * @param event The load event
 *
 * @return The object loaded from the datasource, or null if not found.
 */
protected Serializable loadFromDatasource(final ResolveNaturalIdEvent event) {
    final SessionFactoryImplementor factory = event.getSession().getFactory();
    final boolean stats = factory.getStatistics().isStatisticsEnabled();
    long startTime = 0;
    if ( stats ) {
        startTime = System.nanoTime();
    }

    final Serializable pk = event.getEntityPersister().loadEntityIdByNaturalId(
            event.getOrderedNaturalIdValues(),
            event.getLockOptions(),
            event.getSession()
    );

    if ( stats ) {
        final NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy = event.getEntityPersister().getNaturalIdCacheAccessStrategy();
        final String regionName = naturalIdCacheAccessStrategy == null ? null : naturalIdCacheAccessStrategy.getRegion().getName();
        final long endTime = System.nanoTime();
        final long milliseconds = TimeUnit.MILLISECONDS.convert( endTime - startTime, TimeUnit.NANOSECONDS );
        factory.getStatisticsImplementor().naturalIdQueryExecuted(
                regionName,
                milliseconds );
    }

    //PK can be null if the entity doesn't exist
    if (pk != null) {
        event.getSession().getPersistenceContext().getNaturalIdHelper().cacheNaturalIdCrossReferenceFromLoad(
                event.getEntityPersister(),
                pk,
                event.getOrderedNaturalIdValues()
        );
    }

    return pk;
}

public NaturalIdRegionAccessStrategy buildAccessStrategy(final AccessType accessType) throws CacheException {
    if (AccessType.READ_ONLY.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new ReadOnlyAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    if (AccessType.NONSTRICT_READ_WRITE.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new NonStrictReadWriteAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    if (AccessType.READ_WRITE.equals(accessType)) {
        return new NaturalIdRegionAccessStrategyAdapter(
                new ReadWriteAccessDelegate<HazelcastNaturalIdRegion>(this, props));
    }
    throw new CacheException("AccessType \"" + accessType + "\" is not currently supported by Hazelcast.");
}

public static NaturalIdRegionAccessStrategy buildNaturalIdRegionAccessStrategy(TayzGridNaturalIdRegion region, AccessType accessType) {
    switch (accessType) {
        case READ_ONLY:
            return new ReadOnlyTayzGridNaturalIdRegionAccessStrategy(region);
        case NONSTRICT_READ_WRITE:
            return  new NonStrictReadWriteTayzGridNaturalIdRegionAccessStrategy(region);
        case READ_WRITE:
            return new ReadWriteTayzGridNaturalIdRegionAccessStraegy(region);
        case TRANSACTIONAL:
            throw new IllegalArgumentException(accessType + " access strategy not supported.");
        default:
            throw new IllegalArgumentException(accessType + " is not recognized as valid access type.");
    }
}

public EntityPersisterImpl(
        PersistentClass mappingDescriptor,
        EntityRegionAccessStrategy entityCaching,
        NaturalIdRegionAccessStrategy naturalIdCaching,
        PersisterCreationContext creationContext) {
    super( resolveEntityJavaTypeDescriptor( creationContext, mappingDescriptor), null, null );
    this.entityName = mappingDescriptor.getEntityName();
    this.jpaEntityName = mappingDescriptor.getJpaEntityName();

    setTypeConfiguration( creationContext.getTypeConfiguration() );
}

@Override
public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
    switch (accessType) {
        case READ_ONLY:
            return new ReadOnlyNaturalIdRegionAccessStrategy(this);
        case NONSTRICT_READ_WRITE:
            return new NonstrictReadWriteNaturalIdRegionAccessStrategy(this);
        default:
            throw new CacheException("Unsupported access strategy : " + accessType + ".");
    }
}

public NaturalIdRegionAccessStrategy getNaturalIdCacheAccessStrategy() {
    return naturalIdRegionAccessStrategy;
}

public JoinedSubclassEntityPersister(
        final EntityBinding entityBinding,
        final EntityRegionAccessStrategy cacheAccessStrategy,
        final NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
        final SessionFactoryImplementor factory,
        final Mapping mapping) throws HibernateException {
    super( entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory );
    // TODO: implement!!! initializing final fields to null to make compiler happy
    tableSpan = -1;
    tableNames = null;
    naturalOrderTableNames = null;
    tableKeyColumns = null;
    tableKeyColumnReaders = null;
    tableKeyColumnReaderTemplates = null;
    naturalOrderTableKeyColumns = null;
    naturalOrderTableKeyColumnReaders = null;
    naturalOrderTableKeyColumnReaderTemplates = null;
    naturalOrderCascadeDeleteEnabled = null;
    spaces = null;
    subclassClosure = null;
    subclassTableNameClosure = null;
    subclassTableKeyColumnClosure = null;
    isClassOrSuperclassTable = null;
    naturalOrderPropertyTableNumbers = null;
    propertyTableNumbers = null;
    subclassPropertyTableNumberClosure = null;
    subclassColumnTableNumberClosure = null;
    subclassFormulaTableNumberClosure = null;
    subclassTableSequentialSelect = null;
    subclassTableIsLazyClosure = null;
    discriminatorValues = null;
    notNullColumnNames = null;
    notNullColumnTableNumbers = null;
    constraintOrderedTableNames = null;
    constraintOrderedKeyColumnNames = null;
    discriminatorValue = null;
    discriminatorSQLString = null;
    discriminatorType = StandardBasicTypes.INTEGER;
    explicitDiscriminatorColumnName = null;
    discriminatorAlias = IMPLICIT_DISCRIMINATOR_ALIAS;
    coreTableSpan = -1;
    isNullableTable = null;
    subclassNamesBySubclassTable = null;
}

public static Serializable fromSharedCache(
        SessionImplementor session,
        NaturalIdCacheKey cacheKey,
        NaturalIdRegionAccessStrategy cacheAccessStrategy) {
    return fromSharedCache( session, (Object) cacheKey, cacheAccessStrategy );
}

public NaturalIdCleanup(NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy) {
    this.naturalIdCacheAccessStrategy = naturalIdCacheAccessStrategy;
    this.cacheLock = naturalIdCacheAccessStrategy.lockRegion();
    naturalIdCacheAccessStrategy.removeAll();
}

@Override
public NaturalIdRegionAccessStrategy getNaturalIdCacheAccessStrategy() {
    // TODO Auto-generated method stub
    return null;
}

public MidPointJoinedPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping) throws HibernateException {
    super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, mapping);
}

public MidPointJoinedPersister(EntityBinding entityBinding, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping) throws HibernateException {
    super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, mapping);
}

public MidPointSingleTablePersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping) throws HibernateException {
    super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, mapping);
}

public MidPointSingleTablePersister(EntityBinding entityBinding, EntityRegionAccessStrategy cacheAccessStrategy, NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping) throws HibernateException {
    super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, mapping);
}

@Override
@SuppressWarnings( {"unchecked"})
public EntityPersister createEntityPersister(
        PersistentClass entityBinding,
        EntityRegionAccessStrategy entityCacheAccessStrategy,
        NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy,
        PersisterCreationContext creationContext) throws HibernateException {

    // todo : MappedSuperclass...

    // See if we had an existing (partially created) node...
    EntityHierarchyNode entityHierarchyNode = nameToHierarchyNodeMap.get( entityBinding.getEntityName() );
    if ( entityHierarchyNode != null ) {
        // we create the EntityHierarchyNode for all super types before we
        //      actually create the super's EntityPersister.  This check
        //      makes sure we do not have multiple call paths attempting to
        //      create the same EntityPersister multiple times
        assert entityHierarchyNode.ormJpaType == null;
    }
    else {
        entityHierarchyNode = new EntityHierarchyNode( entityBinding );
        nameToHierarchyNodeMap.put( entityBinding.getEntityName(), entityHierarchyNode );
    }

    final EntityPersister entityPersister = instantiateEntityPersister(
            entityBinding,
            entityCacheAccessStrategy,
            naturalIdCacheAccessStrategy,
            creationContext
    );

    creationContext.registerEntityPersister( entityPersister );

    entityHierarchyNode.ormJpaType = entityPersister;

    final EntityHierarchyNode superTypeNode = interpretSuperTypeNode( entityBinding );

    if ( superTypeNode == null ) {
        roots.add( entityHierarchyNode );
    }
    else {
        superTypeNode.addSubEntityNode( entityHierarchyNode );
    }

    return entityPersister;
}

@SuppressWarnings("unchecked")
    private <T> EntityPersister<T> instantiateEntityPersister(
            PersistentClass entityBinding,
            EntityRegionAccessStrategy entityCacheAccessStrategy,
            NaturalIdRegionAccessStrategy naturalIdCacheAccessStrategy,
            PersisterCreationContext creationContext) {
//      // If the metadata for the entity specified an explicit persister class, use it...
//      Class<? extends EntityPersister> persisterClass = entityBinding.getEntityPersisterClass();
//      if ( persisterClass == null ) {
//          // Otherwise, use the persister class indicated by the PersisterClassResolver service
//          persisterClass = serviceRegistry.getService( PersisterClassResolver.class ).getEntityPersisterClass( entityBinding );
//      }
//
//      return instantiateEntityPersister(
//              persisterClass,
//              entityBinding,
//              entityCacheAccessStrategy,
//              naturalIdCacheAccessStrategy,
//              creationContext
//      );

        EntityJavaTypeDescriptor<T> jtd = (EntityJavaTypeDescriptor<T>) creationContext.getTypeConfiguration()
                .getJavaTypeDescriptorRegistry()
                .getDescriptor( entityBinding.getEntityName() );
        if ( jtd == null ) {
            jtd = new EntityJavaTypeDescriptorImpl(
                    entityBinding.getClassName(),
                    entityBinding.getEntityName(),
                    entityBinding.getMappedClass(),
                    resolveEntitySuperJavaTypeDescriptor( entityBinding ),
                    null,
                    null
            );
            creationContext.getTypeConfiguration().getJavaTypeDescriptorRegistry().addDescriptor( jtd );
        }
        return new EntityPersisterImpl<>(
                entityBinding,
                entityCacheAccessStrategy,
                naturalIdCacheAccessStrategy,
                creationContext
        );
    }

/** {@inheritDoc} */
@Override public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
    return new AccessStrategy(createAccessStrategy(accessType));
}

/** {@inheritDoc} */
@Override public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
    return new AccessStrategy(createAccessStrategy(accessType));
}

@Override
public NaturalIdRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
   throw new UnsupportedOperationException();
}

public MidPointJoinedPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy,
                               NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
                               PersisterCreationContext creationContext) throws HibernateException {
    super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy, creationContext);
}

public MidPointSingleTablePersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy,
                                    NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
                                    PersisterCreationContext creationContext) throws HibernateException {
    super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy, creationContext);
}

public NullableVersionEntityPersister(EntityBinding entityBinding, EntityRegionAccessStrategy cacheAccessStrategy,
        NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)
        throws HibernateException {
    super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, mapping);
}

public NullableVersionEntityPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy,
        NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy, SessionFactoryImplementor factory, Mapping mapping)
        throws HibernateException {
    super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy, factory, mapping);
}

public MidPointJoinedPersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy,
                               NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
                               PersisterCreationContext creationContext) throws HibernateException {
    super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy, creationContext);
}

public MidPointSingleTablePersister(PersistentClass persistentClass, EntityRegionAccessStrategy cacheAccessStrategy,
                                    NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
                                    PersisterCreationContext creationContext) throws HibernateException {
    super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy, creationContext);
}

/**
 * Create an entity persister instance.
 *
 * @param model The O/R mapping metamodel definition for the entity
 * @param cacheAccessStrategy The caching strategy for this entity
 * @param factory The session factory
 * @param cfg The overall mapping
 *
 * @return An appropriate entity persister instance.
 *
 * @throws HibernateException Indicates a problem building the persister.
 */
public EntityPersister createEntityPersister(
        PersistentClass model,
        EntityRegionAccessStrategy cacheAccessStrategy,
        NaturalIdRegionAccessStrategy naturalIdAccessStrategy,
        SessionFactoryImplementor factory,
        Mapping cfg) throws HibernateException;

/**
 * Constructs a new {@code EntityProxySingleTableEntityPersister}
 * instance.
 *
 * @param entityBinding
 *          the entity binding.
 * @param cacheAccessStrategy
 *          the cache access strategy.
 * @param naturalIdRegionAccessStrategy
 *          the natural ID cache access strategy.
 * @param factory
 *          the session.
 * @param mapping
 *          the mapping.
 */
public EntityProxySingleTableEntityPersister(EntityBinding entityBinding,
    EntityRegionAccessStrategy cacheAccessStrategy,
    NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
    SessionFactoryImplementor factory, Mapping mapping) {
  super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy,
      factory, mapping);
}

/**
 * Constructs a new {@code EntityProxySingleTableEntityPersister}
 * instance.
 *
 * @param persistentClass
 *          the persistent class.
 * @param cacheAccessStrategy
 *          the cache access strategy.
 * @param naturalIdRegionAccessStrategy
 *          the natural ID cache access strategy.
 * @param factory
 *          the session.
 * @param mapping
 *          the mapping.
 */
public EntityProxySingleTableEntityPersister(PersistentClass persistentClass,
    EntityRegionAccessStrategy cacheAccessStrategy,
    NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
    SessionFactoryImplementor factory, Mapping mapping) {
  super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy,
      factory, mapping);
}

/**
 * Constructs a new {@code EntityProxyUnionSubclassEntityPersister}
 * instance.
 *
 * @param entityBinding
 *          the entity binding.
 * @param cacheAccessStrategy
 *          the cache access strategy.
 * @param naturalIdRegionAccessStrategy
 *          the natural ID cache access strategy.
 * @param factory
 *          the session.
 * @param mapping
 *          the mapping.
 */
public EntityProxyUnionSubclassEntityPersister(EntityBinding entityBinding,
    EntityRegionAccessStrategy cacheAccessStrategy,
    NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
    SessionFactoryImplementor factory, Mapping mapping) {
  super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy,
      factory, mapping);
}

/**
 * Constructs a new {@code EntityProxyUnionSubclassEntityPersister}
 * instance.
 *
 * @param persistentClass
 *          the persistent class.
 * @param cacheAccessStrategy
 *          the cache access strategy.
 * @param naturalIdRegionAccessStrategy
 *          the natural ID cache access strategy.
 * @param factory
 *          the session.
 * @param mapping
 *          the mapping.
 */
public EntityProxyUnionSubclassEntityPersister(
    PersistentClass persistentClass,
    EntityRegionAccessStrategy cacheAccessStrategy,
    NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
    SessionFactoryImplementor factory, Mapping mapping) {
  super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy,
      factory, mapping);
}

/**
 * Constructs a new {@code EntityProxyJoinedSubclassEntityPersister}
 * instance.
 *
 * @param entityBinding
 *          the entity binding.
 * @param cacheAccessStrategy
 *          the cache access strategy.
 * @param naturalIdRegionAccessStrategy
 *          the natural ID cache access strategy.
 * @param factory
 *          the session.
 * @param mapping
 *          the mapping.
 */
public EntityProxyJoinedSubclassEntityPersister(EntityBinding entityBinding,
    EntityRegionAccessStrategy cacheAccessStrategy,
    NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
    SessionFactoryImplementor factory, Mapping mapping) {
  super(entityBinding, cacheAccessStrategy, naturalIdRegionAccessStrategy,
      factory, mapping);
}

/**
 * Constructs a new {@code EntityProxyJoinedSubclassEntityPersister}
 * instance.
 *
 * @param persistentClass
 *          the persistent class.
 * @param cacheAccessStrategy
 *          the cache access strategy.
 * @param naturalIdRegionAccessStrategy
 *          the natural ID cache access strategy.
 * @param factory
 *          the session.
 * @param mapping
 *          the mapping.
 */
public EntityProxyJoinedSubclassEntityPersister(
    PersistentClass persistentClass,
    EntityRegionAccessStrategy cacheAccessStrategy,
    NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy,
    SessionFactoryImplementor factory, Mapping mapping) {
  super(persistentClass, cacheAccessStrategy, naturalIdRegionAccessStrategy,
      factory, mapping);
}