| ►Cstd::atomic< T > | STL class |
| Cflow::log::Config::Atomic_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 |
| Cflow::util::Basic_blob< Allocator, S_SHARING_ALLOWED > | 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 |
| ►Cflow::util::Basic_blob< std::allocator< uint8_t >, S_SHARING_ALLOWED > | |
| Cflow::util::Blob_with_log_context< S_SHARING_ALLOWED > | 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 |
| ►Cstd::basic_string_view< Char > | STL class |
| Cflow::util::Basic_string_view< Ch, Traits > | 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 |
| Cflow::perf::Checkpointing_timer::Checkpoint | 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 |
| Cflow::log::Component | 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 |
| Cflow::log::Config::Component_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) |
| Cflow::log::Config | 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 |
| Cflow::util::Container_traits< Container > | Properties of various container types |
| Cflow::util::Container_traits< boost::unordered_set< T > > | Traits of boost::unordered_set |
| Cflow::util::Container_traits< std::map< K, V > > | Traits of std::map |
| Cflow::util::Container_traits< std::set< T > > | Traits of std::set |
| Cflow::util::Container_traits< util::Linked_hash_map< K, V > > | Traits of flow::util::Linked_hash_map |
| Cflow::util::Container_traits< util::Linked_hash_set< T, Hash, Pred > > | Traits of flow::util::Linked_hash_set |
| Cflow::cfg::Option_set< Value_set >::Declare_options_func_args | Internal-use structure to use with Declare_options_func callback |
| Cflow::util::Basic_blob< Allocator, S_SHARING_ALLOWED >::Deleter_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 |
| Cflow::perf::Duration_set | Convenience wrapper around an array<Duration, N>, which stores a duration for each of the N possible clock types in perf::Clock_type |
| ►Cboost::chrono::duration_units_default | |
| Cflow::util::Duration_units_beautified | Internally used class that enables some of the activities of beautify_chrono_ostream() API |
| Cflow::cfg::Dynamic_cfg_context< Root, Target, Target_ptr > | Class which facilitates managing access to a dynamic configuration |
| ►Cboost::enable_shared_from_this | |
| Cflow::net_flow::Drop_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 |
| Cflow::net_flow::Event_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 |
| ►Cflow::net_flow::Peer_socket | A peer (non-server) socket operating over the Flow network protocol, with optional stream-of-bytes and reliability support |
| Cflow::net_flow::asio::Peer_socket | A net_flow::Peer_socket that adds integration with boost.asio |
| ►Cflow::net_flow::Server_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 |
| Cflow::net_flow::asio::Server_socket | A net_flow::Server_socket that adds integration with boost.asio |
| ►Cboost::system::error_category | |
| Cflow::net_flow::error::Category | The boost.system category for errors returned by the net_flow Flow module |
| Cflow::cfg::Final_validator_func< Value_set > | Utility/traits type to concisely work with final-validation functions when calling methods like Config_manager::apply_static() |
| Cflow::Function< Signature > | |
| ►Cstd::function | |
| Cflow::Function< 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 |
| Cflow::Function< std::ostream &(std::ostream &)> | |
| Cflow::Function< void(bool drop_all_packets)> | |
| Cflow::Function< void(bool)> | |
| Cflow::Function< void(const Declare_options_func_args &args)> | |
| Cflow::Function< void(const Error_code &err_code)> | |
| Cflow::Function< void(flow::log::Ostream_log_msg_writer *, const flow::log::Msg_metadata &, flow::util::Basic_string_view)> | |
| Cflow::net_flow::Ack_packet::Individual_ack | Specifies the incoming (post-deserialization) acknowledgment of a single received Data_packet |
| Cflow::net_flow::Peer_socket::Individual_ack | Metadata describing the data sent in the acknowledgment of an individual received packet |
| Cflow::net_flow::Ack_packet::Individual_ack_rexmit_off | Specifies the outgoing (pre-serialization) acknowledgment of a single received Data_packet, when retranmission is disabled on the socket |
| Cflow::net_flow::Ack_packet::Individual_ack_rexmit_on | Equivalent of Individual_ack_rexmit_off but for sockets with retransmission enabled |
| Cboost::system::is_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 |
| Cflow::util::Linked_hash_map< Key, Mapped, Hash, Pred > | 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<> |
| Cflow::util::Linked_hash_map< Event_type, Sockets > | |
| Cflow::util::Linked_hash_map< Sequence_number, boost::shared_ptr< Sent_packet > > | |
| Cflow::util::Linked_hash_set< Key, Hash, Pred > | 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<> |
| Cflow::util::Linked_hash_set< Peer_socket_ptr > | |
| ►Cflow::log::Log_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 |
| ►Cflow::cfg::Config_manager< Value_set, Null_value_set > | |
| Cflow::cfg::Static_config_manager< Value_set > | 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 |
| Cflow::async::Cross_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 |
| Cflow::async::Op_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 |
| Cflow::async::Segregated_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 |
| ►Cflow::async::Single_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 |
| Cflow::async::Timed_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() |
| Cflow::async::Task_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 |
| Cflow::cfg::Config_manager< S_d_value_set > | 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 |
| Cflow::cfg::Option_set< Value_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 |
| Cflow::log::Async_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 |
| Cflow::log::Serial_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 |
| Cflow::net_flow::Congestion_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 |
| ►Cflow::net_flow::Congestion_control_strategy | The abstract interface for a per-socket module that determines the socket's congestion control behavior |
| Cflow::net_flow::Congestion_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 |
| Cflow::net_flow::Congestion_control_classic_with_bandwidth_est | Classic congestion control but with backoff to bandwidth estimate-based pipe size |
| Cflow::net_flow::Drop_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 |
| Cflow::net_flow::Event_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 |
| ►Cflow::net_flow::Low_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 |
| Cflow::net_flow::Ack_packet | Internal net_flow struct that encapsulates the Flow-protocol low-level ACK packet |
| Cflow::net_flow::Data_packet | Internal net_flow struct that encapsulates the Flow-protocol low-level DATA packet |
| Cflow::net_flow::Rst_packet | Internal net_flow struct that encapsulates the Flow-protocol low-level RST packet |
| Cflow::net_flow::Syn_ack_ack_packet | Internal net_flow struct that encapsulates the Flow-protocol low-level SYN_ACK_ACK packet |
| Cflow::net_flow::Syn_ack_packet | Internal net_flow struct that encapsulates the Flow-protocol low-level SYN_ACK packet |
| Cflow::net_flow::Syn_packet | Internal net_flow struct that encapsulates the Flow-protocol low-level SYN packet |
| Cflow::net_flow::Net_env_simulator | Objects of this class can be fed to Node to make it internally simulate network conditions like loss, latency, and data duplication |
| ►Cflow::net_flow::Node | 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 |
| Cflow::net_flow::asio::Node | A subclass of net_flow::Node that adds the ability to easily and directly use net_flow sockets in general boost.asio event loops |
| Cflow::net_flow::Peer_socket | A peer (non-server) socket operating over the Flow network protocol, with optional stream-of-bytes and reliability support |
| Cflow::net_flow::Port_space | Internal net_flow class that maintains the available Flow-protocol port space, somewhat similarly to the classic TCP or UDP port scheme |
| Cflow::net_flow::Send_bandwidth_estimator | A per-Peer_socket module that tries to estimate the bandwidth available to the outgoing flow |
| Cflow::net_flow::Sequence_number::Generator | 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 |
| Cflow::net_flow::Server_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 |
| Cflow::net_flow::Socket_buffer | Internal net_flow class that implements a socket buffer, as used by Peer_socket for Send and Receive buffers |
| Cflow::perf::Checkpointing_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 |
| Cflow::perf::Checkpointing_timer::Aggregator | 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 |
| Cflow::util::Blob_with_log_context< S_SHARING_ALLOWED > | 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 |
| Cflow::log::Async_file_logger::Log_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 |
| Cflow::log::Msg_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 |
| Cflow::net_flow::Node_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 |
| ►Cboost::noncopyable | |
| ►Cflow::util::Rnd_gen_uniform_range< std::size_t > | |
| Cflow::util::Rnd_gen_uniform_range_mt< std::size_t > | |
| Cflow::util::Rnd_gen_uniform_range< Peer_socket::security_token_t > | |
| Cflow::async::Cross_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 |
| Cflow::async::Segregated_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 |
| Cflow::async::Task_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 |
| Cflow::cfg::Option_set< Value_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 |
| ►Cflow::log::Logger | 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) |
| Cflow::log::Async_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 |
| Cflow::log::Buffer_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) |
| Cflow::log::Serial_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 |
| Cflow::log::Simple_ostream_logger | An implementation of Logger that logs messages to the given ostreams (e.g., cout or an ofstream for a file) |
| Cflow::log::Ostream_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 |
| Cflow::log::Thread_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 |
| Cflow::net_flow::Congestion_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 |
| Cflow::net_flow::Congestion_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) |
| Cflow::net_flow::Congestion_control_strategy | The abstract interface for a per-socket module that determines the socket's congestion control behavior |
| Cflow::net_flow::Drop_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 |
| Cflow::net_flow::Event_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 |
| Cflow::net_flow::Low_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 |
| Cflow::net_flow::Low_lvl_packet::Aux_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 |
| Cflow::net_flow::Net_env_simulator | Objects of this class can be fed to Node to make it internally simulate network conditions like loss, latency, and data duplication |
| Cflow::net_flow::Node | 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 |
| Cflow::net_flow::Peer_socket | A peer (non-server) socket operating over the Flow network protocol, with optional stream-of-bytes and reliability support |
| Cflow::net_flow::Peer_socket::Received_packet | Metadata (and data, if retransmission is on) for a packet that has been received (and, if retransmission is off, copied to Receive buffer) |
| Cflow::net_flow::Peer_socket::Sent_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 |
| Cflow::net_flow::Peer_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 |
| Cflow::net_flow::Peer_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 |
| Cflow::net_flow::Port_space | Internal net_flow class that maintains the available Flow-protocol port space, somewhat similarly to the classic TCP or UDP port scheme |
| Cflow::net_flow::Send_bandwidth_estimator | A per-Peer_socket module that tries to estimate the bandwidth available to the outgoing flow |
| Cflow::net_flow::Send_pacing_data | The current outgoing packet pacing state, including queue of low-level packets to be sent, for a given Peer_socket |
| Cflow::net_flow::Sequence_number::Generator | 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 |
| Cflow::net_flow::Server_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 |
| Cflow::net_flow::Socket_buffer | Internal net_flow class that implements a socket buffer, as used by Peer_socket for Send and Receive buffers |
| Cflow::perf::Checkpointing_timer::Aggregator | 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 |
| ►Cflow::util::Rnd_gen_uniform_range< range_t > | Simple, non-thread-safe uniform-range random number generator |
| Cflow::util::Rnd_gen_uniform_range_mt< range_t > | Identical to Rnd_gen_uniform_range but safe for concurrent RNG given a single object |
| Cflow::util::Scheduled_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() |
| Cflow::util::String_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 |
| ►Cflow::util::Null_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 |
| ►Cflow::async::Concurrent_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 |
| ►Cflow::async::Timed_concurrent_task_loop_impl< std::atomic< perf::duration_rep_t > > | |
| Cflow::async::Timed_concurrent_task_loop | Decorates a general – potentially multi-threaded – Concurrent_task_loop of any kind but with timing capabilities |
| Cflow::async::Timed_concurrent_task_loop_impl< perf::duration_rep_t > | |
| Cflow::async::Cross_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 |
| Cflow::async::Segregated_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 |
| Cflow::async::Timed_concurrent_task_loop_impl< Time_accumulator > | Decorator of a Concurrent_task_loop with same or greater lifetime that accumulates time elapsed in any tasks posted or scheduled onto that loop |
| Cflow::async::Single_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 |
| Cflow::log::Logger | 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) |
| Cflow::net_flow::Congestion_control_strategy | The abstract interface for a per-socket module that determines the socket's congestion control behavior |
| Cflow::net_flow::Low_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 |
| Cflow::net_flow::Node | 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 |
| Cflow::net_flow::Peer_socket | A peer (non-server) socket operating over the Flow network protocol, with optional stream-of-bytes and reliability support |
| Cflow::net_flow::Server_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 |
| Cflow::cfg::Config_manager< S_d_value_set >::On_dynamic_change_func_handle | Opaque handle for managing a dynamic config change callback |
| ►Cflow::cfg::Option_set_base | Un-templated base for Option_set |
| Cflow::cfg::Option_set< Value_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 |
| Cflow::net_flow::Low_lvl_packet::Packet_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 |
| Cflow::net_flow::Peer_socket_info | A data store that keeps stats about the a Peer_socket connection |
| Cflow::net_flow::Peer_socket_options | A set of low-level options affecting a single Peer_socket |
| ►Cflow::net_flow::Peer_socket_receive_stats | A data store that keeps stats about the incoming direction of a Peer_socket connection to another Flow-protocol Peer_socket |
| Cflow::net_flow::Peer_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 |
| ►Cflow::net_flow::Peer_socket_send_stats | A data store that keeps stats about the outgoing direction of a Peer_socket connection to another Flow-protocol Peer_socket |
| Cflow::net_flow::Peer_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 |
| Cflow::net_flow::Remote_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 |
| ►Cflow::util::Rnd_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 |
| Cflow::util::Rnd_gen_uniform_range< std::size_t > | |
| Cflow::util::Rnd_gen_uniform_range< Peer_socket::security_token_t > | |
| Cflow::util::Rnd_gen_uniform_range< range_t > | Simple, non-thread-safe uniform-range random number generator |
| Cflow::util::Scoped_setter< Value > | 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 |
| Cflow::net_flow::Peer_socket::Sent_packet::Sent_when | Data store to keep timing related info when a packet is sent out |
| Cflow::net_flow::Sequence_number | An internal net_flow sequence number identifying a piece of data |
| Cflow::util::Shared_ptr_alias_holder< Target_ptr, Const_target_ptr > | 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 |
| ►Cflow::util::Shared_ptr_alias_holder< boost::shared_ptr< Drop_timer > > | |
| Cflow::net_flow::Drop_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 |
| ►Cflow::util::Shared_ptr_alias_holder< boost::shared_ptr< Event_set > > | |
| Cflow::net_flow::Event_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 |
| ►Cflow::util::Shared_ptr_alias_holder< boost::shared_ptr< Low_lvl_packet > > | |
| Cflow::net_flow::Low_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 |
| ►Cflow::util::Shared_ptr_alias_holder< boost::shared_ptr< Null_value_set > > | |
| Cflow::cfg::Null_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 |
| ►Cflow::util::Shared_ptr_alias_holder< boost::shared_ptr< Peer_socket > > | |
| Cflow::net_flow::Peer_socket | A peer (non-server) socket operating over the Flow network protocol, with optional stream-of-bytes and reliability support |
| ►Cflow::util::Shared_ptr_alias_holder< boost::shared_ptr< Peer_socket::Received_packet > > | |
| Cflow::net_flow::Peer_socket::Received_packet | Metadata (and data, if retransmission is on) for a packet that has been received (and, if retransmission is off, copied to Receive buffer) |
| ►Cflow::util::Shared_ptr_alias_holder< boost::shared_ptr< Peer_socket::Sent_packet > > | |
| Cflow::net_flow::Peer_socket::Sent_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 |
| ►Cflow::util::Shared_ptr_alias_holder< boost::shared_ptr< Server_socket > > | |
| Cflow::net_flow::Server_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 |
| Cflow::net_flow::Event_set::Socket_as_any_equals | Equality predicate class used in storing various sockets of types wrapped as boost::anys in the Sockets type |
| Cflow::net_flow::Event_set::Socket_as_any_hash | Hasher class used in storing various sockets of types wrapped as boost::anys in the Sockets type |
| Cflow::net_flow::Node::Socket_id | The data nugget uniquely identifying a peer-to-peer connection from a remote endpoint to a port in this Node |
| ►Cboost::system::system_error | |
| Cflow::error::Runtime_error | An std::runtime_error (which is an std::exception) that stores an Error_code |
| Cflow::log::Async_file_logger::Throttling_cfg | Controls behavior of the throttling algorithm as described in Async_file_logger doc header Throttling section |
| Cflow::perf::Time_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 |
| ►Cflow::util::Unique_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 |
| Cflow::log::Logger | 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) |
| Cflow::log::Verbosity_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 |
| Cbool | |
| Cuniform_int_distribution< Peer_socket::security_token_t > | |
| Cuniform_int_distribution< std::size_t > | |
