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_