This section contains a synopsis of the C++ classes found in the Foundation toolkits. Trivial classes or helper classes are not listed. The default prefix os_ is used by most classes to avoid name conflicts with other vendors' class names.

Helper<ToolKit> Classes and Algorithms

Using STL With Pointers to Objects

os_deref1 , os_deref2 powerful function object that uses STL containers of object pointers as if they are containers of object values.

Reference Counting

os_reference templatized reference counter that adorns other objects, adding efficiency with reference-counting without requiring modification to the original class.

STL Helper Algorithms

Helper algorithms

add-on algorithms that simplify the use of STL algorithms for the most common use cases.

Regular Expressions and String Support

`os_regexp`	full cross-platform regular expression interface for use with ANSI/ISO strings, ANSI/ISO IOStreams, or ANSI/ISO Standard Template Library containers.
Regular expression algorithms	complete, powerful regular-expression algorithms designed with the same approach found in the C++ Standard Library. Includes variants of the UNIX `grep` and `sed`.
`os_substring`	nonintrusive substring that simplifies modification of standard strings.
`os_tokenizer`	powerful string tokenizer that separates strings into substrings using user-defined rules.

Generic Function Pointer

os_function templatized function pointer that adds more safety and flexibility than plain function pointers.

Time<ToolKit> Classes

`os_date`	a date between Jan. 1, 4713 b.c. and Dec. 31, 32766 a.d.
`os_time`	a time between 00:00:00 and 23:59:59.
`os_time_and_date`	a time and date between 00:00:00 Jan. 1, 4713 b.c. and 23:59:59 Dec. 31, 32766 a.d.
`os_time_period`	a period between two points in time.
`os_stopwatch`	measures elapsed real time.
`os_time_zone`	a time zone, including offset from Greenwich Mean Time (gmt) and Daylight Savings Time (dst) rules.
`os_time_zone_rule`	the abstract base class of all time zone rules.
`os_calendar_date`	a flexible way to specify a particular day of the year.
`os_simple_time_zone_rule`	adds an offset if a time lies in a certain range, such as Daylight Savings Time (dst) rules.

Thread<ToolKit> Classes

Threads and Thread-Specific Data

`os_thread`	represents a single thread of control.
`os_this_thread`	represents the current thread.
`os_future_thread`	represents a user supplied function that executes asynchronously in a different thread.
`os_future`	represents the future result of a user supplied function.
`os_trap`	represents a way to allow the user to add many `os_futures` and then wait for each in order to return with its redeemed value.
`os_thread_pool`	represents a pool of threads used repeatedly to run small tasks.

Semaphores

`os_critical_section`	simple, highly-efficient synchronization object that locks and unlocks a block of code that is considered a critical section.
`os_mutex`	the most common synchronization mechanism; locks and unlocks a single shared resource. When locked multiple times by the same thread, a mutex must be unlocked the same number of times. Also called a recursive mutex.
`os_fifo_mutex`	similar to `os_mutex`, but guarantees order of resource obtainment based on first-in, first-out (FIFO) scheduling mechanism.
`os_priority_mutex`	similar to `os_mutex`, but guarantees order of resource obtainment based on developer-driven priority mechanism.
`os_simple_mutex`	permits multiple locks by the same thread, but a single-release of resource.
`os_simple_fifo_mutex`	similar to `os_simple_mutex`, but guarantees order of resource obtainment based on FIFO scheduling mechanism.
`os_simple_priority_mutex`	similar to `os_simple_mutex`, but guarantees order of resource obtainment based on developer-driven priority mechanism.
`os_counting_semaphore`	tracks multiple resources to be locked and unlocked.
`os_read_write_semaphore`	protects a resource, limiting access to a single writer or multiple readers.
`os_event_semaphore`	provides a signal device for group notification. Multiple threads block on a single semaphore, then all are released at the same time.
`os_condition_mutex`	allows a single shared resource to be locked and unlocked, specifically `os_condition`. Also called a nonrecursive mutex.

Semaphore Helpers

`os_sem_lock`	synchronization mechanism that automatically releases/unlocks other semaphores when an object goes out of scope, similar to the way `auto_ptr` frees memory. This class is useful for developing exception-safe code.
`os_sem_read_lock`	`os_sem_lock` that obtains a read lock when constructed.
`os_sem_write_lock`	`os_sem_lock` that obtains a write lock when constructed.
`os_monitor`	powerful nonintrusive mechanism that read- or write-locks an object. Monitors adorn other objects, attaching a read/write semaphore without requiring modification to the original code.
`os_sentinel`	synchronization mechanism that provides nonintrusive read/write locking on objects and change notification for multiple threads. Serves as a great foundation for agent technology.
`os_barrier`	synchronization primitive that allows a specified number of threads to reach a specific point and wait before they all can proceed.
`os_condition`	synchronization object that enables a thread to test an arbitrary condition and block until the state of the condition changes, all under the protection of a mutex.
`os_ward`	synchronization mechanism that enables a thread to test several arbitrary conditions and block until one, any, or all conditions change.

Producer-Consumer Containers

`os_pc_priorty_queue`	priority based producer consumer queue.
`os_pc_queue`	FIFO based producer consumer queue.
`os_pc_stack`	LIFO based producer consumer stack.

Summary Of Classes