Persistent version of segment vector with std::vector compatible interface. More...

#include <libpmemobj++/container/segment_vector.hpp>

Public Types
using	policy_type = Policy

using	segment_type = typename policy_type::template segment_type< T >

using	segment_vector_type = typename policy_type::template segment_vector_type< T >

using	policy = policy_type

using	storage = policy_type

using	value_type = T

using	size_type = std::size_t

using	difference_type = std::ptrdiff_t

using	reference = value_type &

using	const_reference = const value_type &

using	pointer = value_type *

using	const_pointer = const value_type *

using	iterator = segment_vector_internal::segment_iterator< segment_vector, false >

using	const_iterator = segment_vector_internal::segment_iterator< segment_vector, true >

using	reverse_iterator = std::reverse_iterator< iterator >

using	const_reverse_iterator = std::reverse_iterator< const_iterator >

Public Member Functions
	segment_vector ()
	Default constructor. More...

	segment_vector (size_type count, const value_type &value)
	Constructs the container with count copies of elements with value value. More...

	segment_vector (size_type count)
	Constructs the container with count copies of T default constructed values. More...

template<typename InputIt , typename std::enable_if< detail::is_input_iterator< InputIt >::value, InputIt >::type * = nullptr>
	segment_vector (InputIt first, InputIt last)
	Constructs the container with the contents of the range [first, last). More...

	segment_vector (const segment_vector &other)
	Copy constructor. More...

	segment_vector (segment_vector &&other)
	Move constructor. More...

	segment_vector (std::initializer_list< T > init)
	Constructs the container with the contents of the initializer list init. More...

	segment_vector (const std::vector< T > &other)
	Copy constructor. More...

segment_vector &	operator= (const segment_vector &other)
	Copy assignment operator. More...

segment_vector &	operator= (segment_vector &&other)
	Move assignment operator. More...

segment_vector &	operator= (std::initializer_list< T > ilist)
	Replaces the contents with those identified by initializer list ilist transactionally. More...

segment_vector &	operator= (const std::vector< T > &other)
	Copy assignment operator. More...

void	assign (size_type count, const_reference value)
	Replaces the contents with count copies of value value transactionally. More...

template<typename InputIt , typename std::enable_if< detail::is_input_iterator< InputIt >::value, InputIt >::type * = nullptr>
void	assign (InputIt first, InputIt last)
	Replaces the contents with copies of those in the range [first, last) transactionally. More...

void	assign (std::initializer_list< T > ilist)
	Replaces the contents with the elements from the initializer list ilist transactionally. More...

void	assign (const segment_vector &other)
	Copy assignment method. More...

void	assign (segment_vector &&other)
	Move assignment method. More...

void	assign (const std::vector< T > &other)
	Copy assignment method. More...

	~segment_vector ()
	Destructor. More...

reference	at (size_type n)
	Access element at specific index with bounds checking and add it to a transaction. More...

const_reference	at (size_type n) const
	Access element at specific index with bounds checking. More...

const_reference	const_at (size_type n) const
	Access element at specific index with bounds checking. More...

reference	operator[] (size_type n)
	Access element at specific index and add it to a transaction. More...

const_reference	operator[] (size_type n) const
	Access element at specific index. More...

reference	front ()
	Access the first element and add this element to a transaction. More...

const_reference	front () const
	Access the first element. More...

const_reference	cfront () const
	Access the first element. More...

reference	back ()
	Access the last element and add this element to a transaction. More...

const_reference	back () const
	Access the last element. More...

const_reference	cback () const
	Access the last element. More...

iterator	begin ()
	Returns an iterator to the beginning. More...

const_iterator	begin () const noexcept
	Returns const iterator to the beginning. More...

const_iterator	cbegin () const noexcept
	Returns const iterator to the beginning. More...

iterator	end ()
	Returns an iterator to past the end. More...

const_iterator	end () const noexcept
	Returns a const iterator to past the end. More...

const_iterator	cend () const noexcept
	Returns a const iterator to the end. More...

reverse_iterator	rbegin ()
	Returns a reverse iterator to the beginning. More...

const_reverse_iterator	rbegin () const noexcept
	Returns a const reverse iterator to the beginning. More...

const_reverse_iterator	crbegin () const noexcept
	Returns a const reverse iterator to the beginning. More...

reverse_iterator	rend ()
	Returns a reverse iterator to the end. More...

const_reverse_iterator	rend () const noexcept
	Returns a const reverse iterator to the end. More...

const_reverse_iterator	crend () const noexcept
	Returns a const reverse iterator to the beginning. More...

slice< iterator >	range (size_type start, size_type n)
	Returns slice and snapshots requested range. More...

slice< const_iterator >	range (size_type start, size_type n) const
	Returns const slice. More...

slice< const_iterator >	crange (size_type start, size_type n) const
	Returns const slice. More...

constexpr bool	empty () const noexcept
	Checks whether the container is empty. More...

size_type	size () const noexcept

constexpr size_type	max_size () const noexcept

void	reserve (size_type capacity_new)
	Increases the capacity of the segment_vector to capacity_new transactionally. More...

size_type	capacity () const noexcept

void	shrink_to_fit ()
	Requests transactional removal of unused capacity. More...

void	clear ()
	Clears the content of a segment_vector transactionally. More...

void	free_data ()
	Clears the content of a segment_vector and frees all allocated persistent memory for data transactionally. More...

iterator	insert (const_iterator pos, const T &value)
	Inserts value before pos in the container transactionally. More...

iterator	insert (const_iterator pos, T &&value)
	Moves value before pos in the container transactionally. More...

iterator	insert (const_iterator pos, size_type count, const T &value)
	Inserts count copies of the value before pos in the container transactionally. More...

template<typename InputIt , typename std::enable_if< detail::is_input_iterator< InputIt >::value, InputIt >::type * = nullptr>
iterator	insert (const_iterator pos, InputIt first, InputIt last)
	Inserts elements from range [first, last) before pos in the container transactionally. More...

iterator	insert (const_iterator pos, std::initializer_list< T > ilist)
	Inserts elements from initializer list ilist before pos in the container transactionally. More...

template<class... Args>
iterator	emplace (const_iterator pos, Args &&... args)
	Inserts a new element into the container directly before pos. More...

