RegionAttributes.hpp

Go to the documentation of this file.

#pragma once
 
#ifndef GEODE_REGIONATTRIBUTES_H_
#define GEODE_REGIONATTRIBUTES_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 "CacheLoader.hpp"
#include "ExpirationAttributes.hpp"
#include "CacheWriter.hpp"
#include "CacheListener.hpp"
#include "PartitionResolver.hpp"
#include "Properties.hpp"
#include "Serializable.hpp"
#include "DiskPolicyType.hpp"
#include "PersistenceManager.hpp"
 
namespace apache {
namespace geode {
namespace client {
class CacheImpl;
 
class AttributesFactory;
class AttributesMutator;
class Cache;
class Region;
 
class CPPCACHE_EXPORT RegionAttributes : public Serializable {
 public:
  CacheLoaderPtr getCacheLoader();
 
  CacheWriterPtr getCacheWriter();
 
  CacheListenerPtr getCacheListener();
 
  PartitionResolverPtr getPartitionResolver();
 
  int getRegionTimeToLive();
  ExpirationAction::Action getRegionTimeToLiveAction();
 
  int getRegionIdleTimeout();
  ExpirationAction::Action getRegionIdleTimeoutAction();
 
  int getEntryTimeToLive();
  ExpirationAction::Action getEntryTimeToLiveAction();
 
  int getEntryIdleTimeout();
  ExpirationAction::Action getEntryIdleTimeoutAction();
 
  inline bool getCachingEnabled() const { return m_caching; }
 
  // MAP ATTRIBUTES
 
  int getInitialCapacity() const;
 
  float getLoadFactor() const;
 
  uint8_t getConcurrencyLevel() const;
 
  uint32_t getLruEntriesLimit() const;
 
  DiskPolicyType::PolicyType getDiskPolicy() const;
 
  const ExpirationAction::Action getLruEvictionAction() const;
 
  const char* getPoolName() const;
 
  /*destructor
   *
   */
  virtual ~RegionAttributes();
 
  virtual void toData(DataOutput& out) const;
 
  virtual Serializable* fromData(DataInput& in);
 
  static Serializable* createDeserializable();
 
  virtual int32_t classId() const;
 
  virtual int8_t typeId() const;
 
  // return zero deliberately
  virtual uint32_t objectSize() const { return 0; }
 
  const char* getCacheLoaderLibrary();
 
  const char* getCacheLoaderFactory();
 
  const char* getCacheListenerLibrary();
 
  const char* getCacheListenerFactory();
 
  const char* getCacheWriterLibrary();
 
  const char* getCacheWriterFactory();
 
  const char* getPartitionResolverLibrary();
 
  const char* getPartitionResolverFactory();
 
  bool operator==(const RegionAttributes& other) const;
 
  bool operator!=(const RegionAttributes& other) const;
 
  void validateSerializableAttributes();
 
  const char* getEndpoints();
 
  bool getClientNotificationEnabled() const;
 
  const char* getPersistenceLibrary();
 
  const char* getPersistenceFactory();
 
  PropertiesPtr getPersistenceProperties();
 
  PersistenceManagerPtr getPersistenceManager();
 
  const char* getPoolName() { return m_poolName; }
  bool getCloningEnabled() { return m_isClonable; }
 
  bool getConcurrencyChecksEnabled() { return m_isConcurrencyChecksEnabled; }
 
 private:
  // Helper function that safely compares two attribute string
  // taking into consideration the fact the one or the other
  // might be NULL
  static int32_t compareStringAttribute(char* attributeA, char* attributeB);
 
  // Helper function that safely copies one string attribute to
  // another.
  static void copyStringAttribute(char*& lhs, const char* rhs);
 
  void setCacheListener(const char* libpath, const char* factoryFuncName);
  void setCacheLoader(const char* libpath, const char* factoryFuncName);
  void setCacheWriter(const char* libpath, const char* factoryFuncName);
  void setPartitionResolver(const char* libpath, const char* factoryFuncName);
  void setPersistenceManager(const char* lib, const char* func,
                             const PropertiesPtr& config);
  void setEndpoints(const char* endpoints);
  void setPoolName(const char* poolName);
  void setCloningEnabled(bool isClonable);
  void setCachingEnabled(bool enable);
  void setLruEntriesLimit(int limit);
  void setDiskPolicy(DiskPolicyType::PolicyType diskPolicy);
  void setConcurrencyChecksEnabled(bool enable);
  inline bool getEntryExpiryEnabled() const {
    return (m_entryTimeToLive != 0 || m_entryIdleTimeout != 0);
  }
 
  inline bool getRegionExpiryEnabled() const {
    return (m_regionTimeToLive != 0 || m_regionIdleTimeout != 0);
  }
 
  // will be created by the factory
  RegionAttributes(const RegionAttributes& rhs);
  RegionAttributes();
 
  ExpirationAction::Action m_regionTimeToLiveExpirationAction;
  ExpirationAction::Action m_regionIdleTimeoutExpirationAction;
  ExpirationAction::Action m_entryTimeToLiveExpirationAction;
  ExpirationAction::Action m_entryIdleTimeoutExpirationAction;
  ExpirationAction::Action m_lruEvictionAction;
  CacheWriterPtr m_cacheWriter;
  CacheLoaderPtr m_cacheLoader;
  CacheListenerPtr m_cacheListener;
  PartitionResolverPtr m_partitionResolver;
  uint32_t m_lruEntriesLimit;
  bool m_caching;
  uint32_t m_maxValueDistLimit;
  uint32_t m_entryIdleTimeout;
  uint32_t m_entryTimeToLive;
  uint32_t m_regionIdleTimeout;
  uint32_t m_regionTimeToLive;
  uint32_t m_initialCapacity;
  float m_loadFactor;
  uint8_t m_concurrencyLevel;
  char* m_cacheLoaderLibrary;
  char* m_cacheWriterLibrary;
  char* m_cacheListenerLibrary;
  char* m_partitionResolverLibrary;
  char* m_cacheLoaderFactory;
  char* m_cacheWriterFactory;
  char* m_cacheListenerFactory;
  char* m_partitionResolverFactory;
  DiskPolicyType::PolicyType m_diskPolicy;
  char* m_endpoints;
  bool m_clientNotificationEnabled;
  char* m_persistenceLibrary;
  char* m_persistenceFactory;
  PropertiesPtr m_persistenceProperties;
  PersistenceManagerPtr m_persistenceManager;
  char* m_poolName;
  bool m_isClonable;
  bool m_isConcurrencyChecksEnabled;
  friend class AttributesFactory;
  friend class AttributesMutator;
  friend class Cache;
  friend class CacheImpl;
  friend class Region;
  friend class RegionInternal;
  friend class RegionXmlCreation;
 
 private:
  const RegionAttributes& operator=(const RegionAttributes&);
};
}  // namespace client
}  // namespace geode
}  // namespace apache
 
#endif  // GEODE_REGIONATTRIBUTES_H_