| actor_mapper | Converts between a schedule actor's id and the actual actor |
| actor_mapping | Encapsulates a schedule actor for searches |
| address_base | |
| amorph< contents > | A dynamic container class that holds any kind of object via pointers |
| anchor_window | Implements a graceful shutdown procedure for an application |
| geometric::angle< contents > | Represents a geometric angle |
| application_base | Provides a base object for the root application portion of a program |
| application_config | Manages the initialization file for a set of registered applications |
| application_shell | The application_shell is a base object for console programs |
| argument_holder | |
| argument_list | |
| array< contents > | Represents a sequential, ordered, contiguous collection of objects |
| attribute_bundle | Encapsulates all of the attributes known for an object |
| auto_synchronizer | Simplifies synchronization by not requiring unlocking calls |
| averager< contents > | Maintains a list of numbers and provides the average for them |
| averager< contents >::weighted_entry | |
| basic_window | |
| nodes::basket< contents > | Basket class holds an object and supports connecting them as nodes |
| bicolored | |
| bit_vector | An array of bits with operations for manipulating and querying individual bits |
| bitmap | |
| bitmap_tree | |
| blank_entity_registry | Blank_entity_registry can be used when security is not an issue |
| blowfish_crypto | Provides BlowFish encryption on byte_arrays using the OpenSSL package |
| bookmark_tree | |
| bounded_int_configlet | Stores an integer in a configuration repository with range checking |
| box | |
| broadcast_spocket_tester | |
| bubble | |
| bubbles_tentacle | |
| buffer | A buffer is a blob of memory broken into pieces that we call "packets" |
| buffer_base | The base class for buffers to be managed by this library |
| buffer_id | |
| buffer_key | Uniquely identifies a buffer by its unique characteristics |
| buffer_manager | A buffer_manager maintains a group of buffers |
| bundle_list | Provides a structure for managing a collection of attribute_bundles |
| button | |
| buzz_root | |
| byte_array | A very common template for a dynamic array of bytes |
| byte_filer | |
| byte_sequence | Similar to a byte array, but provides a sequence of bytes |
| callback_data_block | Simple place-holder that anonymizes the type passed to the callback |
| canvas | |
| 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 |
| nodes::catalogable | A base class for objects that can be stored in the object_catalog |
| chaos | Platform-independent way to acquire random numbers in a specific range |
| char_star_array | Simple wrapper of an array of char *, used by break_line() |
| chat_connection | |
| geometric::circle | |
| earth_time::clock_time | A specific point in time as represented by a 24 hour clock |
| clonable | Provides a means to make a copy of an existing object |
| CNSFlexConstraint | |
| CNSFlexConstraintList | |
| CNSFlexDialog | |
| CNSFlexFormView | |
| CNSFlexHorizontalConstraint | |
| CNSFlexMDIChildWnd | |
| CNSFlexPropertyPage | |
| CNSFlexPropertySheet | |
| CNSFlexPropertySheetView | |
| CNSFlexVerticalConstraint | |
| color | |
| colorable | |
| column_headers | Provides a simple way to design a table structure |
| combo_logger | Combines a file_logger with a console logger (see console_logger.h) |
| command_line | |
| command_parameter | |
| common | "common" structure gathers some popular elements of lower-level classes |
| common_database_support | |
| communication_commons | |
| config_watcher | Object that watches the contents of a configurator for changes |
| configlet | Represents an atom of configuration info |
| configurable | |
| configuration_list | Manages a collection of configlet objects |
| configurator | Provides a base class for configuration repositories |
| connection | |
| connection_id | |
| connection_table | |
| console_logger | A logger that sends to the console screen using the standard output device |
| critical_events | Provides a means of writing events to a log of runtime problems |
| cromp_client | |
| cromp_common | |
| cromp_security | |
| cromp_server | |
| cromp_transaction | |
| database_login_info | Container for authentication information for logging into a database |
| earth_time::day_in_year | An object that represents a particular day in a year |
| debugger | |
| debugging_base | |
| debugging_console_view | |
| debugging_console_window | |
| debugging_frame | |
| deep_array< contents > | This object mimics a C array but tracks its contents as deep pointers |
| desktop | |
| dialog | |
| dimensionable | |
| directory | Implements a scanner that finds all filenames in the directory specified |
| directory_tree | |
| dns_entry | |
| dot | |
| geometric::double_angle | Double_angle provides a non-templated class for forward declarations |
| double_array | An array of double floating point numbers |
| double_matrix | A matrix of double floating point numbers |
| drawable | |
| drawing_window | |
| library_plugins::dynamic_library_loader | |
| geometric::ellipse | Represents a geometric ellipse |
| empty_service | |
| encryption_infoton | Encapsulates the chit-chat necessary to establish an encrypted connection |
| encryption_tentacle | Processes the encryption_infoton object for setting up an encrypted channel |
| encryption_wrapper | Wraps an encrypted infoton when the octopus is in an encrypted mode |
| entity_data_bin | Stores a set of infotons grouped by the entity that owns them |
| entity_registry | Provides a security model for the octopus |
| event_record | A simple record for holding onto event info |
| example_rpc_client | |
| example_rpc_server | |
| example_rpc_server::client_record | |
| file_info | Encapsulates some measures and calculations based on a file's contents |
| file_logger | |
| file_time | A platform independent way to obtain the timestamp of a file |
| file_transfer_header | Describes one portion of an ongoing file transfer |
| file_transfer_infoton | Base objects used by the file transfer tentacle to schedule transfers |
| file_transfer_tentacle | Manages the transferrence of directory trees from one place to another |
| filename | Provides operations commonly needed on file names |
| filename_list | Implements a list of filenames |
| filename_tree | This is a support class for the directory_tree |
| filepointer | |
| flexichar_sequence | A double-byte sequence for use in unicode strings |
| float_plus< contents > | An extension to floating point primitives providing approximate equality |
| fname_tree_creator | This is the tree factory used in the recursive_unpack |
| grid_processor | Morphs grid definitions into database result sets into data fields |
| guarded_value< contents > | Remembers whether a value has actually been initialized |
| hamming | A simulator for a Hamming neural network |
| hash_table< key_type, contents > | Implements hashing into buckets for quick object access |
| hashing_algorithm | A hashing algorithm takes a key and derives a related integer from it |
| heartbeat | Monitors a periodic heartbeat to track a resource's health |
| heavy_file_operations | Provides serious file operations, such as copy and partial writing |
| hospital | |
| house | |
| huge_file | Supports reading and writing to very large files, > 4 gigabytes |
| hysteresis | Provides a mechanism for responding to events with relaxed timing |
| ice_key | This class provides ICE encryption |
| identity_infoton | Encapsulates just the action of identifying an octopus user |
| identity_tentacle | Supports an early step in using octopus services: getting an identity |
| IfParser | |
| inclist | |
| info_edit | |
| infoton | An infoton is an individual request parcel with accompanying information |
| infoton_id_pair | Implements a list of waiting infotons |
| infoton_list | List of pending requests and who made them |
| ini_configurator | |
| ini_parser | Parses strings in the fairly well-known INI file format |
| ini_roller | Implements an id generator that interacts with a configuration file |
| inner_mark_tree | |
| int_array | A simple object that wraps a templated array of ints |
| int_averager | Keeps an average on a stream of integers |
| int_configlet | Stores a simple integer in a configuration repository |
| int_hash< contents > | A hash table for storing integers |
| int_matrix | A matrix of integers |
| int_roller | A roller that's based on integers. This is the most common type so far |
| int_set | A simple object that wraps a templated set of ints |
| internet_address | |
| internet_machine_uid | |
| ipc_address | |
| isprintf | Isprintf is a specialization of istring that provides printf style support |
| istring | Provides a dynamically resizable character string |
| istring_hasher | |
| istring_object | An istring that is also derived from object_base |
| item_statistics | This is the set of timing information collected for a scheduled item |
| ithread | Provides a platform-independent object for adding threads to a program |
| key_repository | |
| keyboard | |
| label | |
| letter | A virtual base class for pieces of "mail". Used by the mailbox object |
| library_wide_cleanup | Per-library class roots global statics and handles static destruction |
| life_maintainer | Provides a catalog service for living_items |
| geometric::line< numeric_type > | Represents a geometric line segment |
| link_record | |
| linked_buffer | Linked buffers replicate storage without multiplying memory usage |
| nodes::list | Implements a guarded, doubly linked list structure |
| nodes::list::iterator | Iterators allow the list to be traversed |
| list_box | |
| list_dialog | Implements a list box where items can be chosen from the list |
| list_manager | Supports distributed management of a list of object states |
| list_parsing | A set of functions that help out with parsing lists of things |
| list_synchronizer | |
| listo_links | |
| living_item | A base class for any catalogable object whose life is based on a heartbeat |
| locked_logger | Supports swapping the program-wide logger out with thread safety |
| locked_object< contents > | Wraps a templated object safely with regard to threads |
| log_base | Provides an abstract base for logging mechanisms |
| login_tentacle | Provides rudimentary login services |
| hoople_api::low_level_methods | Collection of low-level support methods from basis and elsewhere |
| machine_uid | |
| machine_uid_array | |
| mail_stop | Base class for routes on which letters are automatically delivered |
| mail_stop::items_to_deliver | |
| mailbox | Implements a thread safe "mail" delivery system |
| hoople_api::managed_ini_config | |
| managed_object< contents > | Reference counts objects and destroys them automatically |
| managed_thread | |
| hoople_api::managed_time_stamp | Supports comparing times against each other, survives OS uptime rollover |
| manager | |
| manifest_chunk | We will read the manifest pieces out of our own exe image |
| mat_morph< contents > | Represents a two-dimensional matrix of pointers to objects |
| math_ops | A grab-bag of mathematical functions that are frequently useful |
| matrix< contents > | Represents a two-dimensional array of objects |
| memory_limiter | Tracks memory currently in use by memory manager objects |
| menu | |
| 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 |
| message_box | |
| message_id | |
| library_plugins::mfc_library_loader | |
| mouse | |
| mouserciser | |
| mutex | The object that will actually be used for mutual exclusion |
| mutex_base | A simple primitive class that encapsulates OS support for mutual exclusion |
| name_cache | |
| nechung_oracle | |
| network_address | |
| nodes::node | An object representing the interstitial cell in most linked data structures |
| nub | |
| null_logger | Trash can for logging; throws away all entries |
| nodes::objcat_isolater | Allows a catalogable to be manipulated without locking the entire list |
| nodes::objcat_iterator | This structure is used to make the find operation thread safe |
| nodes::objcat_locket | Write access to the item pointed to by the objcat_iterator |
| object_base | A virtual base class that specifies some requirements for HOOPLE objects |
| nodes::object_catalog | Provides a generalized listing service for catalogable objects |
| occurrence | Tracks information about something that happened during runtime |
| octenc_key_record | Tracks the keys that have been assigned for a secure channel |
| octopus | Octopus is a design pattern for generalized request processing systems |
| octopus_entity | Provides a way of identifying users of an octopus object |
| octopus_request_id | Identifies requests made on an octopus by users |
| octopus_request_id_set | Collection of unique request ids |
| off_screen_dc | |
| orderable_unique_id< uniquifier > | A unique identifier class that supports sorting |
| nodes::ordered_list | Adds an ordering, insertion sort, and find function to the list class |
| nodes::ordered_node | Adds an ordering function for comparison, with exact and inexact matching |
| OS_event | Models an OS-level event so we can represent activities occurring there |
| outcome | Outcomes describe the state of completion for an operation |
| oval | |
| packable | A base class for objects that can pack into bytes |
| nodes::packable_tree | A tree object that can be packed into an array of bytes and unpacked again |
| nodes::packable_tree_factory | |
| paintable | |
| pairing< type1, type2 > | Groups two items together |
| palette | |
| 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 |
| pause_indicator | |
| periodicity | Describes the scheduling characteristics of an item to be scheduled |
| picture | |
| picture_part | |
| geometric::point< numeric_type > | Represents a geometric point |
| pointer_hash< contents > | |
| pointer_set | A set of pointers that hides the platform's pointer size |
| geometric::polygon | |
| post_office | Manages a collection of mailboxes and implements delivery routes for mail |
| process_control | Provides a bridge to the operating system for information on processes |
| process_entry | Encapsulates information about OS processes |
| process_entry_array | Handy class that implements an array of process entries |
| process_manager | Provides methods for starting, stopping and checking on processes |
| program_wide_cleanup | Per-application class roots global statics and handles static destruction |
| query_handler | Supports querying a database using the db-lib API from freetds |
| quit_button | |
| radio_box | |
| radio_box_button | |
| range_limiter | |
| raw_socket | |
| reader_writer_lock | Controls multiple threads that may read or write a shared object |
| geometric::rectangle< numeric_type > | Represents a geometric rectangle |
| geometric::rectangle_warper< numeric_type > | |
| recursive_file_copy | Copies entire hierarchies in the file system from one place to another |
| registry_configurator | Supports the configurator class interface on the windows registry |
| rendezvous | An inter-process synchronization primitive |
| resources | |
| ring | |
| roller< contents > | Maintains a pseudo-unique identifier number and issues a new one on demand |
| rotating_byte_hasher | Implements a hashing algorithm based on the contents stored in an object |
| RSA_crypto | Supports public key encryption and decryption |
| runtime_history | Keeps a record of the outcomes that have been recorded by objects |
| safe_callback | A reasonably easy way to make callbacks safe from shutdown ordering issues |
| nodes::safe_list | Implements a thread safe list |
| nodes::safe_list_read_iterator | Iterator used for reading the list |
| nodes::safe_list_write_iterator | Iterator used for writing the list |
| nodes::safe_node | A simple virtual base class for objects that can be in a safe_list |
| safe_roller | Implements a thread-safe roller object |
| schedulable | A base class for objects that can be added into a scheduler for processing |
| schedule_actor | The schedule_actor is the controlling object for a scheduled item |
| schedule_iterator | < the schedule_iterator allows the schedule to be traversed externally |
| scheduler | Processes a list of schedulables by running them at appropriate times |
| scheduling_common | Defines values used within the scheduling library |
| scheduling_id | The unique scheduling id assigned to items in the schedule |
| geometric::screen_point | Simple class used to describe points on a graphics screen |
| geometric::screen_rectangle | Represents a rectangle as interpreted on display screens |
| secret_string | Provides a way to encrypt a string when given an ice_key |
| section_manager | Tracks a collection of related configurations in a configurator |
| security_infoton | Encapsulates security activities (login, logout, refresh) |
| semaphore | Monitors a set of resources and prohibits over-allocation |
| sequence< contents > | An array that can be alphabetically ordered against other instances |
| sequence_tracker | |
| serial_port_address | |
| service_control | Provides functions to manage win32 services |
| service_root | Provides a reusable base class for a Win32 service |
| basis::set< contents > | Emulates a mathematical set, providing several standard set operations |
| shared_memory | Implements storage for memory that can be shared between threads |
| shutdown_alerter | A platform-independent way to alert a program that it should shut down immediately |
| simple_entity_registry | Provides a basic implementation of an entity_registry for octopus |
| simple_service | |
| singleton_application | |
| slider | |
| smtp_client | |
| socket_data | |
| socket_minder | |
| span_manager | Manages lists of numbers representing the completion of some activity |
| spocket | |
| spocket_tester | |
| ssl_init | Some initialization for the RSA and blowfish crypto |
| stack< contents > | An abstraction that represents a stack data structure |
| state_machine | Monitors objects with multiple states and the transitions between states |
| static_bitmap | |
| static_memory_gremlin | Holds onto memory chunks that are allocated globally within the program |
| stdio_redirecter | Redirects I/O for a newly launched application |
| string_array | A simple array of strings with some additional helpful methods |
| string_configlet | String_configlet holds onto a character string value |
| hoople_api::string_conversions | Conversions between string types that ease crossing to the CLR and back |
| string_hash< contents > | Implements a hash table indexed on character strings |
| string_hasher | Implements a simple hashing algorithm for strings |
| string_manipulation | Provides various functions for massaging strings |
| string_matrix | A matrix of strings |
| string_set | A simple object that wraps a templated set of strings |
| string_table | Provides a symbol_table that holds strings as the content |
| subnet_calculator | |
| 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 | |
| synchronizer_base | This is a pure virtual base for the simplest notion of synchronization |
| system_string | |
| system_values | This class provides a way to look up generated values used in the code base |
| t_wxext_frame | |
| table_configurator | Supports the configurator interface using a collection of string tables |
| tag | |
| tagged_window | |
| tcpip_stack | |
| tentacle | Manages a service within an octopus by processing certain infotons |
| tentacle_helper< contents > | Prefab implementations for parts of the tentacle object |
| test_nt_security | Tests out the nt_security class |
| test_rpc_client | |
| test_rpc_server | |
| test_waldo | |
| testing_statistics | |
| text | |
| thermometer | |
| thread_cabinet | Manages a collection of threads |
| throughput_counter | Reports on average bandwidth of the transfers being measured |
| earth_time::time_locus | An object that represents a particular point in time |
| time_stamp | Represents a point in time relative to the operating system startup time |
| timed_object | Timed_object is the base for objects that can be hooked into timer events |
| timer | A class for measuring event durations in real time |
| timer_driver | Provides platform-independent timer support |
| tiny_shell | |
| tokenizer | Manages a bank of textual definitions of variables |
| transition_map | The transition_map manages state machines and causes state changes to occur |
| transport_id | |
| nodes::tree | A dynamically linked tree with an arbitrary number of branches |
| nodes::tree::iterator | |
| geometric::triangle | Represents a geometric triangle |
| unhandled_request | Informs the caller that a request type was unknown to the server octopus |
| unhandled_request_tentacle | |
| unique_id< uniquifier > | Provides an abstraction for the responsibilities of a unique identifier |
| unique_int | A unique identifier based on integers |
| unwrapping_tentacle | This simple tentacle just unpacks the encryption_wrapper infoton |
| user_zinger | Provides a catalog service for zingable objects |
| version | Holds a file's version identifier |
| version_checker | Provides version checking for dynamically linked libraries |
| version_ini | This provides support for writing windows version files |
| version_record | Holds all information about a file's versioning |
| version_stamper | |
| library_plugins::virtual_library | |
| visible_line | |
| library_plugins::vl_data_pack | Helps to make construction parameter passing more generic |
| waldo_attachment | |
| WIdentityPalette | |
| WinGDC | |
| worker | |
| wp_menu_item | |
| write_build_config | |
| wx_debugger | |
| wx_debugging_base | |
| wx_debugging_console_panel | |
| wx_tiny_shell | |
| xml_generator | Supports simple XML output with consistency checking |
| xml_parser | Parses XML input and invokes a callback for the different syntactic pieces |
| zing_table | The manager of zings that are awaiting delivery to zingable objects |
| zingable | A living_item that can be zinged with events |
