117 template <
typename K,
typename V,
typename M = std::
string>
124 typedef std::unique_ptr<PersistentCache<K, V, M>>
UPtr;
194 static UPtr
open(std::string
const& cache_path);
206 OptionalValue
get(K
const& key)
const;
211 OptionalData
get_data(K
const& key)
const;
226 int64_t
size() const noexcept;
264 bool put(K const& key,
266 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
272 bool put(K const& key,
275 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
285 OptionalValue
get_or_put(K const& key, Loader const& load_func);
301 OptionalValue
take(K const& key);
321 template <typename It>
339 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
354 void trim_to(int64_t used_size_in_bytes);
393 template <typename K, typename V, typename M>
395 int64_t max_size_in_bytes,
401 template <
typename K,
typename V,
typename M>
407 template <
typename K,
typename V,
typename M>
409 int64_t max_size_in_bytes,
415 template <
typename K,
typename V,
typename M>
421 template <
typename K,
typename V,
typename M>
424 auto const& svalue = p_->get(CacheCodec<K>::encode(key));
425 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
428 template <
typename K,
typename V,
typename M>
431 auto sdata = p_->get_data(CacheCodec<K>::encode(key));
434 return OptionalData();
439 template <
typename K,
typename V,
typename M>
442 auto smeta = p_->get_metadata(CacheCodec<K>::encode(key));
443 return smeta ? OptionalMetadata(CacheCodec<M>::decode(*smeta)) : OptionalMetadata();
446 template <
typename K,
typename V,
typename M>
449 return p_->contains_key(CacheCodec<K>::encode(key));
452 template <
typename K,
typename V,
typename M>
458 template <
typename K,
typename V,
typename M>
461 return p_->size_in_bytes();
464 template <
typename K,
typename V,
typename M>
467 return p_->max_size_in_bytes();
470 template <
typename K,
typename V,
typename M>
473 return p_->disk_size_in_bytes();
476 template <
typename K,
typename V,
typename M>
479 return p_->discard_policy();
482 template <
typename K,
typename V,
typename M>
488 template <
typename K,
typename V,
typename M>
491 std::chrono::time_point<std::chrono::system_clock> expiry_time)
493 return p_->put(CacheCodec<K>::encode(key), CacheCodec<V>::encode(value), expiry_time);
496 template <
typename K,
typename V,
typename M>
500 std::chrono::time_point<std::chrono::system_clock> expiry_time)
502 return p_->put(CacheCodec<K>::encode(key), CacheCodec<V>::encode(value), CacheCodec<M>::encode(metadata),
506 template <
typename K,
typename V,
typename M>
508 K
const& key, PersistentCache<K, V, M>::Loader
const& load_func)
511 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
513 load_func(key, *
this);
515 auto svalue = p_->get_or_put(skey, sload_func);
516 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
519 template <
typename K,
typename V,
typename M>
521 K
const& key, PersistentCache<K, V, M>::Loader
const& load_func)
524 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
526 load_func(key, *
this);
528 auto sdata = p_->get_or_put_data(skey, sload_func);
531 return OptionalData();
536 template <
typename K,
typename V,
typename M>
539 return p_->put_metadata(CacheCodec<K>::encode(key), CacheCodec<M>::encode(metadata));
542 template <
typename K,
typename V,
typename M>
545 auto svalue = p_->take(CacheCodec<K>::encode(key));
546 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
549 template <
typename K,
typename V,
typename M>
552 auto sdata = p_->take_data(CacheCodec<K>::encode(key));
555 return OptionalData();
560 template <
typename K,
typename V,
typename M>
563 return p_->invalidate(CacheCodec<K>::encode(key));
566 template <
typename K,
typename V,
typename M>
572 template <
typename K,
typename V,
typename M>
573 template <
typename It>
576 std::vector<std::string> skeys;
577 for (
auto&& it = begin; it < end; ++it)
579 skeys.push_back(CacheCodec<K>::encode(*it));
581 p_->invalidate(skeys.begin(), skeys.end());
584 template <
typename K,
typename V,
typename M>
590 template <
typename K,
typename V,
typename M>
596 template <
typename K,
typename V,
typename M>
599 return p_->touch(CacheCodec<K>::encode(key), expiry_time);
602 template <
typename K,
typename V,
typename M>
608 template <
typename K,
typename V,
typename M>
611 p_->resize(size_in_bytes);
614 template <
typename K,
typename V,
typename M>
617 p_->trim_to(used_size_in_bytes);
620 template <
typename K,
typename V,
typename M>
626 template <
typename K,
typename V,
typename M>
629 auto scb = [cb](std::string
const& key,
CacheEvent ev, PersistentCacheStats
const& c)
631 cb(CacheCodec<K>::decode(key), ev, c);
633 p_->set_handler(events, scb);
648 template <
typename V,
typename M>
649 class PersistentCache<
std::string, V, M>
652 typedef std::unique_ptr<PersistentCache<std::string, V, M>>
UPtr;
674 static UPtr
open(std::string
const& cache_path);
676 OptionalValue
get(std::string
const& key)
const;
677 OptionalData
get_data(std::string
const& key)
const;
678 OptionalMetadata
get_metadata(std::string
const& key)
const;
680 int64_t
size() const noexcept;
681 int64_t size_in_bytes() const noexcept;
682 int64_t max_size_in_bytes() const noexcept;
685 PersistentCacheStats
stats() const;
687 bool put(
std::
string const& key,
689 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
690 bool put(
std::
string const& key,
693 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
697 OptionalValue
get_or_put(
std::
string const& key, Loader const& load_func);
701 OptionalValue
take(
std::
string const& key);
705 template <typename It>
710 std::
string const& key,
711 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
713 void resize(int64_t size_in_bytes);
714 void trim_to(int64_t used_size_in_bytes);
725 std::unique_ptr<PersistentStringCache> p_;
728 template <typename V, typename M>
730 int64_t max_size_in_bytes,
732 : p_(PersistentStringCache::
open(cache_path, max_size_in_bytes, policy))
736 template <
typename V,
typename M>
738 : p_(PersistentStringCache::
open(cache_path))
742 template <
typename V,
typename M>
747 new PersistentCache<std::string, V, M>(cache_path, max_size_in_bytes, policy));
750 template <
typename V,
typename M>
752 std::string
const& cache_path)
757 template <
typename V,
typename M>
759 std::string
const& key)
const
761 auto const& svalue = p_->get(key);
762 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
765 template <
typename V,
typename M>
767 std::string
const& key)
const
769 auto sdata = p_->get_data(key);
772 return OptionalData();
777 template <
typename V,
typename M>
779 std::string
const& key)
const
781 auto smeta = p_->get_metadata(key);
782 return smeta ? OptionalMetadata(CacheCodec<M>::decode(*smeta)) : OptionalMetadata();
785 template <
typename V,
typename M>
788 return p_->contains_key(key);
791 template <
typename V,
typename M>
797 template <
typename V,
typename M>
800 return p_->size_in_bytes();
803 template <
typename V,
typename M>
806 return p_->max_size_in_bytes();
809 template <
typename V,
typename M>
812 return p_->disk_size_in_bytes();
815 template <
typename V,
typename M>
818 return p_->discard_policy();
821 template <
typename V,
typename M>
827 template <
typename V,
typename M>
830 std::chrono::time_point<std::chrono::system_clock> expiry_time)
832 return p_->put(key, CacheCodec<V>::encode(value), expiry_time);
835 template <
typename V,
typename M>
839 std::chrono::time_point<std::chrono::system_clock> expiry_time)
841 return p_->put(key, CacheCodec<V>::encode(value), CacheCodec<M>::encode(metadata), expiry_time);
844 template <
typename V,
typename M>
846 std::string
const& key, PersistentCache<std::string, V, M>::Loader
const& load_func)
848 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
850 load_func(key, *
this);
852 auto svalue = p_->get_or_put(key, sload_func);
853 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
856 template <
typename V,
typename M>
858 std::string
const& key, PersistentCache<std::string, V, M>::Loader
const& load_func)
860 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
862 load_func(key, *
this);
864 auto sdata = p_->get_or_put_data(key, sload_func);
867 return OptionalData();
872 template <
typename V,
typename M>
875 return p_->put_metadata(key, CacheCodec<M>::encode(metadata));
878 template <
typename V,
typename M>
880 std::string
const& key)
882 auto svalue = p_->take(key);
883 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
886 template <
typename V,
typename M>
888 std::string
const& key)
890 auto sdata = p_->take_data(key);
893 return OptionalData();
898 template <
typename V,
typename M>
901 return p_->invalidate(key);
904 template <
typename V,
typename M>
910 template <
typename V,
typename M>
911 template <
typename It>
914 std::vector<std::string> skeys;
915 for (
auto&& it = begin; it < end; ++it)
917 skeys.push_back(*it);
919 p_->invalidate(skeys.begin(), skeys.end());
922 template <
typename V,
typename M>
928 template <
typename V,
typename M>
934 template <
typename V,
typename M>
936 std::chrono::time_point<std::chrono::system_clock> expiry_time)
938 return p_->touch(key, expiry_time);
941 template <
typename V,
typename M>
947 template <
typename V,
typename M>
950 p_->resize(size_in_bytes);
953 template <
typename V,
typename M>
956 p_->trim_to(used_size_in_bytes);
959 template <
typename V,
typename M>
965 template <
typename V,
typename M>
968 p_->set_handler(events, cb);
973 template <
typename K,
typename M>
974 class PersistentCache<K,
std::string, M>
977 typedef std::unique_ptr<PersistentCache<K, std::string, M>>
UPtr;
999 static UPtr
open(std::string
const& cache_path);
1001 OptionalValue
get(K
const& key)
const;
1002 OptionalData
get_data(K
const& key)
const;
1005 int64_t
size() const noexcept;
1006 int64_t size_in_bytes() const noexcept;
1007 int64_t max_size_in_bytes() const noexcept;
1010 PersistentCacheStats
stats() const;
1012 bool put(K const& key,
1013 std::
string const& value,
1014 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1015 bool put(K const& key,
1018 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1019 bool put(K const& key,
1020 std::
string const& value,
1022 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1023 bool put(K const& key,
1027 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1031 OptionalValue
get_or_put(K const& key, Loader const& load_func);
1035 OptionalValue
take(K const& key);
1039 template <typename It>
1045 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1047 void resize(int64_t size_in_bytes);
1048 void trim_to(int64_t used_size_in_bytes);
1059 std::unique_ptr<PersistentStringCache> p_;
1062 template <typename K, typename M>
1064 int64_t max_size_in_bytes,
1066 : p_(PersistentStringCache::
open(cache_path, max_size_in_bytes, policy))
1070 template <
typename K,
typename M>
1072 : p_(PersistentStringCache::
open(cache_path))
1076 template <
typename K,
typename M>
1081 new PersistentCache<K, std::string, M>(cache_path, max_size_in_bytes, policy));
1084 template <
typename K,
typename M>
1086 std::string
const& cache_path)
1091 template <
typename K,
typename M>
1094 auto const& svalue = p_->get(CacheCodec<K>::encode(key));
1095 return svalue ? OptionalValue(*svalue) : OptionalValue();
1098 template <
typename K,
typename M>
1102 auto sdata = p_->get_data(CacheCodec<K>::encode(key));
1105 return OptionalData();
1110 template <
typename K,
typename M>
1114 auto smeta = p_->get_metadata(CacheCodec<K>::encode(key));
1115 return smeta ? OptionalMetadata(CacheCodec<M>::decode(*smeta)) : OptionalMetadata();
1118 template <
typename K,
typename M>
1121 return p_->contains_key(CacheCodec<K>::encode(key));
1124 template <
typename K,
typename M>
1130 template <
typename K,
typename M>
1133 return p_->size_in_bytes();
1136 template <
typename K,
typename M>
1139 return p_->max_size_in_bytes();
1142 template <
typename K,
typename M>
1145 return p_->disk_size_in_bytes();
1148 template <
typename K,
typename M>
1151 return p_->discard_policy();
1154 template <
typename K,
typename M>
1160 template <
typename K,
typename M>
1162 std::string
const& value,
1163 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1165 return p_->put(CacheCodec<K>::encode(key), value, expiry_time);
1168 template <
typename K,
typename M>
1172 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1174 return p_->put(CacheCodec<K>::encode(key), value, size, expiry_time);
1177 template <
typename K,
typename M>
1179 std::string
const& value,
1181 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1183 return p_->put(CacheCodec<K>::encode(key), value, CacheCodec<M>::encode(metadata), expiry_time);
1186 template <
typename K,
typename M>
1191 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1194 return p_->put(CacheCodec<K>::encode(key), value, size, md.data(), md.size(), expiry_time);
1197 template <
typename K,
typename M>
1199 K
const& key, PersistentCache<K, std::string, M>::Loader
const& load_func)
1202 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
1204 load_func(key, *
this);
1206 auto svalue = p_->get_or_put(skey, sload_func);
1207 return svalue ? OptionalValue(*svalue) : OptionalValue();
1210 template <
typename K,
typename M>
1212 K
const& key, PersistentCache<K, std::string, M>::Loader
const& load_func)
1215 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
1217 load_func(key, *
this);
1219 auto sdata = p_->get_or_put_data(skey, sload_func);
1222 return OptionalData();
1227 template <
typename K,
typename M>
1230 return p_->put_metadata(CacheCodec<K>::encode(key), CacheCodec<M>::encode(metadata));
1233 template <
typename K,
typename M>
1236 auto svalue = p_->take(CacheCodec<K>::encode(key));
1237 return svalue ? OptionalValue(*svalue) : OptionalValue();
1240 template <
typename K,
typename M>
1244 auto sdata = p_->take_data(CacheCodec<K>::encode(key));
1247 return OptionalData();
1252 template <
typename K,
typename M>
1255 return p_->invalidate(CacheCodec<K>::encode(key));
1258 template <
typename K,
typename M>
1264 template <
typename K,
typename M>
1265 template <
typename It>
1268 std::vector<std::string> skeys;
1269 for (
auto&& it = begin; it < end; ++it)
1271 skeys.push_back(CacheCodec<K>::encode(*it));
1273 p_->invalidate(skeys.begin(), skeys.end());
1276 template <
typename K,
typename M>
1282 template <
typename K,
typename M>
1288 template <
typename K,
typename M>
1290 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1292 return p_->touch(CacheCodec<K>::encode(key), expiry_time);
1295 template <
typename K,
typename M>
1301 template <
typename K,
typename M>
1304 p_->resize(size_in_bytes);
1307 template <
typename K,
typename M>
1310 p_->trim_to(used_size_in_bytes);
1313 template <
typename K,
typename M>
1319 template <
typename K,
typename M>
1322 auto scb = [cb](std::string
const& key,
CacheEvent ev, PersistentCacheStats
const& c)
1324 cb(CacheCodec<K>::decode(key), ev, c);
1326 p_->set_handler(events, scb);
1331 template <
typename K,
typename V>
1332 class PersistentCache<K, V,
std::string>
1335 typedef std::unique_ptr<PersistentCache<K, V, std::string>>
UPtr;
1357 static UPtr
open(std::string
const& cache_path);
1359 OptionalValue
get(K
const& key)
const;
1360 OptionalData
get_data(K
const& key)
const;
1363 int64_t
size() const noexcept;
1364 int64_t size_in_bytes() const noexcept;
1365 int64_t max_size_in_bytes() const noexcept;
1368 PersistentCacheStats
stats() const;
1370 bool put(K const& key,
1372 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1373 bool put(K const& key,
1375 std::
string const& metadata,
1376 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1377 bool put(K const& key,
1379 char const* metadata,
1381 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1385 OptionalValue
get_or_put(K const& key, Loader const& load_func);
1389 bool put_metadata(K const& key,
char const* metadata, int64_t size);
1390 OptionalValue
take(K const& key);
1394 template <typename It>
1400 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1402 void resize(int64_t size_in_bytes);
1403 void trim_to(int64_t used_size_in_bytes);
1414 std::unique_ptr<PersistentStringCache> p_;
1417 template <typename K, typename V>
1419 int64_t max_size_in_bytes,
1421 : p_(PersistentStringCache::
open(cache_path, max_size_in_bytes, policy))
1425 template <
typename K,
typename V>
1427 : p_(PersistentStringCache::
open(cache_path))
1431 template <
typename K,
typename V>
1436 new PersistentCache<K, V, std::string>(cache_path, max_size_in_bytes, policy));
1439 template <
typename K,
typename V>
1441 std::string
const& cache_path)
1446 template <
typename K,
typename V>
1449 auto const& svalue = p_->get(CacheCodec<K>::encode(key));
1450 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
1453 template <
typename K,
typename V>
1457 auto sdata = p_->get_data(CacheCodec<K>::encode(key));
1460 return OptionalData();
1465 template <
typename K,
typename V>
1469 auto smeta = p_->get_metadata(CacheCodec<K>::encode(key));
1470 return smeta ? OptionalMetadata(*smeta) : OptionalMetadata();
1473 template <
typename K,
typename V>
1476 return p_->contains_key(CacheCodec<K>::encode(key));
1479 template <
typename K,
typename V>
1485 template <
typename K,
typename V>
1488 return p_->size_in_bytes();
1491 template <
typename K,
typename V>
1494 return p_->max_size_in_bytes();
1497 template <
typename K,
typename V>
1500 return p_->disk_size_in_bytes();
1503 template <
typename K,
typename V>
1506 return p_->discard_policy();
1509 template <
typename K,
typename V>
1515 template <
typename K,
typename V>
1518 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1520 return p_->put(CacheCodec<K>::encode(key), CacheCodec<V>::encode(value), expiry_time);
1523 template <
typename K,
typename V>
1526 std::string
const& metadata,
1527 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1530 return p_->put(CacheCodec<K>::encode(key), v.data(), v.size(), metadata.data(), metadata.size(), expiry_time);
1533 template <
typename K,
typename V>
1536 char const* metadata,
1538 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1541 return p_->put(CacheCodec<K>::encode(key), v.data(), v.size(), metadata, size, expiry_time);
1544 template <
typename K,
typename V>
1546 K
const& key, PersistentCache<K, V, std::string>::Loader
const& load_func)
1549 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
1551 load_func(key, *
this);
1553 auto svalue = p_->get_or_put(skey, sload_func);
1554 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
1557 template <
typename K,
typename V>
1559 K
const& key, PersistentCache<K, V, std::string>::Loader
const& load_func)
1562 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
1564 load_func(key, *
this);
1566 auto sdata = p_->get_or_put_data(skey, sload_func);
1569 return OptionalData();
1574 template <
typename K,
typename V>
1577 return p_->put_metadata(CacheCodec<K>::encode(key), metadata);
1580 template <
typename K,
typename V>
1583 return p_->put_metadata(CacheCodec<K>::encode(key), metadata, size);
1586 template <
typename K,
typename V>
1589 auto svalue = p_->take(CacheCodec<K>::encode(key));
1590 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
1593 template <
typename K,
typename V>
1597 auto sdata = p_->take_data(CacheCodec<K>::encode(key));
1600 return OptionalData();
1605 template <
typename K,
typename V>
1608 return p_->invalidate(CacheCodec<K>::encode(key));
1611 template <
typename K,
typename V>
1617 template <
typename K,
typename V>
1618 template <
typename It>
1621 std::vector<std::string> skeys;
1622 for (
auto&& it = begin; it < end; ++it)
1624 skeys.push_back(CacheCodec<K>::encode(*it));
1626 p_->invalidate(skeys.begin(), skeys.end());
1629 template <
typename K,
typename V>
1635 template <
typename K,
typename V>
1641 template <
typename K,
typename V>
1643 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1645 return p_->touch(CacheCodec<K>::encode(key), expiry_time);
1648 template <
typename K,
typename V>
1654 template <
typename K,
typename V>
1657 p_->resize(size_in_bytes);
1660 template <
typename K,
typename V>
1663 p_->trim_to(used_size_in_bytes);
1666 template <
typename K,
typename V>
1672 template <
typename K,
typename V>
1675 auto scb = [cb](std::string
const& key,
CacheEvent ev, PersistentCacheStats
const& c)
1677 cb(CacheCodec<K>::decode(key), ev, c);
1679 p_->set_handler(events, scb);
1684 template <
typename M>
1685 class PersistentCache<
std::string, std::string, M>
1688 typedef std::unique_ptr<PersistentCache<std::string, std::string, M>>
UPtr;
1710 static UPtr
open(std::string
const& cache_path);
1712 OptionalValue
get(std::string
const& key)
const;
1713 OptionalData
get_data(std::string
const& key)
const;
1714 OptionalMetadata
get_metadata(std::string
const& key)
const;
1716 int64_t
size() const noexcept;
1717 int64_t size_in_bytes() const noexcept;
1718 int64_t max_size_in_bytes() const noexcept;
1721 PersistentCacheStats
stats() const;
1723 bool put(
std::
string const& key,
1724 std::
string const& value,
1725 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1726 bool put(
std::
string const& key,
1729 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1730 bool put(
std::
string const& key,
1731 std::
string const& value,
1733 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1734 bool put(
std::
string const& key,
1738 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1742 OptionalValue
get_or_put(
std::
string const& key, Loader const& load_func);
1746 OptionalValue
take(
std::
string const& key);
1750 template <typename It>
1755 std::
string const& key,
1756 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
1758 void resize(int64_t size_in_bytes);
1759 void trim_to(int64_t used_size_in_bytes);
1770 std::unique_ptr<PersistentStringCache> p_;
1773 template <typename M>
1775 int64_t max_size_in_bytes,
1777 : p_(PersistentStringCache::
open(cache_path, max_size_in_bytes, policy))
1781 template <
typename M>
1783 : p_(PersistentStringCache::
open(cache_path))
1787 template <
typename M>
1792 new PersistentCache<std::string, std::string, M>(cache_path, max_size_in_bytes, policy));
1795 template <
typename M>
1797 std::string
const& cache_path)
1800 new PersistentCache<std::string, std::string, M>(cache_path));
1803 template <
typename M>
1805 std::string
const& key)
const
1807 auto const& svalue = p_->get(key);
1808 return svalue ? OptionalValue(*svalue) : OptionalValue();
1811 template <
typename M>
1812 typename PersistentCache<std::string, std::string, M>::OptionalData
1815 auto sdata = p_->get_data(key);
1818 return OptionalData();
1823 template <
typename M>
1824 typename PersistentCache<std::string, std::string, M>::OptionalMetadata
1827 auto smeta = p_->get_metadata(key);
1828 return smeta ? OptionalMetadata(CacheCodec<M>::decode(*smeta)) : OptionalMetadata();
1831 template <
typename M>
1834 return p_->contains_key(key);
1837 template <
typename M>
1843 template <
typename M>
1846 return p_->size_in_bytes();
1849 template <
typename M>
1852 return p_->max_size_in_bytes();
1855 template <
typename M>
1858 return p_->disk_size_in_bytes();
1861 template <
typename M>
1864 return p_->discard_policy();
1867 template <
typename M>
1873 template <
typename M>
1875 std::string
const& value,
1876 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1878 return p_->put(key, value, expiry_time);
1881 template <
typename M>
1885 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1887 return p_->put(key, value, size,
nullptr, 0, expiry_time);
1890 template <
typename M>
1892 std::string
const& value,
1894 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1896 return p_->put(key, value, CacheCodec<M>::encode(metadata), expiry_time);
1899 template <
typename M>
1904 std::chrono::time_point<std::chrono::system_clock> expiry_time)
1907 return p_->put(key, value, size, md.data(), md.size(), expiry_time);
1910 template <
typename M>
1911 typename PersistentCache<std::string, std::string, M>::OptionalValue
1913 std::string
const& key, PersistentCache<std::string, std::string, M>::Loader
const& load_func)
1915 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
1917 load_func(key, *
this);
1919 auto svalue = p_->get_or_put(key, sload_func);
1920 return svalue ? OptionalValue(*svalue) : OptionalValue();
1923 template <
typename M>
1924 typename PersistentCache<std::string, std::string, M>::OptionalData
1926 std::string
const& key, PersistentCache<std::string, std::string, M>::Loader
const& load_func)
1928 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
1930 load_func(key, *
this);
1932 auto sdata = p_->get_or_put_data(key, sload_func);
1935 return OptionalData();
1940 template <
typename M>
1943 return p_->put_metadata(key, CacheCodec<M>::encode(metadata));
1946 template <
typename M>
1948 std::string
const& key)
1950 auto svalue = p_->take(key);
1951 return svalue ? OptionalValue(*svalue) : OptionalValue();
1954 template <
typename M>
1955 typename PersistentCache<std::string, std::string, M>::OptionalData
1958 auto sdata = p_->take_data(key);
1961 return OptionalData();
1966 template <
typename M>
1969 return p_->invalidate(key);
1972 template <
typename M>
1978 template <
typename M>
1979 template <
typename It>
1982 std::vector<std::string> skeys;
1983 for (
auto&& it = begin; it < end; ++it)
1985 skeys.push_back(*it);
1987 p_->invalidate(skeys.begin(), skeys.end());
1990 template <
typename M>
1996 template <
typename M>
2002 template <
typename M>
2004 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2006 return p_->touch(key, expiry_time);
2009 template <
typename M>
2015 template <
typename M>
2018 p_->resize(size_in_bytes);
2021 template <
typename M>
2024 p_->trim_to(used_size_in_bytes);
2027 template <
typename M>
2033 template <
typename M>
2036 p_->set_handler(events, cb);
2041 template <
typename V>
2042 class PersistentCache<
std::string, V, std::string>
2045 typedef std::unique_ptr<PersistentCache<std::string, V, std::string>>
UPtr;
2067 static UPtr
open(std::string
const& cache_path);
2069 OptionalValue
get(std::string
const& key)
const;
2070 OptionalData
get_data(std::string
const& key)
const;
2071 OptionalMetadata
get_metadata(std::string
const& key)
const;
2073 int64_t
size() const noexcept;
2074 int64_t size_in_bytes() const noexcept;
2075 int64_t max_size_in_bytes() const noexcept;
2078 PersistentCacheStats
stats() const;
2080 bool put(
std::
string const& key,
2082 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2083 bool put(
std::
string const& key,
2085 std::
string const& metadata,
2086 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2087 bool put(
std::
string const& key,
2089 char const* metadata,
2091 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2095 OptionalValue
get_or_put(
std::
string const& key, Loader const& load_func);
2099 bool put_metadata(
std::
string const& key,
char const* metadata, int64_t size);
2100 OptionalValue
take(
std::
string const& key);
2104 template <typename It>
2109 std::
string const& key,
2110 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2112 void resize(int64_t size_in_bytes);
2113 void trim_to(int64_t used_size_in_bytes);
2124 std::unique_ptr<PersistentStringCache> p_;
2127 template <typename V>
2129 int64_t max_size_in_bytes,
2131 : p_(PersistentStringCache::
open(cache_path, max_size_in_bytes, policy))
2135 template <
typename V>
2137 : p_(PersistentStringCache::
open(cache_path))
2141 template <
typename V>
2146 new PersistentCache<std::string, V, std::string>(cache_path, max_size_in_bytes, policy));
2149 template <
typename V>
2151 std::string
const& cache_path)
2154 new PersistentCache<std::string, V, std::string>(cache_path));
2157 template <
typename V>
2159 std::string
const& key)
const
2161 auto const& svalue = p_->get(key);
2162 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
2165 template <
typename V>
2166 typename PersistentCache<std::string, V, std::string>::OptionalData
2169 auto sdata = p_->get_data(key);
2172 return OptionalData();
2177 template <
typename V>
2178 typename PersistentCache<std::string, V, std::string>::OptionalMetadata
2181 auto smeta = p_->get_metadata(key);
2182 return smeta ? OptionalMetadata(*smeta) : OptionalMetadata();
2185 template <
typename V>
2188 return p_->contains_key(key);
2191 template <
typename V>
2197 template <
typename V>
2200 return p_->size_in_bytes();
2203 template <
typename V>
2206 return p_->max_size_in_bytes();
2209 template <
typename V>
2212 return p_->disk_size_in_bytes();
2215 template <
typename V>
2218 return p_->discard_policy();
2221 template <
typename V>
2227 template <
typename V>
2230 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2232 return p_->put(key, CacheCodec<V>::encode(value), expiry_time);
2235 template <
typename V>
2238 std::string
const& metadata,
2239 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2242 return p_->put(key, v.data(), v.size(), metadata.data(), metadata.size(), expiry_time);
2245 template <
typename V>
2248 char const* metadata,
2250 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2253 return p_->put(key, v.data(), v.size(), metadata, size, expiry_time);
2256 template <
typename V>
2257 typename PersistentCache<std::string, V, std::string>::OptionalValue
2259 std::string
const& key, PersistentCache<std::string, V, std::string>::Loader
const& load_func)
2261 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
2263 load_func(key, *
this);
2265 auto svalue = p_->get_or_put(key, sload_func);
2266 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
2269 template <
typename V>
2270 typename PersistentCache<std::string, V, std::string>::OptionalData
2272 std::string
const& key, PersistentCache<std::string, V, std::string>::Loader
const& load_func)
2274 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
2276 load_func(key, *
this);
2278 auto sdata = p_->get_or_put_data(key, sload_func);
2281 return OptionalData();
2286 template <
typename V>
2289 return p_->put_metadata(key, metadata);
2292 template <
typename V>
2294 char const* metadata,
2297 return p_->put_metadata(key, metadata, size);
2300 template <
typename V>
2302 std::string
const& key)
2304 auto svalue = p_->take(key);
2305 return svalue ? OptionalValue(CacheCodec<V>::decode(*svalue)) : OptionalValue();
2308 template <
typename V>
2309 typename PersistentCache<std::string, V, std::string>::OptionalData
2312 auto sdata = p_->take_data(key);
2315 return OptionalData();
2320 template <
typename V>
2323 return p_->invalidate(key);
2326 template <
typename V>
2332 template <
typename V>
2333 template <
typename It>
2336 std::vector<std::string> skeys;
2337 for (
auto&& it = begin; it < end; ++it)
2339 skeys.push_back(*it);
2341 p_->invalidate(skeys.begin(), skeys.end());
2344 template <
typename V>
2350 template <
typename V>
2356 template <
typename V>
2358 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2360 return p_->touch(key, expiry_time);
2363 template <
typename V>
2369 template <
typename V>
2372 p_->resize(size_in_bytes);
2375 template <
typename V>
2378 p_->trim_to(used_size_in_bytes);
2381 template <
typename V>
2387 template <
typename V>
2390 p_->set_handler(events, cb);
2395 template <
typename K>
2396 class PersistentCache<K,
std::string, std::string>
2399 typedef std::unique_ptr<PersistentCache<K, std::string, std::string>>
UPtr;
2421 static UPtr
open(std::string
const& cache_path);
2423 OptionalValue
get(K
const& key)
const;
2424 OptionalData
get_data(K
const& key)
const;
2427 int64_t
size() const noexcept;
2428 int64_t size_in_bytes() const noexcept;
2429 int64_t max_size_in_bytes() const noexcept;
2432 PersistentCacheStats
stats() const;
2434 bool put(K const& key,
2435 std::
string const& value,
2436 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2437 bool put(K const& key,
2440 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2441 bool put(K const& key,
2442 std::
string const& value,
2443 std::
string const& metadata,
2444 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2445 bool put(K const& key,
2448 char const* metadata,
2449 int64_t metadata_size,
2450 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2454 OptionalValue
get_or_put(K const& key, Loader const& load_func);
2458 bool put_metadata(K const& key,
char const* metadata, int64_t size);
2459 OptionalValue
take(K const& key);
2463 template <typename It>
2469 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2471 void resize(int64_t size_in_bytes);
2472 void trim_to(int64_t used_size_in_bytes);
2483 std::unique_ptr<PersistentStringCache> p_;
2486 template <typename K>
2488 int64_t max_size_in_bytes,
2490 : p_(PersistentStringCache::
open(cache_path, max_size_in_bytes, policy))
2494 template <
typename K>
2496 : p_(PersistentStringCache::
open(cache_path))
2500 template <
typename K>
2505 new PersistentCache<K, std::string, std::string>(cache_path, max_size_in_bytes, policy));
2508 template <
typename K>
2510 std::string
const& cache_path)
2513 new PersistentCache<K, std::string, std::string>(cache_path));
2516 template <
typename K>
2520 auto const& svalue = p_->get(CacheCodec<K>::encode(key));
2521 return svalue ? OptionalValue(*svalue) : OptionalValue();
2524 template <
typename K>
2525 typename PersistentCache<K, std::string, std::string>::OptionalData
2528 auto sdata = p_->get_data(CacheCodec<K>::encode(key));
2531 return OptionalData();
2533 return OptionalData({sdata->value, sdata->metadata});
2536 template <
typename K>
2537 typename PersistentCache<K, std::string, std::string>::OptionalMetadata
2540 auto smeta = p_->get_metadata(CacheCodec<K>::encode(key));
2541 return smeta ? OptionalMetadata(*smeta) : OptionalMetadata();
2544 template <
typename K>
2547 return p_->contains_key(CacheCodec<K>::encode(key));
2550 template <
typename K>
2556 template <
typename K>
2559 return p_->size_in_bytes();
2562 template <
typename K>
2565 return p_->max_size_in_bytes();
2568 template <
typename K>
2571 return p_->disk_size_in_bytes();
2574 template <
typename K>
2577 return p_->discard_policy();
2580 template <
typename K>
2586 template <
typename K>
2588 std::string
const& value,
2589 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2591 return p_->put(CacheCodec<K>::encode(key), value, expiry_time);
2594 template <
typename K>
2598 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2600 return p_->put(CacheCodec<K>::encode(key), value, size, expiry_time);
2603 template <
typename K>
2605 std::string
const& value,
2606 std::string
const& metadata,
2607 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2609 return p_->put(CacheCodec<K>::encode(key), value, metadata, expiry_time);
2612 template <
typename K>
2616 char const* metadata,
2617 int64_t metadata_size,
2618 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2620 return p_->put(CacheCodec<K>::encode(key), value, value_size, metadata, metadata_size, expiry_time);
2623 template <
typename K>
2624 typename PersistentCache<K, std::string, std::string>::OptionalValue
2626 K
const& key, PersistentCache<K, std::string, std::string>::Loader
const& load_func)
2629 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
2631 load_func(key, *
this);
2633 auto svalue = p_->get_or_put(skey, sload_func);
2634 return svalue ? OptionalValue(*svalue) : OptionalValue();
2637 template <
typename K>
2638 typename PersistentCache<K, std::string, std::string>::OptionalData
2640 K
const& key, PersistentCache<K, std::string, std::string>::Loader
const& load_func)
2643 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
2645 load_func(key, *
this);
2647 auto sdata = p_->get_or_put_data(skey, sload_func);
2650 return OptionalData();
2652 return OptionalData({sdata->value, sdata->metadata});
2655 template <
typename K>
2658 return p_->put_metadata(CacheCodec<K>::encode(key), metadata);
2661 template <
typename K>
2664 return p_->put_metadata(CacheCodec<K>::encode(key), metadata, size);
2667 template <
typename K>
2671 auto svalue = p_->take(CacheCodec<K>::encode(key));
2672 return svalue ? OptionalValue(*svalue) : OptionalValue();
2675 template <
typename K>
2676 typename PersistentCache<K, std::string, std::string>::OptionalData
2679 auto sdata = p_->take_data(CacheCodec<K>::encode(key));
2682 return OptionalData();
2684 return OptionalData({sdata->value, sdata->metadata});
2687 template <
typename K>
2690 return p_->invalidate(CacheCodec<K>::encode(key));
2693 template <
typename K>
2699 template <
typename K>
2700 template <
typename It>
2703 std::vector<std::string> skeys;
2704 for (
auto&& it = begin; it < end; ++it)
2706 skeys.push_back(CacheCodec<K>::encode(*it));
2708 p_->invalidate(skeys.begin(), skeys.end());
2711 template <
typename K>
2717 template <
typename K>
2723 template <
typename K>
2725 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2727 return p_->touch(CacheCodec<K>::encode(key), expiry_time);
2730 template <
typename K>
2736 template <
typename K>
2739 p_->resize(size_in_bytes);
2742 template <
typename K>
2745 p_->trim_to(used_size_in_bytes);
2748 template <
typename K>
2754 template <
typename K>
2757 auto scb = [cb](std::string
const& key,
CacheEvent ev, PersistentCacheStats
const& c)
2759 cb(CacheCodec<K>::decode(key), ev, c);
2761 p_->set_handler(events, scb);
2767 class PersistentCache<
std::string, std::string, std::string>
2770 typedef std::unique_ptr<PersistentCache<std::string, std::string, std::string>>
UPtr;
2792 static UPtr
open(std::string
const& cache_path);
2794 OptionalValue
get(std::string
const& key)
const;
2795 OptionalData
get_data(std::string
const& key)
const;
2796 OptionalMetadata
get_metadata(std::string
const& key)
const;
2798 int64_t
size() const noexcept;
2799 int64_t size_in_bytes() const noexcept;
2800 int64_t max_size_in_bytes() const noexcept;
2803 PersistentCacheStats
stats() const;
2805 bool put(
std::
string const& key,
2806 std::
string const& value,
2807 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2808 bool put(
std::
string const& key,
2811 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2812 bool put(
std::
string const& key,
2813 std::
string const& value,
2814 std::
string const& metadata,
2815 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2816 bool put(
std::
string const& key,
2819 char const* metadata,
2820 int64_t metadata_size,
2821 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2826 OptionalValue
get_or_put(
std::
string const& key, Loader const& load_func);
2830 bool put_metadata(
std::
string const& key,
char const* metadata, int64_t size);
2831 OptionalValue
take(
std::
string const& key);
2835 template <typename It>
2840 std::
string const& key,
2841 std::chrono::time_point<
std::chrono::system_clock> expiry_time =
std::chrono::system_clock::time_point());
2843 void resize(int64_t size_in_bytes);
2844 void trim_to(int64_t used_size_in_bytes);
2855 std::unique_ptr<PersistentStringCache> p_;
2859 int64_t max_size_in_bytes,
2861 : p_(PersistentStringCache::
open(cache_path, max_size_in_bytes, policy))
2866 : p_(PersistentStringCache::
open(cache_path))
2870 typename PersistentCache<std::string, std::string, std::string>::UPtr
2872 int64_t max_size_in_bytes,
2876 new PersistentCache<std::string, std::string, std::string>(cache_path, max_size_in_bytes, policy));
2879 typename PersistentCache<std::string, std::string, std::string>::UPtr
2883 new PersistentCache<std::string, std::string, std::string>(cache_path));
2886 typename PersistentCache<std::string, std::string, std::string>::OptionalValue
2889 auto const& svalue = p_->get(key);
2890 return svalue ? OptionalValue(*svalue) : OptionalValue();
2893 typename PersistentCache<std::string, std::string, std::string>::OptionalData
2896 auto sdata = p_->get_data(key);
2899 return OptionalData();
2901 return OptionalData({sdata->value, sdata->metadata});
2904 typename PersistentCache<std::string, std::string, std::string>::OptionalMetadata
2907 auto smeta = p_->get_metadata(key);
2908 return smeta ? OptionalMetadata(*smeta) : OptionalMetadata();
2913 return p_->contains_key(key);
2923 return p_->size_in_bytes();
2928 return p_->max_size_in_bytes();
2933 return p_->disk_size_in_bytes();
2938 return p_->discard_policy();
2947 std::string
const& key, std::string
const& value, std::chrono::time_point<std::chrono::system_clock> expiry_time)
2949 return p_->put(key, value, expiry_time);
2953 std::string
const& key,
2956 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2958 return p_->put(key, value, size, expiry_time);
2962 std::string
const& key,
2963 std::string
const& value,
2964 std::string
const& metadata,
2965 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2967 return p_->put(key, value, metadata, expiry_time);
2971 std::string
const& key,
2974 char const* metadata,
2975 int64_t metadata_size,
2976 std::chrono::time_point<std::chrono::system_clock> expiry_time)
2978 return p_->put(key, value, value_size, metadata, metadata_size, expiry_time);
2981 typename PersistentCache<std::string, std::string, std::string>::OptionalValue
2983 std::string
const& key, PersistentCache<std::string, std::string, std::string>::Loader
const& load_func)
2985 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
2987 load_func(key, *
this);
2989 auto svalue = p_->get_or_put(key, sload_func);
2990 return svalue ? OptionalValue(*svalue) : OptionalValue();
2993 typename PersistentCache<std::string, std::string, std::string>::OptionalData
2995 std::string
const& key, PersistentCache<std::string, std::string, std::string>::Loader
const& load_func)
2997 auto sload_func = [&](std::string
const&, PersistentStringCache
const&)
2999 load_func(key, *
this);
3001 auto sdata = p_->get_or_put_data(key, sload_func);
3004 return OptionalData();
3006 return OptionalData({sdata->value, sdata->metadata});
3010 std::string
const& metadata)
3012 return p_->put_metadata(key, metadata);
3016 char const* metadata,
3019 return p_->put_metadata(key, metadata, size);
3022 typename PersistentCache<std::string, std::string, std::string>::OptionalValue
3025 auto svalue = p_->take(key);
3026 return svalue ? OptionalValue(*svalue) : OptionalValue();
3029 typename PersistentCache<std::string, std::string, std::string>::OptionalData
3032 auto sdata = p_->take_data(key);
3035 return OptionalData();
3037 return OptionalData({sdata->value, sdata->metadata});
3042 return p_->invalidate(key);
3050 template <
typename It>
3053 std::vector<std::string> skeys;
3054 for (
auto&& it = begin; it < end; ++it)
3056 skeys.push_back(*it);
3058 p_->invalidate(skeys.begin(), skeys.end());
3072 std::string
const& key, std::chrono::time_point<std::chrono::system_clock> expiry_time)
3074 return p_->touch(key, expiry_time);
3084 p_->resize(size_in_bytes);
3089 p_->trim_to(used_size_in_bytes);
3099 p_->set_handler(events, cb);
Simple pair of value and metadata.
Definition: persistent_cache.h:129
int64_t disk_size_in_bytes() const
Returns an estimate of the disk space consumed by the cache.
void trim_to(int64_t used_size_in_bytes)
Expires entries.
CacheEvent
Event types that can be monitored.
Definition: cache_events.h:38
bool touch(K const &key, std::chrono::time_point< std::chrono::system_clock > expiry_time=std::chrono::system_clock::time_point())
Updates the access time of an entry.
OptionalData get_data(K const &key) const
Returns the data for an entry in the cache, provided the entry has not expired.
Optional< V > OptionalValue
Definition: persistent_cache.h:156
Top-level namespace for core functionality.
Definition: persistent_cache_stats.h:27
A persistent cache of key-value pairs and metadata of user-defined type.
Definition: persistent_cache.h:118
static UPtr open(std::string const &cache_path, int64_t max_size_in_bytes, CacheDiscardPolicy policy)
Creates or opens a PersistentCache.
void resize(int64_t size_in_bytes)
Changes the maximum size of the cache.
M metadata
Stores the metadata of an entry. If no metadata exists for an entry, metadata is returned as the empt...
Definition: persistent_cache.h:140
Optional< M > OptionalMetadata
Definition: persistent_cache.h:157
int64_t size() const noexcept
Returns the number of entries in the cache.
bool put_metadata(K const &key, M const &metadata)
Adds or replaces the metadata for an entry. If M = std::string, an overload that accepts const char* ...
OptionalData get_or_put_data(K const &key, Loader const &load_func)
Atomically retrieves or stores a cache entry.
PersistentCache & operator=(PersistentCache const &)=delete
std::function< void(K const &key, CacheEvent ev, PersistentCacheStats const &stats)> EventCallback
The type of a handler function.
Definition: persistent_cache.h:371
A cache of key-value pairs with persistent storage.
Definition: persistent_string_cache.h:68
CacheDiscardPolicy discard_policy() const noexcept
Returns the discard policy of the cache.
std::function< void(K const &key, PersistentCache< K, V, M > &cache)> Loader
Function called by the cache to load an entry after a cache miss.
Definition: persistent_cache.h:280
An entry was removed by a call to invalidate(), take(), or take_data().
Optional< K > OptionalKey
Convenience typedefs for returning nullable values.
Definition: persistent_cache.h:155
V value
Stores the value of an entry.
Definition: persistent_cache.h:134
boost::optional< T > Optional
Convenience typedef for nullable values.
Definition: optional.h:33
void invalidate()
Deletes all entries from the cache.
int64_t max_size_in_bytes() const noexcept
Returns the maximum size of the cache in bytes.
bool contains_key(K const &key) const
Tests if an (unexpired) entry is in the cache.
OptionalValue take(K const &key)
Removes an entry and returns its value.
OptionalValue get_or_put(K const &key, Loader const &load_func)
Atomically retrieves or stores a cache entry.
Optional< Data > OptionalData
Definition: persistent_cache.h:158
int64_t size_in_bytes() const noexcept
Returns the number of bytes consumed by entries in the cache.
static std::string encode(T const &value)
Converts a value of custom type T into a string.
bool put(K const &key, V const &value, std::chrono::time_point< std::chrono::system_clock > expiry_time=std::chrono::system_clock::time_point())
Adds or updates an entry. If V = std::string, the method is also overloaded to to accept char const* ...
std::unique_ptr< PersistentCache< K, V, M > > UPtr
Definition: persistent_cache.h:124
static T decode(std::string const &s)
Converts a string into a value of custom type T.
OptionalData take_data(K const &key)
Removes an entry and returns its value and metadata.
void set_handler(CacheEvent events, EventCallback cb)
Installs a handler for one or more events.
OptionalValue get(K const &key) const
Returns the value of an entry in the cache, provided the entry has not expired.
PersistentCache(PersistentCache const &)=delete
~PersistentCache()=default
void clear_stats()
Resets all statistics counters.
CacheDiscardPolicy
Indicates the discard policy to make room for entries when the cache is full.
Definition: cache_discard_policy.h:35
OptionalMetadata get_metadata(K const &key) const
Returns the metadata for an entry in the cache, provided the entry has not expired.
void compact()
Compacts the database.
Class that provides (read-only) access to cache statistics and settings.
Definition: persistent_cache_stats.h:42
PersistentCacheStats stats() const
Returns statistics for the cache.