RegionAttributes.hpp

Go to the documentation of this file.

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