| basis::a_sprintf | A_sprintf is a specialization of astring that provides printf style support |
| structures::amorph< contents > | |
| geometric::angle< contents > | |
| configuration::application_configuration | Defines installation-specific locations in the file system |
| application::application_shell | The application_shell is a base object for console programs |
| basis::array< contents > | Represents a sequential, ordered, contiguous collection of objects |
| basis::astring | Provides a dynamically resizable ASCII character string |
| structures::astring_hasher | |
| basis::attribute | Defines an attribute base class that supports get and set operations |
| basis::auto_synchronizer | Auto_synchronizer simplifies concurrent code by automatically unlocking |
| mathematics::averager< contents > | Maintains a list of numbers and provides the average for them |
| sockets::base_address | |
| application::base_application | Provides a base object for the root application portion of a program |
| basis::base_logger | Provides an abstract base for logging mechanisms |
| basis::base_string | Defines the base class for all string processing objects in hoople |
| basis::base_synchronizer | Interface for a simple form of synchronization |
| nodes::basket< contents > | Basket class holds an object and supports connecting them as nodes |
| structures::bit_vector | An array of bits with operations for manipulating and querying individual bits |
| octopi::blank_entity_registry | Blank_entity_registry can be used when security is not an issue |
| crypto::blowfish_crypto | Provides BlowFish encryption on byte_arrays using the OpenSSL package |
| bogon | |
| bookmark_tree | |
| configuration::bounded_int_configlet | Stores an integer in a configuration repository with range checking |
| broadcast_spocket_tester | |
| structures::bucket< key_type, contents > | |
| synchronic::bundle_list | Provides a structure for managing a collection of synchronizables |
| basis::byte_array | A very common template for a dynamic array of bytes |
| filesystem::byte_filer | Provides file managment services using the standard I/O support |
| textual::byte_formatter | Provides functions for manipulating arrays of bytes |
| processes::callback_data_block | Simple place-holder that anonymizes the type passed to the callback |
| geometric::cartesian_line | Provides a geometric line that use double floating points numbers |
| geometric::cartesian_point | Provides a geometric point that use double floating points numbers |
| geometric::cartesian_rectangle | Provides a geometric rectangle that use double floating points numbers |
| mathematics::chaos | Platform-independent way to acquire random numbers in a specific range |
| processes::char_star_array | Simple wrapper of an array of char *, used by launch_process::break_line() |
| structures::checksums | |
| geometric::circle | Represents a geometric circle |
| timely::clock_time | A specific point in time as represented by a 24 hour clock |
| basis::clonable | A clonable object knows how to make copy of itself |
| loggers::combo_logger | Combines a file_logger with a console logger, behaving like the 'tee' command |
| application::command_line | |
| application::command_parameter | |
| basis::common | "common" class defines our common_outcomes |
| sockets::communication_commons | Defines our communication related outcome values |
| configuration::config_watcher | Object that watches the contents of a configurator for changes |
| configuration::configlet | Represents an atom of configuration info |
| configurable | |
| configuration::configuration_list | Manages a collection of configlet objects |
| configuration::configurator | Provides a base class for configuration repositories |
| processes::configured_applications | Manages the initialization file for a set of registered applications |
| loggers::console_logger | |
| loggers::critical_events | Provides a means of logging events for runtime problems |
| cromp::cromp_client | |
| cromp::cromp_common | A few common features used by both CROMP clients and servers |
| cromp::cromp_security | Implements the client registry in a cromp-appropriate manner |
| cromp::cromp_server | |
| cromp::cromp_transaction | |
| timely::day_in_year | An object that represents a particular day in a year |
| filesystem::directory | Implements a scanner that finds all filenames in the directory specified |
| filesystem::directory_tree | An object that traverses directory trees and provides a view of all files |
| geometric::double_angle | Double_angle provides a non-templated class for forward declarations |
| basis::double_array | An array of double floating point numbers |
| structures::double_matrix | A matrix of double floating point numbers |
| mathematics::double_plus | |
| geometric::ellipse | Represents a geometric ellipse |
| octopi::encryption_infoton | Encapsulates the chit-chat necessary to establish an encrypted connection |
| octopi::encryption_tentacle | Processes the encryption_infoton object for setting up an encrypted channel |
| octopi::encryption_wrapper | Wraps an encrypted infoton when the octopus is in an encrypted mode |
| basis::enhance_cpp | |
| octopi::entity_data_bin | Stores a set of infotons grouped by the entity that owns them |
| octopi::entity_registry | Provides a security model for the octopus |
| basis::environment | Provides access to the system's environment variables |
| loggers::eol_aware | Provides an abstract base for logging mechanisms |
| basis::equalizable | Base class for object that can tell itself apart from other instances |
| processes::ethread | Provides a platform-independent object for adding threads to a program |
| filesystem::file_info | Encapsulates some measures and calculations based on a file's contents |
| loggers::file_logger | |
| filesystem::file_time | |
| filesystem::file_transfer_header | Describes one portion of an ongoing file transfer |
| octopi::file_transfer_infoton | Base objects used by the file transfer tentacle to schedule transfers |
| octopi::file_transfer_tentacle | Manages the transferrence of directory trees from one place to another |
| filesystem::filename | Provides operations commonly needed on file names |
| filesystem::filename_list | |
| filesystem::filename_tree | |
| filepointer | |
| loggers::filter_set | A simple object that wraps a templated set of ints |
| filesystem::fname_tree_creator | This is the tree factory used in the recursive_unpack |
| structures::hash_table< key_type, contents > | Implements hashing into buckets for quick object access |
| structures::hash_wrapper< key_type, contents > | |
| structures::hashing_algorithm | A hashing algorithm takes a key and derives a related integer from it |
| processes::heartbeat | Monitors a periodic heartbeat to track a resource's health |
| filesystem::heavy_file_operations | Provides serious file operations, such as copy and partial writing |
| application::hoople_service | A platform-independent way to alert a program that it should shut down immediately |
| basis::hoople_standard | Base class of the most easily used and tested objects in the library |
| filesystem::huge_file | Supports reading and writing to very large files, > 4 gigabytes |
| octopi::identity_infoton | Encapsulates just the action of identifying an octopus user |
| octopi::identity_tentacle | Supports an early step in using octopus services: getting an identity |
| IfParser | |
| inclist | |
| octopi::infoton | An infoton is an individual request parcel with accompanying information |
| octopi::infoton_id_pair | Implements a list of waiting infotons |
| octopi::infoton_list | List of pending requests and who made them |
| configuration::ini_configurator | Supports a configurator-based interface on text initialization files |
| configuration::ini_parser | Parses strings in the fairly well-known INI file format |
| configuration::ini_roller | Implements an id generator that interacts with a configuration file |
| inner_mark_tree | |
| basis::int_array | A simple object that wraps a templated array of ints |
| mathematics::int_averager | Keeps an average on a stream of integers |
| configuration::int_configlet | Stores a simple integer in a configuration repository |
| structures::int_hash< contents > | A hash table for storing integers |
| structures::int_matrix | A matrix of integers |
| structures::int_roller | A roller that's based on integers. This is the most common type so far |
| structures::int_set | A simple object that wraps a templated set of ints |
| structures::internal_hash_array< key_type, contents > | |
| structures::internal_pointer_hider< contents > | |
| structures::internal_symbol_indexer< contents > | |
| structures::internal_symbol_info< contents > | |
| structures::internal_symbol_list< contents > | |
| sockets::internet_address | This type of address describes a destination out on the internet |
| sockets::internet_machine_uid | |
| processes::mail_stop::items_to_deliver | |
| nodes::tree::iterator | |
| nodes::list::iterator | Iterators allow the list to be traversed |
| octopi::key_repository | |
| application::launch_manager | Provides methods for starting, stopping and checking on processes |
| processes::launch_process | Provides the capability to start processes in a variety of ways to run other applications |
| processes::letter | A virtual base class for pieces of "mail". Used by the mailbox object |
| geometric::line< numeric_type > | Represents a geometric line segment |
| link_record | |
| nodes::list | Implements a guarded, doubly linked list structure |
| synchronic::list_manager | Supports distributed management of a list of object states |
| textual::list_parsing | A set of functions that help out with parsing lists of things |
| synchronic::list_synchronizer | |
| listo_links | |
| octopi::login_tentacle | Provides rudimentary login services |
| sockets::machine_uid | |
| sockets::machine_uid_array | |
| processes::mail_stop | Base class for routes on which letters are automatically delivered |
| processes::mailbox | Implements a thread safe "mail" delivery system |
| manifest_chunk | We will read the manifest pieces out of our own exe image |
| mathematics::math_ops | A grab-bag of mathematical functions that are frequently useful |
| structures::matrix< contents > | Represents a two-dimensional array of objects |
| structures::memory_limiter | Tracks memory currently in use by memory manager objects |
| menu_base | A base class for a menu-driven interface model |
| menu_common_base | Common base class for referring to menu_items or menus polymorphically |
| menu_item | A base class for the active items that can be stored inside a menu |
| basis::mutex | |
| basis::nameable | Root object for any class that knows its own name |
| nechung_oracle | |
| nodes::node | An object representing the interstitial cell in most linked data structures |
| loggers::null_logger | Trash can for logging; throws away all entries |
| octopi::octenc_key_record | Tracks the keys that have been assigned for a secure channel |
| octopi::octopus | Octopus is a design pattern for generalized request processing systems |
| octopi::octopus_entity | Provides a way of identifying users of an octopus object |
| octopi::octopus_request_id | Identifies requests made on an octopus by users |
| octopi::octopus_request_id_set | Collection of unique request ids |
| basis::orderable | A base for objects that can be alphabetically (lexicographically) ordered |
| structures::orderable_unique_id< uniquifier > | A unique identifier class that supports sorting |
| processes::OS_event | Models an OS-level event so we can represent activities occurring there |
| basis::outcome | Outcomes describe the state of completion for an operation |
| basis::packable | A base class for objects that can pack into an array of bytes |
| nodes::packable_tree | A tree object that can be packed into an array of bytes and unpacked again |
| nodes::packable_tree_factory | |
| textual::parser_bits | Warehouses some functions that are often useful during text parsing |
| nodes::path | A method for tracing a route from a tree's root to a particular node |
| geometric::point< numeric_type > | Represents a geometric point |
| structures::pointer_hash< contents > | A hash table for storing pointers |
| structures::pointer_set | A set of pointers that hides the platform's pointer size |
| geometric::polygon | |
| processes::post_office | Manages a collection of mailboxes and implements delivery routes for mail |
| processes::process_control | Provides a bridge to the operating system for information on processes |
| processes::process_entry | Encapsulates information about OS processes |
| processes::process_entry_array | Handy class that implements an array of process entries |
| loggers::program_wide_logger | A class that provides logging facilities vertically to all of hoople |
| sockets::range_limiter | Mechanism for restricting access to a resource by the client's IP address |
| sockets::raw_socket | |
| geometric::rectangle< numeric_type > | Represents a geometric rectangle |
| geometric::rectangle_warper< numeric_type > | |
| octopi::recursive_file_copy | Copies entire hierarchies in the file system from one place to another |
| processes::rendezvous | An inter-process synchronization primitive |
| structures::roller< contents > | Maintains a pseudo-unique identifier number and issues a new one on demand |
| basis::root_object | < Number of bytes in a terabyte |
| structures::rotating_byte_hasher | Implements a hashing algorithm based on the contents stored in an object |
| crypto::rsa_crypto | Supports public key encryption and decryption |
| processes::safe_callback | A reasonably easy way to make callbacks safe from shutdown ordering issues |
| processes::safe_roller | Implements a thread-safe roller object |
| geometric::screen_point | Simple class used to describe points on a graphics screen |
| geometric::screen_rectangle | Represents a rectangle as interpreted on display screens |
| configuration::section_manager | Tracks a collection of related configurations in a configurator |
| octopi::security_infoton | Encapsulates security activities (login, logout, refresh) |
| sockets::sequence_tracker | This will keep track of sequencing for a communication process on a per host basis |
| structures::set< contents > | Emulates a mathematical set, providing several standard set operations |
| application::shared_memory | Implements storage for memory that can be shared between threads |
| octopi::simple_entity_registry | Provides a basic implementation of an entity_registry for octopus |
| application::singleton_application | |
| sockets::socket_data | |
| sockets::socket_minder | |
| sockets::span_manager | Manages lists of numbers representing the completion of some activity |
| sockets::spocket | Abstraction for a higher-level BSD socket that is platform independent |
| spocket_tester | |
| crypto::ssl_init | Some initialization for the RSA and blowfish crypto |
| structures::stack< contents > | An abstraction that represents a stack data structure |
| loggers::standard_log_base | A base class for a very usable logger with a filter_set and eol awareness |
| processes::state_machine | Monitors objects with multiple states and the transitions between states |
| structures::static_memory_gremlin | Holds onto memory chunks that are allocated globally within the program |
| application::stdio_redirecter | Redirects I/O for a newly launched application |
| timely::stopwatch | A class for measuring event durations in real time |
| structures::string_array | An array of strings with some additional helpful methods |
| configuration::string_configlet | String_configlet holds onto a character string value |
| structures::string_hash< contents > | Implements a hash table indexed on character strings |
| structures::string_hasher | Implements a simple hashing algorithm for strings |
| textual::string_manipulation | Provides various functions for massaging strings |
| structures::string_matrix | A matrix of strings |
| structures::string_set | A simple object that wraps a templated set of strings |
| structures::string_table | Provides a symbol_table that holds strings as the content |
| sockets::subnet_calculator | Provides an easy way to determine the range of a subnet given the subnet mask and a sample IP address |
| structures::sym_tab_apply_data< contents > | |
| structures::symbol_table< contents > | Maintains a list of names, where each name has a type and some contents |
| nodes::symbol_tree | A symbol table that supports scope nesting and/or trees of symbol tables |
| symtab | |
| synchronic::synchronizable | Encapsulates all of the attributes known for an object |
| configuration::system_values | This class provides a way to look up generated values used in the code base |
| configuration::table_configurator | Supports the configurator interface using a collection of string tables |
| sockets::tcpip_stack | Helpful functions for interacting with TCP/IP stacks |
| octopi::tentacle | Manages a service within an octopus by processing certain infotons |
| octopi::tentacle_helper< contents > | Prefab implementations for parts of the tentacle object |
| testing_statistics | |
| basis::text_formable | A base class for objects that can provide a synopsis of their current state |
| basis::text_streamable | Base for classes that can stream their contents out to a textual form |
| processes::thread_cabinet | Manages a collection of threads |
| sockets::throughput_counter | Reports on average bandwidth of the transfers being measured |
| timely::time_control | Provides some functions that affect time, or ones perception of time |
| timely::time_locus | An object that represents a particular point in time |
| timely::time_stamp | Represents a point in time relative to the operating system startup time |
| timely::timeable | Timeable is the base for objects that can be hooked into timer events |
| timely::timer_driver | Provides platform-independent timer support |
| processes::transition_map | The transition_map manages state machines and causes state changes to occur |
| nodes::tree | A dynamically linked tree with an arbitrary number of branches |
| geometric::triangle | Represents a geometric triangle |
| octopi::unhandled_request | Informs the caller that a request type was unknown to the server octopus |
| octopi::unhandled_request_tentacle | |
| structures::unique_id< uniquifier > | Provides an abstraction for the responsibilities of a unique identifier |
| structures::unique_int | A unique identifier based on integers |
| unit_test::unit_base | |
| octopi::unwrapping_tentacle | This simple tentacle just unpacks the encryption_wrapper infoton |
| configuration::variable_tokenizer | Manages a bank of textual definitions of variables |
| structures::version | Holds a file's version identifier |
| versions::version_checker | Provides version checking for shared libraries |
| versions::version_ini | This provides support for writing windows version files |
| structures::version_record | Holds all information about a file's versioning |
| mathematics::averager< contents >::weighted_entry | |
| write_build_config | |
| textual::xml_generator | Supports simple XML output with consistency checking |
| textual::xml_parser | Parses XML input and invokes a callback for the different syntactic pieces |
