geode-core/src/main/java/org/apache/geode/internal/cache/InternalRegionFactory.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License. You may obtain a
 * copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package org.apache.geode.internal.cache;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import org.apache.geode.InternalGemFireError;
import org.apache.geode.cache.CacheExistsException;
import org.apache.geode.cache.CacheWriterException;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionExistsException;
import org.apache.geode.cache.RegionFactory;
import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.TimeoutException;
import org.apache.geode.distributed.internal.membership.InternalDistributedMember;
import org.apache.geode.internal.cache.partitioned.RegionAdvisor;
import org.apache.geode.internal.cache.persistence.PersistenceAdvisor;
import org.apache.geode.internal.cache.wan.AbstractGatewaySender;

/**
 * {@code InternalRegionFactory} extends RegionFactory adding {@link RegionShortcut} support.
 * It also supports setting {@link InternalRegionArguments}.
 *
 * @since GemFire 6.5
 */
public class InternalRegionFactory<K, V> extends RegionFactory<K, V> {
  private InternalRegionArguments internalRegionArguments;

  public InternalRegionFactory(InternalCache cache) {
    super(cache);
  }

  public InternalRegionFactory(InternalCache cache, RegionShortcut pra) {
    super(cache, pra);
  }

  public InternalRegionFactory(InternalCache cache, RegionAttributes<K, V> ra) {
    super(cache, ra);
  }

  public InternalRegionFactory(InternalCache cache, String regionAttributesId) {
    super(cache, regionAttributesId);
  }

  public InternalRegionFactory(RegionFactory<K, V> regionFactory) {
    super(regionFactory);
  }

  /**
   * Returns the region attributes that would currently be used to create the region.
   */
  public RegionAttributes<K, V> getCreateAttributes() {
    return getRegionAttributes();
  }

  @Override
  public Region<K, V> create(String name)
      throws CacheExistsException, RegionExistsException, CacheWriterException, TimeoutException {
    if (internalRegionArguments == null) {
      return super.create(name);
    }
    try {
      return getCache().createVMRegion(name, getRegionAttributes(), internalRegionArguments);
    } catch (IOException | ClassNotFoundException e) {
      throw new InternalGemFireError("unexpected exception", e);
    }
  }

  @Override
  @SuppressWarnings("unchecked")
  public Region<K, V> createSubregion(Region<?, ?> parent, String name)
      throws RegionExistsException {
    if (internalRegionArguments == null) {
      return super.createSubregion(parent, name);
    }
    try {
      return ((InternalRegion) parent).createSubregion(name, getRegionAttributes(),
          internalRegionArguments);
    } catch (IOException | ClassNotFoundException e) {
      throw new InternalGemFireError("unexpected exception", e);
    }
  }

  public InternalRegionArguments getInternalRegionArguments() {
    return internalRegionArguments;
  }

  public InternalRegionFactory<K, V> setIsUsedForPartitionedRegionAdmin(boolean adminFlag) {
    makeInternal().setIsUsedForPartitionedRegionAdmin(adminFlag);
    return this;
  }

  public InternalRegionFactory<K, V> setPartitionedRegionBucketRedundancy(int redundancy) {
    makeInternal().setPartitionedRegionBucketRedundancy(redundancy);
    return this;
  }

  public InternalRegionFactory<K, V> setPartitionedRegionAdvisor(RegionAdvisor advisor) {
    makeInternal().setPartitionedRegionAdvisor(advisor);
    return this;
  }

  public InternalRegionFactory<K, V> setBucketAdvisor(BucketAdvisor advisor) {
    makeInternal().setBucketAdvisor(advisor);
    return this;
  }

  public InternalRegionFactory<K, V> setPersistenceAdvisor(PersistenceAdvisor persistenceAdvisor) {
    makeInternal().setPersistenceAdvisor(persistenceAdvisor);
    return this;
  }

  public InternalRegionFactory<K, V> setDiskRegion(DiskRegion diskRegion) {
    makeInternal().setDiskRegion(diskRegion);
    return this;
  }