template<class... Args>
reference	emplace_back (Args &&... args)
	Appends a new element to the end of the container transactionally. More...

iterator	erase (const_iterator pos)
	Removes the element at pos. More...

iterator	erase (const_iterator first, const_iterator last)
	Removes the elements in the range [first, last). More...

void	push_back (const T &value)
	Appends the given element value to the end of the container transactionally. More...

void	push_back (T &&value)
	Appends the given element value to the end of the container transactionally. More...

void	pop_back ()
	Removes the last element of the container transactionally. More...

void	resize (size_type count)
	Resizes the container to count elements transactionally. More...

void	resize (size_type count, const value_type &value)
	Resizes the container to contain count elements transactionally. More...

void	swap (segment_vector &other)
	Exchanges the contents of the container with other transactionally.

Related Functions
(Note that these are not member functions.)
template<typename T , typename Policy >
void	swap (segment_vector< T, Policy > &lhs, segment_vector< T, Policy > &rhs)
	Swaps the contents of lhs and rhs. More...

template<typename T , typename Policy >
bool	operator== (const segment_vector< T, Policy > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator!= (const segment_vector< T, Policy > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator< (const segment_vector< T, Policy > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator<= (const segment_vector< T, Policy > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator> (const segment_vector< T, Policy > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator>= (const segment_vector< T, Policy > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator== (const segment_vector< T, Policy > &lhs, const std::vector< T > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator!= (const segment_vector< T, Policy > &lhs, const std::vector< T > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator< (const segment_vector< T, Policy > &lhs, const std::vector< T > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator<= (const segment_vector< T, Policy > &lhs, const std::vector< T > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator> (const segment_vector< T, Policy > &lhs, const std::vector< T > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator>= (const segment_vector< T, Policy > &lhs, const std::vector< T > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator== (const std::vector< T > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator!= (const std::vector< T > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator< (const std::vector< T > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator<= (const std::vector< T > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator> (const std::vector< T > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

template<typename T , typename Policy >
bool	operator>= (const std::vector< T > &lhs, const segment_vector< T, Policy > &rhs)
	Comparison operator. More...

Detailed Description

template<typename T, typename Policy = exponential_size_vector_policy<>>
class pmem::obj::segment_vector< T, Policy >

Persistent version of segment vector with std::vector compatible interface.

Segment table is a data type with a vector-like interface. Differences are: it does not do reallocations and iterators are not invalidated when adding new elements.

Precondition: if SegmentType for policy is specified it must contain such functions as: default constructor, destructor, assign, operator[], free_data, emplace_back, clear, resize, reserve, erase, capacity(), size(). They must have signature the same as in vector. Also must support iterators.

Policy template represents Segments storing type and managing methods.

Example usage:

#include <iostream>
#include <libpmemobj++/container/segment_vector.hpp>
#include <libpmemobj++/p.hpp>
#include <libpmemobj++/persistent_ptr.hpp>
#include <libpmemobj++/pool.hpp>
 
const int N_ELEMENTS = 4096;
const int SEGMENT_SIZE = 1024;
 
using namespace pmem::obj;
using value_t = p<int>;
using segment_t = pmem::obj::vector<value_t>;
 
/*
 * exponential_size_array_policy<> is equivalent to:
 * exponential_size_array_policy<pmem::obj::vector>
 */
using seg_vec_exp_arr =
    segment_vector<value_t, exponential_size_array_policy<>>;
 
/*
 * exponential_size_vector_policy<> is equivalent to:
 * exponential_size_vector_policy<pmem::obj::vector>
 */
using seg_vec_exp_vec =
    segment_vector<value_t, exponential_size_vector_policy<>>;
 
/*
 * fixed_size_vector_policy<SEGMENT_SIZE> is equivalent to:
 * fixed_size_vector_policy<SEGMENT_SIZE, pmem::obj::vector>
 */
using seg_vec_fix_vec =
    segment_vector<value_t, fixed_size_vector_policy<SEGMENT_SIZE>>;
 
struct root {
    persistent_ptr<segment_t> pptr0;
    persistent_ptr<seg_vec_exp_arr> pptr1;
    persistent_ptr<seg_vec_exp_vec> pptr2;
    persistent_ptr<seg_vec_fix_vec> pptr3;
};
 
/* Before running this example, run:
 * pmempool create obj --layout="segment_vector_example" path_to_pool
 */
int
main(int argc, char *argv[])
{
    if (argc != 2)
        std::cerr << "usage: " << argv[0] << " file-name" << std::endl;
 
    auto path = argv[1];
    pool<root> pop;
    persistent_ptr<root> r;
 
    try {
        pop = pool<root>::open(path, "segment_vector_example");
        r = pop.root();
    } catch (const std::exception &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }
 
    try {
        if (r->pptr0 == nullptr) {
            pmem::obj::transaction::run(pop, [&] {
                r->pptr0 = make_persistent<segment_t>();
                r->pptr1 = make_persistent<seg_vec_exp_arr>();
                r->pptr2 = make_persistent<seg_vec_exp_vec>();
                r->pptr3 = make_persistent<seg_vec_fix_vec>();
            });
        }
 
        auto &seg_vec_0 = *pop.root()->pptr0;
        auto &seg_vec_1 = *pop.root()->pptr1;
        auto &seg_vec_2 = *pop.root()->pptr2;
        auto &seg_vec_3 = *pop.root()->pptr3;
 
        for (int i = 0; i < N_ELEMENTS; ++i) {
            seg_vec_0[i] = i;
        }
 
        seg_vec_1 =
            seg_vec_exp_arr(seg_vec_0.cbegin(), seg_vec_0.cend());
        seg_vec_2 =
            seg_vec_exp_vec(seg_vec_1.cbegin(), seg_vec_1.cend());
        seg_vec_3 =
            seg_vec_fix_vec(seg_vec_2.cbegin(), seg_vec_2.cend());
 
        for (int i = 0; i < N_ELEMENTS; ++i) {
            assert(seg_vec_1[i] = seg_vec_0[i]);
            assert(seg_vec_2[i] = seg_vec_1[i]);
            assert(seg_vec_3[i] = seg_vec_2[i]);
        }
 
        seg_vec_0.clear();
        seg_vec_1.clear();
        seg_vec_2.clear();
        seg_vec_3.clear();
    } catch (const pmem::manual_tx_abort &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    } catch (const pmem::pool_error &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    } catch (const pmem::transaction_out_of_memory &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    } catch (const pmem::transaction_error &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    } catch (const std::out_of_range &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    } catch (const std::logic_error &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }
 
    try {
        pmem::obj::transaction::run(pop, [&] {
            delete_persistent<segment_t>(r->pptr0);
            delete_persistent<seg_vec_exp_arr>(r->pptr1);
            delete_persistent<seg_vec_exp_vec>(r->pptr2);
            delete_persistent<seg_vec_fix_vec>(r->pptr3);
        });
    } catch (const pmem::transaction_scope_error &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    } catch (const pmem::transaction_free_error &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    } catch (const pmem::manual_tx_abort &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    } catch (const pmem::transaction_error &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }
 
    try {
        pop.close();
    } catch (const std::logic_error &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }
    return 0;
}

Constructor & Destructor Documentation

◆ segment_vector() [1/8]

template<typename T , typename Policy >

pmem::obj::segment_vector< T, Policy >::segment_vector

Default constructor.

Constructs an empty container.

Precondition: must be called in transaction scope.

Exceptions

pmem::pool_error	if an object is not in persistent memory.
pmem::transaction_scope_error	if wasn't called in transaction.

◆ segment_vector() [2/8]

template<typename T , typename Policy >

pmem::obj::segment_vector< T, Policy >::segment_vector	(	size_type	count,
		const value_type &	value
	)

Constructs the container with count copies of elements with value value.

Parameters

[in]	count	number of elements to construct.
[in]	value	value of all constructed elements.

Precondition: must be called in transaction scope.

Postcondition: size() == count; capacity() == nearest power of 2 greater than count

Exceptions

rethrows	constructor's exception.
pmem::pool_error	if an object is not in persistent memory.
pmem::transaction_scope_error	if wasn't called in transaction.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_out_of_memory	when not enough memory to allocate.

◆ segment_vector() [3/8]

template<typename T , typename Policy >

pmem::obj::segment_vector< T, Policy >::segment_vector ( size_type count )

explicit

Constructs the container with count copies of T default constructed values.

Parameters

[in] count number of elements to construct.

Precondition: must be called in transaction scope.

Postcondition: size() == count; capacity() == nearest power of 2 greater than count

Exceptions

rethrows	constructor's exception.
pmem::pool_error	if an object is not in persistent memory.
pmem::transaction_scope_error	if wasn't called in transaction.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_out_of_memory	when not enough memory to allocate.

◆ segment_vector() [4/8]

template<typename T , typename Policy >

template<typename InputIt , typename std::enable_if< detail::is_input_iterator< InputIt >::value, InputIt >::type * >

pmem::obj::segment_vector< T, Policy >::segment_vector	(	InputIt	first,
		InputIt	last
	)

Constructs the container with the contents of the range [first, last).

The first and last arguments must satisfy InputIterator requirements. This overload only participates in overload resolution if InputIt satisfies InputIterator, to avoid ambiguity with the overload of count-value constructor.

Parameters

[in]	first	first iterator.
[in]	last	last iterator.

Precondition: must be called in transaction scope.

Postcondition: size() == std::distance(first, last); capacity() == nearest power of 2 greater than std::distance(first, last)

Exceptions

rethrows	constructor's exception.
pmem::pool_error	if an object is not in persistent memory.
pmem::transaction_scope_error	if wasn't called in transaction.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_out_of_memory	when not enough memory to allocate.

◆ segment_vector() [5/8]

template<typename T , typename Policy >

pmem::obj::segment_vector< T, Policy >::segment_vector ( const segment_vector< T, Policy > & other )

Copy constructor.

Constructs the container with the copy of the contents of other.

Parameters

[in] other reference to the segment_vector to be copied.

Precondition: must be called in transaction scope.

Postcondition: size() == other.size(); capacity() == other.capacity()

Exceptions

rethrows	constructor's exception.
pmem::pool_error	if an object is not in persistent memory.
pmem::transaction_scope_error	if wasn't called in transaction.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_out_of_memory	when not enough memory to allocate.

◆ segment_vector() [6/8]

template<typename T , typename Policy >

pmem::obj::segment_vector< T, Policy >::segment_vector ( segment_vector< T, Policy > && other )

Move constructor.

Constructs the container with the contents of other using move semantics. After the move, other is guaranteed to be empty().

Parameters

[in] other rvalue reference to the segment_vector to be moved from.

Precondition: must be called in transaction scope.

Postcondition: size() == other.size(); capacity() == other.capacity(); other.capacity() == 0; other.size() == 0

Exceptions

rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ segment_vector() [7/8]

template<typename T , typename Policy >

pmem::obj::segment_vector< T, Policy >::segment_vector ( std::initializer_list< T > init )

Constructs the container with the contents of the initializer list init.

Parameters

[in] init initializer list with content to be constructed.

Precondition: must be called in transaction scope.

Postcondition: size() == init.size(); capacity() == size()

Exceptions

rethrows	constructor's exception.
pmem::pool_error	if an object is not in persistent memory.
pmem::transaction_scope_error	if wasn't called in transaction.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_out_of_memory	when not enough memory to allocate.

◆ segment_vector() [8/8]

template<typename T , typename Policy >

pmem::obj::segment_vector< T, Policy >::segment_vector ( const std::vector< T > & other )

Copy constructor.

Constructs the container with the copy of the contents of std::vector<T> other.

Parameters

[in] other reference to the vector to be copied.

Precondition: must be called in transaction scope.

Postcondition: size() == other.size(); capacity() == other.capacity()

Exceptions

rethrows	constructor's exception.
pmem::pool_error	if an object is not in persistent memory.
pmem::transaction_scope_error	if wasn't called in transaction.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_out_of_memory	when not enough memory to allocate.

◆ ~segment_vector()

template<typename T , typename Policy >

pmem::obj::segment_vector< T, Policy >::~segment_vector

Destructor.

Note that free_data may throw a transaction_free_error when freeing underlying segments failed. It is recommended to call free_data manually before object destruction, otherwise application can be terminated on failure.

Member Function Documentation

◆ assign() [1/6]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::assign ( const segment_vector< T, Policy > & other )

Copy assignment method.

Replaces the contents with a copy of the contents of other transactionally.

Postcondition: size() == other.size(); capacity() == max(other.size(), capacity())

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ assign() [2/6]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::assign ( const std::vector< T > & other )

Copy assignment method.

Replaces the contents with a copy of the contents of std::vector<T> other transactionally.

Postcondition: size() == other.size(); capacity() == max(other.size(), capacity())

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ assign() [3/6]

template<typename T , typename Policy >

template<typename InputIt , typename std::enable_if< detail::is_input_iterator< InputIt >::value, InputIt >::type * >

void pmem::obj::segment_vector< T, Policy >::assign	(	InputIt	first,
		InputIt	last
	)

Replaces the contents with copies of those in the range [first, last) transactionally.

This overload participates in overload resolution only if InputIt satisfies InputIterator. Only the iterators and references in [0, std::distance(first, last)) remain valid.

Parameters

[in]	first	first iterator.
[in]	last	last iterator.

Postcondition: size() == std::distance(first, last); capacity() == nearest power of 2 greater than max(capacity(), std::distance(first, last))

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_free_error	when freeing underlying segment failed.

using vector policy user may call assign with zero count and in that case we can't call assign of uninitialized vector

◆ assign() [4/6]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::assign ( segment_vector< T, Policy > && other )

Move assignment method.

Replaces the contents with those of other using move semantics (i.e. the data in other is moved from other into this container) transactionally. Other is in a valid but empty state afterwards.

Postcondition: size() == other.size(); capacity() == other.capacity()

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ assign() [5/6]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::assign	(	size_type	count,
		const_reference	value
	)

Replaces the contents with count copies of value value transactionally.

Only the iterators and references in [0, std::distance(first, last)) remain valid.

Parameters

[in]	count	number of elements to construct.
[in]	value	value of all constructed elements.

Postcondition: size() == count; capacity() == nearest power of 2 greater than max(capacity(), count)

Exceptions

std::length_error	if count > max_size().
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
rethrows	constructor's exception.
rethrows	destructor exception.
pmem::transaction_free_error	when freeing underlying segment failed.

using vector policy user may call assign with zero count and in that case we can't call assign of uninitialized vector

◆ assign() [6/6]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::assign ( std::initializer_list< T > ilist )

Replaces the contents with the elements from the initializer list ilist transactionally.

Only the iterators and references in [0, std::distance(ilist.begin(), ilist.end())) remain valid.

Parameters

[in] ilist initializer list with content to be constructed.

Postcondition: size() == std::distance(ilist.begin(), ilist.end()); capacity() == nearest power of 2 greater than max(capacity(), std::distance(ilist.begin(), ilist.end()))

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ at() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::reference pmem::obj::segment_vector< T, Policy >::at ( size_type n )

Access element at specific index with bounds checking and add it to a transaction.

Parameters

[in] n index number.

Returns: reference to element number n in underlying segments.

Exceptions

std::out_of_range	if n is not within the range of the container.
pmem::transaction_error	when adding the object to the transaction failed.

◆ at() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reference pmem::obj::segment_vector< T, Policy >::at ( size_type n ) const

Access element at specific index with bounds checking.

Parameters

[in] n index number.

Returns: const_reference to element number n in underlying segments.

Exceptions

std::out_of_range if n is not within the range of the container.

◆ back() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::reference pmem::obj::segment_vector< T, Policy >::back

Access the last element and add this element to a transaction.

Returns: reference to the last element in underlying segments.

Exceptions

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

◆ back() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reference pmem::obj::segment_vector< T, Policy >::back

Access the last element.

Returns: const_reference to the last element in underlying segments.

◆ begin() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::begin

Returns an iterator to the beginning.

Returns: iterator pointing to the first element in the segment_vector.

◆ begin() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::const_iterator pmem::obj::segment_vector< T, Policy >::begin

noexcept

Returns const iterator to the beginning.

Returns: const_iterator pointing to the first element in the segment_vector.

◆ capacity()

template<typename T , typename Policy >

segment_vector< T, Policy >::size_type pmem::obj::segment_vector< T, Policy >::capacity

noexcept

Returns: number of elements that can be held in currently allocated storage.

◆ cback()

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reference pmem::obj::segment_vector< T, Policy >::cback

Access the last element.

In contradiction to back(), cback() will return const_reference not depending on the const-qualification of the object it is called on.

Returns: const_reference to the last element in underlying segments.

◆ cbegin()

template<typename T , typename Policy >

segment_vector< T, Policy >::const_iterator pmem::obj::segment_vector< T, Policy >::cbegin

noexcept

Returns const iterator to the beginning.

In contradiction to begin(), cbegin() will return const_iterator not depending on the const-qualification of the object it is called on.

Returns: const_iterator pointing to the first element in the segment_vector.

◆ cend()

template<typename T , typename Policy >

segment_vector< T, Policy >::const_iterator pmem::obj::segment_vector< T, Policy >::cend

noexcept

Returns a const iterator to the end.

In contradiction to end(), cend() will return const_iterator not depending on the const-qualification of the object it is called on.

Returns: const_iterator referring to the past-the-end element in the segment_vector.

◆ cfront()

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reference pmem::obj::segment_vector< T, Policy >::cfront

Access the first element.

In contradiction to front(), cfront() will return const_reference not depending on the const-qualification of the object it is called on.

Returns: reference to first element in underlying segments.

◆ clear()

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::clear

Clears the content of a segment_vector transactionally.

Postcondition: size() == 0

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ const_at()

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reference pmem::obj::segment_vector< T, Policy >::const_at ( size_type n ) const

Access element at specific index with bounds checking.

In contradiction to at(), const_at() will return const_reference not depending on the const-qualification of the object it is called on.

Parameters

[in] n index number.

Returns: const_reference to element number n in underlying segments.

Exceptions

std::out_of_range if n is not within the range of the container.

◆ crange()

template<typename T , typename Policy >

slice< typename segment_vector< T, Policy >::const_iterator > pmem::obj::segment_vector< T, Policy >::crange	(	size_type	start,
		size_type	n
	)		const

Returns const slice.

This method is not specified by STL standards.

Parameters

[in]	start	start index of requested range.
[in]	n	number of elements in range.

Returns: pmem::obj::slice from start to start + n.

Exceptions

std::out_of_range if any element of the range would be outside of the segment_vector.

◆ crbegin()

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reverse_iterator pmem::obj::segment_vector< T, Policy >::crbegin

noexcept

Returns a const reverse iterator to the beginning.

In contradiction to rbegin(), crbegin() will return const_reverse_iterator not depending on the const-qualification of the object it is called on.

Returns: const_reverse_iterator pointing to the last element in the segment_vector.

◆ crend()

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reverse_iterator pmem::obj::segment_vector< T, Policy >::crend

noexcept

Returns a const reverse iterator to the beginning.

In contradiction to rend(), crend() will return const_reverse_iterator not depending on the const-qualification of the object it is called on.

Returns: const_reverse_iterator pointing to the theoretical element preceding the first element in the segment_vector.

◆ emplace()

template<typename T , typename Policy >

template<class... Args>

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::emplace	(	const_iterator	pos,
		Args &&...	args
	)

Inserts a new element into the container directly before pos.

The element is constructed in-place. The arguments args... are forwarded to the constructor as std::forward<Args>(args).... Note that standard allows args to be a self reference and internal emplace implementation handles this case by creating temporary element_type object. This object is being stored either on stack or on pmem, see pmem::detail::temp_value for details.

Parameters

[in]	pos	iterator before which the new element will be constructed.
[in]	args	arguments to forward to the constructor of the element.

Returns: Iterator pointing to the emplaced element.

Precondition: value_type must meet the requirements of MoveAssignable, MoveInsertable and EmplaceConstructible.

Postcondition: capacity() == nearest power of 2 greater than size() + 1, or remains the same if there is enough space.

Exceptions

rethrows	constructor's exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ emplace_back()

template<typename T , typename Policy >

template<class... Args>

segment_vector< T, Policy >::reference pmem::obj::segment_vector< T, Policy >::emplace_back ( Args &&... args )

Appends a new element to the end of the container transactionally.

The element is constructed in-place. The arguments args... are forwarded to the constructor as std::forward<Args>(args).... Past-the-end iterator is invalidated.

Parameters

[in] args arguments to forward to the constructor of the element.

Returns: Iterator pointing to the emplaced element.

Precondition: value_type must meet the requirements of MoveInsertable and EmplaceConstructible.; size() must be less than max_size()

Postcondition: capacity() == nearest power of 2 greater than size() + 1, or remains the same if there is enough space.

Exceptions

rethrows	constructor's exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ empty()

template<typename T , typename Policy >

constexpr bool pmem::obj::segment_vector< T, Policy >::empty

constexprnoexcept

Checks whether the container is empty.

Returns: true if container is empty, false otherwise.

◆ end() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::end

Returns an iterator to past the end.

Returns: iterator referring to the past-the-end element in the segment_vector.

◆ end() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::const_iterator pmem::obj::segment_vector< T, Policy >::end

noexcept

Returns a const iterator to past the end.

Returns: const_iterator referring to the past-the-end element in the segment_vector.

◆ erase() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::erase	(	const_iterator	first,
		const_iterator	last
	)

Removes the elements in the range [first, last).

Invalidates iterators and references at or after the point of the erase, including the end() iterator. The iterator pos must be valid and dereferenceable. Thus the end() iterator (which is valid, but is not dereferenceable) cannot be used as a value for pos.

Parameters

[in]	first	beginning of the range of elements to be removed.
[in]	last	end of range of elements to be removed.

Returns: Iterator following the last removed element. If the iterator pos refers to the last element, the end() iterator is returned. If first and last refer to the same element, iterator to this element is returned.

Precondition: value_type must meet the requirements of MoveAssignable.

Postcondition: size() = size() - std::distance(first, last).

Exceptions

rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ erase() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::erase ( const_iterator pos )

Removes the element at pos.

Invalidates iterators and references at or after the point of the erase, including the end() iterator. The iterator pos must be valid and dereferenceable. Thus the end() iterator (which is valid, but is not dereferenceable) cannot be used as a value for pos.

Parameters

[in] pos iterator to the element to be removed.

Returns: Iterator following the last removed element. If the iterator pos refers to the last element, the end() iterator is returned.

Precondition: value_type must meet the requirements of MoveAssignable.

Postcondition: size() = size() - 1.

Exceptions

rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ free_data()

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::free_data

Clears the content of a segment_vector and frees all allocated persistent memory for data transactionally.

Postcondition: size() == 0; capacity() == 0

Exceptions

rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segments failed.

◆ front() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::reference pmem::obj::segment_vector< T, Policy >::front

Access the first element and add this element to a transaction.

Returns: reference to first element in underlying segments.

Exceptions

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

◆ front() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reference pmem::obj::segment_vector< T, Policy >::front

Access the first element.

Returns: const_reference to first element in underlying segments.

◆ insert() [1/5]

template<typename T , typename Policy >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::insert	(	const_iterator	pos,
		const T &	value
	)

Inserts value before pos in the container transactionally.

Causes allocation if the new size() is greater than the old capacity(). Only the iterators and references before the insertion point remain valid.

Parameters

[in]	pos	iterator before which the content will be inserted. pos may be the end() iterator.
[in]	value	element value to be inserted.

Returns: Iterator pointing to the inserted value.

Precondition: value_type must meet the requirements of CopyAssignable and CopyInsertable.

Postcondition: capacity() == nearest power of 2 greater than size() + 1, or remains the same if there is enough space.

Exceptions

rethrows	constructor's exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ insert() [2/5]

template<typename T , typename Policy >

template<typename InputIt , typename std::enable_if< detail::is_input_iterator< InputIt >::value, InputIt >::type * >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::insert	(	const_iterator	pos,
		InputIt	first,
		InputIt	last
	)

Inserts elements from range [first, last) before pos in the container transactionally.

Causes allocation if the new size() is greater than the old capacity(). Only the iterators and references before the insertion point remain valid. This overload participates in overload resolution only if InputIt qualifies as InputIterator, to avoid ambiguity with the pos-count-value overload. The behavior is undefined if first and last are iterators into *this.

Parameters

[in]	pos	iterator before which the content will be inserted. pos may be the end() iterator.
[in]	first	begin of the range of elements to insert, can't be iterator into container for which insert is called.
[in]	last	end of the range of elements to insert, can't be iterator into container for which insert is called.

Returns: Iterator pointing to the first element inserted or pos if first == last.

Precondition: value_type must meet the requirements of EmplaceConstructible, Swappable, CopyAssignable, CopyConstructible and CopyInsertable.; InputIt must satisfies requirements of InputIterator.

Postcondition: capacity() == nearest power of 2 greater than size() + std::distance(first, last), or remains the same if there is enough space.

Exceptions

rethrows	constructor's exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ insert() [3/5]

template<typename T , typename Policy >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::insert	(	const_iterator	pos,
		size_type	count,
		const T &	value
	)

Inserts count copies of the value before pos in the container transactionally.

Causes allocation if the new size() is greater than the old capacity(). Only the iterators and references before the insertion point remain valid.

Parameters

[in]	pos	iterator before which the content will be inserted. pos may be the end() iterator.
[in]	count	number of copies to be inserted.
[in]	value	element value to be inserted.

Returns: Iterator pointing to the first element inserted, or pos if count == 0.

Precondition: value_type must meet the requirements of CopyAssignable and CopyInsertable.

Postcondition: capacity() == nearest power of 2 greater than size() + count, or remains the same if there is enough space.

Exceptions

rethrows	constructor's exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ insert() [4/5]

template<typename T , typename Policy >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::insert	(	const_iterator	pos,
		std::initializer_list< T >	ilist
	)

Inserts elements from initializer list ilist before pos in the container transactionally.

Causes allocation if the new size() is greater than the old capacity(). Only the iterators and references before the insertion point remain valid.

Parameters

[in]	pos	iterator before which the content will be inserted. pos may be the end() iterator.
[in]	ilist	initializer list to insert the values from.

Returns: Iterator pointing to the first element inserted, or pos if ilist is empty.

Precondition: value_type must meet the requirements of EmplaceConstructible, Swappable, CopyAssignable, CopyConstructible and CopyInsertable.

Postcondition: capacity() == nearest power of 2 greater than size() + std::distance(ilist.begin(), ilist.end()), or remains the same if there is enough space.

Exceptions

rethrows	constructor's exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ insert() [5/5]

template<typename T , typename Policy >

segment_vector< T, Policy >::iterator pmem::obj::segment_vector< T, Policy >::insert	(	const_iterator	pos,
		T &&	value
	)

Moves value before pos in the container transactionally.

Causes allocation if the new size() is greater than the old capacity(). Only the iterators and references before the insertion pointremain valid.

Parameters

[in]	pos	iterator before which the content will be inserted. pos may be the end() iterator.
[in]	value	element value to be inserted.

Returns: Iterator pointing to the inserted value.

Precondition: value_type must meet the requirements of MoveAssignable and MoveInsertable.

Postcondition: capacity() == nearest power of 2 greater than size() + 1, or remains the same if there is enough space.

Exceptions

rethrows	constructor's exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ max_size()

template<typename T , typename Policy >

constexpr segment_vector< T, Policy >::size_type pmem::obj::segment_vector< T, Policy >::max_size

constexprnoexcept

Returns: maximum number of elements the container is able to hold due to PMDK limitations.

◆ operator=() [1/4]

template<typename T , typename Policy >

segment_vector< T, Policy > & pmem::obj::segment_vector< T, Policy >::operator= ( const segment_vector< T, Policy > & other )

Copy assignment operator.

Replaces the contents with a copy of the contents of other transactionally.

Postcondition: size() == other.size(); capacity() == nearest power of 2 greater than max(other.size(), capacity())

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ operator=() [2/4]

template<typename T , typename Policy >

segment_vector< T, Policy > & pmem::obj::segment_vector< T, Policy >::operator= ( const std::vector< T > & other )

Copy assignment operator.

Replaces the contents with a copy of the contents of std::vector<T> other transactionally.

Postcondition: size() == other.size(); capacity() == nearest power of 2 greater than max(other.size(), capacity())

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ operator=() [3/4]

template<typename T , typename Policy >

segment_vector< T, Policy > & pmem::obj::segment_vector< T, Policy >::operator= ( segment_vector< T, Policy > && other )

Move assignment operator.

Replaces the contents with those of other using move semantics (i.e. the data in other is moved from other into this container) transactionally. Other is in a valid but empty state afterwards.

Postcondition: size() == other.size(); capacity() == other.capacity()

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ operator=() [4/4]

template<typename T , typename Policy >

segment_vector< T, Policy > & pmem::obj::segment_vector< T, Policy >::operator= ( std::initializer_list< T > ilist )

Replaces the contents with those identified by initializer list ilist transactionally.

Postcondition: size() == std::distance(ilist.begin(), ilist.end()); capacity() == nearest power of 2 greater than max(capacity(), std::distance(ilist.begin(), ilist.end()))

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ operator[]() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::reference pmem::obj::segment_vector< T, Policy >::operator[] ( size_type n )

Access element at specific index and add it to a transaction.

No bounds checking is performed.

Parameters

[in] n index number.

Returns: reference to element number n in underlying segments.

Exceptions

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

◆ operator[]() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reference pmem::obj::segment_vector< T, Policy >::operator[] ( size_type n ) const

Access element at specific index.

No bounds checking is performed.

Parameters

[in] n index number.

Returns: const_reference to element number n in underlying segments.

◆ pop_back()

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::pop_back

Removes the last element of the container transactionally.

Calling pop_back on an empty container does nothing. No iterators or references except for back() and end() are invalidated.

Postcondition: size() == std::max(0, size() - 1)

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ push_back() [1/2]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::push_back ( const T & value )

Appends the given element value to the end of the container transactionally.

The new element is initialized as a copy of value.

Parameters

[in] value the value of the element to be appended.

Precondition: value_type must meet the requirements of CopyInsertable.

Postcondition: size() == size() + 1.; capacity() == nearest power of 2 greater than size() + 1, or remains the same if there is enough space.

Exceptions

std::length_error	when new capacity larger than max_size().
rethrows	constructor's exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ push_back() [2/2]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::push_back ( T && value )

Appends the given element value to the end of the container transactionally.

value is moved into the new element.

Parameters

[in] value the value of the element to be appended.

Precondition: value_type must meet the requirements of MoveInsertable.

Postcondition: size() == size() + 1.; capacity() == nearest power of 2 greater than size() + 1, or remains the same if there is enough space.

Exceptions

std::length_error	when new capacity larger than max_size().
rethrows	constructor's exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ range() [1/2]

template<typename T , typename Policy >

slice< typename segment_vector< T, Policy >::iterator > pmem::obj::segment_vector< T, Policy >::range	(	size_type	start,
		size_type	n
	)

Returns slice and snapshots requested range.

This method is not specified by STL standards.

Parameters

[in]	start	start index of requested range.
[in]	n	number of elements in range.

Returns: pmem::obj::slice from start to start + n.

Exceptions

std::out_of_range	if any element of the range would be outside of the segment_vector.
pmem::transaction_error	when snapshotting failed.

◆ range() [2/2]

template<typename T , typename Policy >

slice< typename segment_vector< T, Policy >::const_iterator > pmem::obj::segment_vector< T, Policy >::range	(	size_type	start,
		size_type	n
	)		const

Returns const slice.

This method is not specified by STL standards.

Parameters

[in]	start	start index of requested range.
[in]	n	number of elements in range.

Returns: pmem::obj::slice from start to start + n.

Exceptions

std::out_of_range if any element of the range would be outside of the segment_vector.

◆ rbegin() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::reverse_iterator pmem::obj::segment_vector< T, Policy >::rbegin

Returns a reverse iterator to the beginning.

Returns: reverse_iterator pointing to the last element in the segment_vector.

◆ rbegin() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reverse_iterator pmem::obj::segment_vector< T, Policy >::rbegin

noexcept

Returns a const reverse iterator to the beginning.

Returns: const_reverse_iterator pointing to the last element in the segment_vector.

◆ rend() [1/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::reverse_iterator pmem::obj::segment_vector< T, Policy >::rend

Returns a reverse iterator to the end.

Returns: reverse_iterator pointing to the theoretical element preceding the first element in the segment_vector.

◆ rend() [2/2]

template<typename T , typename Policy >

segment_vector< T, Policy >::const_reverse_iterator pmem::obj::segment_vector< T, Policy >::rend

noexcept

Returns a const reverse iterator to the end.

Returns: const_reverse_iterator pointing to the theoretical element preceding the first element in the segment_vector.

◆ reserve()

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::reserve ( size_type capacity_new )

Increases the capacity of the segment_vector to capacity_new transactionally.

If segment where should be capacity_new is greater than the current capacity's segment, new segments allocated, otherwise the method does nothing. Past-the-end iterator invalidated if allocation occurs.

Parameters

[in] capacity_new new capacity.

Postcondition: capacity() == max(capacity(), capacity_new)

Exceptions

std::length_error	when capacity_new larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_alloc_error	when allocating new memory failed.

◆ resize() [1/2]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::resize ( size_type count )

Resizes the container to count elements transactionally.

If the current size is greater than count, the container is reduced to its first count elements. If the current size is less than count, additional default-inserted elements are appended.

Parameters

[in] count new size of the container

Postcondition: capacity() == nearest power of 2 greater than std::max(capacity(), count); size() == count

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
std::length_error	when new capacity larger than max_size().
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_out_of_memory	when not enough memory to allocate.

◆ resize() [2/2]

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::resize	(	size_type	count,
		const value_type &	value
	)

Resizes the container to contain count elements transactionally.

If the current size is greater than count, the container is reduced to its first count elements. If the current size is less than count, additional copies of value are appended.

Parameters

[in]	count	new size of the container.
[in]	value	the value to initialize the new elements with.

Postcondition: capacity() == nearest power of 2 greater than std::max(capacity(), count); size() == count

Exceptions

rethrows	constructor's exception.
rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.
std::length_error	when new capacity larger than max_size().
pmem::transaction_alloc_error	when allocating new memory failed.
pmem::transaction_out_of_memory	when not enough memory to allocate.

◆ shrink_to_fit()

template<typename T , typename Policy >

void pmem::obj::segment_vector< T, Policy >::shrink_to_fit

Requests transactional removal of unused capacity.

New capacity will be set to nearest power of 2 greater than current size().

Postcondition: capacity() == nearest power of 2 bigger than size()

Exceptions

rethrows	destructor exception.
pmem::transaction_error	when snapshotting failed.
pmem::transaction_free_error	when freeing underlying segment failed.

◆ size()

template<typename T , typename Policy >

segment_vector< T, Policy >::size_type pmem::obj::segment_vector< T, Policy >::size

noexcept

Returns: number of elements.

Friends And Related Function Documentation

◆ operator!=() [1/3]

template<typename T , typename Policy >

bool operator!=	(	const segment_vector< T, Policy > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers.

Checks if containers have the different number of elements or at least one element in lhs is not equal to element in rhs at the same position.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of the containers are not equal, false otherwise.

◆ operator!=() [2/3]

template<typename T , typename Policy >

bool operator!=	(	const segment_vector< T, Policy > &	lhs,
		const std::vector< T > &	rhs
	)

Compares the contents of two containers.

Checks if containers have the same number of elements and each element in lhs is equal to element in rhs at the same position.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, SegmentPolicy, StoragePolicy>
[in]	rhs	is std::vector<T>.

Returns: true if contents of the containers are not equal, false otherwise.

◆ operator!=() [3/3]

template<typename T , typename Policy >

bool operator!=	(	const std::vector< T > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers.

Checks if containers have the same number of elements and each element in lhs is equal to element in rhs at the same position.

Parameters

[in]	lhs	is std::vector<T>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of the containers are not equal, false otherwise.

◆ operator<() [1/3]

template<typename T , typename Policy >

bool operator<	(	const segment_vector< T, Policy > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of lhs are lexicographically less than contents of rhs, false otherwise.

◆ operator<() [2/3]

template<typename T , typename Policy >

bool operator<	(	const segment_vector< T, Policy > &	lhs,
		const std::vector< T > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, SegmentPolicy, StoragePolicy>
[in]	rhs	is std::vector<T>.

Returns: true if contents of lhs are lexicographically less than contents of rhs, false otherwise.

◆ operator<() [3/3]

template<typename T , typename Policy >

bool operator<	(	const std::vector< T > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is std::vector<T>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of lhs are lexicographically less than contents of rhs, false otherwise.

◆ operator<=() [1/3]

template<typename T , typename Policy >

bool operator<=	(	const segment_vector< T, Policy > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy>.

Returns: true if contents of lhs are lexicographically lesser than or equal to contents of rhs, false otherwise.

◆ operator<=() [2/3]

template<typename T , typename Policy >

bool operator<=	(	const segment_vector< T, Policy > &	lhs,
		const std::vector< T > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, SegmentPolicy, StoragePolicy>
[in]	rhs	is std::vector<T>.

Returns: true if contents of lhs are lexicographically lesser than or equal to contents of rhs, false otherwise.

◆ operator<=() [3/3]

template<typename T , typename Policy >

bool operator<=	(	const std::vector< T > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is std::vector<T>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of lhs are lexicographically lesser than or equal to contents of rhs, false otherwise.

◆ operator==() [1/3]

template<typename T , typename Policy >

bool operator==	(	const segment_vector< T, Policy > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers.

Checks if containers have the same number of elements and each element in lhs is equal to element in rhs at the same position.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of the containers are equal, false otherwise.

◆ operator==() [2/3]

template<typename T , typename Policy >

bool operator==	(	const segment_vector< T, Policy > &	lhs,
		const std::vector< T > &	rhs
	)

Compares the contents of two containers.

Checks if containers have the same number of elements and each element in lhs is equal to element in rhs at the same position.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, SegmentPolicy, StoragePolicy>
[in]	rhs	is std::vector<T>.

Returns: true if contents of the containers are equal, false otherwise.

◆ operator==() [3/3]

template<typename T , typename Policy >

bool operator==	(	const std::vector< T > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers.

Checks if containers have the same number of elements and each element in lhs is equal to element in rhs at the same position.

Parameters

[in]	lhs	is std::vector<T>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of the containers are equal, false otherwise.

◆ operator>() [1/3]

template<typename T , typename Policy >

bool operator>	(	const segment_vector< T, Policy > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of lhs are lexicographically greater than contents of rhs, false otherwise.

◆ operator>() [2/3]

template<typename T , typename Policy >

bool operator>	(	const segment_vector< T, Policy > &	lhs,
		const std::vector< T > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, SegmentPolicy, StoragePolicy>
[in]	rhs	is std::vector<T>.

Returns: true if contents of lhs are lexicographically greater than contents of rhs, false otherwise.

◆ operator>() [3/3]

template<typename T , typename Policy >

bool operator>	(	const std::vector< T > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is std::vector<T>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of lhs are lexicographically greater than contents of rhs, false otherwise.

◆ operator>=() [1/3]

template<typename T , typename Policy >

bool operator>=	(	const segment_vector< T, Policy > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of lhs are lexicographically greater than or equal to contents of rhs, false otherwise.

◆ operator>=() [2/3]

template<typename T , typename Policy >

bool operator>=	(	const segment_vector< T, Policy > &	lhs,
		const std::vector< T > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is pmem::obj::experimental::segment_vector<T, SegmentPolicy, StoragePolicy>
[in]	rhs	is std::vector<T>.

Returns: true if contents of lhs are lexicographically greater than or equal to contents of rhs, false otherwise.

◆ operator>=() [3/3]

template<typename T , typename Policy >

bool operator>=	(	const std::vector< T > &	lhs,
		const segment_vector< T, Policy > &	rhs
	)

Compares the contents of two containers lexicographically.

Parameters

[in]	lhs	is std::vector<T>.
[in]	rhs	is pmem::obj::experimental::segment_vector<T, Policy, SPolicy>.

Returns: true if contents of lhs are lexicographically greater than or equal to contents of rhs, false otherwise.

◆ swap()

template<typename T , typename Policy >

void swap	(	segment_vector< T, Policy > &	lhs,
		segment_vector< T, Policy > &	rhs
	)

Parameters

[in]	lhs	first segment_vector.
[in]	rhs	second segment_vector.

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

libpmemobj++/container/segment_vector.hpp

Public Types

Public Member Functions

Related Functions

Detailed Description

template<typename T, typename Policy = exponential_size_vector_policy<>> class pmem::obj::segment_vector< T, Policy >

Constructor & Destructor Documentation

◆ segment_vector() [1/8]

◆ segment_vector() [2/8]

◆ segment_vector() [3/8]

◆ segment_vector() [4/8]

◆ segment_vector() [5/8]

◆ segment_vector() [6/8]

◆ segment_vector() [7/8]

◆ segment_vector() [8/8]

◆ ~segment_vector()

Member Function Documentation

◆ assign() [1/6]

◆ assign() [2/6]

◆ assign() [3/6]

◆ assign() [4/6]

◆ assign() [5/6]

◆ assign() [6/6]

◆ at() [1/2]

◆ at() [2/2]

◆ back() [1/2]

◆ back() [2/2]

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ cback()

◆ cbegin()

◆ cend()

◆ cfront()

◆ clear()

◆ const_at()

◆ crange()

◆ crbegin()

◆ crend()

◆ emplace()

◆ emplace_back()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ erase() [1/2]

◆ erase() [2/2]

◆ free_data()

◆ front() [1/2]

◆ front() [2/2]

◆ insert() [1/5]

◆ insert() [2/5]

◆ insert() [3/5]

◆ insert() [4/5]

◆ insert() [5/5]

◆ max_size()

◆ operator=() [1/4]

◆ operator=() [2/4]

◆ operator=() [3/4]

◆ operator=() [4/4]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ pop_back()

◆ push_back() [1/2]

◆ push_back() [2/2]

◆ range() [1/2]

◆ range() [2/2]

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ rend() [1/2]

◆ rend() [2/2]

◆ reserve()

◆ resize() [1/2]

◆ resize() [2/2]

◆ shrink_to_fit()

◆ size()

Friends And Related Function Documentation

◆ operator!=() [1/3]

◆ operator!=() [2/3]

◆ operator!=() [3/3]

◆ operator<() [1/3]

◆ operator<() [2/3]

template<typename T, typename Policy = exponential_size_vector_policy<>>
class pmem::obj::segment_vector< T, Policy >