Region.hpp

Go to the documentation of this file.

#ifndef __GEMFIRE_REGION_H__
#define __GEMFIRE_REGION_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.
*
* The specification of function behaviors is found in the corresponding .cpp file.
*
*========================================================================
*/

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

#include "gfcpp_globals.hpp"
#include "gf_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 gemfire {
  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 CachePtr getCache() const = 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 gemfire


#endif //ifndef __GEMFIRE_REGION_H__