Class List

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

[detail level 1234]

►Nderecho
►Nrpc
Cconst_partial_wrapped	Exactly the same as the partial_wrapped template, but for pointer-to-member-functions that are const
Cnode_removed_from_group_exception	Indicates that an RPC call to a node failed because the node was removed from the Replicated Object's subgroup (and possibly from the enclosing Group entirely) after the RPC message was sent but before a reply was received
COpcode	An RPC function call can be uniquely identified by the tuple (class, subgroup ID, function ID, is-reply), which is what this struct encapsulates
Cpartial_wrapped	Template that pairs a FunctionTag with a pointer-to-member-function
CPendingBase	Abstract base type for PendingResults
CPendingResults	Data structure that holds a set of promises for a single RPC function call; the promises transmit one response (either a value or an exception) for each node that was called
CPendingResults< void >	Specialization of PendingResults for void functions, which do not generate replies
►CQueryResults	Data structure that (indirectly) holds a set of futures for a single RPC function call; there is one future for each node contacted to make the call, and it will eventually contain that node's reply
CReplyMap
►CQueryResults< void >	Specialization of QueryResults for void functions, which do not generate replies
CReplyMap
Crecv_ret	Return type of all the RemoteInvocable::receive_* methods
Cremote_exception_occurred	Indicates that an RPC call failed because executing the RPC function on the remote node resulted in an exception
CRemoteInvocable
CRemoteInvocable< Tag, std::function< Ret(Args...)> >	Provides functions to implement handling RPC calls to a single function, identified by its compile-time "tag" or opcode
CRemoteInvocableClass	Transforms a class into a "replicated object" with methods that can be invoked by RPC, given a place to store RPC message handlers (which should be the "receivers map" of RPCManager)
CRemoteInvocableClass< IdentifyingClass >	Specialization of RemoteInvocableClass for classes that have no RPC methods
CRemoteInvocablePairs
CRemoteInvocablePairs< wrapped< id, FunType > >	Base case for RemoteInvocablePairs, where the template parameter pack contains only a single wrapped<id, FunType>
CRemoteInvocablePairs< wrapped< id, FunType >, rest... >	This struct exists purely to inherit from a series of RemoteInvoker and RemoteInvocables; it inherits one pair of RemoteInvoker/RemoteInvocable for each wrapped<id, FunType> type in its template parameter pack
CRemoteInvoker
►CRemoteInvoker< Tag, std::function< Ret(Args...)> >	Provides functions to implement RPC sends for function calls to a single function, identified by its compile-time "tag" or ID
Csend_return	Return type for the send function
CRemoteInvokerForClass	Transforms a class into an RPC client for the methods of that class, given a place to store RPC message handlers (which should be the "receivers map" of RPCManager)
CRemoteInvokerForClass< IdentifyingClass >	Specialization of RemoteInvokerForClass for classes that have no RPC methods
CRemoteInvokers	Technically, RemoteInvokers is a specialization of this template, but it's the only specialization, so this template does nothing
CRemoteInvokers< wrapped< Tag, FunType > >	Base case for RemoteInvokers, where the template parameter pack contains only a single wrapped<id, FunType>
CRemoteInvokers< wrapped< Tag, FunType >, RestWrapped... >	This struct exists purely to inherit from a list of RemoteInvokers, one for each wrapped<> type in its template parameter pack
►CRPCManager
Cfifo_req
Csender_removed_from_group_exception	Indicates that an RPC call from this node was aborted because this node was removed from its subgroup/shard (and reassigned to another one) during the view change
CString	This "compile-time String" puts a short sequence of characters into a type's template parameter, allowing it to be accessed at compile-time in a constexpr hash function
Cwrapped	This matches uses of wrapped<> where the second argument is not a function, and does nothing
Cwrapped< Tag, std::function< Ret(Arguments...)> >	Template that pairs a FunctionTag with a function pointer, thus "naming" the function with a tag (ID) that is a compile-time value
C_Group
CCallbackSet	Bundles together a set of callback functions for message delivery events
CConf	The single configuration file for derecho
CCrossProductPolicy	An alternate type of subgroup allocation policy for subgroup types whose membership will be defined as a cross-product of other subgroups
CDefaultSubgroupAllocator	Functor of type shard_view_generator_t that implements the default subgroup allocation algorithm, parameterized based on a policy for each subgroup type (i.e
Cderecho_exception	Base exception class for all exceptions raised by Derecho
CDerechoParams	Bundles together a set of low-level parameters for configuring Derecho groups
CDerechoSST	The GMS and derecho_group will share the same SST for efficiency
Cempty_reference_exception	Exception that means a reference-like type is "empty" (does not contain a valid object)
CExternalCaller
CGroup	The top-level object for creating a Derecho group
CGroupProjection
CGroupReference
CIDeserializationContext	The Deserialization Interface to be implemented by user applications
Cinvalid_node_exception	Exception that means the user requested an operation targeting a specific node and that node was not as valid target, e.g
Cinvalid_subgroup_exception	Exception that means the user made an invalid request for a subgroup handle, such as by supplying an out-of-bounds subgroup index
CJoinResponse	Bundles together a JoinResponseCode and the leader's node ID, which it also needs to send to the new node that wants to join
►CLockedQueue	A little helper class that implements a threadsafe queue by requiring all clients to lock a mutex before accessing the queue
CLockedListAccess
CLockedReference	A little helper class that wraps together a reference and a lock on a related mutex
CMessageBuffer	Represents a block of memory used to store a message
CMulticastGroup	Implements the low-level mechanics of tracking multicasts in a Derecho group, using RDMC to deliver messages and SST to track their arrival and stability
CPersistenceManager	PersistenceManager is responsible for persisting all the data in a group
CPersistsFields	This is a marker interface for user-defined Replicated Objects (i.e
CRaggedTrim	Represents the data needed to log a "ragged trim" decision to disk
CRawObject	An empty class to be used as the "replicated type" for a subgroup that doesn't implement a Replicated Object
CRDMCMessage	A structure containing an RDMC message (which consists of some bytes in a registered memory region) and some associated metadata
CReplicated
CReplicatedObject	Common interface for all types of Replicated<T>, specifying some methods for state transfer and persistence
CRestartLeaderState
CRestartState
CShardAllocationPolicy	A data structure defining the parameters of the default subgroup allocation function for a single subgroup; it specifies how one subgroup is divided into shards
CShardIterator
CSSTMessage
Csubgroup_provisioning_exception	An exception that indicates that a subgroup membership function was unable to finish executing because its enclosing Group was not in a valid state
CSubgroupAllocationPolicy	A data structure defining the parameters of the default subgroup allocation function for a single subgroup type
CSubgroupInfo	Container for whatever information is needed to describe a Group's subgroups and shards
CSubgroupSettings	A collection of settings for a single subgroup that this node is a member of
CSubView	The subset of a View associated with a single shard, or a single subgroup if the subgroup is non-sharded
CView
CViewManager
►Nmutils
CByteRepresentable	A non-POD type which wishes to mark itself byte representable should extend this class
CBytes
CContextDeleter
CContextDeleter< void >
CDeserializationManager	The manager for any RemoteDeserializationContexts
Cdsr_info
Cis_list
Cis_list< std::list< T > >
Cis_map
Cis_map< std::map< K, V > >
Cis_pair
Cis_pair< std::pair< T, U > >
Cis_string
Cis_string< const std::string >
Cis_string< std::string >
Cmarshalled	The "marshalled" type is a wrapper for already-serialized types;
CRemoteDeserializationContext	If a class which implements ByteRepresentable requires a context in order to correctly deserialize, that context should be represented as a class that extends RemoteDeserializationContext
►Nobjectstore
CBlob
CDeltaObjectStoreCore
CIObjectStoreAPI
CIObjectStoreService
CIReplica
CObject
CObjectStoreService
CPersistentLoggedObjectStore
CVolatileUnloggedObjectStore
►Npersistent	This file include all common types internal to derecho and not necessarily being known by a client program
C_NameMaker
CFilePersistLog
Chlc_index_entry
Chlc_index_entry_comp
CIDeltaObjectFactory
CIDeltaSupport
CITemporalQueryFrontierProvider
Clog_entry
Clog_entry.fields
Cmeta_header
Cmeta_header.fields
CPersistent
CPersistentRegistry	PersistentRegistry is a book for all the Persistent<T> or Volatile<T> variables
CPersistLog
CVolatile
►Nrdma	Contains functions and classes for low-level RDMA operations, such as setting up memory regions and queue pairs
Ccm_con_data_t
Ccompletion_handler_set	Listener to detect new incoming connections
Ccompletion_queue	A C++ wrapper for the libfabric fid_cq struct and its associated functions
Cconfig_t
Cconfiguration_failure
Cconnection_broken
Ccq_creation_failure
Ccreation_failure
Cendpoint	A C++ wrapper for the libfabric fid_ep struct and its associated functions
Cep_creation_failure
Cexception
Cfeature_set
Cibv_resources
Cinvalid_args
Clf_ctxt	Global states
Cmanaged_endpoint
Cmanaged_queue_pair
Cmanager_endpoint
Cmanager_queue_pair
Cmemory_region	A wrapper for fi_close
Cmessage_type
Cmessage_types_exhausted
Cmr_creation_failure
Cqp_creation_failure
Cqueue_pair	A C++ wrapper for the IB Verbs ibv_qp struct and its associated functions
Cremote_memory_region
►Ctask
Ctask_impl
Cunsupported_feature
►Nrdmc
Cbarrier_group
Cconnection_broken
Cexception
Cgroup_busy
Cinvalid_args
Cnonroot_sender
Creceive_destination
►Nsst
►Nutil
CPollingData
C_resources	Represents the set of RDMA resources needed to maintain a two-way connection to a single remote node
C_SSTField	Internal helper class, never exposed to the client
Ccm_con_data_t	Structure to exchange the data needed to connect the Queue Pairs
Cglobal_resources	Structure containing global system resources
Clf_ctxt	Global States
Clf_sender_ctxt
Cmulticast_group
Cmulticast_sst
CP2PConnections
CP2PParams
►CPredicates
Cpred_handle
Cresources	A public-facing version of the internal _resources class that extends it with more convenient functions
Cresources_two_sided	A public-facing version of the internal _resources class that extends it with functions that support two-sided sends and receives
CSST
CSSTField	Clients should use instances of this class with the appropriate template parameter to declare fields in their SST; for example, SSTField<int> is the type of an integer-valued SST field
CSSTFieldVector	Clients should use instances of this class to declare vector-like fields in their SST; the template parameter is the type of the vector's elements, just like with std::vector
CSSTParams	Constructor parameter pack for SST
Cverbs_sender_ctxt
►Ntcp
Cconnection_failure
Cconnection_listener
Cexception
Csocket
Ctcp_connections
Cbinomial_schedule
Cchain_schedule
Cevent
►CGetPot
Cvariable
Cgroup
CHLC
CIntegerWithDelta
CLoggerFactory
CParsedImmediate
CParsedTag
Cpolling_group
CReplicatedT
Cs1
Cs2
Cs3
Cs4
Cs5
►Cschedule
Cblock_transfer
Csend_stats
Csequential_schedule
Cstat
CStringOrCharP
CTestSerialization
Ctree_schedule
CTypeInfo
CTypeInfo< bool >
CTypeInfo< char >
CTypeInfo< const char * >
CTypeInfo< double >
CTypeInfo< float >
CTypeInfo< int >
CTypeInfo< long >
CTypeInfo< short >
CTypeInfo< std::string >
CTypeInfo< unsigned char >
CTypeInfo< unsigned int >
CTypeInfo< unsigned long >
CTypeInfo< unsigned short >
CVariableBytes
CX