  public InternalRegionFactory<K, V> setIsUsedForMetaRegion(boolean isMetaRegion) {
    makeInternal().setIsUsedForMetaRegion(isMetaRegion);
    return this;
  }

  public InternalRegionFactory<K, V> setMetaRegionWithTransactions(
      boolean metaRegionWithTransactions) {
    makeInternal().setMetaRegionWithTransactions(metaRegionWithTransactions);
    return this;
  }

  public InternalRegionFactory<K, V> setLoaderHelperFactory(
      LoaderHelperFactory loaderHelperFactory) {
    makeInternal().setLoaderHelperFactory(loaderHelperFactory);
    return this;
  }

  public InternalRegionFactory<K, V> setDestroyLockFlag(boolean getDestoryLock) {
    makeInternal().setDestroyLockFlag(getDestoryLock);
    return this;
  }

  public InternalRegionFactory<K, V> setSnapshotInputStream(InputStream snapshotInputStream) {
    makeInternal().setSnapshotInputStream(snapshotInputStream);
    return this;
  }

  public InternalRegionFactory<K, V> setImageTarget(InternalDistributedMember imageTarget) {
    makeInternal().setImageTarget(imageTarget);
    return this;
  }

  public InternalRegionFactory<K, V> setRecreateFlag(boolean recreate) {
    makeInternal().setRecreateFlag(recreate);
    return this;
  }

  public InternalRegionFactory<K, V> setInternalMetaRegion(LocalRegion r) {
    makeInternal().setInternalMetaRegion(r);
    return this;
  }

  public InternalRegionFactory<K, V> setCachePerfStatsHolder(
      HasCachePerfStats cachePerfStatsHolder) {
    makeInternal().setCachePerfStatsHolder(cachePerfStatsHolder);
    return this;
  }

  public InternalRegionFactory<K, V> setPartitionedRegion(PartitionedRegion partitionedRegion) {
    makeInternal().setPartitionedRegion(partitionedRegion);
    return this;
  }

  public InternalRegionFactory<K, V> setTestCallable(LocalRegion.TestCallable c) {
    makeInternal().setTestCallable(c);
    return this;
  }

  public InternalRegionFactory<K, V> setUserAttribute(Object userAttr) {
    makeInternal().setUserAttribute(userAttr);
    return this;
  }

  public InternalRegionFactory<K, V> setIsUsedForSerialGatewaySenderQueue(boolean queueFlag) {
    makeInternal().setIsUsedForSerialGatewaySenderQueue(queueFlag);
    return this;
  }

  public InternalRegionFactory<K, V> setIsUsedForParallelGatewaySenderQueue(boolean queueFlag) {
    makeInternal().setIsUsedForParallelGatewaySenderQueue(queueFlag);
    return this;
  }

  public InternalRegionFactory<K, V> setParallelGatewaySender(AbstractGatewaySender pgSender) {
    makeInternal().setParallelGatewaySender(pgSender);
    return this;
  }

  public InternalRegionFactory<K, V> setSerialGatewaySender(AbstractGatewaySender serialSender) {
    makeInternal().setSerialGatewaySender(serialSender);
    return this;
  }

  public InternalRegionFactory<K, V> setIndexes(List indexes) {
    makeInternal().setIndexes(indexes);
    return this;
  }

  public InternalRegionFactory<K, V> addCacheServiceProfile(CacheServiceProfile profile) {
    makeInternal().addCacheServiceProfile(profile);
    return this;
  }

  public InternalRegionFactory<K, V> addInternalAsyncEventQueueId(String aeqId) {
    makeInternal().addInternalAsyncEventQueueId(aeqId);
    return this;
  }

  public InternalRegionFactory<K, V> setInternalRegion(final boolean internalRegion) {
    makeInternal().setInternalRegion(internalRegion);
    return this;
  }

  private InternalRegionArguments makeInternal() {
    if (internalRegionArguments == null) {
      internalRegionArguments = new InternalRegionArguments();
    }
    return internalRegionArguments;
  }
}