|
Flow 1.0.0
Flow project: Public API.
|
| ▼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 |
| 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 |
| Nfs | Short-hand for namespace boost::filesystem |
| Nopts | Short-hand for namespace boost::program_options |
| ▼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 |
| Nfs | Short-hand for namespace boost::filesystem |
| ▼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 |
| 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 |
| 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 |
| CSimple_ostream_logger | An implementation of Logger that logs messages to the given ostreams (e.g., cout or an ofstream for a file) |
| 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 |
| ▼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 |
| 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 |
| 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 |
| 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_send_stats | A data store that keeps stats about the outgoing direction of a Peer_socket connection to another Flow-protocol Peer_socket |
| 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 |
| 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 |
| ▼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 |
| Nthis_thread | Short-hand for standard this-thread namespace |
| 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 |
| 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 |
| 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 |
| 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< 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 |
1.9.4