RegionAttributes.hpp

Go to the documentation of this file.

#ifndef __GEMFIRE_REGIONATTRIBUTES_H__
#define __GEMFIRE_REGIONATTRIBUTES_H__
/*=========================================================================
 * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * more patents listed at http://www.pivotal.io/patents.
 *========================================================================
 */

#include "gfcpp_globals.hpp"
#include "gf_types.hpp"
#include "CacheLoader.hpp"
#include "ScopeType.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 gemfire {
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() ;



  ScopeType::Scope getScope() 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::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 setScope(ScopeType::Scope scope);
  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;
   ScopeType::Scope m_scope;
   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 gemfire

#endif //ifndef __GEMFIRE_REGIONATTRIBUTES_H__