Region.hpp

Go to the documentation of this file.

#pragma once

#ifndef GEODE_REGION_H_
#define GEODE_REGION_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.
 */

//#### Warning: DO NOT directly include Region.hpp, include Cache.hpp instead.

#include "geode_globals.hpp"
#include "geode_types.hpp"
#include "CacheableKey.hpp"
#include "CacheableString.hpp"
#include "CacheStatistics.hpp"
#include "ExceptionTypes.hpp"
#include "CacheableString.hpp"
#include "UserData.hpp"
#include "CacheableBuiltins.hpp"

#include "RegionEntry.hpp"
#include "CacheListener.hpp"
#include "PartitionResolver.hpp"
#include "CacheWriter.hpp"
#include "CacheLoader.hpp"
#include "RegionAttributes.hpp"
#include "AttributesMutator.hpp"
#include "AttributesFactory.hpp"
#include "CacheableKey.hpp"
#include "Query.hpp"
#define DEFAULT_RESPONSE_TIMEOUT 15

namespace apache {
namespace geode {
namespace client {
class CPPCACHE_EXPORT Region : public SharedBase {
 public:
  virtual const char* getName() const = 0;
  // virtual uint64_t getUpdateReceived() const { return 0; };

  virtual const char* getFullPath() const = 0;

  virtual RegionPtr getParentRegion() const = 0;

  virtual RegionAttributesPtr getAttributes() const = 0;

  virtual AttributesMutatorPtr getAttributesMutator() const = 0;

  // virtual void updateAccessOrModifiedTime() = 0;

  virtual CacheStatisticsPtr getStatistics() const = 0;

