hmbdc
simplify-high-performance-messaging-programming
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
 Chmbdc::add_if_not_in_tuple< T, Tuple >
 Chmbdc::add_if_not_in_tuple< T, std::tuple< Types ... > >
 Chmbdc::tips::typetagset_detail::adder< T, MessageTuple >
 Chmbdc::tips::typetagset_detail::adder< T, std::tuple< Message, Messages... > >
 Chmbdc::tips::typetagset_detail::advertise_for< MessageTuple, CcNode, TypeTagSet >
 Chmbdc::tips::typetagset_detail::advertise_for< std::tuple< Message, Messages... >, CcNode, TypeTagSet >
 Chmbdc::tips::aggregate_recv_msgs< Nodes >
 Chmbdc::tips::aggregate_recv_msgs< Node, Nodes ... >
 Chmbdc::tips::aggregate_send_msgs< Nodes >
 Chmbdc::tips::aggregate_send_msgs< Node, Nodes ... >
 Chmbdc::apply_template_on< apply, Tuple >
 Chmbdc::apply_template_on< apply, std::tuple< T, Ts... > >
 Chmbdc::function_traits< ReturnType(ClassType::*)(Args...) const >::arg< i >
 Chmbdc::function_traits< ReturnType(ClassType::*)(Args...)>::arg< i >
 Catomic_flag
 Chmbdc::tips::reliable::AttBufferAdaptor< Buffer, TransportMessageHeader, AttachmentAllocator >
 Chmbdc::tips::reliable::AttBufferAdaptor< OutputBufferIn, TransportMessageHeader, AttachmentAllocator >
 Chmbdc::tips::reliable::backupsendservert_detail::BackupSendServerT< TypeTagBackupSource, BackupSendSession >
 Chmbdc::tips::reliable::backupsendsessiont_detail::BackupSendSessionT< TransportMessageHeader >
 Chmbdc::os::BasePtrAllocatorHelping allocating object and its aggregated objects in a continouse memory
 Chmbdc::pattern::BlockingBuffer
 Chmbdc::app::BlockingContext< MessageTuples >A BlockingContext is like a media object that facilitates the communications for the Clients that it is holding. Each Client is powered by a single OS thread. a Client needs to be started once and only once to a single BlockingContext before any messages sending happens - typically in the initialization stage in main(), undefined behavior otherwise
 Chmbdc::app::context_property::broadcast< max_parallel_consumer >Context template parameter inidcating each message is sent to all clients within the Context. This is the default property of a Context
 Chmbdc::bsearch_tuple< Tuple, from, to >
 Chmbdc::bsearch_tuple< std::tuple< Ts... >, from, to >
 Chmbdc::app::BlockingContext< MessageTuples >::can_handle< Message >
 Chmbdc::pattern::lf_misc::chunk_base_ptr< Seq >
 Chmbdc::pattern::lf_misc::chunk_base_ptr< Sequence >
 Chmbdc::app::Client< CcClient, Messages >A Client represents a thread of execution/a task. The execution is managed by a Context. a Client object could participate in message dispatching as the receiver of specifed message types
 Chmbdc::app::Client< AsyncLoggerT< Ctx >, LoggingT< Ctx::MAX_MESSAGE_SIZE > >
 Chmbdc::app::Client< CcClient, Messages... >
 Chmbdc::app::Client< RecvTransportEngine< OutBuffer > >
 Chmbdc::app::Client< RecvTransportEngine< OutputBuffer, AttachmentAllocator > >
 Chmbdc::app::Client< RecvTransportEngineImpl< OutputBuffer > >
 Chmbdc::app::Client< SendTransportEngine >
 Chmbdc::app::Client< StuckClientPurger< Buffer > >
 Chmbdc::app::client_using_tuple< CcClient, MessageTuple >
 Chmbdc::app::client_using_tuple< CcClient, std::tuple< Messages... > >
 Chmbdc::concat_tuple< Tuple0, Tuple1 >
 Chmbdc::concat_tuple< std::tuple< T... >, std::tuple< U... > >
 Chmbdc::app::context_detail::context_property_aggregator< ContextProperties >
 Chmbdc::app::blocking_context_detail::context_property_aggregator< MessageTuples >
 Chmbdc::app::context_detail::context_property_aggregator< ContextProperties... >
 Chmbdc::app::blocking_context_detail::context_property_aggregator< MessageTuple, MessageTuples ... >
 Chmbdc::app::BlockingContext< MessageTuples >::createEntry
 Chmbdc::os::DefaultAllocatorDefault vanilla allocate
 Chmbdc::tips::DefaultAttachmentAllocatorWhen Domain (it's pumps) receives a hasMemoryAttachment, there is a need to allocate desired memory to hold the attachment bytes and release it after consumed. This is the policy type dictating how that is done by default - using malloc/free
 Chmbdc::app::BlockingContext< MessageTuples >::deliverAll
 Chmbdc::app::messagehandler_detail::dispatcher< CcClient, Message >
 Chmbdc::tips::Domain< RecvMessageTupleIn, IpcProp, NetProp, NodeContext, AttachmentAllocator >Messages published on a TIPS pub/sub domain reach all the Nodes within that domain based on their subscriptions. This class represents a TIPS domain's handle / interface / fascade in its process. Typically - by recommendation - there is just a single Domain object for a specific TIPS domain within a process
 Chmbdc::os::DownloadFile
 Chmbdc::tips::tcpcast::recvsession_detail::RecvSession< OutputBuffer, AttachmentAllocator >::DownloadMemory
 Chmbdc::os::DownloadMemory
 Chmbdc::time::Duration
 Chmbdc::app::EmptyLogTrailer
 Chmbdc::Endian
 Chmbdc::comm::inet::Endpoint
 Chmbdc::app::utils::EpollFd
 Cexception
 Chmbdc::os::ExecutionIoExecute a program as a child and capture its stdin stdout and/or stderr
 Chmbdc::filter_in_tuple< target_pred_template, MTuple >
 Chmbdc::filter_in_tuple< target_pred_template, std::tuple< M, Ms... > >
 Chmbdc::filter_in_tuple_by_base< Base, MTuple >
 Chmbdc::filter_in_tuple_by_base< Base, std::tuple< M, Ms... > >
 Chmbdc::filter_out_tuple< target_pred_template, MTuple >
 Chmbdc::filter_out_tuple< target_pred_template, std::tuple< M, Ms... > >
 Chmbdc::filter_out_tuple_by_base< Base, MTuple >
 Chmbdc::filter_out_tuple_by_base< Base, std::tuple< M, Ms... > >
 Chmbdc::function_traits< T >
 Chmbdc::function_traits< ReturnType(ClassType::*)(Args...) const >
 Chmbdc::function_traits< ReturnType(ClassType::*)(Args...)>
 Chmbdc::pattern::GuardedSingleton< Singleton >Base for the Singleton that works with SingletonGuardian
 Chmbdc::pattern::GuardedSingleton< AsyncLoggerT< Ctx > >
 Chmbdc::pattern::GuardedSingleton< EpollTask >
 Chmbdc::pattern::GuardedSingleton< NoProtocol >
 Chmbdc::pattern::GuardedSingleton< Protocol >
 Chmbdc::pattern::GuardedSingleton< SyncLogger >
 Chmbdc::os::HandleSignalsFunctions to handle signals
 Cstd::hash< hmbdc::text::TypedString< NAME, SIZE > >
 Chmbdc::comm::inet::HashEndpoint< asio_endpoint >
 Chmbdc::comm::inet::HashSockAddrIn< sockaddr_in >
 Chmbdc::app::hasMemoryAttachmentIf a specific hmbdc network transport (for example tcpcast, rmcast, and rnetmap) supports message with memory attachment, the message needs to be derived from this base - as the FIRST base, so it can be handled properly by the hmbdc network transport when sending and receiving it
 Chmbdc::tips::hasSharedPtrAttachment< Message, T >Internal use
 Chmbdc::app::hasTag< tag >Each message type has 16 bit tag
 Chmbdc::app::hasTag< 0 >
 Chmbdc::app::hasTag< 250 >
 Chmbdc::app::hasTag< 254 >
 Chmbdc::app::hasTag< 255 >
 Chmbdc::app::hasTag< 3 >
 Chmbdc::app::hasTag< 4 >
 Chmbdc::app::hasTag< 453 >
 Chmbdc::app::hasTag< 454 >
 Chmbdc::app::hasTag< 455 >
 Chmbdc::app::hasTag< 456 >
 Chmbdc::app::hasTag< 5 >
 Chmbdc::app::hasTag< 553 >
 Chmbdc::app::hasTag< 554 >
 Chmbdc::app::hasTag< 555 >
 Chmbdc::app::hasTag< 556 >
 Chmbdc::app::hasTag< 6 >
 Chmbdc::app::hasTag< 7 >
 Chmbdc::app::hasTag< 8 >
 Chmbdc::app::hasTag< 999 >
 Chmbdc::app::client_detail::InBandMemoryAttachmentProcessor< MAX_MEMORY_ATTACHMENT >
 Chmbdc::tips::Domain< RecvMessageTupleIn, IpcProp, NetProp, NodeContext, AttachmentAllocator >::InBandMemoryAttachmentProcessor< MAX_MEMORY_ATTACHMENT >
 Chmbdc::tips::Domain< RecvMessageTupleIn, IpcProp, NetProp, NodeContext, AttachmentAllocator >::InBandMemoryAttachmentProcessor< std::max((size_t) PumpInIpcPortal::MAX_MEMORY_ATTACHMENT,(size_t)(64 *1024))>
 Chmbdc::index_in_tuple< T, Tuple >
 Chmbdc::index_in_tuple< T, std::tuple< T, Types... > >
 Chmbdc::index_in_tuple< T, std::tuple< U, Types... > >
 Chmbdc::index_in_tuple< T, std::tuple<> >
 Chmbdc::forwardtupletofunc_detail::index_tuple<... >
 Chmbdc::insert_in_ordered_tuple< pred, T, Ts >
 Chmbdc::insert_in_ordered_tuple< pred, T, std::tuple< T0, Ts... > >
 Chmbdc::app::inTagRange< tagStart, rangeSize >
 CInterestsStd tuple holding messages types it can dispatch
 Chmbdc::app::context_property::ipc_enabledContext template parameter indicating the Context is ipc enabled and it can create or be attached to an ipc transport thru a transport name
 Chmbdc::tips::ipc_property< IpcCapacity, MaxMessageSize >Template that Domain uses for the IPC communication properties
 Chmbdc::app::is_hasMemoryAttachment_first_base_of< Message >
 Chmbdc::tips::domain_detail::is_ipcable< Message >
 Chmbdc::is_subset< TupleSub, TupleSup >
 Chmbdc::pattern::lf_misc::iterator< Seq >
 Chmbdc::pattern::blocking_buffer_detail::iterator
 Citerator
 Chmbdc::pattern::seqarb_detail::SeqArb< PARTICIPANT_COUNT, Seq, THREADSAFE >::J
 Chmbdc::pattern::LockFreeBufferT< MAX_PARALLE_CONSUMER >
 Chmbdc::pattern::LockFreeBufferT< 2 >
 Chmbdc::app::utils::AsyncLoggerT< Ctx >::LogHeader
 Chmbdc::app::LogTrailer
 Chmbdc::forwardtupletofunc_detail::make_indices_impl< I, IndexTuple, Types >
 Chmbdc::forwardtupletofunc_detail::make_indices_impl< 0, index_tuple<>, Types... >
 Chmbdc::forwardtupletofunc_detail::make_indices_impl< I, index_tuple< Indexes... > >
 Chmbdc::forwardtupletofunc_detail::make_indices_impl< I, index_tuple< Indexes... >, T, Types... >
 Chmbdc::tips::domain_detail::matching_ipcable< Message, canSerialize >
 Chmbdc::tips::domain_detail::matching_ipcable< Message, false >
 Chmbdc::max_size_in_tuple< Tuple >
 Chmbdc::max_size_in_tuple< std::tuple< T, Ts... > >
 Chmbdc::app::BlockingContext< MessageTuples >::MCGen< Tuple >
 Chmbdc::app::BlockingContext< MessageTuples >::MCGen< Interests >
 Chmbdc::app::BlockingContext< MessageTuples >::MCGen< std::tuple< Messages ... > >
 Chmbdc::pattern::memringbuffer_detail::MemRingBuffer< parallel_consumer_count, SeqT >
 Chmbdc::pattern::memringbuffer_detail::MemRingBuffer< 0 >
 Chmbdc::pattern::memringbuffer_detail::MemRingBuffer< 0u, SeqT >
 Chmbdc::pattern::memringbuffer_detail::MemRingBuffer< parallel_consumer_count >
 Chmbdc::merge_tuple_unique< Tuple1, Tuple2 >
 Chmbdc::merge_tuple_unique< Tuple1, std::tuple< T, Types... > >
 Chmbdc::merge_tuple_unique< Tuple1, std::tuple<> >
 Chmbdc::app::MessageDispacher< CcClient, MessageTuple >
 Chmbdc::app::MessageHead
 Chmbdc::pattern::MonoLockFreeBuffer
 Chmbdc::app::context_property::msgless_poolContext template parameter indicating the Context must contain a pool to run Clients and the Clients in the pool shall not receive messages - Unlike the default pool
 Chmbdc::tips::net_property< Protocol, MaxMessageSize >Template that Domain uses for the network communication properties
 Chmbdc::app::utils::NetContextUtil
 Chmbdc::tips::Node< CcNode, RecvMessageTuple, HasMessageStash >Node is a thread of execution that can suscribe and receive Messages
 Chmbdc::tips::Node< RegistrationNode< SendMessageTupleIn, RecvMessageTupleIn >, RecvMessageTupleIn >
 Cnumeric_limits
 Chmbdc::tips::Domain< RecvMessageTupleIn, IpcProp, NetProp, NodeContext, AttachmentAllocator >::OneBuffer
 Chmbdc::text::lfb_stream::OStringStream< Buffer, BufferItem, STREAMABLE_TYPE_TAG >
 Chmbdc::text::lfb_stream::OStringStream< Ctx::Buffer, MessageWrap< LoggingT< Ctx::MAX_MESSAGE_SIZE > >, LoggingT< Ctx::MAX_MESSAGE_SIZE >::typeTag >
 Chmbdc::app::context_property::partitionContext template parameter inidcating each message is sent to one and only one of the clients within the Context and its attached ipc Contexts if appllies
 Chmbdc::app::context_property::pci_ipcWhen processes are distributed on a PCIe board and host PC, add this property
 Chmbdc::comm::eth::pkt
 Chmbdc::comm::eth::pkt_n< N >
 Chmbdc::pattern::PoolConsumer
 Chmbdc::pattern::PoolMinus
 Chmbdc::pattern::PoolMinusImpl
 Chmbdc::pattern::PoolT< Buffer >
 Chmbdc::pattern::PoolTImpl< LockFreeBuffer >
 Cptree
 Chmbdc::time::Rater
 Chmbdc::app::blocking_context_detail::RealInterests< Interests >
 Chmbdc::tips::domain_detail::recv_ipc_converted< MessageTuple >
 Chmbdc::tips::domain_detail::recv_ipc_converted< std::tuple< Message, Messages... > >
 Chmbdc::tips::domain_detail::recv_ipc_converted< std::tuple<> >
 Chmbdc::tips::tcpcast::recvsession_detail::RecvSession< OutputBuffer, AttachmentAllocator >
 Chmbdc::remove_duplicate< Tuple >
 Chmbdc::pattern::RingBuffer< T, parallel_consumer_count >
 Chmbdc::pattern::RingBuffer< PoolConsumer *, 0 >
 Chmbdc::pattern::RingBuffer< T, 0 >
 Cruntime_error
 Chmbdc::tips::tcpcast::sendserver_detail::SendServer
 Chmbdc::tips::tcpcast::sendsession_detail::SendSession
 Chmbdc::pattern::seqarb_detail::SeqArb< PARTICIPANT_COUNT, Seq, THREADSAFE >
 Chmbdc::pattern::seqarb_detail::SeqArb< PARTICIPANT_COUNT, HMBDC_SEQ_TYPE, false >
 Chmbdc::pattern::seqarb_detail::SeqArb< PARTICIPANT_COUNT, Seq, false >
 Cset_base_hook
 Chmbdc::numeric::set_bits_count< v >
 Chmbdc::numeric::set_bits_count< 0 >
 Chmbdc::app::BlockingContext< MessageTuples >::setupConduit< MsgConduits, DeliverPred, Tuple >
 Chmbdc::app::BlockingContext< MessageTuples >::setupConduit< MsgConduits, DeliverPred, std::tuple< M, Messages... > >
 Chmbdc::app::context_detail::ThreadCommBase< MaxMessageSize, ContextProperties >::ShmAttAllocator
 Chmbdc::app::single_thread_powered_clientTrait class, if a Client can only run on a single specific thread in Pool, derive the Client from it, hmbdc will check to ensure that is the case
 Chmbdc::pattern::seqarb_detail::SingleThreadSeqArb< PARTICIPANT_COUNT, Seq >
 Chmbdc::pattern::seqarb_detail::SingleThreadSeqArb< 2, HMBDC_SEQ_TYPE >
 Chmbdc::pattern::SingletonGuardian< Singleton >RAII representing the lifespan of the underlying Singleton which also ganrantees the singularity of underlying Singleton
 Chmbdc::pattern::SingletonPlacementGuardian< Singleton >Similar to SingletonGuardian, but supports placement new of the underlying Singleton
 Chmbdc::comm::inet::SockAddrInEqual< sockaddr_in >
 Chmbdc::sort_tuple< pred, Tuple >
 Chmbdc::sort_tuple< pred, std::tuple< T, Ts... > >
 Chmbdc::sort_tuple< pred, std::tuple<> >
 Chmbdc::numeric::Stat< T >
 Chmbdc::numeric::stathistogram_detail::StatHistogramBase
 Chmbdc::text::lfb_stream::Streamable
 Chmbdc::tips::typetagset_detail::subscribe_for< MessageTuple, CcNode, TypeTagSet >
 Chmbdc::tips::typetagset_detail::subscribe_for< std::tuple< Message, Messages... >, CcNode, TypeTagSet >
 Chmbdc::time::SysTime
 Chmbdc::app::hasTag< tag >::tagBase
 Chmbdc::app::inTagRange< tagStart, rangeSize >::tagBase
 Chmbdc::templatized_aggregator< target_template, Tuple >
 Chmbdc::templatized_aggregator< target_template, std::tuple< T, Ts... > >
 Chmbdc::templatized_aggregator< target_template, std::tuple< target_template< T >, Ts... > >
 Chmbdc::templatized_subtractor< target_template, Tuple >
 Chmbdc::templatized_subtractor< target_template, std::tuple< T, Ts... > >
 Chmbdc::templatized_subtractor< target_template, std::tuple< target_template< T >, Ts... > >
 Chmbdc::time::TimerManager
 Chmbdc::app::blocking_context_detail::tm_runner< is_timer_manager >
 Chmbdc::app::context_detail::tm_runner< is_timer_manager >
 Chmbdc::app::blocking_context_detail::tm_runner< true >
 Chmbdc::app::context_detail::tm_runner< true >
 Chmbdc::app::Trace
 Chmbdc::tips::rmcast::transport_detail::Transport
 Chmbdc::app::blocking_context_detail::Transport
 Chmbdc::tips::tcpcast::Transport
 Chmbdc::tips::rnetmap::transport_detail::Transport
 Chmbdc::app::blocking_context_detail::TransportEntry< Message >
 Chmbdc::app::blocking_context_detail::TransportEntry< JustBytes >
 Chmbdc::tips::netmap::TransportMessageHeader
 Chmbdc::tips::rnetmap::TransportMessageHeader
 Chmbdc::tips::udpcast::TransportMessageHeader
 Chmbdc::tips::tcpcast::TransportMessageHeader
 Chmbdc::tips::rmcast::TransportMessageHeader
 Ctype
 Ctype
 Ctype
 Chmbdc::Typed< NAME, T >
 Chmbdc::text::TypedString< NAME, SIZE >
 Chmbdc::tips::TypeTagSet
 Chmbdc::tips::TypeTagSetST
 Cvector
 Chmbdc::comm::eth::virt_header
 Chmbdc::XmitEndian< T >
 Chmbdc::XmitEndian< size_t >
 Chmbdc::XmitEndian< uint16_t >
 Chmbdc::XmitEndian< uint32_t >
 Chmbdc::XmitEndianByteField< T, N >
 Chmbdc::XmitEndianByteField< uint64_t, 6 >
 CMessage