38 #ifndef LIBPMEMOBJ_CPP_PERSISTENT_PTR_HPP
39 #define LIBPMEMOBJ_CPP_PERSISTENT_PTR_HPP
50 #include "libpmemobj.h"
101 template <
typename T>
104 persistent_ptr() =
default;
134 typename pmem::detail::sp_dereference<T>::type
operator*() const
143 typename pmem::detail::sp_member_access<T>::type
operator->() const
154 template <typename = typename std::enable_if<!std::is_void<T>::value>>
155 typename pmem::detail::sp_array_access<T>::type
159 (i < pmem::detail::sp_extent<T>::value ||
160 pmem::detail::sp_extent<T>::value == 0) &&
161 "persistent array index out of bounds");
163 return this->
get()[i];
172 detail::conditional_add_to_tx(
this);
173 this->oid.off +=
sizeof(T);
184 PMEMoid noid = this->oid;
196 detail::conditional_add_to_tx(
this);
197 this->oid.off -=
sizeof(T);
208 PMEMoid noid = this->oid;
220 detail::conditional_add_to_tx(
this);
221 this->oid.off +=
static_cast<std::uint64_t
>(s) *
sizeof(T);
232 detail::conditional_add_to_tx(
this);
233 this->oid.off -=
static_cast<std::uint64_t
>(s) *
sizeof(T);
246 pop.
persist(this->
get(),
sizeof(T));
258 pmemobjpool *pop = pmemobj_pool_by_oid(this->
raw());
262 "persistent pointer");
264 pmemobj_persist(pop, this->
get(),
sizeof(T));
275 pop.
flush(this->
get(),
sizeof(T));
287 pmemobjpool *pop = pmemobj_pool_by_oid(this->
raw());
291 "persistent pointer");
293 pmemobj_flush(pop, this->
get(),
sizeof(T));
378 template <
typename T,
typename Y>
380 operator==(persistent_ptr<T>
const &lhs, persistent_ptr<Y>
const &rhs) noexcept
382 return OID_EQUALS(lhs.raw(), rhs.raw());
388 template <
typename T,
typename Y>
390 operator!=(persistent_ptr<T>
const &lhs, persistent_ptr<Y>
const &rhs) noexcept
392 return !(lhs == rhs);
398 template <
typename T>
400 operator==(persistent_ptr<T>
const &lhs, std::nullptr_t) noexcept
402 return lhs.get() ==
nullptr;
408 template <
typename T>
410 operator==(std::nullptr_t, persistent_ptr<T>
const &lhs) noexcept
412 return lhs.get() ==
nullptr;
418 template <
typename T>
420 operator!=(persistent_ptr<T>
const &lhs, std::nullptr_t) noexcept
422 return lhs.get() !=
nullptr;
428 template <
typename T>
430 operator!=(std::nullptr_t, persistent_ptr<T>
const &lhs) noexcept
432 return lhs.get() !=
nullptr;
442 template <
typename T,
typename Y>
444 operator<(persistent_ptr<T>
const &lhs, persistent_ptr<Y>
const &rhs) noexcept
446 if (lhs.raw().pool_uuid_lo == rhs.raw().pool_uuid_lo)
447 return lhs.raw().off < rhs.raw().off;
449 return lhs.raw().pool_uuid_lo < rhs.raw().pool_uuid_lo;
457 template <
typename T,
typename Y>
459 operator<=(persistent_ptr<T>
const &lhs, persistent_ptr<Y>
const &rhs) noexcept
469 template <
typename T,
typename Y>
471 operator>(persistent_ptr<T>
const &lhs, persistent_ptr<Y>
const &rhs) noexcept
481 template <
typename T,
typename Y>
483 operator>=(persistent_ptr<T>
const &lhs, persistent_ptr<Y>
const &rhs) noexcept
493 template <
typename T>
495 operator<(persistent_ptr<T>
const &lhs, std::nullptr_t) noexcept
497 return std::less<typename persistent_ptr<T>::element_type *>()(
504 template <
typename T>
506 operator<(std::nullptr_t, persistent_ptr<T>
const &rhs) noexcept
508 return std::less<typename persistent_ptr<T>::element_type *>()(
515 template <
typename T>
517 operator<=(persistent_ptr<T>
const &lhs, std::nullptr_t) noexcept
519 return !(
nullptr < lhs);
525 template <
typename T>
527 operator<=(std::nullptr_t, persistent_ptr<T>
const &rhs) noexcept
529 return !(rhs <
nullptr);
535 template <
typename T>
537 operator>(persistent_ptr<T>
const &lhs, std::nullptr_t) noexcept
539 return nullptr < lhs;
545 template <
typename T>
547 operator>(std::nullptr_t, persistent_ptr<T>
const &rhs) noexcept
549 return rhs <
nullptr;
555 template <
typename T>
557 operator>=(persistent_ptr<T>
const &lhs, std::nullptr_t) noexcept
559 return !(lhs <
nullptr);
565 template <
typename T>
567 operator>=(std::nullptr_t, persistent_ptr<T>
const &rhs) noexcept
569 return !(
nullptr < rhs);
575 template <
typename T>
576 inline persistent_ptr<T>
577 operator+(persistent_ptr<T>
const &lhs, std::ptrdiff_t s)
580 noid.pool_uuid_lo = lhs.raw().pool_uuid_lo;
581 noid.off = lhs.raw().off +
static_cast<std::uint64_t
>(s) *
sizeof(T);
583 return persistent_ptr<T>(noid);
589 template <
typename T>
590 inline persistent_ptr<T>
591 operator-(persistent_ptr<T>
const &lhs, std::ptrdiff_t s)
594 noid.pool_uuid_lo = lhs.raw().pool_uuid_lo;
595 noid.off = lhs.raw().off -
static_cast<std::uint64_t
>(s) *
sizeof(T);
597 return persistent_ptr<T>(noid);
607 template <
typename T,
typename Y,
608 typename =
typename std::enable_if<
609 std::is_same<typename std::remove_cv<T>::type,
610 typename std::remove_cv<Y>::type>::value>>
612 operator-(persistent_ptr<T>
const &lhs, persistent_ptr<Y>
const &rhs)
614 assert(lhs.raw().pool_uuid_lo == rhs.raw().pool_uuid_lo);
615 auto d =
static_cast<std::ptrdiff_t
>(lhs.raw().off - rhs.raw().off);
617 return d /
static_cast<std::ptrdiff_t
>(
sizeof(T));
623 template <
typename T>
625 operator<<(std::ostream &os, persistent_ptr<T>
const &pptr)
627 PMEMoid raw_oid = pptr.raw();
628 os << std::hex <<
"0x" << raw_oid.pool_uuid_lo <<
", 0x" << raw_oid.off
persistent_ptr< T > & operator++()
Prefix increment operator.
Definition: persistent_ptr.hpp:170
Persistent_ptr base class.
Definition: persistent_ptr_base.hpp:68
void persist(void)
Persists what the persistent pointer points to.
Definition: persistent_ptr.hpp:256
Helper template for persistent ptr specialization.
Persistent pointer class.
Definition: common.hpp:59
pmem::detail::sp_member_access< T >::type operator->() const noexcept
Member access operator.
Definition: persistent_ptr.hpp:143
The non-template pool base class.
Definition: pool.hpp:66
Custom pool error class.
Definition: pexceptions.hpp:53
persistent_ptr< T > & operator-=(std::ptrdiff_t s)
Subtraction assignment operator.
Definition: persistent_ptr.hpp:230
persistent_ptr(persistent_ptr< const void > const &rhs) noexcept
Explicit const void specialization of the converting constructor.
Definition: persistent_ptr.hpp:118
persistent_ptr< T > operator++(int)
Postfix increment operator.
Definition: persistent_ptr.hpp:182
void persist(pool_base &pop)
Persists the content of the underlying object.
Definition: persistent_ptr.hpp:244
bool bool_type
The used bool_type.
Definition: persistent_ptr.hpp:328
void flush(pool_base &pop)
Flushes what the persistent pointer points to.
Definition: persistent_ptr.hpp:273
PMEMobj pool class.
Definition: persistent_ptr.hpp:59
persistent_ptr< T > operator--(int)
Postfix decrement operator.
Definition: persistent_ptr.hpp:206
Commonly used functionality.
std::random_access_iterator_tag iterator_category
The persistent_ptr iterator category.
Definition: persistent_ptr.hpp:337
persistent_ptr< T > & operator--()
Prefix decrement operator.
Definition: persistent_ptr.hpp:194
persistent_ptr< T > & operator+=(std::ptrdiff_t s)
Addition assignment operator.
Definition: persistent_ptr.hpp:218
void flush(void)
Flushes what the persistent pointer points to.
Definition: persistent_ptr.hpp:285
void persist(const void *addr, size_t len) noexcept
Performs persist operation on a given chunk of memory.
Definition: pool.hpp:283
pmem::detail::sp_array_access< T >::type operator[](std::ptrdiff_t i) const noexcept
Array access operator.
Definition: persistent_ptr.hpp:156
static persistent_ptr< T > pointer_to(T &ref)
Create a persistent pointer from a given reference.
Definition: persistent_ptr.hpp:309
const PMEMoid & raw() const noexcept
Get PMEMoid encapsulated by this object.
Definition: persistent_ptr_base.hpp:304
pmem::detail::sp_dereference< T >::type operator*() const noexcept
Dereference operator.
Definition: persistent_ptr.hpp:134
Resides on pmem class.
Definition: p.hpp:64
T value_type
The type of the value pointed to by the persistent_ptr.
Definition: persistent_ptr.hpp:347
void flush(const void *addr, size_t len) noexcept
Performs flush operation on a given chunk of memory.
Definition: pool.hpp:319
Base class for persistent_ptr.
std::ptrdiff_t difference_type
The persistent_ptr difference type.
Definition: persistent_ptr.hpp:342
persistent_ptr(persistent_ptr< void > const &rhs) noexcept
Explicit void specialization of the converting constructor.
Definition: persistent_ptr.hpp:110
T & reference
The reference type of the value pointed to by the persistent_ptr.
Definition: persistent_ptr.hpp:352