cppcache/include/geode/RegionAttributes.hpp

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

/**
 * @file
 */

#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 RegionAttributes RegionAttributes.hpp
 * Defines attributes for configuring a region.
 *
 * These are
 * <code>CacheListener</code>, <code>CacheLoader</code>,
 * <code>CacheWriter</code>,
 * scope expiration attributes
 * for the region itself; expiration attributes for the region entries;
 * and whether statistics are enabled for the region and its entries.
 *
 * To create an instance of this interface, use {@link
 * RegionAttributesFactory::create}.
 *
 * For compatibility rules and default values, see {@link
 * RegionAttributesFactory}.
 *
 * <p>Note that the <code>RegionAttributes</code> are not distributed with the
 * region.
 *
 * @see RegionAttributesFactory
 * @see AttributesMutator
 * @see Region::getAttributes
 */
class APACHE_GEODE_EXPORT RegionAttributes
    : public internal::DataSerializableInternal {
  /**
   * @brief public static methods
   */
 public:
  /** Gets the cache loader for the region.
   * @return  a pointer that points to the region's ,
   * <code>CacheLoader</code> , nullptr if there is no CacheLoader for this
   * region.
   */
  std::shared_ptr<CacheLoader> getCacheLoader() const;

  /** Gets the cache writer for the region.
   * @return  a pointer that points to the region's ,
   * <code>CacheWriter</code> , nullptr if there is no CacheWriter for this
   * region
   */
  std::shared_ptr<CacheWriter> getCacheWriter() const;

  /** Gets the cache listener for the region.
   * @return  a pointer that points to the region's ,
   * <code>CacheListener</code> , nullptr if there is no CacheListener defined
   * for this region.
   */
  std::shared_ptr<CacheListener> getCacheListener() const;

  /** Gets the partition resolver for the partition region.
   * @return  a pointer that points to the region's ,
   * <code>PartitionResolver</code> , nullptr if there is no PartitionResolver
   * defined
   * for this region.
   */
  std::shared_ptr<PartitionResolver> getPartitionResolver() const;

  /** Gets the <code>timeToLive</code> expiration attributes for the region as a
   * whole.
   * @return the timeToLive expiration attributes for this region
   */
  std::chrono::seconds getRegionTimeToLive() const;

  ExpirationAction getRegionTimeToLiveAction() const;

  /** Gets the idleTimeout expiration attributes for the region as a whole.
   *
   * @return the IdleTimeout expiration attributes for this region
   */
  std::chrono::seconds getRegionIdleTimeout() const;

  ExpirationAction getRegionIdleTimeoutAction() const;

  /** Gets the <code>timeToLive</code> expiration attributes for entries in this
   * region.
   * @return the timeToLive expiration attributes for entries in this region
   */
  std::chrono::seconds getEntryTimeToLive() const;

  ExpirationAction getEntryTimeToLiveAction() const;

  /** Gets the <code>idleTimeout</code> expiration attributes for entries in
   * this region.
   * @return the idleTimeout expiration attributes for entries in this region
   */
  std::chrono::seconds getEntryIdleTimeout() const;

  ExpirationAction getEntryIdleTimeoutAction() const;

  /**
   * If true, this region will store data in the current process.
   * @return true or false, indicating cachingEnabled state.
   */
  inline bool getCachingEnabled() const { return m_caching; }

  // MAP ATTRIBUTES

  /** Returns the initial capacity of the entry's local cache.
   * @return the initial capacity of the entry's local cache
   */
  int getInitialCapacity() const;

  /** Returns the load factor of the entry's local cache.
   * @return the load factor of the entry's local cache
   */
  float getLoadFactor() const;

  /** Returns the concurrencyLevel of the entry's local cache.
   * @return the concurrencyLevel
   * @see RegionAttributesFactory
   */
  uint8_t getConcurrencyLevel() const;

  /**
   * Returns the maximum number of entries this cache will hold before
   * using LRU eviction. A return value of zero, 0, indicates no limit.
   */
  uint32_t getLruEntriesLimit() const;

  /** Returns the disk policy type of the region.
   *
   * @return the <code>DiskPolicyType</code>, default is
   * DiskPolicyType::NONE.
   */
  DiskPolicyType getDiskPolicy() const;

  /**
   * Returns the ExpirationAction used for LRU Eviction, default is
   * LOCAL_DESTROY.
   */
  ExpirationAction getLruEvictionAction() const;

  /**
   * Returns the name of the pool attached to the region.
   */
  const std::string& getPoolName() const { return m_poolName; }

  // will be created by the factory
  RegionAttributes();
  RegionAttributes(const RegionAttributes& rhs) = default;

  /*destructor
   *
   */
  ~RegionAttributes() noexcept override;

  /** Return an empty instance for deserialization. */
  static std::shared_ptr<Serializable> createDeserializable();

  void toData(DataOutput& out) const override;

  void fromData(DataInput& in) override;

  /**
   * This method returns the path of the library from which
   * the factory function will be invoked on a cache server.
   */
  const std::string& getCacheLoaderLibrary() const;

  /**
   * This method returns the symbol name of the factory function from which
   * the loader will be created on a cache server.
   */
  const std::string& getCacheLoaderFactory() const;

  /**
   * This method returns the path of the library from which
   * the factory function will be invoked on a cache server.
   */
  const std::string& getCacheListenerLibrary() const;

  /**
   * This method returns the symbol name of the factory function from which
   * the loader will be created on a cache server.
   */
  const std::string& getCacheListenerFactory() const;

  /**
   * This method returns the path of the library from which
   * the factory function will be invoked on a cache server.
   */
  const std::string& getCacheWriterLibrary() const;

  /**
   * This method returns the symbol name of the factory function from which
   * the loader will be created on a cache server.
   */
  const std::string& getCacheWriterFactory() const;

  /**
   * This method returns the path of the library from which
   * the factory function will be invoked on a cache server.
   */
  const std::string& getPartitionResolverLibrary() const;

  /**
   * This method returns the symbol name of the factory function from which
   * the loader will be created on a cache server.
   */
  const std::string& getPartitionResolverFactory() const;

  /** Return true if all the attributes are equal to those of other. */
  bool operator==(const RegionAttributes& other) const;

  /** Return true if any of the attributes are not equal to those of other. */
  bool operator!=(const RegionAttributes& other) const;

  /** throws IllegalStateException if the attributes are not suited for
   * serialization
   * such as those that have a cache callback (listener, loader, or writer) set
   * directly instead of through the string value setters.
   */
  void validateSerializableAttributes();

  /**
   * This method returns the list of servername:portno separated by comma
   */
  const std::string& getEndpoints() const;

  /**
   * This method returns the setting of client notification
   */
  bool getClientNotificationEnabled() const;

  /**
   * This method returns the path of the library from which
   * the factory function will be invoked on a cache server.
   */
  const std::string& getPersistenceLibrary() const;

  /**
   * This method returns the symbol name of the factory function from which
   * the persistence will be created on a cache server.
   */
  const std::string& getPersistenceFactory() const;

  /**
   * This method returns the properties pointer which is set for persistence.
   */
  std::shared_ptr<Properties> getPersistenceProperties() const;

  /** Gets the persistence for the region.
   * @return  a pointer that points to the region's ,
   * <code>PersistenceManager</code> , nullptr if there is no PersistenceManager
   * for this
   * region.
   */
  std::shared_ptr<PersistenceManager> getPersistenceManager() const;

  bool getCloningEnabled() const { return m_isClonable; }

  /**
   * Returns true if concurrent update checks are turned on for this region.
   * <p>
   * @return true if concurrent update checks are turned on
   */
  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_