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

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 EntityRegionAccessStrategy buildAccessStrategy(final AccessType accessType) throws CacheException {
    if (AccessType.READ_ONLY.equals(accessType)) {
        return new EntityRegionAccessStrategyAdapter(
                new ReadOnlyAccessDelegate<HazelcastEntityRegion>(this, props));
    }
    if (AccessType.NONSTRICT_READ_WRITE.equals(accessType)) {
        return new EntityRegionAccessStrategyAdapter(
                new NonStrictReadWriteAccessDelegate<HazelcastEntityRegion>(this, props));
    }
    if (AccessType.READ_WRITE.equals(accessType)) {
        return new EntityRegionAccessStrategyAdapter(
                new ReadWriteAccessDelegate<HazelcastEntityRegion>(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 EntityRegionAccessStrategy 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 ReadOnlyMemcachedEntityRegionAccessStrategy(this, settings);
            case READ_WRITE:
                return new ReadWriteMemcachedEntityRegionAccessStrategy(this, settings);
            case NONSTRICT_READ_WRITE:
                return new NonStrictReadWriteMemcachedEntityRegionAccessStrategy(this, settings);
            case TRANSACTIONAL:
                return new TransactionalMemcachedEntityRegionAccessStrategy(this, cache, settings);
            default:
                throw new IllegalArgumentException("unrecognized access strategy type [" + accessType + "]");
        }
    }

@Override
    public EntityRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
        switch ( accessType ) {
            case READ_ONLY:
                if ( getCacheDataDescription().isMutable() ) {
                    LOG.warnf( "read-only cache configured for mutable entity [ %s ]", getName() );
                }
                return new ReadOnlyEntityRegionAccessStrategy( this );
            case READ_WRITE:
                return new ReadWriteEntityRegionAccessStrategy( this );
            case NONSTRICT_READ_WRITE:
                return new NonstrictReadWriteEntityRegionAccessStrategy( this );
            case TRANSACTIONAL:
//              throw new UnsupportedOperationException( "doesn't support this access strategy" );
                return new TransactionalEntityRegionAccessStrategy( this );

            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 );
}

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

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

public static EntityRegionAccessStrategy buildEntityRegionAccessStrategy(TayzGridEntityRegion region, AccessType accessType) {
    switch (accessType) {
        case READ_ONLY:
            return new ReadOnlyTayzGridEntityRegionAccessStrategy(region);
        case NONSTRICT_READ_WRITE:
            return new NonStrictReadWriteTayzGridEntityRegionAccessStrategy(region);
        case READ_WRITE:
            return new ReadWriteTayzGridEntityRegionAccessStrategy(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() );
}

public EntityRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
    if(AccessType.READ_ONLY.equals(accessType)) {
        return new ReadOnlyMemcachedEntityRegionAccessStrategy(this, settings);
    } else if(AccessType.READ_WRITE.equals(accessType)) {
        return new ReadWriteMemcachedEntityRegionAccessStrategy(this, settings);
    } else if(AccessType.NONSTRICT_READ_WRITE.equals(accessType)) {
        return new NonStrictReadWriteMemcachedEntityRegionAccessStrategy(this, settings);
    } else if(AccessType.TRANSACTIONAL.equals(accessType)) {
        throw new CacheException("Transactional access is not supported by Memcached region factory");
    } else {
        throw new IllegalArgumentException("Unknown access strategy type - " + accessType);
    }
}

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

public EntityRegionAccessStrategy getCacheAccessStrategy() {
    return cacheAccessStrategy;
}

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;
}

private EntityCleanup(EntityRegionAccessStrategy cacheAccess) {
    this.cacheAccess = cacheAccess;
    this.cacheLock = cacheAccess.lockRegion();
    cacheAccess.removeAll();
}

@Override
public EntityRegionAccessStrategy getCacheAccessStrategy() {
    // 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 EntityRegionAccessStrategy buildAccessStrategy(AccessType accessType) throws CacheException {
    return new AccessStrategy(createAccessStrategy(accessType));
}

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

@Override
public EntityRegionAccessStrategy 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);
}

/**
 * Get the cache (optional operation)
 */
public EntityRegionAccessStrategy getCacheAccessStrategy();

/**
 * 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(
        EntityBinding model,
        EntityRegionAccessStrategy cacheAccessStrategy,
        SessionFactoryImplementor factory,
        Mapping cfg) throws HibernateException;