38 #ifndef PMEMOBJ_PERSISTENT_PTR_HPP 39 #define PMEMOBJ_PERSISTENT_PTR_HPP 47 #include "libpmemobj++/detail/persistent_ptr_base.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
158 assert(i >= 0 && (i < pmem::detail::sp_extent<T>::value ||
159 pmem::detail::sp_extent<T>::value == 0) &&
160 "persistent array index out of bounds");
162 return this->
get()[i];
170 detail::conditional_add_to_tx(
this);
171 this->oid.off +=
sizeof(T);
181 PMEMoid noid = this->oid;
192 detail::conditional_add_to_tx(
this);
193 this->oid.off -=
sizeof(T);
203 PMEMoid noid = this->oid;
215 detail::conditional_add_to_tx(
this);
216 this->oid.off += s *
sizeof(T);
227 detail::conditional_add_to_tx(
this);
228 this->oid.off -= s *
sizeof(T);
241 pop.
persist(this->
get(),
sizeof(T));
253 pmemobjpool *pop = pmemobj_pool_by_oid(this->
raw());
257 "persistent pointer");
259 pmemobj_persist(pop, this->
get(),
sizeof(T));
270 pop.
flush(this->
get(),
sizeof(T));
282 pmemobjpool *pop = pmemobj_pool_by_oid(this->
raw());
286 "persistent pointer");
288 pmemobj_flush(pop, this->
get(),
sizeof(T));
373 template <
typename T,
typename Y>
377 return OID_EQUALS(lhs.raw(), rhs.raw());
383 template <
typename T,
typename Y>
387 return !(lhs == rhs);
393 template <
typename T>
397 return lhs.get() ==
nullptr;
403 template <
typename T>
407 return lhs.get() ==
nullptr;
413 template <
typename T>
417 return lhs.get() !=
nullptr;
423 template <
typename T>
427 return lhs.get() !=
nullptr;
437 template <
typename T,
typename Y>
441 if (lhs.raw().pool_uuid_lo == rhs.raw().pool_uuid_lo)
442 return lhs.
raw().off < rhs.raw().off;
444 return lhs.raw().pool_uuid_lo < rhs.raw().pool_uuid_lo;
452 template <
typename T,
typename Y>
464 template <
typename T,
typename Y>
476 template <
typename T,
typename Y>
488 template <
typename T>
490 operator<(persistent_ptr<T>
const &lhs, std::nullptr_t) noexcept
492 return std::less<typename persistent_ptr<T>::element_type *>()(
499 template <
typename T>
501 operator<(std::nullptr_t, persistent_ptr<T>
const &rhs) noexcept
503 return std::less<typename persistent_ptr<T>::element_type *>()(
510 template <
typename T>
512 operator<=(persistent_ptr<T>
const &lhs, std::nullptr_t) noexcept
514 return !(
nullptr < lhs);
520 template <
typename T>
522 operator<=(std::nullptr_t, persistent_ptr<T>
const &rhs) noexcept
524 return !(rhs <
nullptr);
530 template <
typename T>
534 return nullptr < lhs;
540 template <
typename T>
544 return rhs <
nullptr;
550 template <
typename T>
554 return !(lhs <
nullptr);
560 template <
typename T>
564 return !(
nullptr < rhs);
570 template <
typename T>
571 inline persistent_ptr<T>
575 noid.pool_uuid_lo = lhs.raw().pool_uuid_lo;
576 noid.off = lhs.raw().off + (s *
sizeof(T));
583 template <
typename T>
584 inline persistent_ptr<T>
588 noid.pool_uuid_lo = lhs.raw().pool_uuid_lo;
589 noid.off = lhs.raw().off - (s *
sizeof(T));
600 template <
typename T,
typename Y,
601 typename =
typename std::enable_if<
602 std::is_same<typename std::remove_cv<T>::type,
603 typename std::remove_cv<Y>::type>::value>>
607 assert(lhs.raw().pool_uuid_lo == rhs.raw().pool_uuid_lo);
608 ptrdiff_t d = lhs.raw().off - rhs.raw().off;
610 return d /
sizeof(T);
616 template <
typename T>
618 operator<<(std::ostream &os, persistent_ptr<T>
const &pptr)
620 PMEMoid raw_oid = pptr.raw();
621 os << std::hex <<
"0x" << raw_oid.pool_uuid_lo <<
", 0x" << raw_oid.off
bool operator==(standard_alloc_policy< T > const &, standard_alloc_policy< T2 > const &)
Determines if memory from another allocator can be deallocated from this one.
Definition: allocator.hpp:406
persistent_ptr< T > & operator++()
Prefix increment operator.
Definition: persistent_ptr.hpp:168
Persistent_ptr base class.
Definition: persistent_ptr_base.hpp:62
void persist(void)
Persists what the persistent pointer points to.
Definition: persistent_ptr.hpp:251
Helper template for persistent ptr specialization.
Persistent pointer class.
Definition: common.hpp:51
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:65
Custom pool error class.
Definition: pexceptions.hpp:53
persistent_ptr< T > & operator-=(std::ptrdiff_t s)
Subtraction assignment operator.
Definition: persistent_ptr.hpp:225
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:179
bool operator>=(persistent_ptr< T > const &lhs, persistent_ptr< Y > const &rhs) noexcept
Greater or equal than operator.
Definition: persistent_ptr.hpp:478
void persist(pool_base &pop)
Persists the content of the underlying object.
Definition: persistent_ptr.hpp:239
bool bool_type
The used bool_type.
Definition: persistent_ptr.hpp:323
void flush(pool_base &pop)
Flushes what the persistent pointer points to.
Definition: persistent_ptr.hpp:268
PMEMobj pool class.
Definition: persistent_ptr.hpp:59
persistent_ptr< T > operator--(int)
Postfix decrement operator.
Definition: persistent_ptr.hpp:201
persistent_ptr< T > operator+(persistent_ptr< T > const &lhs, std::ptrdiff_t s)
Addition operator for persistent pointers.
Definition: persistent_ptr.hpp:572
Commonly used functionality.
std::random_access_iterator_tag iterator_category
The persistent_ptr iterator category.
Definition: persistent_ptr.hpp:332
persistent_ptr< T > & operator--()
Prefix decrement operator.
Definition: persistent_ptr.hpp:190
persistent_ptr< T > & operator+=(std::ptrdiff_t s)
Addition assignment operator.
Definition: persistent_ptr.hpp:213
void flush(void)
Flushes what the persistent pointer points to.
Definition: persistent_ptr.hpp:280
void persist(const void *addr, size_t len) noexcept
Performs persist operation on a given chunk of memory.
Definition: pool.hpp:282
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:304
persistent_ptr< T > operator-(persistent_ptr< T > const &lhs, std::ptrdiff_t s)
Subtraction operator for persistent pointers.
Definition: persistent_ptr.hpp:585
const PMEMoid & raw() const noexcept
Get PMEMoid encapsulated by this object.
Definition: persistent_ptr_base.hpp:296
pmem::detail::sp_dereference< T >::type operator*() const noexcept
Dereference operator.
Definition: persistent_ptr.hpp:134
Resides on pmem class.
Definition: p.hpp:64
bool operator!=(const allocator< T, P, Tr > &lhs, const OtherAllocator &rhs)
Determines if memory from another allocator can be deallocated from this one.
Definition: allocator.hpp:522
T value_type
The type of the value pointed to by the persistent_ptr.
Definition: persistent_ptr.hpp:342
Definition: allocator.hpp:48
void flush(const void *addr, size_t len) noexcept
Performs flush operation on a given chunk of memory.
Definition: pool.hpp:318
std::ptrdiff_t difference_type
The persistent_ptr difference type.
Definition: persistent_ptr.hpp:337
bool operator>(persistent_ptr< T > const &lhs, persistent_ptr< Y > const &rhs) noexcept
Greater than operator.
Definition: persistent_ptr.hpp:466
persistent_ptr(persistent_ptr< void > const &rhs) noexcept
Explicit void specialization of the converting constructor.
Definition: persistent_ptr.hpp:110
void swap(p< T > &a, p< T > &b)
Swaps two p objects of the same type.
Definition: p.hpp:187
T & reference
The reference type of the value pointed to by the persistent_ptr.
Definition: persistent_ptr.hpp:347