moost::mq::stomp_client::ack | |
AddressConfigurable | |
moost::service::appender_factory_iface | Interface for socket appender factories |
moost::service::appender_iface | Interface for log appenders |
moost::thread::async_batch_processor | Allow a batch of jobs to be processed asyncronously whilst you wait |
moost::io::async_stream_forwarder | |
moost::thread::async_worker< TWork > | Async_worker is a virtual class that simplifies the mechanics of doing work asynchronously |
moost::io::async_writer< TWork, TRolloverPolicy > | Async_writer is a class that simplifies the mechanics of writing to a file asynchronously |
moost::digest::base | |
moost::service::validator::base | |
moost::transaction::BasePersistedTQ< dataT, serializerT, queueT > | |
moost::utils::scope_exit::basic_scope_exit< policyT > | This is the basic scope exit class, used when supplying custom policies |
moost::posix_time::basic_timestamp< TimeBasePolicy > | |
moost::thread::async_batch_processor::batch_state | |
moost::utils::benchmark | |
moost::container::BinaryArchivePolicy | |
moost::configurable::binder | Binder is a helper class that aids synchronized binding/setting/getting of nested configurations |
moost::configurable::binding< T > | Binding wraps the reference to a value with persistable qualities |
moost::configurable::binding< bool > | Bool-specific template specialization: we want to interpret true and false |
moost::configurable::binding< std::string > | String-specific template specialization: we need to read the whole line for strings |
moost::container::bit_filter< itemT, hashT > | |
moost::io::block_store | Block_store provides block-level storage by presenting a thread-safe pool of streams, for allocing, reading/writing, freeing |
BoolConfigurable | |
moost::algorithm::ketama_partitioner< T >::bucket_hash | |
moost::utils::scope_exit::policy::call_free_function_with_ref< scopedT > | Calls a free function or functor, passing it scoped by *reference* |
moost::utils::scope_exit::policy::call_free_function_with_val< scopedT > | Calls a free function or functor, passing it scoped by *value* |
moost::utils::scope_exit::policy::call_functor | Calls a boost::function0<void> functor |
moost::utils::scope_exit::policy::call_member_function< scopedT > | |
moost::utils::scope_exit::policy::call_member_function< scopedT * > | Specialisation of call_member_function for "this" pointers |
moost::container::policies::cf_sparsevec_reader< K, T > | |
moost::service::validator::cfile | |
moost::service::skeleton< ServiceT, ProcessOwnershipPolicy, LoggingPolicy, ConsoleLoggerPolicy >::child_init_func | |
moost::pdl::class_not_found_error | |
ClientTester< TClient, TConnection, TKeyTransformPolicy > | |
moost::service::validator::cnumber< T > | |
moost::service::remote_shell_server_impl::command | |
moost::which< N >::comparer< Pred > | Comparer |
ComplexConfigurable | |
moost::configurable::configurable | Anything that inherits from this type guarantees it can have configurations stored/retrieved/listed |
const_hash | |
moost::container::mmd_dense_hash_map< Key, T, HashFcn >::const_iterator | |
moost::container::multi_map< TKey, TVal, TLocMap >::const_iterator | |
moost::container::multi_map< TKey, TVal, TLocMap >::const_range | |
moost::safe_shared_ptr< T >::const_scoped_lock | |
moost::kvds::ConstDbt | User defined data that must NEVER be modified! |
moost::io::count_rollover | |
moost::service::validator::cregex | |
moost::nagios::nsca_crypto::crypt_instance | |
moost::murcl::curl_easyopt< optval > | Abstraction of the LibCurl easy interface options |
moost::murcl::curl_multiopt< optval > | Abstraction of the LibCurl multi interface options |
moost::murcl::curl_opt_base< optval > | Base class for the option abstractions that implements common behaviour |
moost::murcl::curl_shareopt< optval > | Abstraction of the libCurl share interface options |
log4cxx::CustomPatternLayout | |
moost::process::daemon | Provides everything necessary to convert a process into a daemon |
moost::process::daemon_impl | |
moost::utils::histogram< FloatType >::data_info | |
moost::io::data_policy_base< T > | |
moost::process::daemon::default_child_init_func | |
moost::container::bit_filter_types::default_hash | |
moost::process::service< ServiceT, ConsoleLoggerPolicy >::default_parent_exit_func | |
moost::thread::default_safe_thread_policy | |
moost::kvstore::DefaultAccessPolicy | |
moost::container::policies::dense_hs_map< TKey, TVal > | |
moost::progress::display< policyT > | |
moost::pdl::dynamic_class | |
moost::pdl::dynamic_library | |
moost::pdl::dynamic_library_if | |
moost::pdl::dynamic_library_impl | |
moost::murcl::easy | An abstract represenation of the LibCurl easy interface |
moost::murcl::easyopt | A type-safe representaion of all the supported LibCurl options |
moost::process::service< ServiceT, ConsoleLoggerPolicy >::enable_logger_func | |
moost::thread::enqueue_timeout | Thrown by async_worker when there is a timeout while trying to enqueue more work |
moost::testing::error_matcher | |
moost::pdl::exception | |
moost::guarded_ptr< T >::exclusive_access | Objects of this class represent an exclusive lock of the guarded_ptr's mutex |
moost::algorithm::FastHashFunctor< TSeed > | Functor that uses fast_hash |
moost::io::file_backed_data_source< DataPolicy > | |
moost::io::file_backed_data_source_config | |
moost::io::file_backed_data_source_config_factory | |
moost::io::file_backed_data_source_factory | |
moost::io::file_operations | Collection of file operations not easily doable using stdlib functions |
moost::io::file_watcher | Asynchronously watches a path for changes, then notifies a callback function when a change occurs |
moost::utils::fixed_interval_timer | A fixed interval timer |
Fixture | |
Fixture_default | |
Fixture_dense | |
Fixture_generic< TMultiMap > | |
Fixture_map | |
Fixture_sparse | |
Fixture_sparsevec | |
Fixture_stl_map | |
Fixture_vec | |
Fixture_vector | |
FixtureThreshold | |
FloatValueDoubler | |
moost::io::detail::forwarding_loop | |
moost::utils::scope_exit::policy::free_malloc< scopedT > | Calls free on pointer to release a malloc/realloc allocation |
moost::transaction::FullyPersistedTQ< dataT, serializerT, queueT > | |
moost::container::policies::generic_map< TMap > | |
moost::container::geo_map< Data > | Geo_map is a container that associates locations with objects of type Data |
moost::container::get_deleted_key< Key, bool > | |
moost::container::get_deleted_key< Key, true > | |
moost::xml::get_opt_detail< T > | |
moost::xml::get_opt_detail< bool > | |
moost::logging::global | Initialise the global logging API |
moost::murcl::global | This class initialialises the Curl 'program environment' |
moost::logging::global_scoped_logger | Handles scoped logging gracefully across the whole project. global_scoped_logger takes a scoped_logger and makes it available across the whole project without having to pass the object around. global_scoped_logger is thread safe because each object is thread specific. In order to be able to use global_scoped_logger you need to define the scope where the logging will operate: |
moost::guarded_ptr< T > | Wrapper around shared_ptr that guards the referenced object with a mutex |
moost::hash::murmur3::hash32< T, Seed > | |
moost::serialization::hash_map_load__ | |
moost::serialization::hash_map_save__ | |
moost::serialization::hash_set_load__ | |
moost::serialization::hash_set_save__ | |
moost::container::mmd_dense_hash_map< Key, T, HashFcn >::HashingPolicy | |
moost::io::detail::helper | |
log4cxx::pattern::HighlightLevelPatternConverter | |
moost::utils::histogram< FloatType > | |
HKDFContext | |
HMACContext | |
moost::murcl::http_scheme | |
moost::process::hup_handler | |
moost::kvstore::IConnection | |
moost::container::IdentityPolicy | |
moost::container::IdentityTransform< TVal > | |
IKvdsTester | |
moost::kvstore::IKyotoTycoonConnection | |
moost::mq::stomp_client::impl | |
log4cxx_appender::impl | |
moost::signal::signal_handler::impl | |
moost::process::sleeper::impl | |
IncrementingIntDataPolicy | |
moost::container::index_translator< TFrom, TTo, TMap > | |
moost::configurable::indexed_binder< T > | Indexed_binder allows a variable number of configurables accessed by index |
moost::io::ionotify | |
moost::kvds::Kvds< keyT, valT, KvdsTypeKey, KvdsTypeVal >::Iow | |
Item | |
moost::container::multi_map< TKey, TVal, TLocMap >::iterator | |
moost::which< N >::iterator_accessor | |
moost::transaction::ITransactionQueue< dataT > | |
moost::thread::job_batch | |
moost::algorithm::ketama_partitioner< T > | Ketama_partitioner implements consistent hashing, such that the addition or removal of buckets does not significantly change the mapping of keys to buckets. By using consistent hashing, only K/n keys need to be remapped on average, where K is the number of keys, and n is the number of buckets |
moost::kvds::Kvds< keyT, valT, KvdsTypeKey, KvdsTypeVal > | Provides a nice user friendly adaptor for an ikvds interface |
moost::kvds::KvdsPodType< T >::vector_type::kvds_vector< U > | |
moost::kvds::KvdsPodType< T >::vector_type::kvds_vector< U const > | |
moost::kvds::KvdsBdb< dbtypeT > | *** This class is NOT thread safe *** |
moost::kvds::KvdsKch | |
moost::kvds::KvdsKeyIterator< kvdsT > | *** This class is NOT thread safe *** |
KvdsKeyIteratorTester< kvdsT > | |
moost::kvds::KvdsMem< T > | *** This class is NOT thread safe *** |
moost::kvds::KvdsPageMapDefaultKeyHashFunctor | Default key hash functor used to hash the byte array key for the keyval index |
moost::kvds::KvdsPageMapIntrinsicKey< keyT > | A intrinsic type pagemap |
moost::kvds::KvdsPageMapNonIntrinsicKey< KeyHashFunctorT > | *** This class is NOT thread safe *** |
moost::kvds::KvdsPageMapShared< pagemapT > | |
moost::kvds::KvdsPageStore< PageMapT > | *** This class is NOT thread safe *** |
moost::kvds::KvdsPodType< T > | *** This class is NOT thread safe *** |
moost::kvds::KvdsTch | *** This class is NOT thread safe *** |
moost::kvds::KvdsTemplate | *** This class is NOT thread safe *** |
KvdsTester< kvdsT > | |
moost::kvstore::KyotoTycoonClient | |
moost::kvstore::detail::KyotoTycoonConnection | |
moost::pdl::library_load_error | |
moost::pdl::library_not_found_error | |
moost::io::loadable | |
moost::container::geo_map< Data >::location | Key/lookup type of geo_map |
moost::io::map_store< Key, HashFcn >::location | |
log4cxx_appender | |
moost::service::log4cxx_appender_factory | A factory for log4cxx appenders |
moost::container::lru< Key, Data, HashFcn > | Lru is a collection of keys and values, with a max size. Once the max size is reached, further inserted elements push out least recently used elements |
moost::kvds::MallocDbt | Dbd allocated memory that must be released |
moost::container::policies::map_policy_selector< TKey, TVal, TMap > | |
moost::container::policies::map_policy_selector< TKey, TVal, moost::container::dense_hash_map< TKey, TVal > > | |
moost::container::policies::map_policy_selector< TKey, TVal, moost::container::sparse_hash_map< TKey, TVal > > | |
moost::container::policies::map_policy_selector< TKey, TVal, std::vector< TVal > > | |
moost::io::map_store< Key, HashFcn > | Map_store provides storage by presenting a thread-safe scoped_stream given a key and requested size |
moost::container::memory_mapped_dataset | |
moost::kvds::KvdsPageMapShared< pagemapT >::metadata | |
moost::container::mmd_dense_hash_map< Key, T, HashFcn > | |
moost::container::mmd_generic_archive< ArchivePolicy > | |
moost::container::mmd_hash_multimap< Key, T, HashFcn, IndexType > | |
moost::container::memory_mapped_dataset::mmd_header | |
moost::container::mmd_section_writer_base | |
moost::container::mmd_vector< T > | |
moost::kvstore::MockKyotoTycoonConnection< AccessPolicy > | |
moost::algorithm::modulo_partitioner< T > | Modulo_partitioner hashes the key then modulos the result against the number of buckets. This results in an even spread given a reasonable hasher |
moost::service::MoostLoggingPolicy | This policy implements logging using moost::logging |
moost::process::MoostStandardConsoleLoggerPolicy | |
moost::container::multi_map< TKey, TVal, TLocMap > | Multi_map is a container that associates keys to list of values |
moost::multi_timer | |
moost::hash::murmur3 | |
my_fail_class | |
my_test_class | |
my_test_class1 | |
my_test_class2 | |
my_test_interface | |
moost::container::neigh_multi_map< TLocMap > | Neigh_multi_map is a container that associates keys to list of pairs of integers and floats read from the standard-mir format neigh |
moost::container::no_resource_available | |
moost::process::NoConsoleLoggerPolicy | |
moost::service::NoLoggingPolicy | This policy implements no logging |
noncopyable | |
moost::transaction::NonePersistedTQ< dataT, queueT > | |
moost::process::service< ServiceT, ConsoleLoggerPolicy >::noop_child_init_func | |
moost::logging::noop_deleter | |
moost::service::remote_shell_server_impl::noop_pre_shutdown_func | |
moost::service::NoProcessOwnershipPolicy | This policy implements no process ownership handling |
moost::nagios::nsca_client | |
moost::nagios::nsca_config | |
moost::nagios::nsca_crc32 | |
moost::nagios::nsca_crypto | |
moost::nagios::nsca_data_packet | |
moost::nagios::nsca_encpass | |
moost::nagios::nsca_encryption_method | |
moost::nagios::nsca_enctype | |
moost::nagios::nsca_init_packet | |
log4cxx::NscaAppender | An appender that sends alerts to nagios via an nsca client |
null_appender | |
moost::service::null_appender_factory | A factory for appenders that do nothing |
moost::null_terminal_format | |
moost::murcl::option< OptTraits > | This class is an abstract representation of a LibCurl option. Upon construction it requires an interface handle and a value, which it will use to set the appropriate LibCurl option |
moost::service::standard_options::option | |
moost::murcl::option_base | This is a polymorphic base class for options |
moost::murcl::option_setter< CurlOption, ValueType > | A generic option setter to abstract details of both the option value types and the LibCurl interface being used (easy, multi or share) |
moost::murcl::option_setter< CurlOption, std::string > | Specialisation of the generic option setter for std::string type values |
moost::murcl::option_traits< O, T > | A traits class to abstract out the differences between the different interfaces, options and option values. Each supported option has an associated traits class that defines the options compile-time traits |
moost::service::option_validator | |
moost::service::standard_options::options | |
moost::process::ownership | Process ownership information and manipulation |
moost::process::detail::ownership | |
moost::transaction::PartiallyPersistedTQ< dataT, serializerT, queueT > | |
moost::algorithm::partitioner< T > | A partitioner can assign templatized types to a specified number of buckets |
moost::configurable::persistable | Anything that inherits from this type guarantees that it can be persisted to/loaded from a stream |
moost::psql::pgq_consumer | This class represents a consumer for a queue in pgq |
moost::process::pidfile | Create a process pid file |
ClientTester< TClient, TConnection, TKeyTransformPolicy >::pod | |
moost::container::pod_pair< T1, T2 > | |
moost::utils::scope_exit::policy::policy_base< scopedT > | The base for all policies. Models common concept interface |
moost::utils::scope_exit::policy::policy_base_with_get< scopedT > | The base for all policies that implement a getter |
moost::murcl::uri_scheme::port | A enum of supported schemes and their associated default ports |
moost::service::detail::posix_stream_stealer | |
moost::service::posix_stream_stealer | |
moost::mq::stomp_client::impl::protocol | |
moost::logging::pseudo_ostream | A pseudo stream acts as an abstraction to a normal ostream |
moost::container::policies::python_sparsevec_reader< K, T > | |
moost::container::policies::python_vec_reader< K, T > | |
moost::process::quit_handler | Note, SIGKILL and SIGSTOP are not handled (this is a Posix restriction) |
moost::container::multi_map< TKey, TVal, TLocMap >::range | |
moost::utils::histogram< FloatType >::range_info | |
moost::container::policies::reader_value_traits< double > | |
moost::container::policies::reader_value_traits< float > | |
moost::container::policies::reader_value_traits< int > | |
moost::container::policies::reader_value_traits< long > | |
moost::multi_timer::reassignable_scoped_time | |
moost::scoped_verbose::recurrurring_bookmark | |
moost::utils::relops< T > | Sub-class this to implement relops in your class |
moost::service::remote_shell< HandlerType > | A remote command shell used for interacting with the user |
moost::service::remote_shell_iface | Interface for remote command shell |
moost::service::remote_shell_server | Compiler firewall for remote_shell_server_impl |
moost::service::remote_shell_server_impl | |
moost::io::remote_watcher | Asynchronously watches a remote file, then notifies a callback function when a change occurs |
moost::murcl::request | |
moost::container::resource_stack< T > | Resource_stack is a thread-safe collection of resources. Threads can get resources from the stack by using a scoped_resource |
moost::murcl::response | This class is an object representation of a LibCurl response |
moost::utils::scope_exit::policy::restore_original_value< scopedT > | This policy just resets scoped back to the original value |
moost::safe_shared_ptr< T > | |
moost::thread::safe_thread< Policy > | |
moost::thread::safe_thread_group< Policy > | |
moost::io::block_store::scoped_block | |
moost::io::variable_store::scoped_block | |
moost::io::map_store< Key, HashFcn >::scoped_block | |
moost::scoped_verbose::scoped_bookmark | |
moost::scoped_format | |
moost::thread::token_mutex< T >::scoped_full_lock | Locks everybody but first wait that beding are done |
moost::thread::token_mutex< T >::scoped_lock | Locks a token mutex with a given token |
moost::safe_shared_ptr< T >::scoped_lock | |
moost::logging::scoped_logger | Handles verbose with log4cxx gracefully. scoped_logger takes care of collecting the log information within the scope, then spit it out (to whatever it was configured to) |
moost::thread::token_mutex< T >::scoped_promote_lock | Locks everybody but first wait that beding are done |
moost::container::resource_stack< T >::scoped_resource | Use a scoped_resource to get a resource from the resource_stack |
moost::utils::scoped_stopwatch | |
scoped_tempfile | |
moost::multi_timer::scoped_time | |
moost::timer::scoped_time | Used for scoped access to timer |
moost::logging::scoped_timing | |
moost::thread::token_mutex< T >::scoped_try_lock | Locks a token mutex with a given token |
moost::scoped_verbose | Handles verbose gracefully. It behaves like ostringstream and prints the verbose at the end of the scope. Example |
moost::kvds::ScopedFree< T > | |
moost::mpl::detail::search_impl< bool > | |
moost::mpl::detail::search_impl< false > | |
moost::container::memory_mapped_dataset::section_info | |
moost::transaction::Serializer< dataT, istreamT, ostreamT > | |
moost::transaction::SerializerBase | |
moost::process::service< ServiceT, ConsoleLoggerPolicy > | |
moost::nagios::nsca_client::service_state | |
moost::process::service< ServiceT, ConsoleLoggerPolicy >::service_wrapper | |
session< SessionIoT, AllowQuit, EnableCLS > | |
session_base | |
session_io_console | |
session_io_socket | |
session_writer< SessionIoT > | |
moost::utils::scope_exit::policy::set_default_value< scopedT > | This policy just sets scoped to the default constructed value |
moost::utils::scope_exit::policy::set_specific_value< scopedT > | This policy just sets scoped to a specific value |
SHA1Context | |
SHA256Context | |
SHA512Context | |
moost::guarded_ptr< T >::shared_access | Objects of this class represent a shared lock of the guarded_ptr's mutex |
moost::shell< HandlerType > | |
moost::signal::signal_handler | |
moost::utils::fixed_interval_timer::signal_t | Represents an atomic signal |
moost::thread::simple_job_batch | |
moost::thread::simple_job_scheduler | |
moost::container::simple_multi_map< TKey, TVal, TLocMap > | |
moost::xml::simple_parser | |
moost::algorithm::SimpleAccumulatorPolicy< FloatType > | |
SimpleAsyncWorker | |
SimpleConfigurable | |
moost::utils::singleton_default< T > | |
moost::service::skeleton< ServiceT, ProcessOwnershipPolicy, LoggingPolicy, ConsoleLoggerPolicy > | Configurable template implementing common functionality to run a service |
moost::progress::policy::skeleton< CounterType > | |
moost::process::sleeper | |
moost::logging::scoped_logger::sLogEntry | |
so_load_watcher | |
moost::container::policies::sparse_hs_map< TKey, TVal > | |
moost::progress::policy::spinner | |
moost::algorithm::spline_interpolation | Generate a spline interpolation of X and Y data points using the GNU Scientific Library |
moost::logging::standard_console | |
moost::service::standard_options | |
moost::mq::stomp_client::impl::state | |
moost::utils::histogram< FloatType >::stats | |
moost::mq::stomp_client | |
moost::mq::stomp_client_error_category | |
stomp_test_client | |
moost::utils::stopwatch | |
moost::kvstore::MockKyotoTycoonConnection< AccessPolicy >::Store | |
moost::kvds::KvdsPageStore< PageMapT >::Store | |
moost::mq::stream | |
moost::mq::stream_manager | |
moost::service::stream_writer_iface | |
StringLiteralToPodTypePolicy | |
StringLiteralToStringPolicy | |
moost::io::tempdir | |
Fixture::TempDirectory | |
test_dataset | |
test_dense_hash_map< HashFcn > | |
moost::testing::test_directory_creator | |
test_val | |
moost::safe_shared_ptr< T >::Tester | Using strategy from "Modern C++ design", page 178 |
moost::container::TextArchivePolicy | |
moost::thread::threaded_job_batch | |
moost::thread::threaded_job_scheduler | |
moost::io::timeofday_rollover | |
TimeoutAsyncWorker | |
moost::utils::benchmark::timer | |
moost::timer | |
moost::thread::token_mutex< T > | Token_mutex allows you to enter a critical section of code if you have a token that no one else does |
moost::transaction::TransactionHandler< queueT, commitFunctorT > | |
moost::xml::simple_parser::tree_node | |
moost::container::policies::tsv_sparsevec_reader< K, T > | |
moost::container::policies::tsv_vec_reader< K, T > | |
moost::utils::scope_exit::type< scopedT > | This is the general scope exit class, with the various policies ready for use |
moost::service::validator::typed_base< T > | |
moost::service::UidGidProcessOwnershipPolicy | This policy implements process ownership handling based on user/groud IDs |
UnitTestAccessPolicy | |
moost::posix_time::universal_timebase | |
moost::guarded_ptr< T >::upgradable_access | Objects of this class represent an upgradable lock of the guarded_ptr's mutex |
moost::guarded_ptr< T >::upgradable_access::upgrade | Objects of this class represent an upgrade of an upgradable lock |
moost::murcl::uri | This class is an object representation of a RFC-2396 encoded uri |
moost::murcl::uri_elements | This class represents the basic elements that make up a standard uri |
moost::murcl::uri_encoder | This class can be used to uri encode a string representing a uri |
moost::murcl::uri_params | This class is an object representaion of uri/post parameters encoded |
moost::murcl::uri_scheme | This class is a base class for all supported uri schemes |
moost::murcl::user_agent | Generates a simple LibCurl user agent |
moost::murcl::response::userdata | Represents the userdata object to the request callback |
moost::kvds::UsermemDbt | User defined data that may be modified! |
USHAContext | |
moost::which< N >::value_comparer< T, Pred > | Value_comparer |
moost::algorithm::variable_length_encoding | |
moost::io::variable_store | Variable_store provides variable length storage by presenting a thread-safe scoped_stream given a requested size |
moost::container::policies::vector_map< TVal > | |
moost::kvds::KvdsPodType< T >::vector_type | To support getall and putall we need to handle vectors of kvds_type |
moost::vt_100_terminal_format | |
moost::which< N > | |
moost::which_back_inserter_iterator< Cont, N > | |
moost::detail::which_helper< Pair, 1 > | |
moost::detail::which_helper< Pair, 2 > | |
moost::which_inserter_iterator< Cont, N > | |
moost::thread::worker_group | |
moost::container::mmd_dense_hash_map< Key, T, HashFcn >::writer | |
moost::container::memory_mapped_dataset::writer | |
test_dataset::writer | |
moost::container::mmd_hash_multimap< Key, T, HashFcn, IndexType >::writer | |
moost::container::mmd_generic_archive< ArchivePolicy >::writer | |
moost::container::mmd_vector< T >::writer | |
moost::thread::xtime_util | Some xtime utils to hide ugly operations |
moost::utils::YesNo | |