| toast::log::always_output | This VerbosityPolicy causes the logger to output log messages regardless of their severity |
| toast::assert_exception | Exception thrown by toast assertions in the case that TOAST_THROW_ASSERTS is used |
| toast::basic_log_handle< CharT > | A handle for a logger |
| toast::basic_logbuf< CharT, Traits, Alloc > | Logbuf Warning: ignores the Alloc template parameter. Will always allocate internal buffer with new |
| toast::basic_logstream< CharT, Traits, Alloc > | Logstream |
| toast::log::check_verbosity | This VerbosityPolicy causes the logger to output log messages based on their severity compared to the level of verbosity set by the user |
| toast::log::ConsumingOutputPolicy | OutputPolicy's should subclass this to indicate that they support message consumption |
| toast::default_factory< T > | This factory creates T with its default constructor |
| toast::dereference_iterator< Iterator > | Turns iterators to pointers into iterators to pointees |
| toast::enable_unintrusive_from_this< T > | Allows you to return an unintrusive_ptr to *this |
| toast::first_iterator< Iterator > | Turns iterators to pairs into iterators to pair.first values |
| toast::log::FooterPolicyConcept< Policy > | The FooterPolicyConcept describes the interface of a FooterPolicy |
| toast::global_factory< T > | This factory creates T with any toast::typed_factory<T> you like |
| toast::log::HeaderPolicyConcept< Policy > | The HeaderPolicyConcept describes the interface of a HeaderPolicy. Currently the library provides three HeaderPolicies: toast::log::no_header, toast::log::microseconds, and toast::log::severity |
| toast::async::lockable< T > | A convenience wrapper around T for synchronizing its use across threads |
| toast::async::locked< T > | Allows access to a T within a toast::lockable<T> |
| toast::async::locking_queue< T > | Queue for passing data between threads |
| toast::logger< VerbosityPolicy, OutputPolicy, ThreadPolicy > | All log messages go through here |
| toast::log::max_file_size | |
| toast::log::message_limit | |
| toast::log::microseconds | This HeaderPolicy tells the logger to print a microsecond timestamp before each message |
| toast::log::neutral | This ThreadPolicy causes the logger to ignore threads and locking |
| toast::log::never_output | This VerbosityPolicy causes the logger to suppress log messages regardless of their severity. This also allows the compiler to generate very little if any code with minimal optimizations turned on |
| toast::log::never_rotate | |
| toast::log::newline | This FooterPolicy tells the logger to append a newline to each message |
| toast::log::no_footer | This FooterPolicy tells the logger not to print a footer |
| toast::log::no_header | This HeaderPolicy tells the logger not to print a header |
| toast::log::OutputPolicyConcept< Policy > | The OutputPolicyConcept describes the interface of a OutputPolicy. Currently the library provides five OutputPolicies: toast::log::to_stdout, toast::log::to_stderr, toast::log::to_stderr_buffered, toast::log::to_stream, and toast::log::to_file |
| toast::pair_ref_traits< T & > | Given the reference to a pair will define first_type and second_type unchanged |
| toast::pair_ref_traits< T const & > | Given a const reference will const modify the first_type and second_type |
| toast::pointer_traits< boost::shared_ptr< T > > | Given some boost::shared_ptr will provide typedef's for pointer_type, value_type and reference_type |
| toast::pointer_traits< T * > | Given some pointer type will provide typedef's for pointer_type, value_type and reference_type |
| toast::async::promise< T > | Represents a value that will eventually be defined |
| toast::python::register_container< T > | Register a container to be automatically wrapped in python with Boost.Python |
| toast::python::register_optional< T > | Registers a boost::optional<Type> for in Python, making empty optionals into 'None' in Python |
| toast::log::roll_rotation | |
| toast::log::RotationCheckPolicyConcept< Policy > | |
| toast::log::RotationImplPolicyConcept< Policy > | |
| toast::log::RotationPolicyConcept< Policy > | |
| toast::scope_guard | Calls a function on destruction unless dismissed |
| toast::second_iterator< Iterator > | Turns iterators to pairs into iterators to pair.second values |
| toast::log::severity_header | This HeaderPolicy tells the logger to print the severity of the event being logged before each message |
| toast::singleton_helper< T, HolderType, FactoryType, Enable > | This helper deals with all the accounting details of properly managing a singleton |
| toast::log::StreamPolicyConcept< Policy > | The StreamPolicyConcept describes the interface of a StreamPolicy. Currently the library provides five StreamPolicies: toast::log::any_stream, toast::log::cout_stream, toast::log::cerr_stream, toast::log::clog_stream, and toast::log::file_stream |
| toast::thread_specific_factory< T > | This factory creates T with any toast::typed_factory<T> you like |
| toast::async::thread_specific_request_queue | Queue for passing requests to specific threads |
| toast::log::ThreadPolicyConcept< Policy > | The ThreadPolicyConcept describes the interface of a ThreadPolicy. Currently the library provides one ThreadPolicy: toast::log::neutral |
| toast::log::to_file< HeaderPolicy, FooterPolicy, RotationPolicy > | This OutputPolicy directs the loggers output to a file based on a user provided file name |
| toast::log::to_stderr< HeaderPolicy, FooterPolicy > | This OutputPolicy directs the loggers output to stderr |
| toast::log::to_stderr_buffered< HeaderPolicy, FooterPolicy > | This OutputPolicy buffers the loggers output and directs it to stderr |
| toast::log::to_stdout< HeaderPolicy, FooterPolicy > | This OutputPolicy directs the loggers output to stdout |
| toast::log::to_stream< HeaderPolicy, FooterPolicy, StreamPolicy > | This OutputPolicy directs the loggers output to a user provided stream |
| toast::type_info | 'portable' layer to std::type_info |
| typed_factory< T > | An object that holds arguments for deferred object creation |
| toast::unintrusive_ptr< T > | An unintrusive smart pointer that is faster than boost::shared_ptr |
| toast::log::VerbosityPolicyConcept< Policy > | The VerbosityPolicyConcept describes the interface of a VerbosityPolicy. Currently the library provides three VerbosityPolicies: toast::log::always_output, toast::log::never_output, and toast::log::check_verbosity |
| toast::weak_unintrusive_ptr< T > | Weak unintrusive smart pointer |
| toast::async::worker | Thread and provides a way of passing it requests |
| toast::async::worker_pool | Pool of workers |
| toast::python::wrapper< T > | Base class for python bindings that helps wrapping pure virtual functions |