1 #ifndef ISPN_HOTROD_REMOTECACHE_H
2 #define ISPN_HOTROD_REMOTECACHE_H
23 namespace infinispan {
58 #ifndef SWIG // Let SWIG ignore this method
59 template<
typename Function>
60 inline std::future<typename std::result_of<Function()>::type> goAsync(Function&& f,
61 std::function<
typename std::result_of<Function()>::type (
typename std::result_of<Function()>::type)> success, std::function<
typename std::result_of<Function()>::type (std::exception&)> fail)
63 auto fq= [=]{
try{
return success==0 ? f() : success(f());}
64 catch (std::exception& ex)
65 {
if (fail!=0){
return fail(ex);}
68 return std::async(fq);
107 V*
get(
const K& key) {
120 std::future<V*>
getAsync(
const K& key, std::function<V* (V*)> success=
nullptr, std::function<V* (std::exception&)> fail=
nullptr) {
122 auto f= [=] {
return this->
get(*pKey); };
123 return goAsync(f,success,fail);
146 V*
put(
const K& key,
const V& val, uint64_t lifespan = 0, uint64_t maxIdle = 0) {
168 V*
put(
const K& key,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit) {
169 return put(key, val, lifespan, lifespanUnit, 0,
SECONDS);
194 V*
put(
const K& key,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, uint64_t maxIdle,
TimeUnit maxIdleUnit) {
195 return (V *)
base_put(&key, &val, toSeconds(lifespan, lifespanUnit), toSeconds(maxIdle, maxIdleUnit));
206 std::future<V*>
putAsync(
const K& key,
const V& val, uint64_t lifespan = 0, uint64_t maxIdle = 0, std::function<V* (V*)> success=
nullptr, std::function<V* (std::exception&)> fail=
nullptr) {
207 auto pKey=&key, pVal=&val;
208 auto f=[=] {
return this->
put(*pKey,*pVal,lifespan,maxIdle); };
209 return goAsync(f,success,fail);
220 std::future<V*>
putAsync(
const K& key,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, std::function<V* (V*)> success=
nullptr, std::function<V* (std::exception&)> fail=
nullptr) {
221 auto pKey=&key, pVal=&val;
222 auto f= [=] {
return this->
put(*pKey,*pVal,lifespan,lifespanUnit); };
223 return goAsync(f,success,fail);
234 std::future<V*>
putAsync(
const K& key,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, uint64_t maxIdle,
TimeUnit maxIdleUnit, std::function<V* (V*)> success=
nullptr, std::function<V* (std::exception&)> fail=
nullptr) {
235 auto pKey=&key, pVal=&val;
236 auto f= [=] { this->
put(*pKey,*pVal,lifespan, lifespanUnit,maxIdle,maxIdleUnit); };
237 return goAsync(f,success,fail);
251 V*
putIfAbsent(
const K& key,
const V& val, uint64_t lifespan = 0, uint64_t maxIdle = 0) {
281 return (V *)
base_putIfAbsent(&key, &val, toSeconds(lifespan, lifespanUnit), toSeconds(maxIdle, maxIdleUnit));
291 std::future<V*>
putIfAbsentAsync(
const K& key,
const V& val, uint64_t lifespan = 0, uint64_t maxIdle = 0, std::function<V* (V*)> success=
nullptr, std::function<V* (std::exception&)> fail=
nullptr) {
292 auto pKey=&key, pVal=&val;
293 auto f= [=] { this->
putIfAbsent(*pKey,*pVal, lifespan, maxIdle); };
294 return goAsync(f,success,fail);
304 std::future<V*>
putIfAbsentAsync(
const K& key,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, std::function<V* (V*)> success=
nullptr, std::function<V* (std::exception&)> fail=
nullptr) {
305 auto pKey=&key, pVal=&val;
307 return goAsync(f,success,fail);
317 std::future<V*>
putIfAbsentAsync(
const K& key,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, uint64_t maxIdle,
TimeUnit maxIdleUnit, std::function<V* (V*)> success=
nullptr, std::function<V* (std::exception&)> fail=
nullptr) {
318 auto pKey=&key, pVal=&val;
319 auto f= [=] { this->
putIfAbsent(*pKey,*pVal, lifespan, lifespanUnit, maxIdle, maxIdleUnit); };
320 return goAsync(f,success,fail);
334 void putAll(
const std::map<K, V>& map, uint64_t lifespan = 0, uint64_t maxIdle = 0) {
348 void putAll(
const std::map<K, V>& map, uint64_t lifespan,
TimeUnit lifespanUnit) {
365 void putAll(
const std::map<K, V>& map, uint64_t lifespan,
TimeUnit lifespanUnit, uint64_t maxIdle,
TimeUnit maxIdleUnit) {
366 uint64_t lifespanMillis = toSeconds(lifespan, lifespanUnit);
367 uint64_t maxIdleMillis = toSeconds(maxIdle, maxIdleUnit);
369 for (
typename std::map<K, V>::const_iterator it = map.begin(); it != map.end(); ++it) {
370 put(it->first, it->second, lifespanMillis, maxIdleMillis);
382 std::future<void>
putAllAsync(
const std::map<K, V>& map, uint64_t lifespan = 0, uint64_t maxIdle = 0, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
384 auto f = [=] { this->
putAll(*pMap,lifespan, maxIdle); };
385 return goAsync(f,success,fail);
396 std::future<void>
putAllAsync(
const std::map<K, V>& map, uint64_t lifespan,
TimeUnit lifespanUnit, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
398 auto f = [=] { this->
putAll(*pMap,lifespan, lifespanUnit); };
399 return goAsync(f,success,fail);
410 std::future<void>
putAllAsync(
const std::map<K, V>& map, uint64_t lifespan,
TimeUnit lifespanUnit, uint64_t maxIdle,
TimeUnit maxIdleUnit, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
412 auto f = [=] { this->
putAll(*pMap,lifespan, lifespanUnit, maxIdle, maxIdleUnit); };
413 return goAsync(f,success,fail);
427 V*
replace(
const K& key,
const V& val, uint64_t lifespan = 0, uint64_t maxIdle = 0) {
458 return (V *)
base_replace(&key, &val, toSeconds(lifespan, lifespanUnit), toSeconds(maxIdle, maxIdleUnit));
472 V*
replace(
const K& key,
const V& oldVal,
const V& val, uint64_t lifespan = 0, uint64_t maxIdle = 0) {
486 V*
replace(
const K& key,
const V& oldVal,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit) {
487 return replace(key, oldVal, val, lifespan, lifespanUnit, 0,
SECONDS);
502 V*
replace(
const K& key,
const V& oldVal,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, uint64_t maxIdle,
TimeUnit maxIdleUnit) {
514 std::future<V*>
replaceAsync(
const K& key,
const V& val, uint64_t lifespan = 0, uint64_t maxIdle = 0, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
515 auto pKey=&key, pVal=&val;
517 return goAsync(f,success,fail);
528 std::future<V*>
replaceAsync(
const K& key,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
529 auto pKey=&key, pVal=&val;
530 auto f= [=] { this->
replace(*pKey, *pVal, lifespan, lifespanUnit, 0,
SECONDS); };
531 return goAsync(f,success,fail);
542 std::future<V*>
replaceAsync(
const K& key,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, uint64_t maxIdle,
TimeUnit maxIdleUnit, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
543 auto pKey=&key, pVal=&val;
544 auto f= [=] { this->
replace(*pKey, *pVal, lifespan, lifespanUnit, maxIdle, maxIdleUnit); };
545 return goAsync(f,success,fail);
556 std::future<V*>
replaceAsync(
const K& key,
const V& oldVal,
const V& val, uint64_t lifespan = 0, uint64_t maxIdle = 0, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
557 auto pKey=&key, pVal=&val, pOldVal=&oldVal;
559 return goAsync(f,success,fail);
570 std::future<V*>
replaceAsync(
const K& key,
const V& oldVal,
const V& val, uint64_t lifespan,
TimeUnit lifespanUnit, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
571 auto pKey=&key, pVal=&val, pOldVal=&oldVal;
572 auto f= [=] { this->
replace(*pKey, *oldVal, *pVal, lifespan, lifespanUnit, 0,
SECONDS); };
573 return goAsync(f,success,fail);
583 V*
remove(
const K& key) {
595 std::future<bool>
removeAsync(
const K& key, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
596 auto f = [=] { this->
remove(&key); };
597 return goAsync(f,success,fail);
632 const K& key,
const V& val,
633 uint64_t version, uint64_t lifespan = 0, uint64_t maxIdle = 0) {
646 uint64_t version, uint64_t lifespan, uint64_t maxIdle, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
648 return goAsync(f,success,fail);
681 std::future<bool>
removeWithVersionAsync(
const K& key, uint64_t version, std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
683 return goAsync(f,success,fail);
699 return std::make_pair(std::shared_ptr<V>((V *) value), version);
714 return std::make_pair(std::shared_ptr<V>((V *) value), metadata);
720 std::map<std::shared_ptr<K>, std::shared_ptr<V> >
getBulk() {
727 std::map<std::shared_ptr<K>, std::shared_ptr<V> >
getBulk(
int nrOfEntries) {
728 std::map<void* , void*> mbuf;
729 std::map<std::shared_ptr<K>, std::shared_ptr<V> > result;
731 for (
auto it = mbuf.begin(); it != mbuf.end(); ++it)
733 result[std::shared_ptr<K>((K*)it->first)]=std::shared_ptr<V>((V*)it->second);
743 std::vector<unsigned char>
execute(
const std::string& name,
const std::map<std::string,std::string>& args)
765 std::vector<unsigned char>
query(std::vector<unsigned char> qr,
size_t size)
785 std::vector<void*> p;
788 std::set<std::shared_ptr<K> > result;
789 for (
size_t i = 0; i < p.size(); ++i) {
790 result.insert(std::shared_ptr<K>((K*)p.data()[i]));
823 std::map<std::string, std::string>
stats() {
824 std::map<std::string, std::string> statistics;
846 std::future<void>
clearAsync(std::function<V* (V*)> success=
nullptr, std::function<
void (std::exception&)> fail=
nullptr) {
847 auto f = [=] { this->
clear(); };
848 return goAsync(f,success,fail);
860 void addClientListener(
ClientListener& clientListener, std::vector<std::vector<char> > filterFactoryParams, std::vector<std::vector<char> > converterFactoryParams,
const std::function<
void()> &recoveryCallback =
nullptr)
885 RemoteCacheBase(other), keyMarshaller(other.keyMarshaller), valueMarshaller(other.valueMarshaller)
887 setMarshallers(
this, &keyMarshall, &valueMarshall, &keyUnmarshall, &valueUnmarshall);
891 RemoteCacheBase::operator=(other);
892 keyMarshaller = other.keyMarshaller;
893 valueMarshaller = other.valueMarshaller;
894 setMarshallers(
this, &keyMarshall, &valueMarshall, &keyUnmarshall, &valueUnmarshall);
900 setMarshallers(
this, &keyMarshall, &valueMarshall, &keyUnmarshall, &valueUnmarshall);
904 uint64_t toSeconds(uint64_t time,
TimeUnit unit) {
908 result = (uint64_t) ceil(time / 1000000000.0);
911 result = (uint64_t) ceil(time / 1000000.0);
914 result = (uint64_t) ceil(time / 1000.0);
923 result = time * 3600;
926 result = time * 86400;
929 std::stringstream ss;
930 ss <<
"Unhandled TimeUnit specified: " << unit <<
".";
931 throw std::invalid_argument(ss.str());
937 static void keyMarshall(
void *thisp,
const void* key, std::vector<char> &buf) {
940 static void valueMarshall(
void* thisp,
const void* val, std::vector<char> &buf) {
943 static void* keyUnmarshall(
void *thisp,
const std::vector<char> &buf) {
946 static void* valueUnmarshall(
void* thisp,
const std::vector<char> &buf) {
950 std::shared_ptr<Marshaller<K> > keyMarshaller;
951 std::shared_ptr<Marshaller<V> > valueMarshaller;
void putAll(const std::map< K, V > &map, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit)
Definition: RemoteCache.h:365
HR_EXTERN QueryResponse base_query(const QueryRequest &qr)
std::future< V * > putAsync(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, std::function< V *(V *)> success=nullptr, std::function< V *(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:220
std::map< std::shared_ptr< K >, std::shared_ptr< V > > getBulk(int nrOfEntries)
Definition: RemoteCache.h:727
V * putIfAbsent(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit)
Definition: RemoteCache.h:264
std::future< V * > putIfAbsentAsync(const K &key, const V &val, uint64_t lifespan=0, uint64_t maxIdle=0, std::function< V *(V *)> success=nullptr, std::function< V *(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:291
std::vector< unsigned char > query(std::vector< unsigned char > qr, size_t size)
Definition: RemoteCache.h:765
HR_EXTERN void base_removeClientListener(ClientListener &clientListener)
HR_EXTERN void * base_replace(const void *key, const void *value, int64_t life, int64_t idle)
V * put(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit)
Definition: RemoteCache.h:194
std::string getName()
Definition: RemoteCache.h:78
std::pair< std::shared_ptr< V >, VersionedValue > getWithVersion(const K &key)
Definition: RemoteCache.h:696
std::set< std::pair< K, V > > entrySet()
Definition: RemoteCache.h:774
HR_EXTERN bool base_replaceWithVersion(const void *key, const void *value, int64_t version, int64_t life, int64_t idle)
HR_EXTERN void base_ping()
HR_EXTERN bool base_containsKey(const void *key)
HR_EXTERN void base_withFlags(Flag flag)
std::future< V * > replaceAsync(const K &key, const V &oldVal, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:570
HR_EXTERN void setMarshallers(void *rc, MarshallHelperFn kf, MarshallHelperFn vf, UnmarshallHelperFn ukf, UnmarshallHelperFn uvf)
static const char * getProtocolVersionCString()
Definition: Version.h:32
Definition: CacheTopologyInfo.h:10
bool containsKey(const K &key)
Definition: RemoteCache.h:606
HR_EXTERN void * base_remove(const void *key)
std::map< std::string, std::string > stats()
Definition: RemoteCache.h:823
HR_EXTERN void * base_put(const void *key, const void *value, int64_t life, int64_t idle)
std::future< V * > putIfAbsentAsync(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit, std::function< V *(V *)> success=nullptr, std::function< V *(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:317
std::future< bool > removeAsync(const K &key, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:595
V * replace(const K &key, const V &oldVal, const V &val, uint64_t lifespan=0, uint64_t maxIdle=0)
Definition: RemoteCache.h:472
std::set< std::shared_ptr< K > > keySet()
Definition: RemoteCache.h:784
void putAll(const std::map< K, V > &map, uint64_t lifespan=0, uint64_t maxIdle=0)
Definition: RemoteCache.h:334
RemoteCache< K, V > & withFlags(Flag flags)
Definition: RemoteCache.h:879
std::vector< V > values()
Definition: RemoteCache.h:814
HR_EXTERN bool base_removeWithVersion(const void *key, int64_t version)
V * putIfAbsent(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit)
Definition: RemoteCache.h:280
std::map< std::shared_ptr< K >, std::shared_ptr< V > > getBulk()
Definition: RemoteCache.h:720
std::future< V * > replaceAsync(const K &key, const V &oldVal, const V &val, uint64_t lifespan=0, uint64_t maxIdle=0, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:556
RemoteCache< K, V > & operator=(const RemoteCache &other)
Definition: RemoteCache.h:890
std::future< bool > removeWithVersionAsync(const K &key, uint64_t version, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:681
HR_EXTERN const char * base_getName()
Definition: CacheClientListener.h:28
Definition: TimeUnit.h:14
Definition: TimeUnit.h:18
V * putIfAbsent(const K &key, const V &val, uint64_t lifespan=0, uint64_t maxIdle=0)
Definition: RemoteCache.h:251
Definition: TimeUnit.h:15
std::future< V * > replaceAsync(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:542
std::future< void > putAllAsync(const std::map< K, V > &map, uint64_t lifespan, TimeUnit lifespanUnit, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:396
std::future< V * > putAsync(const K &key, const V &val, uint64_t lifespan=0, uint64_t maxIdle=0, std::function< V *(V *)> success=nullptr, std::function< V *(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:206
V * replace(const K &key, const V &oldVal, const V &val, uint64_t lifespan, TimeUnit lifespanUnit)
Definition: RemoteCache.h:486
std::future< V * > putIfAbsentAsync(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, std::function< V *(V *)> success=nullptr, std::function< V *(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:304
uint64_t size()
Definition: RemoteCache.h:799
std::future< V * > getAsync(const K &key, std::function< V *(V *)> success=nullptr, std::function< V *(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:120
void removeClientListener(ClientListener &clientListener)
Definition: RemoteCache.h:865
RemoteCache()
Definition: RemoteCache.h:899
void addClientListener(ClientListener &clientListener, std::vector< std::vector< char > > filterFactoryParams, std::vector< std::vector< char > > converterFactoryParams, const std::function< void()> &recoveryCallback=nullptr)
Definition: RemoteCache.h:860
HR_EXTERN void base_clear()
std::vector< unsigned char > execute(const std::string &name, const std::map< std::string, std::string > &args)
Definition: RemoteCache.h:743
std::future< void > putAllAsync(const std::map< K, V > &map, uint64_t lifespan=0, uint64_t maxIdle=0, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:382
CacheTopologyInfo getCacheTopologyInfo()
Definition: RemoteCache.h:870
void clear()
Definition: RemoteCache.h:833
bool isEmpty()
Definition: RemoteCache.h:807
V * put(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit)
Definition: RemoteCache.h:168
RemoteCache(const RemoteCache &other)
Definition: RemoteCache.h:884
HR_EXTERN std::vector< unsigned char > base_execute(const std::string &cmdName, const std::map< std::string, std::string > &args)
HR_EXTERN void * base_putIfAbsent(const void *key, const void *value, int64_t life, int64_t idle)
bool replaceWithVersion(const K &key, const V &val, uint64_t version, uint64_t lifespan=0, uint64_t maxIdle=0)
Definition: RemoteCache.h:631
std::string getVersion()
Definition: RemoteCache.h:87
Definition: RemoteCacheManager.h:38
Definition: TimeUnit.h:17
std::string getProtocolVersion()
Definition: RemoteCache.h:96
HR_EXTERN void * base_getWithVersion(const void *key, VersionedValue *version)
V * replace(const K &key, const V &oldVal, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit)
Definition: RemoteCache.h:502
Definition: ClientListener.h:35
V * replace(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit)
Definition: RemoteCache.h:457
void ping()
Definition: RemoteCache.h:856
Definition: exceptions.h:117
HR_EXTERN void base_keySet(int scope, std::vector< void * > &sbuf)
std::future< V * > putAsync(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit, std::function< V *(V *)> success=nullptr, std::function< V *(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:234
HR_EXTERN CacheTopologyInfo base_getCacheTopologyInfo()
QueryResponse query(const QueryRequest &qr)
Definition: RemoteCache.h:754
HR_EXTERN void base_stats(std::map< std::string, std::string > &sbuf)
HR_EXTERN void base_addClientListener(ClientListener &clientListener, const std::vector< std::vector< char > > filterFactoryParam, const std::vector< std::vector< char > > converterFactoryParams, const std::function< void()> &recoveryCallback)
HR_EXTERN void * base_getWithMetadata(const void *key, MetadataValue *metadata)
static const char * getVersionCString()
Definition: Version.h:41
TimeUnit
Definition: TimeUnit.h:13
std::future< V * > replaceAsync(const K &key, const V &val, uint64_t lifespan=0, uint64_t maxIdle=0, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:514
Definition: RemoteCacheBase.h:36
HR_EXTERN std::vector< unsigned char > base_query_char(std::vector< unsigned char > qr, size_t size)
std::future< void > putAllAsync(const std::map< K, V > &map, uint64_t lifespan, TimeUnit lifespanUnit, uint64_t maxIdle, TimeUnit maxIdleUnit, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:410
HR_EXTERN uint64_t base_size()
HR_EXTERN void base_getBulk(int size, std::map< void *, void * > &mbuf)
std::future< V * > replaceAsync(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:528
bool containsValue(const V &val)
Definition: RemoteCache.h:614
V * replace(const K &key, const V &val, uint64_t lifespan, TimeUnit lifespanUnit)
Definition: RemoteCache.h:441
Definition: TimeUnit.h:16
Definition: TimeUnit.h:19
Definition: TimeUnit.h:20
V * replace(const K &key, const V &val, uint64_t lifespan=0, uint64_t maxIdle=0)
Definition: RemoteCache.h:427
std::pair< std::shared_ptr< V >, MetadataValue > getWithMetadata(const K &key)
Definition: RemoteCache.h:711
std::future< void > clearAsync(std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:846
std::future< void > replaceWithVersionAsync(const K &key, const V &val, uint64_t version, uint64_t lifespan, uint64_t maxIdle, std::function< V *(V *)> success=nullptr, std::function< void(std::exception &)> fail=nullptr)
Definition: RemoteCache.h:645
Definition: VersionedValue.h:9
V * put(const K &key, const V &val, uint64_t lifespan=0, uint64_t maxIdle=0)
Definition: RemoteCache.h:146
HR_EXTERN void * base_get(const void *key)
void putAll(const std::map< K, V > &map, uint64_t lifespan, TimeUnit lifespanUnit)
Definition: RemoteCache.h:348
bool removeWithVersion(const K &key, uint64_t version)
Definition: RemoteCache.h:669