Namespace List

Here is a list of all documented namespaces with brief descriptions:

[detail level 12345]

▼Npmem	Persistent memory namespace
▼Ndetail	Implementation details
Cconcurrent_skip_list	Persistent memory aware implementation of the concurrent skip list
Ccontiguous_iterator	Base class for iterators which satisfies RandomAccessIterator and operate on contiguous memory
Crange_snapshotting_iterator	Non-const iterator which adds elements to a transaction in a bulk
Cbasic_contiguous_iterator	Default non-const iterator which adds element to a transaction on every access
Cebr	Epoch-based reclamation (EBR)
Cid_manager	This structure is used for assigning unique thread ids so that those ids will be reused in case of thread exit
Cthread_id_type	RAII-style structure for holding thread id
Cenumerable_thread_specific	Class for storing thread local data
Cis_output_iterator	Type trait to determine if a given parameter type satisfies requirements of OutputIterator
Cis_input_iterator	Type trait to determine if a given parameter type satisfies requirements of InputIterator
Cis_forward_iterator	Type trait to determine if a given parameter type satisfies requirements of ForwardIterator
Cis_bidirectional_iterator	Type trait to determine if a given parameter type satisfies requirements of BidirectionalIterator
Cis_random_access_iterator	Type trait to determine if a given parameter type satisfies requirements of RandomAccessIterator
Cself_relative_ptr_base_impl	Self_relative_ptr base template class
Cself_relative_accessor	Static class accessor to self_relative_ptr_base
Ctemp_value	Template class for caching objects based on constructor's variadic template arguments and LIBPMEMOBJ_CPP_MAX_STACK_ALLOC_SIZE
Cvolatile_state	Global key value store which allows persistent objects to use volatile memory
Ccan_do_snapshot< std::atomic< obj::experimental::self_relative_ptr< T > > >	Pmem::detail::can_do_snapshot atomic specialization for self_relative_ptr
Ccan_do_snapshot	A structure that checks if it is possible to snapshot the specified memory
Ctransaction_base	Common functionality for basic_transaction and flat_transaction
▼Nobj	Main libpmemobj namespace
Nconcurrent_hash_map_internal
▼Nexperimental	Experimental implementations
Nringbuf
Catomic_persistent_aware_ptr	Atomic specialization of a persistent ptr (self_relative_ptr) that manages its persistence by itself
Cconcurrent_map	Persistent memory aware implementation of Intel TBB concurrent_map with API partially compatible to std::map
Cbasic_dram_inline_string	Pmem/DRAM variation of pmem::obj::string, where data is kept right next to the inline_string structure
Cbasic_inline_string	Pmem-only variation of pmem::obj::string, where data is kept right next to the inline_string structure
Ctotal_sizeof	A helper trait which calculates required memory capacity (in bytes) for a type
Ctotal_sizeof< basic_inline_string< CharT, Traits > >	A helper trait which calculates required memory capacity (in bytes) for a type
Ctotal_sizeof< basic_dram_inline_string< CharT, Traits > >	A helper trait which calculates required memory capacity (in bytes) for a type
▼Cmpsc_queue	Persistent memory aware implementation of multi producer single consumer queue
Cbatch_type	Type representing the range of the mpsc_queue elements
Cpmem_log_type	Type representing persistent data, which may be managed by mpsc_queue
Cworker	Mpsc_queue producer worker class
▼Cradix_tree	Persistent associative, ordered container with API similar and partially compatible with the API of std::map
Cleaf	This is the structure which 'holds' key/value pair
Cnode	This is internal node
Cself_relative_ptr	Persistent self-relative pointer class
Cv	Volatile residing on pmem class
▼Nsegment_vector_internal	Internal implementation of pmem's segment vector
Csegment_iterator	Iterator for segment_vector
Callocation_flag	Type of flag which can be passed to make_persistent
Callocation_flag_atomic	Type of flag which can be passed to make_persistent_atomic
▼Cobject_traits	Encapsulates object specific allocator functionality
Crebind	Rebind to a different type
▼Cobject_traits< void >	Object traits specialization for the void type
Crebind	Rebind to a different type
▼Cstandard_alloc_policy	The allocation policy template for a given type
Crebind	Rebind to a different type
▼Cstandard_alloc_policy< void >	Void specialization of the standard allocation policy
Crebind	Rebind to a different type
▼Callocator	(EXPERIMENTAL) Encapsulates the information about the persistent memory allocation model using PMDK's libpmemobj
Crebind	Rebind to a different type
Ccondition_variable	Persistent memory resident condition variable
Carray	Persistent container with std::array compatible interface
Cbasic_string	Persistent string container with std::basic_string compatible interface
▼Cconcurrent_hash_map	Persistent memory aware implementation of Intel TBB concurrent_hash_map
Caccessor	Allows write access to elements and combines data access, locking, and garbage collection
Cbucket_accessor	Bucket accessor is to find, rehash, acquire a lock, and access a bucket
Cconst_accessor	Combines data access, locking, and garbage collection
Cmutex_vector	Vector of locks to be unlocked at the destruction time
Cserial_bucket_accessor	Serial bucket accessor used to access bucket in a serial operations
Csegment_vector	Persistent version of segment vector with std::vector compatible interface
Cvector	Persistent container with std::vector compatible interface
Cdefrag	Defrag class
Cpersistent_ptr	Persistent pointer class
Cmutex	Persistent memory resident mutex implementation
Cp	Resides on pmem class
Cpool	PMEMobj pool class
Cpersistent_ptr< void >	Persistent_ptr void specialization
Cpersistent_ptr< const void >	Persistent_ptr const void specialization
Cpersistent_ptr_base	Persistent_ptr base (non-template) class
Cpool_base	The non-template pool base class
Cshared_mutex	Persistent memory resident shared_mutex implementation
Cslice	Provides interface to access sequence of objects
Cbasic_string_view	Our partial std::string_view implementation
Ctimed_mutex	Persistent memory resident timed_mutex implementation
Cbasic_transaction	C++ transaction handler class
Cflat_transaction	C++ flat transaction handler class
Cpool_error	Custom pool error class
Cpool_invalid_argument	Custom pool error class
Ctransaction_error	Custom transaction error class
Clock_error	Custom lock error class
Ctransaction_alloc_error	Custom transaction error class
Ctransaction_out_of_memory	Custom out of memory error class
Ctransaction_free_error	Custom transaction error class
Ctransaction_scope_error	Custom transaction error class
Cmanual_tx_abort	Custom transaction error class
Clayout_error	Custom layout error class
Cctl_error	Custom ctl error class
Cdefrag_error	Custom defrag error class
▼Nstd	STL namespace
Chash< pmem::obj::p< T > >	Specialization of std::hash for p<T>
Catomic< pmem::obj::experimental::self_relative_ptr< T > >	Atomic specialization for self_relative_ptr
Cnumeric_limits< pmem::obj::p< T > >	Specialization of std::numeric_limits for p<T>
Cless< pmem::obj::p< T > >	Specialization of std::less for p<T>