vmware-gemfire-native-client-c++-api-reference/latest/a00206_source.html

/*

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

 */


#pragma once


#ifndef GEODE_REGIONATTRIBUTES_H_

#define GEODE_REGIONATTRIBUTES_H_


#include <chrono>


#include "CacheListener.hpp"

#include "CacheLoader.hpp"

#include "CacheWriter.hpp"

#include "DiskPolicyType.hpp"

#include "ExpirationAttributes.hpp"

#include "PartitionResolver.hpp"

#include "Properties.hpp"

#include "Serializable.hpp"

#include "internal/DataSerializableInternal.hpp"

#include "internal/chrono/duration.hpp"

#include "internal/geode_globals.hpp"


namespace apache {

namespace geode {

namespace client {


class CacheImpl;

class RegionAttributesFactory;

class AttributesMutator;

class Cache;

class Region;

class PersistenceManager;


class APACHE_GEODE_EXPORT RegionAttributes

    : public internal::DataSerializableInternal {

 public:

  std::shared_ptr<CacheLoader> getCacheLoader() const;


  std::shared_ptr<CacheWriter> getCacheWriter() const;


  std::shared_ptr<CacheListener> getCacheListener() const;


  std::shared_ptr<PartitionResolver> getPartitionResolver() const;


  std::chrono::seconds getRegionTimeToLive() const;


  ExpirationAction getRegionTimeToLiveAction() const;


  std::chrono::seconds getRegionIdleTimeout() const;


  ExpirationAction getRegionIdleTimeoutAction() const;


  std::chrono::seconds getEntryTimeToLive() const;


  ExpirationAction getEntryTimeToLiveAction() const;


  std::chrono::seconds getEntryIdleTimeout() const;


  ExpirationAction getEntryIdleTimeoutAction() const;


  inline bool getCachingEnabled() const { return m_caching; }


  // MAP ATTRIBUTES


  int getInitialCapacity() const;


  float getLoadFactor() const;


  uint8_t getConcurrencyLevel() const;


  uint32_t getLruEntriesLimit() const;


  DiskPolicyType getDiskPolicy() const;


  ExpirationAction getLruEvictionAction() const;


  const std::string& getPoolName() const { return m_poolName; }


  // will be created by the factory

  RegionAttributes();

  RegionAttributes(const RegionAttributes& rhs) = default;


  /*destructor

   *

   */

  ~RegionAttributes() noexcept override;


  static std::shared_ptr<Serializable> createDeserializable();


  void toData(DataOutput& out) const override;


  void fromData(DataInput& in) override;


  const std::string& getCacheLoaderLibrary() const;


  const std::string& getCacheLoaderFactory() const;


  const std::string& getCacheListenerLibrary() const;


  const std::string& getCacheListenerFactory() const;


  const std::string& getCacheWriterLibrary() const;


  const std::string& getCacheWriterFactory() const;


  const std::string& getPartitionResolverLibrary() const;


  const std::string& getPartitionResolverFactory() const;


  bool operator==(const RegionAttributes& other) const;


  bool operator!=(const RegionAttributes& other) const;


  void validateSerializableAttributes();


  const std::string& getEndpoints() const;


  bool getClientNotificationEnabled() const;


  const std::string& getPersistenceLibrary() const;


  const std::string& getPersistenceFactory() const;


  std::shared_ptr<Properties> getPersistenceProperties() const;


  std::shared_ptr<PersistenceManager> getPersistenceManager() const;


  bool getCloningEnabled() const { return m_isClonable; }


  bool getConcurrencyChecksEnabled() const {

    return m_isConcurrencyChecksEnabled;

  }

  RegionAttributes& operator=(const RegionAttributes&) = default;


 private:

  void setCacheListener(const std::string& libpath,

                        const std::string& factoryFuncName);

  void setCacheLoader(const std::string& libpath,

                      const std::string& factoryFuncName);

  void setCacheWriter(const std::string& libpath,

                      const std::string& factoryFuncName);

  void setPartitionResolver(const std::string& libpath,

                            const std::string& factoryFuncName);

  void setPersistenceManager(const std::string& lib, const std::string& func,

                             const std::shared_ptr<Properties>& config);

  void setEndpoints(const std::string& endpoints);

  void setPoolName(const std::string& poolName);

  void setCloningEnabled(bool isClonable);

  void setCachingEnabled(bool enable);

  void setLruEntriesLimit(int limit);

  void setDiskPolicy(DiskPolicyType diskPolicy);

  void setConcurrencyChecksEnabled(bool enable);


  inline bool getEntryExpiryEnabled() const {

    return (m_entryTimeToLive > std::chrono::seconds::zero() ||

            m_entryIdleTimeout > std::chrono::seconds::zero());

  }


  inline bool getRegionExpiryEnabled() const {

    return (m_regionTimeToLive > std::chrono::seconds::zero() ||

            m_regionIdleTimeout > std::chrono::seconds::zero());

  }


  ExpirationAction m_regionTimeToLiveExpirationAction;

  ExpirationAction m_regionIdleTimeoutExpirationAction;

  ExpirationAction m_entryTimeToLiveExpirationAction;

  ExpirationAction m_entryIdleTimeoutExpirationAction;

  ExpirationAction m_lruEvictionAction;

  mutable std::shared_ptr<CacheWriter> m_cacheWriter;

  mutable std::shared_ptr<CacheLoader> m_cacheLoader;

  mutable std::shared_ptr<CacheListener> m_cacheListener;

  mutable std::shared_ptr<PartitionResolver> m_partitionResolver;

  uint32_t m_lruEntriesLimit;

  bool m_caching;

  uint32_t m_maxValueDistLimit;

  std::chrono::seconds m_entryIdleTimeout;

  std::chrono::seconds m_entryTimeToLive;

  std::chrono::seconds m_regionIdleTimeout;

  std::chrono::seconds m_regionTimeToLive;

  uint32_t m_initialCapacity;

  float m_loadFactor;

  uint8_t m_concurrencyLevel;

  std::string m_cacheLoaderLibrary;

  std::string m_cacheWriterLibrary;

  std::string m_cacheListenerLibrary;

  std::string m_partitionResolverLibrary;

  std::string m_cacheLoaderFactory;

  std::string m_cacheWriterFactory;

  std::string m_cacheListenerFactory;

  std::string m_partitionResolverFactory;

  DiskPolicyType m_diskPolicy;

  std::string m_endpoints;

  bool m_clientNotificationEnabled;

  std::string m_persistenceLibrary;

  std::string m_persistenceFactory;

  std::shared_ptr<Properties> m_persistenceProperties;

  mutable std::shared_ptr<PersistenceManager> m_persistenceManager;

  std::string m_poolName;

  bool m_isClonable;

  bool m_isConcurrencyChecksEnabled;

  friend class RegionAttributesFactory;

  friend class AttributesMutator;

  friend class Cache;

  friend class CacheImpl;

  friend class Region;

  friend class RegionInternal;

  friend class RegionXmlCreation;


 private:

};


}  // namespace client

}  // namespace geode

}  // namespace apache


