Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
toast::log::always_outputThis VerbosityPolicy causes the logger to output log messages regardless of their severity
toast::assert_exceptionException 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_verbosityThis VerbosityPolicy causes the logger to output log messages based on their severity compared to the level of verbosity set by the user
toast::log::ConsumingOutputPolicyOutputPolicy'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::microsecondsThis HeaderPolicy tells the logger to print a microsecond timestamp before each message
toast::log::neutralThis ThreadPolicy causes the logger to ignore threads and locking
toast::log::never_outputThis 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::newlineThis FooterPolicy tells the logger to append a newline to each message
toast::log::no_footerThis FooterPolicy tells the logger not to print a footer
toast::log::no_headerThis 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_guardCalls a function on destruction unless dismissed
toast::second_iterator< Iterator >Turns iterators to pairs into iterators to pair.second values
toast::log::severity_headerThis 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_queueQueue 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::workerThread and provides a way of passing it requests
toast::async::worker_poolPool of workers
toast::python::wrapper< T >Base class for python bindings that helps wrapping pure virtual functions

SourceForge.net Logo