PMDK C++ bindings  1.12.1-rc1
This is the C++ bindings documentation for PMDK's libpmemobj.
Classes | Typedefs | Functions
pmem::obj::experimental Namespace Reference

Experimental implementations. More...

Classes

class  basic_inline_string
 This class serves similar purpose to pmem::obj::string, but keeps the data within the same allocation as inline_string itself. More...
 
class  concurrent_map
 Persistent memory aware implementation of Intel TBB concurrent_map. More...
 
class  radix_tree
 Radix tree is an associative, ordered container. More...
 
class  self_relative_ptr
 Persistent self-relative pointer class. More...
 
struct  total_sizeof
 A helper trait which calculates required memory capacity (in bytes) for a type. More...
 
struct  total_sizeof< basic_inline_string< CharT, Traits > >
 A helper trait which calculates required memory capacity (in bytes) for a type. More...
 
class  v
 Volatile residing on pmem class. More...
 

Typedefs

using self_relative_ptr_base = pmem::detail::self_relative_ptr_base_impl< std::ptrdiff_t >
 self_relative_ptr base (non-template) class More...
 

Functions

template<typename Key , typename Value , typename Comp , typename Allocator >
void swap (concurrent_map< Key, Value, Comp, Allocator > &lhs, concurrent_map< Key, Value, Comp, Allocator > &rhs)
 Non-member swap.
 
template<typename Key , typename Value , typename BytesView >
void swap (radix_tree< Key, Value, BytesView > &lhs, radix_tree< Key, Value, BytesView > &rhs)
 Non-member swap.
 
template<typename K , typename V , typename BV >
std::ostream & operator<< (std::ostream &os, const radix_tree< K, V, BV > &tree)
 Prints tree in DOT format. More...
 
template<class T >
void swap (self_relative_ptr< T > &a, self_relative_ptr< T > &b)
 Swaps two self_relative_ptr objects of the same type. More...
 
template<typename T , typename Y >
bool operator== (self_relative_ptr< T > const &lhs, self_relative_ptr< Y > const &rhs) noexcept
 Equality operator.
 
template<typename T , typename Y >
bool operator!= (self_relative_ptr< T > const &lhs, self_relative_ptr< Y > const &rhs) noexcept
 Inequality operator.
 
template<typename T >
bool operator== (self_relative_ptr< T > const &lhs, std::nullptr_t) noexcept
 Equality operator with nullptr.
 
template<typename T >
bool operator== (std::nullptr_t, self_relative_ptr< T > const &lhs) noexcept
 Equality operator with nullptr.
 
template<typename T >
bool operator!= (self_relative_ptr< T > const &lhs, std::nullptr_t) noexcept
 Inequality operator with nullptr.
 
template<typename T >
bool operator!= (std::nullptr_t, self_relative_ptr< T > const &lhs) noexcept
 Inequality operator with nullptr.
 
template<typename T , typename Y >
bool operator< (self_relative_ptr< T > const &lhs, self_relative_ptr< Y > const &rhs) noexcept
 Less than operator. More...
 
template<typename T , typename Y >
bool operator<= (self_relative_ptr< T > const &lhs, self_relative_ptr< Y > const &rhs) noexcept
 Less or equal than operator. More...
 
template<typename T , typename Y >
bool operator> (self_relative_ptr< T > const &lhs, self_relative_ptr< Y > const &rhs) noexcept
 Greater than operator. More...
 
template<typename T , typename Y >
bool operator>= (self_relative_ptr< T > const &lhs, self_relative_ptr< Y > const &rhs) noexcept
 Greater or equal than operator. More...
 
template<typename T >
bool operator< (self_relative_ptr< T > const &lhs, std::nullptr_t) noexcept
 Compare a self_relative_ptr with a null pointer.
 
template<typename T >
bool operator< (std::nullptr_t, self_relative_ptr< T > const &rhs) noexcept
 Compare a self_relative_ptr with a null pointer.
 
template<typename T >
bool operator<= (self_relative_ptr< T > const &lhs, std::nullptr_t) noexcept
 Compare a self_relative_ptr with a null pointer.
 
template<typename T >
bool operator<= (std::nullptr_t, self_relative_ptr< T > const &rhs) noexcept
 Compare a self_relative_ptr with a null pointer.
 
template<typename T >
bool operator> (self_relative_ptr< T > const &lhs, std::nullptr_t) noexcept
 Compare a self_relative_ptr with a null pointer.
 
template<typename T >
bool operator> (std::nullptr_t, self_relative_ptr< T > const &rhs) noexcept
 Compare a self_relative_ptr with a null pointer.
 