  virtual void invalidateRegion(
      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  virtual void localInvalidateRegion(
      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  virtual void destroyRegion(
      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
  virtual void clear(const UserDataPtr& aCallbackArgument = NULLPTR) = 0;
  virtual void localClear(const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  virtual void localDestroyRegion(
      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  virtual RegionPtr getSubregion(const char* path) = 0;

  virtual RegionPtr createSubregion(
      const char* subregionName,
      const RegionAttributesPtr& aRegionAttributes) = 0;

  virtual void subregions(const bool recursive, VectorOfRegion& sr) = 0;

  virtual RegionEntryPtr getEntry(const CacheableKeyPtr& key) = 0;

  template <class KEYTYPE>
  inline RegionEntryPtr getEntry(const KEYTYPE& key) {
    return getEntry(createKey(key));
  }

  virtual CacheablePtr get(const CacheableKeyPtr& key,
                           const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE>
  inline CacheablePtr get(const KEYTYPE& key,
                          const UserDataPtr& callbackArg = NULLPTR) {
    return get(createKey(key), callbackArg);
  }

  virtual void put(const CacheableKeyPtr& key, const CacheablePtr& value,
                   const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE, class VALUETYPE>
  inline void put(const KEYTYPE& key, const VALUETYPE& value,
                  const UserDataPtr& arg = NULLPTR) {
    put(createKey(key), createValue(value), arg);
  }

  template <class KEYTYPE>
  inline void put(const KEYTYPE& key, const CacheablePtr& value,
                  const UserDataPtr& arg = NULLPTR) {
    put(createKey(key), value, arg);
  }

  template <class VALUETYPE>
  inline void put(const CacheableKeyPtr& key, const VALUETYPE& value,
                  const UserDataPtr& arg = NULLPTR) {
    put(key, createValue(value), arg);
  }

  virtual void putAll(const HashMapOfCacheable& map,
                      uint32_t timeout = DEFAULT_RESPONSE_TIMEOUT,
                      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  virtual void localPut(const CacheableKeyPtr& key, const CacheablePtr& value,
                        const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE, class VALUETYPE>
  inline void localPut(const KEYTYPE& key, const VALUETYPE& value,
                       const UserDataPtr& arg = NULLPTR) {
    localPut(createKey(key), createValue(value), arg);
  }

  template <class KEYTYPE>
  inline void localPut(const KEYTYPE& key, const CacheablePtr& value,
                       const UserDataPtr& arg = NULLPTR) {
    localPut(createKey(key), value, arg);
  }

  template <class VALUETYPE>
  inline void localPut(const CacheableKeyPtr& key, const VALUETYPE& value,
                       const UserDataPtr& arg = NULLPTR) {
    localPut(key, createValue(value), arg);
  }

  virtual void create(const CacheableKeyPtr& key, const CacheablePtr& value,
                      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE, class VALUETYPE>
  inline void create(const KEYTYPE& key, const VALUETYPE& value,
                     const UserDataPtr& arg = NULLPTR) {
    create(createKey(key), createValue(value), arg);
  }

  template <class KEYTYPE>
  inline void create(const KEYTYPE& key, const CacheablePtr& value,
                     const UserDataPtr& arg = NULLPTR) {
    create(createKey(key), value, arg);
  }

  template <class VALUETYPE>
  inline void create(const CacheableKeyPtr& key, const VALUETYPE& value,
                     const UserDataPtr& arg = NULLPTR) {
    create(key, createValue(value), arg);
  }

  virtual void localCreate(const CacheableKeyPtr& key,
                           const CacheablePtr& value,
                           const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE, class VALUETYPE>
  inline void localCreate(const KEYTYPE& key, const VALUETYPE& value,
                          const UserDataPtr& arg = NULLPTR) {
    localCreate(createKey(key), createValue(value), arg);
  }

  template <class KEYTYPE>
  inline void localCreate(const KEYTYPE& key, const CacheablePtr& value,
                          const UserDataPtr& arg = NULLPTR) {
    localCreate(createKey(key), value, arg);
  }

  template <class VALUETYPE>
  inline void localCreate(const CacheableKeyPtr& key, const VALUETYPE& value,
                          const UserDataPtr& arg = NULLPTR) {
    localCreate(key, createValue(value), arg);
  }

  virtual void invalidate(const CacheableKeyPtr& key,
                          const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE>
  inline void invalidate(const KEYTYPE& key, const UserDataPtr& arg = NULLPTR) {
    invalidate(createKey(key), arg);
  }

  virtual void localInvalidate(
      const CacheableKeyPtr& key,
      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE>
  inline void localInvalidate(const KEYTYPE& key,
                              const UserDataPtr& arg = NULLPTR) {
    localInvalidate(createKey(key), arg);
  }

  virtual void destroy(const CacheableKeyPtr& key,
                       const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE>
  inline void destroy(const KEYTYPE& key, const UserDataPtr& arg = NULLPTR) {
    destroy(createKey(key), arg);
  }

  virtual void localDestroy(const CacheableKeyPtr& key,
                            const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE>
  inline void localDestroy(const KEYTYPE& key,
                           const UserDataPtr& arg = NULLPTR) {
    localDestroy(createKey(key), arg);
  }

  virtual bool remove(const CacheableKeyPtr& key, const CacheablePtr& value,
                      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE, class VALUETYPE>
  inline bool remove(const KEYTYPE& key, const VALUETYPE& value,
                     const UserDataPtr& arg = NULLPTR) {
    return remove(createKey(key), createValue(value), arg);
  }

  template <class KEYTYPE>
  inline bool remove(const KEYTYPE& key, const CacheablePtr& value,
                     const UserDataPtr& arg = NULLPTR) {
    return remove(createKey(key), value, arg);
  }

  template <class VALUETYPE>
  inline bool remove(const CacheableKeyPtr& key, const VALUETYPE& value,
                     const UserDataPtr& arg = NULLPTR) {
    return remove(key, createValue(value), arg);
  }

  bool remove(const CacheableKeyPtr& key) { return removeEx(key); }

  template <class KEYTYPE>
  inline bool remove(const KEYTYPE& key) {
    return remove(createKey(key));
  }

  virtual bool removeEx(const CacheableKeyPtr& key,
                        const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE>
  inline bool removeEx(const KEYTYPE& key, const UserDataPtr& arg = NULLPTR) {
    return removeEx(createKey(key), arg);
  }

  virtual bool localRemove(const CacheableKeyPtr& key,
                           const CacheablePtr& value,
                           const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE, class VALUETYPE>
  inline bool localRemove(const KEYTYPE& key, const VALUETYPE& value,
                          const UserDataPtr& arg = NULLPTR) {
    return localRemove(createKey(key), createValue(value), arg);
  }

  template <class KEYTYPE>
  inline bool localRemove(const KEYTYPE& key, const CacheablePtr& value,
                          const UserDataPtr& arg = NULLPTR) {
    return localRemove(createKey(key), value, arg);
  }

  template <class VALUETYPE>
  inline bool localRemove(const CacheableKeyPtr& key, const VALUETYPE& value,
                          const UserDataPtr& arg = NULLPTR) {
    return localRemove(key, createValue(value), arg);
  }

  virtual bool localRemoveEx(
      const CacheableKeyPtr& key,
      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  template <class KEYTYPE>
  inline bool localRemoveEx(const KEYTYPE& key,
                            const UserDataPtr& arg = NULLPTR) {
    return localRemoveEx(createKey(key), arg);
  }

  virtual void keys(VectorOfCacheableKey& v) = 0;

  virtual void serverKeys(VectorOfCacheableKey& v) = 0;

  virtual void values(VectorOfCacheable& vc) = 0;

  virtual void entries(VectorOfRegionEntry& me, bool recursive) = 0;

  virtual RegionServicePtr getRegionService() const = 0;

  virtual bool isDestroyed() const = 0;

  virtual bool containsValueForKey(const CacheableKeyPtr& keyPtr) const = 0;

  template <class KEYTYPE>
  inline bool containsValueForKey(const KEYTYPE& key) const {
    return containsValueForKey(createKey(key));
  }

  virtual bool containsKey(const CacheableKeyPtr& keyPtr) const = 0;
  virtual bool containsKeyOnServer(const CacheableKeyPtr& keyPtr) const = 0;
  virtual void getInterestList(VectorOfCacheableKey& vlist) const = 0;
  virtual void getInterestListRegex(VectorOfCacheableString& vregex) const = 0;
  template <class KEYTYPE>
  inline bool containsKey(const KEYTYPE& key) const {
    return containsKey(createKey(key));
  }

  virtual void registerKeys(const VectorOfCacheableKey& keys,
                            bool isDurable = false,
                            bool getInitialValues = false,
                            bool receiveValues = true) = 0;

  virtual void unregisterKeys(const VectorOfCacheableKey& keys) = 0;

  virtual void registerAllKeys(bool isDurable = false,
                               VectorOfCacheableKeyPtr resultKeys = NULLPTR,
                               bool getInitialValues = false,
                               bool receiveValues = true) = 0;

  virtual void unregisterAllKeys() = 0;

  virtual void registerRegex(const char* regex, bool isDurable = false,
                             VectorOfCacheableKeyPtr resultKeys = NULLPTR,
                             bool getInitialValues = false,
                             bool receiveValues = true) = 0;

  virtual void unregisterRegex(const char* regex) = 0;

  virtual void getAll(const VectorOfCacheableKey& keys,
                      HashMapOfCacheablePtr values,
                      HashMapOfExceptionPtr exceptions,
                      bool addToLocalCache = false,
                      const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  virtual SelectResultsPtr query(
      const char* predicate,
      uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;

  virtual bool existsValue(
      const char* predicate,
      uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;

  virtual SerializablePtr selectValue(
      const char* predicate,
      uint32_t timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;

  virtual void removeAll(const VectorOfCacheableKey& keys,
                         const UserDataPtr& aCallbackArgument = NULLPTR) = 0;

  virtual uint32_t size() = 0;

  virtual const PoolPtr& getPool() = 0;

 protected:
  Region();
  virtual ~Region();

 private:
  // Disallow copy constructor and assignment operator.
  Region(const Region&);
  Region& operator=(const Region&);
};
}  // namespace client
}  // namespace geode
}  // namespace apache

#endif  // GEODE_REGION_H_