public AbstractDomainDataRegion(
			DomainDataRegionConfig regionConfig,
			RegionFactory regionFactory,
			CacheKeysFactory defaultKeysFactory,
			DomainDataRegionBuildingContext buildingContext) {
//		super( regionFactory.qualify( regionConfig.getRegionName() ), regionFactory );
		super( regionConfig.getRegionName(), regionFactory );

		this.sessionFactory = buildingContext.getSessionFactory();

		if ( defaultKeysFactory == null ) {
			defaultKeysFactory = DefaultCacheKeysFactory.INSTANCE;
		}
		this.effectiveKeysFactory = buildingContext.getEnforcedCacheKeysFactory() != null
				? buildingContext.getEnforcedCacheKeysFactory()
				: defaultKeysFactory;
	}
 

private Map<NavigableRole, EntityDataAccess> generateEntityDataAccessMap(
		DomainDataRegionConfig regionConfig) {
	if ( regionConfig.getEntityCaching().isEmpty() ) {
		return Collections.emptyMap();
	}

	final Map<NavigableRole, EntityDataAccess> accessMap = new ConcurrentHashMap<>();
	for ( EntityDataCachingConfig entityAccessConfig : regionConfig.getEntityCaching() ) {
		accessMap.computeIfAbsent(
				entityAccessConfig.getNavigableRole(),
				hierarchy -> generateEntityAccess( entityAccessConfig )
		);
	}

	return Collections.unmodifiableMap( accessMap );
}
 

private Map<NavigableRole, CollectionDataAccess> generateCollectionDataAccessMap(
		DomainDataRegionConfig regionConfig) {
	if ( regionConfig.getCollectionCaching().isEmpty() ) {
		return Collections.emptyMap();
	}

	final Map<NavigableRole, CollectionDataAccess> accessMap = new ConcurrentHashMap<>();
	for ( CollectionDataCachingConfig cachingConfig : regionConfig.getCollectionCaching() ) {
		accessMap.computeIfAbsent(
				cachingConfig.getNavigableRole(),
				hierarchy -> generateCollectionAccess( cachingConfig )
		);
	}

	return Collections.unmodifiableMap( accessMap );
}
 

@Override
protected DomainDataStorageAccess createDomainDataStorageAccess(DomainDataRegionConfig regionConfig,
        DomainDataRegionBuildingContext buildingContext) {
    String defaultKey = null;
    if (!regionConfig.getCollectionCaching().isEmpty()) {
        defaultKey = COLLECTION_DEF;
    } else if (!regionConfig.getEntityCaching().isEmpty()) {
        defaultKey = ENTITY_DEF;
    } else if (!regionConfig.getNaturalIdCaching().isEmpty()) {
        defaultKey = NATURAL_ID_DEF;
    } else {
        throw new IllegalArgumentException("Unable to determine entity cache type!");
    }
    
    RMapCache<Object, Object> mapCache = getCache(regionConfig.getRegionName(), buildingContext.getSessionFactory().getProperties(), defaultKey);
    return new RedissonStorage(mapCache, ((Redisson)redisson).getConnectionManager(), buildingContext.getSessionFactory().getProperties(), defaultKey);
}
 

public DomainDataRegionTemplate(
		DomainDataRegionConfig regionConfig,
		RegionFactory regionFactory,
		DomainDataStorageAccess storageAccess,
		CacheKeysFactory defaultKeysFactory,
		DomainDataRegionBuildingContext buildingContext) {
	super( regionConfig, regionFactory, defaultKeysFactory, buildingContext );
	this.storageAccess = storageAccess;

	// now the super-type calls will have access to the `DomainDataStorageAccess` reference
	completeInstantiation( regionConfig, buildingContext );
}
 

/**
 * Should be called at the end of the subtype's constructor, or at least after the
 * `#super(...)` (aka, this type's constructor) call.  It's a timing issue - we need access
 * to the DomainDataStorageAccess in DomainDataRegionTemplate but in methods initiated
 * (atm) from AbstractDomainDataRegion's constructor
 */
