pmem::obj::persistent_ptr< T > Class Template Reference

Persistent pointer class. More...

`#include <libpmemobj++/persistent_ptr.hpp>`

Inheritance diagram for pmem::obj::persistent_ptr< T >:
[legend]
Collaboration diagram for pmem::obj::persistent_ptr< T >:
[legend]

## Public Types

template<class U >
using | rebind = pmem::obj::persistent_ptr< U >
| Rebind to a different type of pointer.
using | persistency_type = p< T >
| The persistency type to be used with this pointer.
using | bool_type = bool
| The used bool_type.
using | iterator_category = std::random_access_iterator_tag
| The persistent_ptr iterator category.
using | difference_type = std::ptrdiff_t
| The persistent_ptr difference type.
using | value_type = T
| The type of the value pointed to by the persistent_ptr.
using | reference = T &
| The reference type of the value pointed to by the persistent_ptr.
using | pointer = persistent_ptr< T >
| The pointer type.
Public Types inherited from pmem::detail::persistent_ptr_base< T >
typedef pmem::detail::sp_element< T >::type | element_type
| Type of an actual object with all qualifier removed, used for easy underlying type access.

## Public Member Functions

| persistent_ptr (persistent_ptr< void > const &rhs) noexcept
| Explicit void specialization of the converting constructor.
| persistent_ptr (persistent_ptr< const void > const &rhs) noexcept
| Explicit const void specialization of the converting constructor.
| operator persistent_ptr< void > () const noexcept
| Persistent pointer to void conversion operator.
pmem::detail::sp_dereference< T >::type | operator* () const noexcept
| Dereference operator.
pmem::detail::sp_member_access< T >::type | operator-> () const noexcept
| Member access operator.
template<typename = typename std::enable_if<!std::is_void<T>::value>>
pmem::detail::sp_array_access< T >::type | operator[] (std::ptrdiff_t i) const noexcept
| Array access operator. More...
persistent_ptr< T > & | operator++ ()
| Prefix increment operator.
persistent_ptr< T > | operator++ (int)
| Postfix increment operator.
persistent_ptr< T > & | operator-- ()
| Prefix decrement operator.
persistent_ptr< T > | operator-- (int)
| Postfix decrement operator.
persistent_ptr< T > & | operator+= (std::ptrdiff_t s)
| Addition assignment operator.
persistent_ptr< T > & | operator-= (std::ptrdiff_t s)
| Subtraction assignment operator.
void | persist (pool_base &pop)
| Persists the content of the underlying object. More...
void | persist (void)
| Persists what the persistent pointer points to. More...
void | flush (pool_base &pop)
| Flushes what the persistent pointer points to. More...
void | flush (void)
| Flushes what the persistent pointer points to. More...
Public Member Functions inherited from pmem::detail::persistent_ptr_base< T >
| persistent_ptr_base ()
| Default constructor, zeroes the PMEMoid.
| persistent_ptr_base (PMEMoid oid) noexcept
| PMEMoid constructor. More...
| persistent_ptr_base (element_type *ptr)
| Volatile pointer constructor. More...
template<typename U , typename = typename std::enable_if< !std::is_same<T, U>::value && std::is_same<typename std::remove_cv<T>::type, U>::value>::type>
| persistent_ptr_base (persistent_ptr_base< U > const &r) noexcept
| Copy constructor from a different persistent_ptr<>. More...
template<typename U , typename Dummy = void, typename = typename std::enable_if< !std::is_same< typename std::remove_cv<T>::type, typename std::remove_cv<U>::type>::value && !std::is_void<U>::value, decltype(static_cast<T *>(std::declval<U *>()))>::type>
| persistent_ptr_base (persistent_ptr_base< U > const &r) noexcept
| Copy constructor from a different persistent_ptr<>. More...
template<typename Y , typename = typename std::enable_if< !std::is_same< typename std::remove_cv<T>::type, typename std::remove_cv<Y>::type>::value && !std::is_void<Y>::value, decltype(static_cast<T *>(std::declval<Y *>()))>::type>
| operator persistent_ptr_base< Y > () noexcept
| Conversion operator to a different persistent_ptr<>. More...
| persistent_ptr_base (persistent_ptr_base &&r) noexcept
| Defaulted move constructor.
persistent_ptr_base & | operator= (persistent_ptr_base &&r)
| Defaulted move assignment operator.
persistent_ptr_base & | operator= (persistent_ptr_base const &r)
| Assignment operator. More...
persistent_ptr_base & | operator= (std::nullptr_t &&)
| Nullptr move assignment operator. More...
template<typename Y , typename = typename std::enable_if< std::is_convertible<Y *, T *>::value>::type>
persistent_ptr_base & | operator= (persistent_ptr_base< Y > const &r)
| Converting assignment operator from a different persistent_ptr<>. More...
void | swap (persistent_ptr_base &other)
| Swaps two persistent_ptr objects of the same type. More...
element_type * | get () const noexcept
| Get a direct pointer. More...
const PMEMoid & | raw () const noexcept
| Get PMEMoid encapsulated by this object. More...
PMEMoid * | raw_ptr () noexcept
| Get pointer to PMEMoid encapsulated by this object. More...

