PMDK C++ bindings  1.12.1-rc1
This is the C++ bindings documentation for PMDK's libpmemobj.
Namespaces | Functions
make_persistent.hpp File Reference

Persistent_ptr transactional allocation functions for objects. More...

#include <libpmemobj++/allocation_flag.hpp>
#include <libpmemobj++/detail/check_persistent_ptr_array.hpp>
#include <libpmemobj++/detail/common.hpp>
#include <libpmemobj++/detail/life.hpp>
#include <libpmemobj++/detail/variadic.hpp>
#include <libpmemobj++/make_persistent_array.hpp>
#include <libpmemobj++/pexceptions.hpp>
#include <libpmemobj/tx_base.h>
#include <new>
#include <utility>

Go to the source code of this file.

Namespaces

 pmem
 Persistent memory namespace.
 
 pmem::obj
 Main libpmemobj namespace.
 

Functions

template<typename T , typename... Args>
detail::pp_if_not_array< T >::type pmem::obj::make_persistent (allocation_flag flag, Args &&... args)
 Transactionally allocate and construct an object of type T. More...
 
template<typename T , typename... Args>
std::enable_if< !detail::is_first_arg_same< allocation_flag, Args... >::value, typename detail::pp_if_not_array< T >::type >::type pmem::obj::make_persistent (Args &&... args)
 Transactionally allocate and construct an object of type T. More...
 
template<typename T >
void pmem::obj::delete_persistent (typename detail::pp_if_not_array< T >::type ptr)
 Transactionally free an object of type T held in a persistent_ptr. More...
 

Detailed Description

Persistent_ptr transactional allocation functions for objects.

The typical usage examples would be:

#include <fcntl.h>
using namespace pmem::obj;
void
make_persistent_example()
{
struct compound_type {
compound_type(int val, double dval)
: some_variable(val), some_other_variable(dval)
{
}
void
set_some_variable(int val)
{
some_variable = val;
}
p<int> some_variable;
p<double> some_other_variable;
};
/* pool root structure */
struct root {
};
/* create a pmemobj pool */
auto pop = pool<root>::create("poolfile", "layout", PMEMOBJ_MIN_POOL);
auto proot = pop.root();
/* typical usage schemes */
transaction::run(pop, [&] {
/* allocation with constructor argument passing */
proot->comp = make_persistent<compound_type>(1, 2.0);
/* transactionally delete the object, ~compound_type() is called
*/
delete_persistent<compound_type>(proot->comp);
/* set pointer to null so that after restart it's known whether
* compound_type is still allocated or not */
proot->comp = nullptr;
});
/* throws an transaction_scope_error exception */
auto arr1 = make_persistent<compound_type>(2, 15.0);
delete_persistent<compound_type>(arr1);
}
pmem::obj::pool::create
static pool< T > create(const std::string &path, const std::string &layout, std::size_t size=PMEMOBJ_MIN_POOL, mode_t mode=DEFAULT_MODE)
Creates a new transactional object store pool.
Definition: pool.hpp:677
pmem::obj::basic_transaction::run
static void run(obj::pool_base &pool, std::function< void()> tx, Locks &... locks)
Execute a closure-like transaction and lock locks.
Definition: transaction.hpp:688
pmem::obj::p
Resides on pmem class.
Definition: p.hpp:35
pool.hpp
C++ pmemobj pool.
make_persistent.hpp
Persistent_ptr transactional allocation functions for objects.
pmem::obj
Main libpmemobj namespace.
Definition: allocation_flag.hpp:18
transaction.hpp
C++ pmemobj transactions.
pmem::obj::persistent_ptr
Persistent pointer class.
Definition: persistent_ptr.hpp:152
p.hpp
Resides on pmem property template.
persistent_ptr.hpp
Persistent smart pointer.