Class List

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

[detail level 12345]

▼Nboost
▼Nsystem	We may add some ADL-based overloads into this namespace outside flow
Cis_error_code_enum<::flow::net_flow::error::Code >	Ummm – it specializes this struct to – look – the end result is boost.system uses this as authorization to make enum Code convertible to Error_code
▼Nflow	Catch-all namespace for the Flow project: A collection of various production-quality modules written in modern C++17, originally by ygoldfel
▼Nasync	Flow module containing tools enabling multi-threaded event loops operating under the asynchronous-task proactor pattern, by providing a streamlined API around boost.asio event loops with added advanced task- and thread-scheduling features
CConcurrent_task_loop	The core flow::async interface, providing an optionally multi-threaded thread pool onto which runnable Tasks, optionally arranged into concurrency-avoiding Ops, can be boost.asio-posted for subsequent execution
CCross_thread_task_loop	Concrete Concurrent_task_loop that is able to efficiently schedule Tasks within a given Op to execute in different threads while still properly avoiding concurrency
COp_list	Simple, immutable vector-like sequence of N opaque async::Op objects, usually corresponding to N worker threads, with typically used operations such as [index] and random Op selection
CSegregated_thread_task_loop	Concrete Concurrent_task_loop that uses the legacy pin-Tasks-within-1-Op-to-1-thread method of achieving required non-concurrency of Tasks
CSingle_thread_task_loop	A Concurrent_task_loop-related adapter-style class that represents a single-thread task loop; essentially it is pleasant syntactic sugar around a Concurrent_task_loop impl that cuts out concepts that become irrelevant with only one thread involved
CTask_qing_thread	Internally used building block of various concrete Concurrent_task_loop subclasses that encapsulates a thread that spawns at construction time and a dedicated-or-shared util::Task_engine (a/k/a boost.asio io_service) run()ning in that new thread
CTimed_concurrent_task_loop	Decorates a general – potentially multi-threaded – Concurrent_task_loop of any kind but with timing capabilities
CTimed_concurrent_task_loop_impl	Decorator of a Concurrent_task_loop with same or greater lifetime that accumulates time elapsed in any tasks posted or scheduled onto that loop
CTimed_single_thread_task_loop	Identical to Single_thread_task_loop, but all tasks posted through it are automatically timed, with the result accessible via accumulated_time()
▼Ncfg	Flow module that facilitates configuring modules, such as applications and APIs, via statically and/or dynamically parsed sets of name/value pairs from config sources like files and command lines
►CConfig_manager	Manages a config setup, intended for a single daemon process, by maintaining 1 or more set(s) of static config and dynamic config, each, via that number of Option_set<>-ready raw value struct types supplied by the user as template arguments
COn_dynamic_change_func_handle	Opaque handle for managing a dynamic config change callback
CDynamic_cfg_context	Class which facilitates managing access to a dynamic configuration
CFinal_validator_func	Utility/traits type to concisely work with final-validation functions when calling methods like Config_manager::apply_static()
CNull_value_set	Empty struct suitable as a *_value_set template arg for Config_manager, when a slot requires a Value_set, but you have no config to actually parse there
►COption_set	The core config-parsing facility, which builds parsing/comparison/output capabilities on top of a given simple config-holding object, of the type Value_set, a template argument to this class template
CDeclare_options_func_args	Internal-use structure to use with Declare_options_func callback
COption_set_base	Un-templated base for Option_set
CStatic_config_manager	A Config_manager-related adapter-style class that manages a simple config setup involving a single (though arbitrarily complex) Option_set<>-ready raw value struct config store type Value_set, meant to be used only in static fashion
▼Nerror	Flow module that facilitates working with error codes and exceptions; essentially comprised of niceties on top boost.system's error facility
CRuntime_error	An std::runtime_error (which is an std::exception) that stores an Error_code
▼Nlog	Flow module providing logging functionality
►CAsync_file_logger	An implementation of Logger that logs messages to a given file-system path but never blocks any logging thread for file I/O; suitable for heavy-duty file logging
CLog_request	In addition to the task object (function) itself, these are the data placed onto the queue of m_async_worker tasks for a particular do_log() call, to be used by that task and then freed immediately upon logging of the message to file
CThrottling_cfg	Controls behavior of the throttling algorithm as described in Async_file_logger doc header Throttling section
CBuffer_logger	An implementation of Logger that logs messages to an internal std::string buffer and provides read-only access to this buffer (for example, if one wants to write out its contents when exiting program)
CComponent	A light-weight class, each object storing a component payload encoding an enum value from enum type of user's choice, and a light-weight ID of that enum type itself
►CConfig	Class used to configure the filtering and logging behavior of Loggers; its use in your custom Loggers is optional but encouraged; supports dynamically changing filter settings even while concurrent logging occurs
CAtomic_raw_sev	Trivial wrapper of atomic<raw_sev_t> which adds a couple of things to make it possible to construct, and therefore use, a vector of such atomics
CComponent_config	The set of config stored for each distinct (as determined by Component::payload_type(), essentially C++ built-in std::type_info) component payload type (in English – component enum class)
CLog_context	Convenience class that simply stores a Logger and/or Component passed into a constructor; and returns this Logger and Component via get_logger() and get_log_component() public accessors
CLogger	Interface that the user should implement, passing the implementing Logger into logging classes (Flow's own classes like net_flow::Node; and user's own logging classes) at construction (plus free/static logging functions)
CMsg_metadata	Simple data store containing all of the information generated at every logging call site by flow::log, except the message itself, which is passed to Logger::do_log() assuming Logger::should_log() had returned true
COstream_log_msg_writer	Utility class, each object of which wraps a given ostream and outputs discrete messages to it adorned with time stamps and other formatting such as separating newlines
CSerial_file_logger	An internal-use implementation of Logger that logs messages to a given file-system path, blocking the calling thread while the I/O occurs, and usable safely only if logging occurs non-concurrently
CSimple_ostream_logger	An implementation of Logger that logs messages to the given ostreams (e.g., cout or an ofstream for a file)
CThread_local_string_appender	Internal flow::log class that facilitates a more efficient way to get util::ostream_op_to_string() behavior by allowing each thread to repeatedly reuse the structures that function creates from scratch on stack each time it is invoked; furthermore each logging entity is allotted a separate such set of structures to enable each entity to not affect the streams of other entities
CVerbosity_config	Optional-use structure encapsulating a full set of verbosity config, such that one can parse it from a config source (like an options file) in concise form and apply it to a log::Config object
▼Nnet_flow	Flow module containing the API and implementation of the Flow network protocol, a TCP-inspired stream protocol that uses UDP as underlying transport
►Nasio	Contains classes that add boost.asio integration to the main Flow-protocol classes such as net_flow::Node and net_flow::Peer_socket, so that net_flow sockets can be easily used in boost.asio-driven event loops, e.g., ones also performing TCP networking and scheduling timers
CNode	A subclass of net_flow::Node that adds the ability to easily and directly use net_flow sockets in general boost.asio event loops
CPeer_socket	A net_flow::Peer_socket that adds integration with boost.asio
CServer_socket	A net_flow::Server_socket that adds integration with boost.asio
►Nerror	Namespace containing the net_flow module's extension of boost.system error conventions, so that Flow network protocol API can return codes/messages from within its own new set of error codes/messages
CCategory	The boost.system category for errors returned by the net_flow Flow module
►CAck_packet	Internal net_flow struct that encapsulates the Flow-protocol low-level ACK packet
CIndividual_ack	Specifies the incoming (post-deserialization) acknowledgment of a single received Data_packet
CIndividual_ack_rexmit_off	Specifies the outgoing (pre-serialization) acknowledgment of a single received Data_packet, when retranmission is disabled on the socket
CIndividual_ack_rexmit_on	Equivalent of Individual_ack_rexmit_off but for sockets with retransmission enabled
CCongestion_control_classic	Classic congestion control, based on Reno (TCP RFC 5681), with congestion avoidance, slow start, and congestion window halving (etc.) upon a loss event
CCongestion_control_classic_data	Utility class for use by Congestion_control_strategy implementations that implements congestion window and slow start threshold storage and classic Reno-style "slow start" and "congestion avoidance" algorithms
CCongestion_control_classic_with_bandwidth_est	Classic congestion control but with backoff to bandwidth estimate-based pipe size
CCongestion_control_selector	Namespace-like class that enables an enum-based selection of the Congestion_control_strategy interface implementation to use for a given socket (for programmatic socket options) and facilitates stream I/O of these enums (allowing parsing and outputting these socket options)
CCongestion_control_strategy	The abstract interface for a per-socket module that determines the socket's congestion control behavior
CData_packet	Internal net_flow struct that encapsulates the Flow-protocol low-level DATA packet
CDrop_timer	Internal net_flow class that maintains the Drop Timer for DATA packet(s) to have been sent out over a connection but not yet acknowledged by the receiver
►CEvent_set	A user-set collection of sockets and desired conditions on those sockets (such as: "socket has data to read"), with the ability to wait for those conditions to become true and signal the user when so
CSocket_as_any_equals	Equality predicate class used in storing various sockets of types wrapped as boost::anys in the Sockets type
CSocket_as_any_hash	Hasher class used in storing various sockets of types wrapped as boost::anys in the Sockets type
►CLow_lvl_packet	Internal net_flow struct that encapsulates the Flow-protocol low-level packet structure and serves as the super-type for all specific packet types, represented by derived structs like Ack_packet, Rst_packet, etc
CAux_raw_data	Helper data store type for storing binary data needed by serialize_to_raw_data(), when certains bits are not already represented by the public data members present in struct Low_lvl_packet
CPacket_type_info	A simple, unmodifiable data store that contains the properties unique to each packet type a/k/a concrete sub-type of Low_lvl_packet
CNet_env_simulator	Objects of this class can be fed to Node to make it internally simulate network conditions like loss, latency, and data duplication
►CNode	An object of this class is a single Flow-protocol networking node, in the sense that: (1) it has a distinct IP address and UDP port; and (2) it speaks the Flow protocol over a UDP transport layer
CSocket_id	The data nugget uniquely identifying a peer-to-peer connection from a remote endpoint to a port in this Node
CNode_options	A set of low-level options affecting a single Flow Node, including Peer_socket objects and other objects subsequently generated by that Flow Node
►CPeer_socket	A peer (non-server) socket operating over the Flow network protocol, with optional stream-of-bytes and reliability support
CIndividual_ack	Metadata describing the data sent in the acknowledgment of an individual received packet
CReceived_packet	Metadata (and data, if retransmission is on) for a packet that has been received (and, if retransmission is off, copied to Receive buffer)
►CSent_packet	Metadata (and data, if retransmission is on) for a packet that has been sent one (if retransmission is off) or possibly more (if on) times
CSent_when	Data store to keep timing related info when a packet is sent out
CPeer_socket_info	A data store that keeps stats about the a Peer_socket connection
CPeer_socket_options	A set of low-level options affecting a single Peer_socket
CPeer_socket_receive_stats	A data store that keeps stats about the incoming direction of a Peer_socket connection to another Flow-protocol Peer_socket
CPeer_socket_receive_stats_accumulator	A class that keeps a Peer_socket_receive_stats data store, includes methods to conveniently accumulate data in it, and provides output to ostream
CPeer_socket_send_stats	A data store that keeps stats about the outgoing direction of a Peer_socket connection to another Flow-protocol Peer_socket
CPeer_socket_send_stats_accumulator	A class that keeps a Peer_socket_send_stats data store, includes methods to conveniently accumulate data in it, and provides output to ostream
CPort_space	Internal net_flow class that maintains the available Flow-protocol port space, somewhat similarly to the classic TCP or UDP port scheme
CRemote_endpoint	Represents the remote endpoint of a Flow-protocol connection; identifies the UDP endpoint of the remote Node and the logical Flow-protocol port within that Node
CRst_packet	Internal net_flow struct that encapsulates the Flow-protocol low-level RST packet
CSend_bandwidth_estimator	A per-Peer_socket module that tries to estimate the bandwidth available to the outgoing flow
CSend_pacing_data	The current outgoing packet pacing state, including queue of low-level packets to be sent, for a given Peer_socket
►CSequence_number	An internal net_flow sequence number identifying a piece of data
CGenerator	An object of this type generates a series of initial sequence numbers (ISN) that are meant to be sufficiently secure to protect against ISN attacks and confusion among different connections between the same endpoints occurring in series
CServer_socket	A server socket able to listen on a single Flow port for incoming connections and return peer sockets (Peer_socket objects) to the local user once such connections are established
CSocket_buffer	Internal net_flow class that implements a socket buffer, as used by Peer_socket for Send and Receive buffers
CSyn_ack_ack_packet	Internal net_flow struct that encapsulates the Flow-protocol low-level SYN_ACK_ACK packet
CSyn_ack_packet	Internal net_flow struct that encapsulates the Flow-protocol low-level SYN_ACK packet
CSyn_packet	Internal net_flow struct that encapsulates the Flow-protocol low-level SYN packet
▼Nperf	Flow module containing tools for profiling and optimization
►CCheckpointing_timer	The central class in the perf Flow module, this efficiently times the user's operation, with a specified subset of timing methods; and with the optional ability to time intermediate checkpoints within the overall operation
CAggregator	This companion/inner class of Checkpointing_timer provides aggregation of results from many Checkpointing_timers each measuring some user operation being repeated many times; particularly when the operation consists of multiple steps (checkpoints) of interest
CCheckpoint	The entirety of the information recorded with each Checkpointing_timer::checkpoint() call; it contains the Duration values (for each Clock_type) with the time elapsed since either the preceding T.checkpoint() or construction
CDuration_set	Convenience wrapper around an array<Duration, N>, which stores a duration for each of the N possible clock types in perf::Clock_type
CTime_pt_set	Convenience wrapper around an array<Time_pt, N>, which stores a time point for each of the N possible clock types in perf::Clock_type
▼Nutil	Flow module containing miscellaneous general-use facilities that don't fit into any other Flow module
►CBasic_blob	A hand-optimized and API-tweaked replacement for vector<uint8_t>, i.e., buffer of bytes inside an allocated area of equal or larger size; also optionally supports limited garbage-collected memory pool functionality and SHM-friendly custom-allocator support
CDeleter_raw	Internal deleter functor used if and only if S_IS_VANILLA_ALLOC is false and therefore only with Buf_ptr being boost::interprocess::shared_ptr or deleter-parameterized unique_ptr
CBasic_string_view	Essentially alias for a C++17-conforming string-view class template, which is a very lightweight std::string-like representation of a character sequence already in memory
CBlob_with_log_context	Basic_blob that works in regular heap (and is itself placed in heap or stack) and memorizes a log::Logger, enabling easier logging albeit with a small perf trade-off
CContainer_traits	Properties of various container types
CContainer_traits< boost::unordered_set< T > >	Traits of boost::unordered_set
CContainer_traits< std::map< K, V > >	Traits of std::map
CContainer_traits< std::set< T > >	Traits of std::set
CContainer_traits< util::Linked_hash_map< K, V > >	Traits of flow::util::Linked_hash_map
CContainer_traits< util::Linked_hash_set< T, Hash, Pred > >	Traits of flow::util::Linked_hash_set
CDuration_units_beautified	Internally used class that enables some of the activities of beautify_chrono_ostream() API
CLinked_hash_map	An object of this class is a map that combines the lookup speed of a boost::unordered_map<> and ordering and iterator stability capabilities of an std::list<>
CLinked_hash_set	An object of this class is a set that combines the lookup speed of an unordered_set<> and ordering and iterator stability capabilities of an std::list<>
CNull_interface	An empty interface, consisting of nothing but a default virtual destructor, intended as a boiler-plate-reducing base for any other (presumably virtual-method-having) class that would otherwise require a default virtual destructor
CRnd_gen_uniform_range	Simple, non-thread-safe uniform-range random number generator
CRnd_gen_uniform_range_base	Base class for Rnd_gen_uniform_range and Rnd_gen_uniform_range_mt for various aliases and similar, so template arguments need not be involved
CRnd_gen_uniform_range_mt	Identical to Rnd_gen_uniform_range but safe for concurrent RNG given a single object
CScheduled_task_handle_state	Internal-use data store used by schedule[d]_task_*(), each object containing the state relevant to a single call to either schedule_task_from_now() or schedule_task_at()
CScoped_setter	A simple RAII-pattern class template that, at construction, sets the specified location in memory to a specified value, memorizing the previous contents; and at destruction restores the value
CShared_ptr_alias_holder	Convenience class template that endows the given subclass T with nested aliases Ptr and Const_ptr aliased to shared_ptr<T> and shared_ptr<const T> respectively
CString_ostream	Similar to ostringstream but allows fast read-only access directly into the std::string being written; and some limited write access to that string
CUnique_id_holder	Each object of this class stores (at construction) and returns (on demand) a numeric ID unique from all other objects of the same class ever constructed, across all time from program start to end
CFunction
CFunction< Result(Args...)>	Intended as the polymorphic function wrapper of choice for Flow, internally and externally; to be used instead of std::function or boost::function