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