src/cppcache/include/gfcpp/RegionFactory.hpp - geode-native - Git at Google

 #pragma once

 #ifndef GEODE_GFCPP_REGIONFACTORY_H_
 #define GEODE_GFCPP_REGIONFACTORY_H_

 /*
  * 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.
  */

 #include "gfcpp_globals.hpp"
 #include "gf_types.hpp"
 #include "AttributesFactory.hpp"
 /**
  * @file
  */

 namespace apache {
 namespace geode {
 namespace client {
 class CacheImpl;
 class CPPCACHE_EXPORT RegionFactory : public SharedBase {
  public:
   /*
    * To create the (@link Region}.
    * @param name
    *        the name of the Region.
    * @throws RegionExistsException if a region is already in
    * this cache
    * @throws CacheClosedException if the cache is closed
    */
   RegionPtr create(const char* name);

   /** Sets the cache loader for the next <code>RegionAttributes</code> created.
    * @param cacheLoader the cache loader or NULLPTR if no loader
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setCacheLoader(const CacheLoaderPtr& cacheLoader);

   /** Sets the cache writer for the next <code>RegionAttributes</code> created.
    * @param cacheWriter the cache writer or NULLPTR if no cache writer
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setCacheWriter(const CacheWriterPtr& cacheWriter);

   /** Sets the CacheListener for the next <code>RegionAttributes</code> created.
    * @param aListener a user defined CacheListener, NULLPTR if no listener
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setCacheListener(const CacheListenerPtr& aListener);

   /** Sets the PartitionResolver for the next <code>RegionAttributes</code>
    * created.
    * @param aResolver a user defined PartitionResolver, NULLPTR if no resolver
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setPartitionResolver(const PartitionResolverPtr& aResolver);

   /**
    * Sets the library path for the library that will be invoked for the loader
    * of the region.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setCacheLoader(const char* libpath,
                                   const char* factoryFuncName);

   /**
    * Sets the library path for the library that will be invoked for the writer
    * of the region.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setCacheWriter(const char* libpath,
                                   const char* factoryFuncName);

   /**
    * Sets the library path for the library that will be invoked for the listener
    * of the region.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setCacheListener(const char* libpath,
                                     const char* factoryFuncName);

   /**
    * Sets the library path for the library that will be invoked for the
    * partition resolver of the region.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setPartitionResolver(const char* libpath,
                                         const char* factoryFuncName);

   // EXPIRATION ATTRIBUTES

   /** Sets the idleTimeout expiration attributes for region entries for the next
    * <code>RegionAttributes</code> created.
    * @param action the expiration action for entries in this region.
    * @param idleTimeout the idleTimeout in seconds for entries in this region.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setEntryIdleTimeout(ExpirationAction::Action action,
                                        int32_t idleTimeout);

   /** Sets the timeToLive expiration attributes for region entries for the next
    * <code>RegionAttributes</code> created.
    * @param action the expiration action for entries in this region.
    * @param timeToLive the timeToLive in seconds for entries in this region.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setEntryTimeToLive(ExpirationAction::Action action,
                                       int32_t timeToLive);

   /** Sets the idleTimeout expiration attributes for the region itself for the
    * next <code>RegionAttributes</code> created.
    * @param action the expiration action for entries in this region.
    * @param idleTimeout the idleTimeout in seconds for the region as a whole.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setRegionIdleTimeout(ExpirationAction::Action action,
                                         int32_t idleTimeout);

   /** Sets the timeToLive expiration attributes for the region itself for the
    * next <code>RegionAttributes</code> created.
    * @param action the expiration action for entries in this region.
    * @param timeToLive the timeToLive in seconds for the region as a whole.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setRegionTimeToLive(ExpirationAction::Action action,
                                        int32_t timeToLive);

   // PERSISTENCE
   /**
    * Sets the library path for the library that will be invoked for the
    * persistence of the region.
    * If the region is being created from a client on a server, or on a server
    * directly, then
    * this must be used to set the PersistenceManager.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setPersistenceManager(const char* libpath,
                                          const char* factoryFuncName,
                                          const PropertiesPtr& config = NULLPTR);

   /** Sets the PersistenceManager for the next <code>RegionAttributes</code>
   * created.
   * @param persistenceManager a user defined PersistenceManager, NULLPTR if no
   * persistenceManager
   * @return a reference to <code>this</code>
   */
   RegionFactoryPtr setPersistenceManager(
       const PersistenceManagerPtr& persistenceManager,
       const PropertiesPtr& config = NULLPTR);

   // MAP ATTRIBUTES
   /** Sets the entry initial capacity for the next <code>RegionAttributes</code>
    * created. This value
    * is used in initializing the map that holds the entries.
    * @param initialCapacity the initial capacity of the entry map
    * @return a reference to <code>this</code>
    * @throws IllegalArgumentException if initialCapacity is negative.
    */
   RegionFactoryPtr setInitialCapacity(int initialCapacity);

   /** Sets the entry load factor for the next <code>RegionAttributes</code>
    * created. This value is
    * used in initializing the map that holds the entries.
    * @param loadFactor the load factor of the entry map
    * @return a reference to <code>this</code>
    * @throws IllegalArgumentException if loadFactor is nonpositive
    */
   RegionFactoryPtr setLoadFactor(float loadFactor);

   /** Sets the concurrency level tof the next <code>RegionAttributes</code>
    * created. This value is used in initializing the map that holds the entries.
    * @param concurrencyLevel the concurrency level of the entry map
    * @return a reference to <code>this</code>
    * @throws IllegalArgumentException if concurrencyLevel is nonpositive
    */
   RegionFactoryPtr setConcurrencyLevel(uint8_t concurrencyLevel);

   /**
    * Sets a limit on the number of entries that will be held in the cache.
    * If a new entry is added while at the limit, the cache will evict the
    * least recently used entry. Defaults to 0, meaning no LRU actions will
    * used.
    * @param entriesLimit number of enteries to keep in region
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setLruEntriesLimit(const uint32_t entriesLimit);

   /** Sets the Disk policy type for the next <code>RegionAttributes</code>
    * created.
    * @param diskPolicy the type of disk policy to use for the region
    * @return a reference to <code>this</code>
    * @throws IllegalArgumentException if diskPolicyType is Invalid
    */
   RegionFactoryPtr setDiskPolicy(const DiskPolicyType::PolicyType diskPolicy);

   /**
    * Set caching enabled flag for this region. If set to false, then no data is
    * stored
    * in the local process, but events and distributions will still occur, and
    * the region can still be used to put and remove, etc...
    * The default if not set is 'true', 'false' is illegal for regions of 'local'
    * scope.
    * This also requires that interestLists are turned off for the region.
    * @param cachingEnabled if true, cache data for this region in this process.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setCachingEnabled(bool cachingEnabled);

   /*
    * Set the PoolName to attach the Region with that Pool.
    * Use only when Cache ha more than one Pool
    * @param name
    *        the name of the Pool to which region will be attached.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setPoolName(const char* name);

   /*
    * Set boolean to enable/disable cloning while applying delta.
    * @param isClonable whether to enable cloning or not.
    * @return a reference to <code>this</code>
    */
   RegionFactoryPtr setCloningEnabled(bool isClonable);

   /**
   * Enables or disables concurrent modification checks
   * @since 7.0
   * @param concurrencyChecksEnabled whether to perform concurrency checks on
   * operations
   * @return a reference to <code>this</code>
   */
   RegionFactoryPtr setConcurrencyChecksEnabled(bool enable);

   /**
   * Sets time out for tombstones
   * @since 7.0
   * @param tombstoneTimeoutInMSec tombstone timeout in milli second
   * @return a reference to <code>this</code>
   */
   RegionFactoryPtr setTombstoneTimeout(uint32_t tombstoneTimeoutInMSec);

  private:
   RegionFactory(apache::geode::client::RegionShortcut preDefinedRegion);

   RegionShortcut m_preDefinedRegion;

   AttributesFactoryPtr m_attributeFactory;

   void setRegionShortcut();

   ~RegionFactory();
   friend class CacheImpl;
 };
 }  // namespace client
 }  // namespace geode
 }  // namespace apache

 #endif // GEODE_GFCPP_REGIONFACTORY_H_
	#pragma once

	#ifndef GEODE_GFCPP_REGIONFACTORY_H_
	#define GEODE_GFCPP_REGIONFACTORY_H_

	/*
	* 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.
	*/

	#include "gfcpp_globals.hpp"
	#include "gf_types.hpp"
	#include "AttributesFactory.hpp"
	/**
	* @file
	*/

	namespace apache {
	namespace geode {
	namespace client {
	class CacheImpl;
	class CPPCACHE_EXPORT RegionFactory : public SharedBase {
	public:
	/*
	* To create the (@link Region}.
	* @param name
	* the name of the Region.
	* @throws RegionExistsException if a region is already in
	* this cache
	* @throws CacheClosedException if the cache is closed
	*/
	RegionPtr create(const char* name);

	/** Sets the cache loader for the next <code>RegionAttributes</code> created.
	* @param cacheLoader the cache loader or NULLPTR if no loader
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setCacheLoader(const CacheLoaderPtr& cacheLoader);

	/** Sets the cache writer for the next <code>RegionAttributes</code> created.
	* @param cacheWriter the cache writer or NULLPTR if no cache writer
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setCacheWriter(const CacheWriterPtr& cacheWriter);

	/** Sets the CacheListener for the next <code>RegionAttributes</code> created.
	* @param aListener a user defined CacheListener, NULLPTR if no listener
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setCacheListener(const CacheListenerPtr& aListener);

	/** Sets the PartitionResolver for the next <code>RegionAttributes</code>
	* created.
	* @param aResolver a user defined PartitionResolver, NULLPTR if no resolver
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setPartitionResolver(const PartitionResolverPtr& aResolver);

	/**
	* Sets the library path for the library that will be invoked for the loader
	* of the region.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setCacheLoader(const char* libpath,
	const char* factoryFuncName);

	/**
	* Sets the library path for the library that will be invoked for the writer
	* of the region.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setCacheWriter(const char* libpath,
	const char* factoryFuncName);

	/**
	* Sets the library path for the library that will be invoked for the listener
	* of the region.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setCacheListener(const char* libpath,
	const char* factoryFuncName);

	/**
	* Sets the library path for the library that will be invoked for the
	* partition resolver of the region.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setPartitionResolver(const char* libpath,
	const char* factoryFuncName);

	// EXPIRATION ATTRIBUTES

	/** Sets the idleTimeout expiration attributes for region entries for the next
	* <code>RegionAttributes</code> created.
	* @param action the expiration action for entries in this region.
	* @param idleTimeout the idleTimeout in seconds for entries in this region.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setEntryIdleTimeout(ExpirationAction::Action action,
	int32_t idleTimeout);

	/** Sets the timeToLive expiration attributes for region entries for the next
	* <code>RegionAttributes</code> created.
	* @param action the expiration action for entries in this region.
	* @param timeToLive the timeToLive in seconds for entries in this region.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setEntryTimeToLive(ExpirationAction::Action action,
	int32_t timeToLive);

	/** Sets the idleTimeout expiration attributes for the region itself for the
	* next <code>RegionAttributes</code> created.
	* @param action the expiration action for entries in this region.
	* @param idleTimeout the idleTimeout in seconds for the region as a whole.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setRegionIdleTimeout(ExpirationAction::Action action,
	int32_t idleTimeout);

	/** Sets the timeToLive expiration attributes for the region itself for the
	* next <code>RegionAttributes</code> created.
	* @param action the expiration action for entries in this region.
	* @param timeToLive the timeToLive in seconds for the region as a whole.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setRegionTimeToLive(ExpirationAction::Action action,
	int32_t timeToLive);

	// PERSISTENCE
	/**
	* Sets the library path for the library that will be invoked for the
	* persistence of the region.
	* If the region is being created from a client on a server, or on a server
	* directly, then
	* this must be used to set the PersistenceManager.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setPersistenceManager(const char* libpath,
	const char* factoryFuncName,
	const PropertiesPtr& config = NULLPTR);

	/** Sets the PersistenceManager for the next <code>RegionAttributes</code>
	* created.
	* @param persistenceManager a user defined PersistenceManager, NULLPTR if no
	* persistenceManager
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setPersistenceManager(
	const PersistenceManagerPtr& persistenceManager,
	const PropertiesPtr& config = NULLPTR);

	// MAP ATTRIBUTES
	/** Sets the entry initial capacity for the next <code>RegionAttributes</code>
	* created. This value
	* is used in initializing the map that holds the entries.
	* @param initialCapacity the initial capacity of the entry map
	* @return a reference to <code>this</code>
	* @throws IllegalArgumentException if initialCapacity is negative.
	*/
	RegionFactoryPtr setInitialCapacity(int initialCapacity);

	/** Sets the entry load factor for the next <code>RegionAttributes</code>
	* created. This value is
	* used in initializing the map that holds the entries.
	* @param loadFactor the load factor of the entry map
	* @return a reference to <code>this</code>
	* @throws IllegalArgumentException if loadFactor is nonpositive
	*/
	RegionFactoryPtr setLoadFactor(float loadFactor);

	/** Sets the concurrency level tof the next <code>RegionAttributes</code>
	* created. This value is used in initializing the map that holds the entries.
	* @param concurrencyLevel the concurrency level of the entry map
	* @return a reference to <code>this</code>
	* @throws IllegalArgumentException if concurrencyLevel is nonpositive
	*/
	RegionFactoryPtr setConcurrencyLevel(uint8_t concurrencyLevel);

	/**
	* Sets a limit on the number of entries that will be held in the cache.
	* If a new entry is added while at the limit, the cache will evict the
	* least recently used entry. Defaults to 0, meaning no LRU actions will
	* used.
	* @param entriesLimit number of enteries to keep in region
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setLruEntriesLimit(const uint32_t entriesLimit);

	/** Sets the Disk policy type for the next <code>RegionAttributes</code>
	* created.
	* @param diskPolicy the type of disk policy to use for the region
	* @return a reference to <code>this</code>
	* @throws IllegalArgumentException if diskPolicyType is Invalid
	*/
	RegionFactoryPtr setDiskPolicy(const DiskPolicyType::PolicyType diskPolicy);

	/**
	* Set caching enabled flag for this region. If set to false, then no data is
	* stored
	* in the local process, but events and distributions will still occur, and
	* the region can still be used to put and remove, etc...
	* The default if not set is 'true', 'false' is illegal for regions of 'local'
	* scope.
	* This also requires that interestLists are turned off for the region.
	* @param cachingEnabled if true, cache data for this region in this process.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setCachingEnabled(bool cachingEnabled);

	/*
	* Set the PoolName to attach the Region with that Pool.
	* Use only when Cache ha more than one Pool
	* @param name
	* the name of the Pool to which region will be attached.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setPoolName(const char* name);

	/*
	* Set boolean to enable/disable cloning while applying delta.
	* @param isClonable whether to enable cloning or not.
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setCloningEnabled(bool isClonable);

	/**
	* Enables or disables concurrent modification checks
	* @since 7.0
	* @param concurrencyChecksEnabled whether to perform concurrency checks on
	* operations
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setConcurrencyChecksEnabled(bool enable);

	/**
	* Sets time out for tombstones
	* @since 7.0
	* @param tombstoneTimeoutInMSec tombstone timeout in milli second
	* @return a reference to <code>this</code>
	*/
	RegionFactoryPtr setTombstoneTimeout(uint32_t tombstoneTimeoutInMSec);

	private:
	RegionFactory(apache::geode::client::RegionShortcut preDefinedRegion);

	RegionShortcut m_preDefinedRegion;

	AttributesFactoryPtr m_attributeFactory;

	void setRegionShortcut();

	~RegionFactory();
	friend class CacheImpl;
	};
	} // namespace client
	} // namespace geode
	} // namespace apache

	#endif // GEODE_GFCPP_REGIONFACTORY_H_