Pivotal GemFire Native C++ Reference  10.1.3
Region.hpp
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #pragma once
19 
20 #ifndef GEODE_REGION_H_
21 #define GEODE_REGION_H_
22 
23 #include <chrono>
24 #include <iosfwd>
25 #include <memory>
26 
27 #include "AttributesMutator.hpp"
28 #include "CacheListener.hpp"
29 #include "CacheLoader.hpp"
30 #include "CacheStatistics.hpp"
31 #include "CacheWriter.hpp"
32 #include "CacheableBuiltins.hpp"
33 #include "CacheableKey.hpp"
34 #include "CacheableString.hpp"
35 #include "ExceptionTypes.hpp"
36 #include "PartitionResolver.hpp"
37 #include "Query.hpp"
38 #include "RegionAttributes.hpp"
40 #include "RegionEntry.hpp"
41 #include "Serializable.hpp"
42 #include "internal/geode_globals.hpp"
43 
44 namespace apache {
45 namespace geode {
46 namespace client {
47 
48 class Pool;
49 class AttributesMutator;
50 class Cache;
51 class CacheStatistics;
52 class CacheableKey;
53 class RegionAttributes;
54 class RegionEntry;
55 class RegionService;
56 class SelectResults;
57 class Serializable;
58 
59 static constexpr std::chrono::milliseconds DEFAULT_RESPONSE_TIMEOUT =
60  std::chrono::seconds(15);
61 
95 class APACHE_GEODE_EXPORT Region : public std::enable_shared_from_this<Region> {
98  public:
100  virtual const std::string& getName() const = 0;
101  // virtual uint64_t getUpdateReceived() const { return 0; };
102 
106  virtual const std::string& getFullPath() const = 0;
107 
111  virtual std::shared_ptr<Region> getParentRegion() const = 0;
112 
115  virtual const RegionAttributes& getAttributes() const = 0;
116 
121  virtual std::shared_ptr<AttributesMutator> getAttributesMutator() const = 0;
122 
123  // virtual void updateAccessOrModifiedTime() = 0;
124 
125  virtual std::shared_ptr<CacheStatistics> getStatistics() const = 0;
126 
143  virtual void invalidateRegion(
144  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
145 
165  virtual void localInvalidateRegion(
166  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
167 
204  virtual void destroyRegion(
205  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
213  virtual void clear(
214  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
222  virtual void localClear(
223  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
224 
244  virtual void localDestroyRegion(
245  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
246 
249  virtual std::shared_ptr<Region> getSubregion(const std::string& path) = 0;
250 
252  virtual std::shared_ptr<Region> createSubregion(
253  const std::string& subregionName, RegionAttributes aRegionAttributes) = 0;
254 
262  virtual std::vector<std::shared_ptr<Region>> subregions(
263  const bool recursive) = 0;
264 
268  virtual std::shared_ptr<RegionEntry> getEntry(
269  const std::shared_ptr<CacheableKey>& key) = 0;
270 
272  template <class KEYTYPE>
273  inline std::shared_ptr<RegionEntry> getEntry(const KEYTYPE& key) {
274  return getEntry(CacheableKey::create(key));
275  }
276 
318  virtual std::shared_ptr<Cacheable> get(
319  const std::shared_ptr<CacheableKey>& key,
320  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
321 
323  template <class KEYTYPE>
324  inline std::shared_ptr<Cacheable> get(
325  const KEYTYPE& key,
326  const std::shared_ptr<Serializable>& callbackArg = nullptr) {
327  return get(CacheableKey::create(key), callbackArg);
328  }
329 
375  virtual void put(
376  const std::shared_ptr<CacheableKey>& key,
377  const std::shared_ptr<Cacheable>& value,
378  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
379 
381  template <class KEYTYPE, class VALUETYPE>
382  inline void put(const KEYTYPE& key, const VALUETYPE& value,
383  const std::shared_ptr<Serializable>& arg = nullptr) {
384  put(CacheableKey::create(key), Serializable::create(value), arg);
385  }
386 
388  template <class KEYTYPE>
389  inline void put(const KEYTYPE& key, const std::shared_ptr<Cacheable>& value,
390  const std::shared_ptr<Serializable>& arg = nullptr) {
391  put(CacheableKey::create(key), value, arg);
392  }
393 
395  template <class VALUETYPE>
396  inline void put(const std::shared_ptr<CacheableKey>& key,
397  const VALUETYPE& value,
398  const std::shared_ptr<Serializable>& arg = nullptr) {
399  put(key, Serializable::create(value), arg);
400  }
401 
420  virtual void putAll(
421  const HashMapOfCacheable& map,
422  std::chrono::milliseconds timeout = DEFAULT_RESPONSE_TIMEOUT,
423  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
424 
449  virtual void localPut(
450  const std::shared_ptr<CacheableKey>& key,
451  const std::shared_ptr<Cacheable>& value,
452  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
453 
455  template <class KEYTYPE, class VALUETYPE>
456  inline void localPut(const KEYTYPE& key, const VALUETYPE& value,
457  const std::shared_ptr<Serializable>& arg = nullptr) {
458  localPut(CacheableKey::create(key), Serializable::create(value), arg);
459  }
460 
462  template <class KEYTYPE>
463  inline void localPut(const KEYTYPE& key,
464  const std::shared_ptr<Cacheable>& value,
465  const std::shared_ptr<Serializable>& arg = nullptr) {
466  localPut(CacheableKey::create(key), value, arg);
467  }
468 
470  template <class VALUETYPE>
471  inline void localPut(const std::shared_ptr<CacheableKey>& key,
472  const VALUETYPE& value,
473  const std::shared_ptr<Serializable>& arg = nullptr) {
474  localPut(key, Serializable::create(value), arg);
475  }
476 
523  virtual void create(
524  const std::shared_ptr<CacheableKey>& key,
525  const std::shared_ptr<Cacheable>& value,
526  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
527 
529  template <class KEYTYPE, class VALUETYPE>
530  inline void create(const KEYTYPE& key, const VALUETYPE& value,
531  const std::shared_ptr<Serializable>& arg = nullptr) {
532  create(CacheableKey::create(key), Serializable::create(value), arg);
533  }
534 
536  template <class KEYTYPE>
537  inline void create(const KEYTYPE& key,
538  const std::shared_ptr<Cacheable>& value,
539  const std::shared_ptr<Serializable>& arg = nullptr) {
540  create(CacheableKey::create(key), value, arg);
541  }
542 
544  template <class VALUETYPE>
545  inline void create(const std::shared_ptr<CacheableKey>& key,
546  const VALUETYPE& value,
547  const std::shared_ptr<Serializable>& arg = nullptr) {
548  create(key, Serializable::create(value), arg);
549  }
550 
576  virtual void localCreate(
577  const std::shared_ptr<CacheableKey>& key,
578  const std::shared_ptr<Cacheable>& value,
579  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
580 
582  template <class KEYTYPE, class VALUETYPE>
583  inline void localCreate(const KEYTYPE& key, const VALUETYPE& value,
584  const std::shared_ptr<Serializable>& arg = nullptr) {
585  localCreate(CacheableKey::create(key), Serializable::create(value), arg);
586  }
587 
589  template <class KEYTYPE>
590  inline void localCreate(const KEYTYPE& key,
591  const std::shared_ptr<Cacheable>& value,
592  const std::shared_ptr<Serializable>& arg = nullptr) {
593  localCreate(CacheableKey::create(key), value, arg);
594  }
595 
597  template <class VALUETYPE>
598  inline void localCreate(const std::shared_ptr<CacheableKey>& key,
599  const VALUETYPE& value,
600  const std::shared_ptr<Serializable>& arg = nullptr) {
601  localCreate(key, Serializable::create(value), arg);
602  }
603 
626  virtual void invalidate(
627  const std::shared_ptr<CacheableKey>& key,
628  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
629 
631  template <class KEYTYPE>
632  inline void invalidate(const KEYTYPE& key,
633  const std::shared_ptr<Serializable>& arg = nullptr) {
634  invalidate(CacheableKey::create(key), arg);
635  }
636 
657  virtual void localInvalidate(
658  const std::shared_ptr<CacheableKey>& key,
659  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
660 
662  template <class KEYTYPE>
663  inline void localInvalidate(
664  const KEYTYPE& key, const std::shared_ptr<Serializable>& arg = nullptr) {
665  localInvalidate(CacheableKey::create(key), arg);
666  }
667 
712  virtual void destroy(
713  const std::shared_ptr<CacheableKey>& key,
714  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
715 
717  template <class KEYTYPE>
718  inline void destroy(const KEYTYPE& key,
719  const std::shared_ptr<Serializable>& arg = nullptr) {
720  destroy(CacheableKey::create(key), arg);
721  }
722 
747  virtual void localDestroy(
748  const std::shared_ptr<CacheableKey>& key,
749  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
750 
752  template <class KEYTYPE>
753  inline void localDestroy(const KEYTYPE& key,
754  const std::shared_ptr<Serializable>& arg = nullptr) {
755  localDestroy(CacheableKey::create(key), arg);
756  }
757 
806  virtual bool remove(
807  const std::shared_ptr<CacheableKey>& key,
808  const std::shared_ptr<Cacheable>& value,
809  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
810 
812  template <class KEYTYPE, class VALUETYPE>
813  inline bool remove(const KEYTYPE& key, const VALUETYPE& value,
814  const std::shared_ptr<Serializable>& arg = nullptr) {
815  return remove(CacheableKey::create(key), Serializable::create(value), arg);
816  }
817 
819  template <class KEYTYPE>
820  inline bool remove(const KEYTYPE& key,
821  const std::shared_ptr<Cacheable>& value,
822  const std::shared_ptr<Serializable>& arg = nullptr) {
823  return remove(CacheableKey::create(key), value, arg);
824  }
825 
827  template <class VALUETYPE>
828  inline bool remove(const std::shared_ptr<CacheableKey>& key,
829  const VALUETYPE& value,
830  const std::shared_ptr<Serializable>& arg = nullptr) {
831  return remove(key, Serializable::create(value), arg);
832  }
833 
834  bool remove(const std::shared_ptr<CacheableKey>& key) {
835  return removeEx(key);
836  }
837 
839  template <class KEYTYPE>
840  inline bool remove(const KEYTYPE& key) {
841  return remove(CacheableKey::create(key));
842  }
843 
890  virtual bool removeEx(
891  const std::shared_ptr<CacheableKey>& key,
892  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
893 
895  template <class KEYTYPE>
896  inline bool removeEx(const KEYTYPE& key,
897  const std::shared_ptr<Serializable>& arg = nullptr) {
898  return removeEx(CacheableKey::create(key), arg);
899  }
900 
928  virtual bool localRemove(
929  const std::shared_ptr<CacheableKey>& key,
930  const std::shared_ptr<Cacheable>& value,
931  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
932 
934  template <class KEYTYPE, class VALUETYPE>
935  inline bool localRemove(const KEYTYPE& key, const VALUETYPE& value,
936  const std::shared_ptr<Serializable>& arg = nullptr) {
937  return localRemove(CacheableKey::create(key), Serializable::create(value),
938  arg);
939  }
940 
942  template <class KEYTYPE>
943  inline bool localRemove(const KEYTYPE& key,
944  const std::shared_ptr<Cacheable>& value,
945  const std::shared_ptr<Serializable>& arg = nullptr) {
946  return localRemove(CacheableKey::create(key), value, arg);
947  }
948 
950  template <class VALUETYPE>
951  inline bool localRemove(const std::shared_ptr<CacheableKey>& key,
952  const VALUETYPE& value,
953  const std::shared_ptr<Serializable>& arg = nullptr) {
954  return localRemove(key, Serializable::create(value), arg);
955  }
956 
983  virtual bool localRemoveEx(
984  const std::shared_ptr<CacheableKey>& key,
985  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
986 
988  template <class KEYTYPE>
989  inline bool localRemoveEx(
990  const KEYTYPE& key, const std::shared_ptr<Serializable>& arg = nullptr) {
991  return localRemoveEx(CacheableKey::create(key), arg);
992  }
993 
998  virtual std::vector<std::shared_ptr<CacheableKey>> keys() = 0;
999 
1025  virtual std::vector<std::shared_ptr<CacheableKey>> serverKeys() = 0;
1026 
1031  virtual std::vector<std::shared_ptr<Cacheable>> values() = 0;
1032 
1033  virtual std::vector<std::shared_ptr<RegionEntry>> entries(bool recursive) = 0;
1034 
1039  virtual RegionService& getRegionService() const = 0;
1040 
1041  virtual bool isDestroyed() const = 0;
1042 
1048  virtual bool containsValueForKey(
1049  const std::shared_ptr<CacheableKey>& keyPtr) const = 0;
1050 
1057  template <class KEYTYPE>
1058  inline bool containsValueForKey(const KEYTYPE& key) const {
1059  return containsValueForKey(CacheableKey::create(key));
1060  }
1061 
1067  virtual bool containsKey(
1068  const std::shared_ptr<CacheableKey>& keyPtr) const = 0;
1075  virtual bool containsKeyOnServer(
1076  const std::shared_ptr<CacheableKey>& keyPtr) const = 0;
1083  virtual std::vector<std::shared_ptr<CacheableKey>> getInterestList()
1084  const = 0;
1091  virtual std::vector<std::shared_ptr<CacheableString>> getInterestListRegex()
1092  const = 0;
1099  template <class KEYTYPE>
1100  inline bool containsKey(const KEYTYPE& key) const {
1101  return containsKey(CacheableKey::create(key));
1102  }
1103 
1139  virtual void registerKeys(
1140  const std::vector<std::shared_ptr<CacheableKey>>& keys,
1141  bool isDurable = false, bool getInitialValues = false,
1142  bool receiveValues = true) = 0;
1143 
1169  virtual void unregisterKeys(
1170  const std::vector<std::shared_ptr<CacheableKey>>& keys) = 0;
1171 
1204  virtual void registerAllKeys(bool isDurable = false,
1205  bool getInitialValues = false,
1206  bool receiveValues = true) = 0;
1207 
1230  virtual void unregisterAllKeys() = 0;
1231 
1275  virtual void registerRegex(const std::string& regex, bool isDurable = false,
1276  bool getInitialValues = false,
1277  bool receiveValues = true) = 0;
1278 
1306  virtual void unregisterRegex(const std::string& regex) = 0;
1307 
1350  virtual HashMapOfCacheable getAll(
1351  const std::vector<std::shared_ptr<CacheableKey>>& keys,
1352  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
1353 
1380  virtual std::shared_ptr<SelectResults> query(
1381  const std::string& predicate,
1382  std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
1383 
1404  virtual bool existsValue(
1405  const std::string& predicate,
1406  std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
1407 
1430  virtual std::shared_ptr<Serializable> selectValue(
1431  const std::string& predicate,
1432  std::chrono::milliseconds timeout = DEFAULT_QUERY_RESPONSE_TIMEOUT) = 0;
1433 
1461  virtual void removeAll(
1462  const std::vector<std::shared_ptr<CacheableKey>>& keys,
1463  const std::shared_ptr<Serializable>& aCallbackArgument = nullptr) = 0;
1464 
1469  virtual uint32_t size() = 0;
1470 
1471  virtual const std::shared_ptr<Pool>& getPool() const = 0;
1472 
1473  Cache& getCache();
1474 
1475  Region(const Region&) = delete;
1476  Region& operator=(const Region&) = delete;
1477 
1478  protected:
1479  explicit Region(CacheImpl* cacheImpl);
1480  virtual ~Region() noexcept;
1481 
1482  CacheImpl* m_cacheImpl;
1483 };
1484 
1485 } // namespace client
1486 } // namespace geode
1487 } // namespace apache
1488 
1489 #endif // GEODE_REGION_H_
CacheableString.hpp
apache::geode::client::Region::localCreate
void localCreate(const std::shared_ptr< CacheableKey > &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing value to be a const char*.
Definition: Region.hpp:598
apache::geode::client::Region::localDestroy
void localDestroy(const KEYTYPE &key, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:753
apache::geode::client::Region::localRemove
bool localRemove(const KEYTYPE &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing both key and value to be a const char*.
Definition: Region.hpp:935
apache::geode::client::Region::localCreate
void localCreate(const KEYTYPE &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing both key and value to be a const char*.
Definition: Region.hpp:583
apache::geode::client::Region::localRemove
bool localRemove(const KEYTYPE &key, const std::shared_ptr< Cacheable > &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:943
CacheStatistics.hpp
apache::geode::client::Region::localCreate
void localCreate(const KEYTYPE &key, const std::shared_ptr< Cacheable > &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:590
apache::geode::client::Region::create
void create(const KEYTYPE &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing both key and value to be a const char*.
Definition: Region.hpp:530
apache::geode::client::Cache
Definition: Cache.hpp:67
apache::geode::client::Region::remove
bool remove(const KEYTYPE &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing both key and value to be a const char*.
Definition: Region.hpp:813
apache::geode::client::Region::create
void create(const std::shared_ptr< CacheableKey > &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing value to be a const char*.
Definition: Region.hpp:545
apache::geode::client::Region::localRemove
bool localRemove(const std::shared_ptr< CacheableKey > &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing value to be a const char*.
Definition: Region.hpp:951
RegionAttributesFactory.hpp
apache::geode::client::Region::getEntry
std::shared_ptr< RegionEntry > getEntry(const KEYTYPE &key)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:273
CacheableKey.hpp
apache::geode::client::Region::localPut
void localPut(const std::shared_ptr< CacheableKey > &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing value to be a const char*.
Definition: Region.hpp:471
apache::geode::client::Region::removeEx
bool removeEx(const KEYTYPE &key, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:896
apache::geode::client::Region::put
void put(const std::shared_ptr< CacheableKey > &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing value to be a const char*.
Definition: Region.hpp:396
apache::geode::client::Region::localPut
void localPut(const KEYTYPE &key, const std::shared_ptr< Cacheable > &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:463
apache::geode::client::Region::containsValueForKey
bool containsValueForKey(const KEYTYPE &key) const
Convenience method allowing key to be a const char* This operations checks for the value in the local...
Definition: Region.hpp:1058
apache::geode::client::Region::create
void create(const KEYTYPE &key, const std::shared_ptr< Cacheable > &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:537
apache::geode::client::Region::destroy
void destroy(const KEYTYPE &key, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:718
CacheableBuiltins.hpp
Contains generic template definitions for Cacheable types and instantiations for built-in types.
apache::geode::client::RegionService
A RegionService provides access to existing regions that exist in a Geode cache.
Definition: RegionService.hpp:62
AttributesMutator.hpp
apache::geode::client::Region::remove
bool remove(const std::shared_ptr< CacheableKey > &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing value to be a const char*.
Definition: Region.hpp:828
CacheLoader.hpp
apache::geode::client::Region::localRemoveEx
bool localRemoveEx(const KEYTYPE &key, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:989
RegionEntry.hpp
Query.hpp
apache::geode::client::CacheableKey::create
static std::shared_ptr< CacheableKey > create(_T value)
Factory method that creates the key type that matches the type of value.
apache::geode::client::Serializable::create
static std::shared_ptr< Serializable > create(_T value)
Factory method that creates the Serializable object that matches the type of value.
RegionAttributes.hpp
apache::geode::client::RegionAttributes
Definition: RegionAttributes.hpp:76
apache::geode::client::Region::remove
bool remove(const KEYTYPE &key, const std::shared_ptr< Cacheable > &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:820
apache::geode::client::Region::put
void put(const KEYTYPE &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing both key and value to be a const char*.
Definition: Region.hpp:382
apache::geode::client::Region::remove
bool remove(const KEYTYPE &key)
Convenience method allowing both key and value to be a const char*.
Definition: Region.hpp:840
apache::geode::client::Region::put
void put(const KEYTYPE &key, const std::shared_ptr< Cacheable > &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:389
apache::geode::client::Region::localInvalidate
void localInvalidate(const KEYTYPE &key, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:663
apache::geode::client::Region::containsKey
bool containsKey(const KEYTYPE &key) const
Convenience method allowing key to be a const char* This operations checks for the key in the local c...
Definition: Region.hpp:1100
apache::geode::client::Region
Definition: Region.hpp:95
CacheListener.hpp
apache::geode::client::Region::get
std::shared_ptr< Cacheable > get(const KEYTYPE &key, const std::shared_ptr< Serializable > &callbackArg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:324
apache::geode::client::Region::invalidate
void invalidate(const KEYTYPE &key, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing key to be a const char*.
Definition: Region.hpp:632
apache::geode::client::Region::localPut
void localPut(const KEYTYPE &key, const VALUETYPE &value, const std::shared_ptr< Serializable > &arg=nullptr)
Convenience method allowing both key and value to be a const char*.
Definition: Region.hpp:456

Apache Geode C++ Cache API Documentation