#endif  // GEODE_REGIONATTRIBUTES_H_

CacheListener.hpp

CacheLoader.hpp

DiskPolicyType.hpp

apache::geode::client::DiskPolicyType
DiskPolicyType
DiskPolicyType.hpp Enumerated type for disk policy.
Definition DiskPolicyType.hpp:42

apache::geode::client::ExpirationAction
ExpirationAction
ExpirationAction.hpp Enumerated type for expiration actions.
Definition ExpirationAction.hpp:42

ExpirationAttributes.hpp

Properties.hpp

apache::geode::client::DataInput
Provide operations for reading primitive data values, byte arrays, strings, Serializable objects from...
Definition DataInput.hpp:59

apache::geode::client::DataOutput
Provide operations for writing primitive data values, byte arrays, strings, Serializable objects to a...
Definition DataOutput.hpp:48

apache::geode::client::PersistenceManager
PersistenceManager API for persistence and overflow.
Definition PersistenceManager.hpp:52

apache::geode::client::Properties
Contains a set of (key, value) pair properties with key being the name of the property; value,...
Definition Properties.hpp:52

apache::geode::client::RegionAttributes
Defines attributes for configuring a region.
Definition RegionAttributes.hpp:77

apache::geode::client::RegionAttributes::getInitialCapacity
int getInitialCapacity() const
Returns the initial capacity of the entry's local cache.

apache::geode::client::RegionAttributes::getCacheWriter
std::shared_ptr< CacheWriter > getCacheWriter() const
Gets the cache writer for the region.

apache::geode::client::RegionAttributes::getRegionTimeToLive
std::chrono::seconds getRegionTimeToLive() const
Gets the timeToLive expiration attributes for the region as a whole.

apache::geode::client::RegionAttributes::getRegionIdleTimeout
std::chrono::seconds getRegionIdleTimeout() const
Gets the idleTimeout expiration attributes for the region as a whole.

apache::geode::client::RegionAttributes::getCacheListener
std::shared_ptr< CacheListener > getCacheListener() const
Gets the cache listener for the region.

apache::geode::client::RegionAttributes::getConcurrencyLevel
uint8_t getConcurrencyLevel() const
Returns the concurrencyLevel of the entry's local cache.

apache::geode::client::RegionAttributes::getPoolName
const std::string & getPoolName() const
Returns the name of the pool attached to the region.
Definition RegionAttributes.hpp:189

apache::geode::client::RegionAttributes::getCachingEnabled
bool getCachingEnabled() const
If true, this region will store data in the current process.
Definition RegionAttributes.hpp:147

apache::geode::client::RegionAttributes::getCacheLoader
std::shared_ptr< CacheLoader > getCacheLoader() const
public static methods

apache::geode::client::RegionAttributes::getPartitionResolver
std::shared_ptr< PartitionResolver > getPartitionResolver() const
Gets the partition resolver for the partition region.

apache::geode::client::RegionAttributes::getLruEntriesLimit
uint32_t getLruEntriesLimit() const
Returns the maximum number of entries this cache will hold before using LRU eviction.

apache::geode::client::RegionAttributes::getEntryTimeToLive
std::chrono::seconds getEntryTimeToLive() const
Gets the timeToLive expiration attributes for entries in this region.

apache::geode::client::RegionAttributes::getDiskPolicy
DiskPolicyType getDiskPolicy() const
Returns the disk policy type of the region.

apache::geode::client::RegionAttributes::getConcurrencyChecksEnabled
bool getConcurrencyChecksEnabled() const
Returns true if concurrent update checks are turned on for this region.
Definition RegionAttributes.hpp:310

apache::geode::client::RegionAttributes::getEntryIdleTimeout
std::chrono::seconds getEntryIdleTimeout() const
Gets the idleTimeout expiration attributes for entries in this region.

apache::geode::client::RegionAttributes::getLoadFactor
float getLoadFactor() const
Returns the load factor of the entry's local cache.

apache::geode::client::RegionAttributes::getLruEvictionAction
ExpirationAction getLruEvictionAction() const
Returns the ExpirationAction used for LRU Eviction, default is LOCAL_DESTROY.

apache::geode::client::Serializable
This base class is the superclass of all user objects in the cache that can be serialized.
Definition Serializable.hpp:53