RegionFactory.hpp

Go to the documentation of this file.

#pragma once

#ifndef GEODE_REGIONFACTORY_H_
#define GEODE_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 "geode_globals.hpp"
#include "geode_types.hpp"
#include "AttributesFactory.hpp"
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);

  RegionFactoryPtr setCacheLoader(const CacheLoaderPtr& cacheLoader);

  RegionFactoryPtr setCacheWriter(const CacheWriterPtr& cacheWriter);

  RegionFactoryPtr setCacheListener(const CacheListenerPtr& aListener);

  RegionFactoryPtr setPartitionResolver(const PartitionResolverPtr& aResolver);

  RegionFactoryPtr setCacheLoader(const char* libpath,
                                  const char* factoryFuncName);

  RegionFactoryPtr setCacheWriter(const char* libpath,
                                  const char* factoryFuncName);

  RegionFactoryPtr setCacheListener(const char* libpath,
                                    const char* factoryFuncName);

  RegionFactoryPtr setPartitionResolver(const char* libpath,
                                        const char* factoryFuncName);

  // EXPIRATION ATTRIBUTES

  RegionFactoryPtr setEntryIdleTimeout(ExpirationAction::Action action,
                                       int32_t idleTimeout);

  RegionFactoryPtr setEntryTimeToLive(ExpirationAction::Action action,
                                      int32_t timeToLive);

  RegionFactoryPtr setRegionIdleTimeout(ExpirationAction::Action action,
                                        int32_t idleTimeout);

  RegionFactoryPtr setRegionTimeToLive(ExpirationAction::Action action,
                                       int32_t timeToLive);

  // PERSISTENCE
  RegionFactoryPtr setPersistenceManager(const char* libpath,
                                         const char* factoryFuncName,
                                         const PropertiesPtr& config = NULLPTR);

  RegionFactoryPtr setPersistenceManager(
      const PersistenceManagerPtr& persistenceManager,
      const PropertiesPtr& config = NULLPTR);

  // MAP ATTRIBUTES
  RegionFactoryPtr setInitialCapacity(int initialCapacity);

  RegionFactoryPtr setLoadFactor(float loadFactor);

  RegionFactoryPtr setConcurrencyLevel(uint8_t concurrencyLevel);

  RegionFactoryPtr setLruEntriesLimit(const uint32_t entriesLimit);

  RegionFactoryPtr setDiskPolicy(const DiskPolicyType::PolicyType diskPolicy);

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

  RegionFactoryPtr setConcurrencyChecksEnabled(bool enable);

  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_REGIONFACTORY_H_