template<typename T >
bool operator>= (self_relative_ptr< T > const &lhs, std::nullptr_t) noexcept
 Compare a self_relative_ptr with a null pointer.
 
template<typename T >
bool operator>= (std::nullptr_t, self_relative_ptr< T > const &rhs) noexcept
 Compare a self_relative_ptr with a null pointer.
 
template<typename T >
self_relative_ptr< T > operator+ (self_relative_ptr< T > const &lhs, std::ptrdiff_t s)
 Addition operator for self-relative pointers.
 
template<typename T >
self_relative_ptr< T > operator- (self_relative_ptr< T > const &lhs, std::ptrdiff_t s)
 Subtraction operator for self-relative pointers.
 
template<typename T , typename Y , typename = typename std::enable_if< std::is_same<typename std::remove_cv<T>::type, typename std::remove_cv<Y>::type>::value>>
ptrdiff_t operator- (self_relative_ptr< T > const &lhs, self_relative_ptr< Y > const &rhs)
 Subtraction operator for self-relative pointers of identical type. More...
 
template<typename T >
std::ostream & operator<< (std::ostream &os, self_relative_ptr< T > const &ptr)
 Ostream operator.
 
template<class T >
void swap (v< T > &a, v< T > &b)
 Swaps two v objects of the same type. More...
 

Detailed Description

Experimental implementations.

It contains implementations, which are not yet ready to be used in production. They may be not finished, not fully tested or still in discussion. It is located within pmem::obj namespace.

Typedef Documentation

◆ self_relative_ptr_base

self_relative_ptr base (non-template) class

Implements some of the functionality of the self_relative_ptr class. It defines all applicable conversions from and to a self_relative_ptr_base.

It can be used e.g. as a parameter, where self_relative_ptr of any template type is required. It is similar to self_relative_ptr<void> (it can point to whatever type), but it can be used when you want to have pointer to some unspecified self_relative_ptr (with self_relative_ptr<void> it can't be done, because: self_relative_ptr<T>* does not convert to self_relative_ptr<void>*).

Function Documentation

◆ operator-()

template<typename T , typename Y , typename = typename std::enable_if< std::is_same<typename std::remove_cv<T>::type, typename std::remove_cv<Y>::type>::value>>
ptrdiff_t pmem::obj::experimental::operator- ( self_relative_ptr< T > const &  lhs,
self_relative_ptr< Y > const &  rhs 
)
inline

Subtraction operator for self-relative pointers of identical type.

Calculates the offset difference. Calculating the difference of pointers from objects of different pools is not allowed.

◆ operator<()

template<typename T , typename Y >
bool pmem::obj::experimental::operator< ( self_relative_ptr< T > const &  lhs,
self_relative_ptr< Y > const &  rhs 
)
inlinenoexcept

Less than operator.

Returns
true if the sum(this, offset) of lhs is less than the sum(this, offset) of rhs. Returns false otherwise.

◆ operator<<()

template<typename K , typename V , typename BV >
std::ostream& pmem::obj::experimental::operator<< ( std::ostream &  os,
const radix_tree< K, V, BV > &  tree 
)

Prints tree in DOT format.

Used for debugging.

◆ operator<=()

template<typename T , typename Y >
bool pmem::obj::experimental::operator<= ( self_relative_ptr< T > const &  lhs,
self_relative_ptr< Y > const &  rhs 
)
inlinenoexcept

Less or equal than operator.

See less than operator for comparison rules.

◆ operator>()

template<typename T , typename Y >
bool pmem::obj::experimental::operator> ( self_relative_ptr< T > const &  lhs,
self_relative_ptr< Y > const &  rhs 
)
inlinenoexcept

Greater than operator.

See less than operator for comparison rules.

◆ operator>=()

template<typename T , typename Y >
bool pmem::obj::experimental::operator>= ( self_relative_ptr< T > const &  lhs,
self_relative_ptr< Y > const &  rhs 
)
inlinenoexcept

Greater or equal than operator.

See less than operator for comparison rules.

◆ swap() [1/2]

template<class T >
void pmem::obj::experimental::swap ( self_relative_ptr< T > &  a,
self_relative_ptr< T > &  b 
)
inline

Swaps two self_relative_ptr objects of the same type.

Non-member swap function as required by Swappable concept. en.cppreference.com/w/cpp/concept/Swappable

◆ swap() [2/2]

template<class T >
void pmem::obj::experimental::swap ( v< T > &  a,
v< T > &  b 
)
inline

Swaps two v objects of the same type.

Non-member swap function as required by Swappable concept. en.cppreference.com/w/cpp/concept/Swappable