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

Resides on pmem class. More...

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

## Public Member Functions

| p (const T &_val) noexcept
| Value constructor. More...
| p ()=default
| Defaulted constructor.
p & | operator= (const p &rhs)
| Assignment operator. More...
template<typename Y , typename = typename std::enable_if< std::is_convertible<Y, T>::value>::type>
p & | operator= (const p< Y > &rhs)
| Converting assignment operator from a different p<>. More...
| operator T () const noexcept
| Conversion operator back to the underlying type.
T & | get_rw ()
| Retrieves read-write reference of the object. More...
const T & | get_ro () const noexcept
| Retrieves read-only const reference of the object. More...
void | swap (p &other)
| Swaps two p objects of the same type. More...

## Detailed Description

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

Resides on pmem class.

p class is a property-like template class that has to be used for all variables (excluding persistent pointers), which are used in pmemobj transactions. The p property makes sure that changes to a variable within a transaction are made atomically with respect to persistence. It does it by creating a snapshot of the variable when modified in the transaction scope. The p class is not designed to be used with compound types. For that see the persistent_ptr.

#include <fcntl.h>
#include <libpmemobj++/p.hpp>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj++/transaction.hpp>
using namespace pmem::obj;
void
p_property_example()
{
struct compound_type {
void
set_some_variable(int val)
{
some_variable = val;
}
int some_variable;
double some_other_variable;
};
// pool root structure
static struct root {
p<int> counter; // this is OK
p<compound_type> whoops; // this is hard to use
} proot;
// create a pmemobj pool
auto pop = pool<root>::create("poolfile", "layout", PMEMOBJ_MIN_POOL);
// typical usage schemes
transaction::exec_tx(pop, [&] {
proot.counter = 12; // atomic
// one way to change `whoops`
proot.whoops.get_rw().set_some_variable(2);
proot.whoops.get_rw().some_other_variable = 3.0;
});
// Changing a p<> variable outside of a transaction is a volatile
// modification. No way to ensure persistence in case of power failure.
proot.counter = 12;
}

## Constructor & Destructor Documentation

## p()

template<typename T>

pmem::obj::p< T >::p | ( | const T & | _val | ) |

inline noexcept

Value constructor.

Directly assigns a value to the underlying storage.

Parameters

  _val | const reference to the value to be assigned.

## Member Function Documentation

## get_ro()

template<typename T>

const T& pmem::obj::p< T >::get_ro | ( |  | ) | const

inline noexcept

Retrieves read-only const reference of the object.

This method has no transaction side effects.

Returns
  a const reference to the object.

## get_rw()

template<typename T>

T& pmem::obj::p< T >::get_rw | ( |  | ) |

inline

Retrieves read-write reference of the object.

The entire object is automatically added to the transaction.

Returns
  a reference to the object.

Exceptions

  pmem::transaction_error | when adding the object to the transaction failed.

## operator=() [1/2]

template<typename T>

p& pmem::obj::p< T >::operator= | ( | const p< T > & | rhs | ) |

inline

Assignment operator.

The p<> class property assignment within a transaction automatically registers this operation so that a rollback is possible.

Exceptions

  pmem::transaction_error | when adding the object to the transaction failed.

## operator=() [2/2]

template<typename T>
template<typename Y , typename = typename std::enable_if< std::is_convertible<Y, T>::value>::type>

p& pmem::obj::p< T >::operator= | ( | const p< Y > & | rhs | ) |

inline

Converting assignment operator from a different p<>.

Available only for convertible types. Just like regular assignment, also automatically registers itself in a transaction.

Exceptions

  pmem::transaction_error | when adding the object to the transaction failed.

## swap()

template<typename T>

void pmem::obj::p< T >::swap | ( | p< T > & | other | ) |

inline

Swaps two p objects of the same type.

Exceptions

  pmem::transaction_error | when adding the object to the transaction failed.

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

- pmdk-1.4.1/src/include/libpmemobj++/p.hpp