protected void completeInstantiation(
		DomainDataRegionConfig regionConfig,
		DomainDataRegionBuildingContext buildingContext) {
	log.tracef( "DomainDataRegion created [%s]; key-factory = %s", regionConfig.getRegionName(), effectiveKeysFactory );

	this.entityDataAccessMap = generateEntityDataAccessMap( regionConfig );
	this.naturalIdDataAccessMap = generateNaturalIdDataAccessMap( regionConfig );
	this.collectionDataAccessMap = generateCollectionDataAccessMap( regionConfig );

}
 

private Map<NavigableRole, NaturalIdDataAccess> generateNaturalIdDataAccessMap(DomainDataRegionConfig regionConfig) {
	if ( regionConfig.getNaturalIdCaching().isEmpty() ) {
		return Collections.emptyMap();
	}

	final Map<NavigableRole, NaturalIdDataAccess> accessMap = new ConcurrentHashMap<>();
	for ( NaturalIdDataCachingConfig naturalIdAccessConfig : regionConfig.getNaturalIdCaching() ) {
		accessMap.computeIfAbsent(
				naturalIdAccessConfig.getNavigableRole(),
				hierarchy -> generateNaturalIdAccess( naturalIdAccessConfig )
		);
	}

	return Collections.unmodifiableMap( accessMap );
}
 

@SuppressWarnings("WeakerAccess")
public DomainDataRegionImpl(
		DomainDataRegionConfig regionConfig,
		RegionFactoryTemplate regionFactory,
		DomainDataStorageAccess domainDataStorageAccess,
		CacheKeysFactory defaultKeysFactory,
		DomainDataRegionBuildingContext buildingContext) {
	super(
			regionConfig,
			regionFactory,
			domainDataStorageAccess,
			defaultKeysFactory,
			buildingContext
	);
}
 

@Override
public DomainDataRegion buildDomainDataRegion(
		DomainDataRegionConfig regionConfig,
		DomainDataRegionBuildingContext buildingContext) {
	verifyStarted();
	return new DomainDataRegionTemplate(
			regionConfig,
			this,
			createDomainDataStorageAccess( regionConfig, buildingContext ),
			getImplicitCacheKeysFactory(),
			buildingContext
	);
}
 

/** {@inheritDoc} */
@Override public DomainDataRegion buildDomainDataRegion(
    DomainDataRegionConfig regionCfg,
    DomainDataRegionBuildingContext buildingCtx) {
    return new IgniteDomainDataRegion(regionCfg, this, null, buildingCtx,
        accessStgyFactory);
}
 

/** */
public IgniteDomainDataRegion(DomainDataRegionConfig regionCfg,
    RegionFactory regionFactory,
    CacheKeysFactory defKeysFactory,
    DomainDataRegionBuildingContext buildingCtx,
    HibernateAccessStrategyFactory stgyFactory) {
    super(regionCfg, regionFactory, defKeysFactory, buildingCtx);

    this.stgyFactory = stgyFactory;

    cache = stgyFactory.regionCache(getName());

    completeInstantiation(regionCfg, buildingCtx);
}
 

@Override
public DomainDataRegion buildDomainDataRegion(
        DomainDataRegionConfig regionConfig,
        DomainDataRegionBuildingContext buildingContext) {
    verifyStarted();
    return new DomainDataRegionImpl(
            regionConfig,
            this,
            createDomainDataStorageAccess( regionConfig, buildingContext ),
            getImplicitCacheKeysFactory(),
            buildingContext
    );
}
 

protected DomainDataStorageAccess createDomainDataStorageAccess(
		DomainDataRegionConfig regionConfig,
		DomainDataRegionBuildingContext buildingContext) {
	throw new UnsupportedOperationException( "Not implemented by caching provider" );
}
 

@Override
public void prime(Set<DomainDataRegionConfig> cacheRegionConfigs) {
	// nothing to do
}
 