## Static Public Member Functions

static persistent_ptr< T > | pointer_to (T &ref)
| Create a persistent pointer from a given reference. More...

## Additional Inherited Members

Protected Member Functions inherited from pmem::detail::persistent_ptr_base< T >
| persistent_ptr_base (element_type *vptr, int)
| Private constructor enabling persistent_ptrs to volatile objects. More...
template<typename U >
ptrdiff_t | calculate_offset () const
| Calculate in-object offset for structures with inheritance. More...

## Detailed Description

### template<typename T>
class pmem::obj::persistent_ptr< T >

Persistent pointer class.

persistent_ptr implements a smart ptr. It encapsulates the PMEMoid fat pointer and provides member access, dereference and array access operators. The persistent_ptr is not designed to work with polymorphic types, as they have runtime RTTI info embedded, which is implementation specific and thus not consistently rebuildable. Such constructs as polymorphic members or members of a union defined within a class held in a persistent_ptr will also yield undefined behavior. This type does NOT manage the life-cycle of the object. The typical usage example would be:

#include <fcntl.h>
#include <libpmemobj++/make_persistent.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj++/transaction.hpp>
using namespace pmem::obj;
void
persistent_ptr_example()
{
struct compound_type {
void
set_some_variable(int val)
{
some_variable = val;
}
int some_variable;
double some_other_variable;
};
// pool root structure
struct root {
persistent_ptr<compound_type> comp;
} proot;
// create a pmemobj pool
auto pop = pool<root>::create("poolfile", "layout", PMEMOBJ_MIN_POOL);
// typical usage schemes
transaction::exec_tx(pop, [&] {
proot.comp = make_persistent<compound_type>(); // allocation
proot.comp->set_some_variable(12); // call function
proot.comp->some_other_variable = 2.3; // set variable
});
// reading from the persistent_ptr
compound_type tmp = *proot.comp;
(void)tmp;
// Changing a persistent_ptr<> variable outside of a transaction is a
// volatile modification. No way to ensure persistence in case of power
// failure.
proot.comp->some_variable = 12;
}

## Member Function Documentation

## flush() [1/2]

template<typename T>

void pmem::obj::persistent_ptr< T >::flush | ( | pool_base & | pop | ) |

inline

Flushes what the persistent pointer points to.

Parameters

  [in] | pop | Pmemobj pool

## flush() [2/2]

template<typename T>

void pmem::obj::persistent_ptr< T >::flush | ( | void |  | ) |

inline

Flushes what the persistent pointer points to.

Exceptions

  pool_error | when cannot get pool from persistent pointer

## operator[]()

template<typename T>
template<typename = typename std::enable_if<!std::is_void<T>::value>>

pmem::detail::sp_array_access<T>::type pmem::obj::persistent_ptr< T >::operator[] | ( | std::ptrdiff_t | i | ) | const

inline noexcept

Array access operator.

Contains run-time bounds checking for static arrays.

## persist() [1/2]

template<typename T>

void pmem::obj::persistent_ptr< T >::persist | ( | pool_base & | pop | ) |

inline

Persists the content of the underlying object.

Parameters

  [in] | pop | Pmemobj pool

## persist() [2/2]

template<typename T>

void pmem::obj::persistent_ptr< T >::persist | ( | void |  | ) |

inline

Persists what the persistent pointer points to.

Exceptions

  pool_error | when cannot get pool from persistent pointer

## pointer_to()

template<typename T>

static persistent_ptr<T> pmem::obj::persistent_ptr< T >::pointer_to | ( | T & | ref | ) |

inline static

Create a persistent pointer from a given reference.

This can create a persistent_ptr to a volatile object, use with extreme caution.

Parameters

  ref | reference to an object.

The documentation for this class was generated from the following files:

- pmdk-1.4.1/src/include/libpmemobj++/detail/common.hpp
- pmdk-1.4.1/src/include/libpmemobj++/persistent_ptr.hpp