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/pexceptions.hpp>
#include <libpmemobj++/detail/variadic.hpp>
#include <libpmemobj/tx_base.h>
#include <new>
#include <utility>

Go to the source code of this file.

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>
#include <libpmemobj++/make_persistent.hpp>
#include <libpmemobj++/p.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/pool.hpp>
#include <libpmemobj++/transaction.hpp>
 
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 {
        persistent_ptr<compound_type> comp; //
    };
 
    // 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);
    });
 
    // throws an transaction_scope_error exception
    auto arr1 = make_persistent<compound_type>(2, 15.0);
    delete_persistent<compound_type>(arr1);
}

Function Documentation

delete_persistent()

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.

This function can be used to transactionally free an object. Calls the object's destructor before freeing memory. Cannot be used for array types.

Parameters

[in,out]

ptr

persistent pointer to an object that is not an array.

Exceptions

transaction_scope_error	if called outside of an active transaction
transaction_free_error	on transactional free failure.

make_persistent() [1/2]

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.

This function can be used to transactionally allocate an object. Cannot be used for array types.

Parameters

[in]	flag	affects behaviour of allocator
[in,out]	args	a list of parameters passed to the constructor.

Returns

persistent_ptr<T> on success

Exceptions

transaction_scope_error	if called outside of an active transaction
transaction_alloc_error	on transactional allocation failure.
rethrow	exception from T constructor

make_persistent() [2/2]

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.

This function can be used to transactionally allocate an object. Cannot be used for array types.

Parameters

[in,out]

args

a list of parameters passed to the constructor.

Returns

persistent_ptr<T> on success

Exceptions

transaction_scope_error	if called outside of an active transaction
transaction_alloc_error	on transactional allocation failure.
rethrow	exception from T constructor