@Override
public void prime(Set<DomainDataRegionConfig> cacheRegionConfigs) {
	for ( DomainDataRegionConfig regionConfig : cacheRegionConfigs ) {
		final DomainDataRegion region = getRegionFactory().buildDomainDataRegion( regionConfig, this );
		regionsByName.put( region.getName(), region );

		if ( ! Objects.equals( region.getName(), regionConfig.getRegionName() ) ) {
			throw new HibernateException(
					String.format(
							Locale.ROOT,
							"Region [%s] returned from RegionFactory [%s] was named differently than requested name.  Expecting `%s`, but found `%s`",
							region,
							getRegionFactory().getClass().getName(),
							regionConfig.getRegionName(),
							region.getName()
					)
			);
		}

		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// Entity caching

		for ( EntityDataCachingConfig entityAccessConfig : regionConfig.getEntityCaching() ) {
			final EntityDataAccess entityDataAccess = entityAccessMap.put(
					entityAccessConfig.getNavigableRole(),
					region.getEntityDataAccess( entityAccessConfig.getNavigableRole() )
			);

			legacySecondLevelCacheNames.add(
					StringHelper.qualifyConditionally(
							getSessionFactory().getSessionFactoryOptions().getCacheRegionPrefix(),
							region.getName()
					)
			);
		}


		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// Natural-id caching

		if ( regionConfig.getNaturalIdCaching().isEmpty() ) {
			legacyNaturalIdAccessesForRegion.put( region.getName(), Collections.emptySet() );
		}
		else {
			final HashSet<NaturalIdDataAccess> accesses = new HashSet<>();

			for ( NaturalIdDataCachingConfig naturalIdAccessConfig : regionConfig.getNaturalIdCaching() ) {
				final NaturalIdDataAccess naturalIdDataAccess = naturalIdAccessMap.put(
						naturalIdAccessConfig.getNavigableRole(),
						region.getNaturalIdDataAccess( naturalIdAccessConfig.getNavigableRole() )
				);
				accesses.add( naturalIdDataAccess );
			}

			legacyNaturalIdAccessesForRegion.put( region.getName(), accesses );
		}


		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
		// Collection caching

		for ( CollectionDataCachingConfig collectionAccessConfig : regionConfig.getCollectionCaching() ) {
			final CollectionDataAccess collectionDataAccess = collectionAccessMap.put(
					collectionAccessConfig.getNavigableRole(),
					region.getCollectionDataAccess( collectionAccessConfig.getNavigableRole() )
			);

			legacySecondLevelCacheNames.add(
					StringHelper.qualifyConditionally(
							getSessionFactory().getSessionFactoryOptions().getCacheRegionPrefix(),
							region.getName()
					)
			);
		}
	}

}
 

@Override
public DomainDataRegion buildDomainDataRegion(
		DomainDataRegionConfig regionConfig, DomainDataRegionBuildingContext buildingContext) {
	throw new NoCacheRegionFactoryAvailableException();
}
 

@Override
public DomainDataRegion buildDomainDataRegion(DomainDataRegionConfig regionConfig, DomainDataRegionBuildingContext buildingContext) {
    return new DomainDataRegionImpl(regionConfig, this, createDomainDataStorageAccess(regionConfig, buildingContext), cacheKeysFactory, buildingContext);
}
 

@Override
protected DomainDataStorageAccess createDomainDataStorageAccess(DomainDataRegionConfig regionConfig, DomainDataRegionBuildingContext buildingContext) {
    return new StorageAccessImpl(getOrCreateCache(regionConfig.getRegionName(), buildingContext.getSessionFactory()));
}
 

/**
 * An initialization phase allowing the caching provider to prime itself
 * from the passed configs
 *
 * @since 5.3
 */
void prime(Set<DomainDataRegionConfig> cacheRegionConfigs);
 

/**
 * Create a named Region for holding domain model data
 *
 * @param regionConfig The user requested caching configuration for this Region
 * @param buildingContext Access to delegates useful in building the Region
 */
DomainDataRegion buildDomainDataRegion(
		DomainDataRegionConfig regionConfig,
		DomainDataRegionBuildingContext buildingContext);
 

/**
 * An initialization phase allowing the caching provider to prime itself
 * from the passed configs
 *
 * @since 5.3
 */
void prime(Set<DomainDataRegionConfig> cacheRegionConfigs);