Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 12345]

▼Npmem	Persistent memory namespace
▼Ndetail	Implementation details
Cbasic_contiguous_iterator	Default non-const iterator which adds element to a transaction on every access
Ccan_do_snapshot	A structure that checks if it is possible to snapshot the specified memory
Ccan_do_snapshot< std::atomic< obj::experimental::self_relative_ptr< T > > >	Can_do_snapshot atomic specialization for self_relative_ptr
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
Cenumerable_thread_specific	Class for storing thread local data
Cid_manager	This structure is used for assigning unique thread ids so that those ids will be reused in case of thread exit
Cis_bidirectional_iterator	Type trait to determine if a given parameter type satisfies requirements of BidirectionalIterator
Cis_forward_iterator	Type trait to determine if a given parameter type satisfies requirements of ForwardIterator
Cis_input_iterator	Type trait to determine if a given parameter type satisfies requirements of InputIterator
Cis_output_iterator	Type trait to determine if a given parameter type satisfies requirements of OutputIterator
Cis_random_access_iterator	Type trait to determine if a given parameter type satisfies requirements of RandomAccessIterator
Crange_snapshotting_iterator	Non-const iterator which adds elements to a transaction in a bulk
Cself_relative_accessor	Static class accesssor to self_relative_ptr_base
Cself_relative_ptr_base_impl	Self_relative_ptr base template class
Cthread_id_type	RAII-style structure for holding thread id
▼Ctransaction_base	Common functionality for basic_transaction and flat_transaction
Ctx_data	This data is stored along with the pmemobj transaction data using pmemobj_tx_set_data()
Cvolatile_state	Global key value store which allows persistent objects to use volatile memory
▼Nobj	Main libpmemobj namespace
▼Nexperimental	Experimental implementations
Cbasic_inline_string	This class serves similar purpose to pmem::obj::string, but keeps the data within the same allocation as inline_string itself
Cconcurrent_map	Persistent memory aware implementation of Intel TBB concurrent_map
▼Cradix_tree	Radix tree is an associative, ordered container
Cleaf	This is the structure which 'holds' key/value pair
Cnode	This is internal node
Cradix_tree_iterator	Radix tree iterator supports multipass and bidirectional iteration
Cself_relative_ptr	Persistent self-relative pointer class
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
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
▼Callocator	(EXPERIMENTAL) Encapsulates the information about the persistent memory allocation model using PMDK's libpmemobj
Crebind	Rebind to a different type
Carray	Pmem::obj::array - persistent container with std::array compatible interface
Cbasic_string	Pmem::obj::string - persistent container with std::basic_string compatible interface
Cbasic_string_view	Our partial std::string_view implementation
Cbasic_transaction	C++ transaction handler class
▼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
Ccondition_variable	Persistent memory resident condition variable
Cdefrag	Defrag class
Cflat_transaction	C++ flat transaction handler class
Cmutex	Persistent memory resident mutex implementation
▼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
Cp	Resides on pmem class
Cpersistent_ptr	Persistent pointer class
Cpersistent_ptr< const void >	Persistent_ptr const void specialization
Cpersistent_ptr< void >	Persistent_ptr void specialization
Cpersistent_ptr_base	Persistent_ptr base (non-template) class
Cpool	PMEMobj pool class
Cpool_base	The non-template pool base class
Csegment_vector	A persistent version of segment vector implementation
Cshared_mutex	Persistent memory resident shared_mutex implementation
Cslice	Pmem::obj::slice - provides interface to access sequence of objects
▼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
Ctimed_mutex	Persistent memory resident timed_mutex implementation
Cvector	Pmem::obj::vector - persistent container with std::vector compatible interface
Cctl_error	Custom ctl error class
Cdefrag_error	Custom defrag error class
Clayout_error	Custom layout error class
Clock_error	Custom lock error class
Cmanual_tx_abort	Custom transaction error class
Cpool_error	Custom pool error class
Ctransaction_alloc_error	Custom transaction error class
Ctransaction_error	Custom transaction error class
Ctransaction_free_error	Custom transaction error class
Ctransaction_out_of_memory	Custom out of memory error class
Ctransaction_scope_error	Custom transaction error class
▼Nstd
Catomic< pmem::obj::experimental::self_relative_ptr< T > >	Atomic specialization for self_relative_ptr
Chash< pmem::obj::p< T > >	Specialization of std::hash for p<T>
Cless< pmem::obj::p< T > >	Specialization of std::less for p<T>
Cnumeric_limits< pmem::obj::p< T > >	Specialization of std::numeric_limits for p<T>