|
lean cpp library
A lean C++ library providing efficient utility classes for high-performance C++ applications.
|
| lean::containers::accumulation_map< Container > | Map wrapper class providing improved performance on repeated element accumulation |
| lean::containers::accumulation_vector< Container, ReallocationPolicy > | Vector wrapper class providing improved performance on repeated element accumulation |
| lean::memory::aligned< Alignment, Heap > | Aligns derived classes according to the given alignment template argument |
| lean::containers::any | Any interface |
| lean::containers::any_value< Value, Heap > | Any value |
| lean::strings::assert_nullterminated_compatible< Compatible, Char, Traits > | Asserts that the given type is nullterminated-character-range-compatible |
| lean::smart::auto_restore< Value > | Auto restore class that automatically restores the initial value of the stored object on destruction |
| lean::strings::basic_charbuf< Elem, Traits > | Character stream buffer class that is required to allow for allocation-free usage of STL streaming facilities |
| lean::strings::basic_charstream< Elem, Traits > | Character stream class that allows for allocation-free usage of STL streaming facilities |
| lean::containers::simple_hash_map< Key, Element, Policy, Hash, KeyValues, Pred, Allocator >::basic_iterator< Element > | Simple hash map iterator class |
| lean::logging::basic_log_stream< Char, Traits > | Log stream class that prints any given input to a given stream. As streams are not guaranteed to be thread-safe, it is recommended to only ever hold one wrapper for any given stream at a time |
| lean::functional::callable_fun< Signature > | Stores the pointer to a function to be called on invokation of operator () |
| lean::functional::callable_memfun< Class, Signature > | Stores an object and a pointer to a method to be called on invokation of operator () |
| lean::meta::ce_int< ConstIntExpr > | Helper struct that may be used to pass constant integers (compile-time literals) |
| lean::strings::char_traits< Char > | Provides common null-terminated character range functionality for the given character type. The default implementation treats characters as arbitrary POD types |
| lean::strings::char_traits< char > | |
| lean::strings::char_traits< wchar_t > | |
| lean::types::char_type< Size > | Provides a character type of the given size |
| lean::memory::check_alignment< Alignment > | Checks whether the given alignment is a valid power of two |
| lean::memory::chunk_heap< ChunkSize, Heap, StaticChunkSize, DefaultAlignment > | Contiguous chunk allocator heap |
| lean::time::clocktimer | Clock timer class |
| lean::smart::cloneable | Base class that may be used to tag a specific class cloneable |
| lean::smart::cloneable_obj< Cloneable, PointerSemantics > | Cloneable object class that stores an automatic instance of the given cloneable type |
| lean::smart::close_handle_policy< Handle > | Default handle guard policy |
| lean::smart::com_ptr< COMType, Critical > | COM pointer class that performs reference counting on COM objects of the given type |
| lean::meta::complete_type_or_base< FullType, BaseType > | Redefines FullType if complete (and derived from BaseType), BaseType otherwise |
| lean::meta::conditional_type< Condition, TrueType, FalseType > | Redefines TrueType if condition fulfilled, FalseType otherwise |
| lean::concurrent::critical_section | Implements a light-weight reentrant binary lock |
| lean::memory::crt_heap | Default CRT heap |
| lean::properties::deallocate_property_data_policy | |
| lean::containers::default_keys< Key > | Defines default values for invalid & end keys |
| lean::containers::default_keys< std::basic_string< Char, Traits, Allocator > > | |
| lean::containers::default_keys< Value * > | |
| lean::smart::default_lock_policy< Lockable > | Default locking policy |
| lean::containers::default_reallocation_policy< Container > | Leaves reallocation to the specified container type |
| lean::properties::delete_property_data_policy | |
| lean::smart::delete_ptr_policy< Type > | Delete scoped pointer policy |
| lean::smart::delete_ptr_policy< Type[]> | |
| lean::meta::dependent_false< T > | Defines a false literal, ignoring any template arguments |
| lean::smart::destroy_ptr_policy< Type > | Destroy scoped pointer policy |
| lean::smart::destroy_window_policy< Handle > | Window handle guard policy |
| lean::properties::destruct_property_data_policy | |
| lean::containers::dynamic_array< Element, Heap > | Dynamic array class |
| lean::meta::enable_if< Cond, Type > | Redefines the given type if true, empty otherwise |
| lean::strings::enable_if_not_range< Range, Type > | Redefines the given type if Range is not a range, empty otherwise |
| lean::strings::enable_if_not_range2< Range1, Range2, Type > | Redefines the given type if either Range1 or Range2 is not a range, empty otherwise |
| lean::strings::enable_if_range< Range, Type > | Redefines the given type if Range is a range, empty otherwise |
| lean::strings::enable_if_range2< Range1, Range2, Type > | Redefines the given type if both Range1 and Range2 are ranges, empty otherwise |
| lean::concurrent::event | Implements an event |
| lean::io::filesystem_chars< Char > | Special file system characters |
| lean::meta::first_non_void< Type1, Type2 > | Redefines Type1 if not void, else Type2 if not void, nothing otherwise |
| lean::io::float_serialization< Type, Delimiter > | Float value serialization |
| lean::types::float_type< Size > | Provides a floating-point type of the given size |
| lean::pimpl::forward_val< Value, Size > | Opaque value class that stores values of the given size & forward-declared type |
| lean::smart::free_library_policy< Handle > | Dll handle guard policy |
| lean::properties::generic_property_type< Type, Heap, Alignment > | Generic property type implementation |
| lean::smart::generic_ptr_policy< Type > | Generic scoped pointer policy |
| lean::smart::generic_ptr_policy< Type[]> | |
| lean::io::generic_serialization< Type, Delimiter > | Generic value serialization |
| lean::io::generic_serializer< Serialization > | Generic value serializer |
| lean::smart::handle_guard< Handle, ReleasePolicy > | Handle guard that releases the stored handle on destruction |
| lean::containers::Impl::has_reverse_iterator< Container > | Checks whether the given type has a reverse iterator type |
| lean::functional::hash< Element > | Computes hash values from elements of the given type |
| lean::memory::heap_allocator< Element, Heap, Alignment > | STL allocator heap adapter |
| lean::memory::heap_bound< Heap > | Always allocates space for derived classes on the same specified heap |
| lean::time::highres_timer | High-resolution timer class |
| lean::meta::identity< Type > | Redefines the given type |
| lean::types::ieee_float< Float, Desc > | Provides utility methods for floating-point values of the given type |
| lean::types::ieee_float_desc< Float > | Describes the given float type |
| lean::meta::inh_strip_array< Type > | Inherits the stripped type |
| lean::meta::inh_strip_modref< Type > | Inherits the stripped type |
| lean::meta::inh_strip_pointer< Type > | Inherits the stripped type |
| lean::meta::inh_strip_reference< Type > | Inherits the stripped type |
| lean::properties::property_collection< Class, Description, Vector >::inplace_builder< Collection > | Allows for fully inplace construction of whole property collections |
| lean::meta::int_dependent_false< N > | Defines a false literal, ignoring any template arguments |
| lean::io::int_serialization< Type, Delimiter > | Integer value serialization |
| lean::types::int_type< Class, Size > | Provides an integer type of the given class and size |
| lean::meta::is_derived< Type, Base > | True if Type is derived from Base, false otherwise |
| lean::meta::is_equal< Type1, Type2 > | True if types are equal, false otherwise |
| lean::strings::is_nullterminated_compatible< Compatible, Char, Traits > | Checks if the given type is nullterminated-character-range-compatible |
| lean::strings::is_nullterminated_convertible< Compatible, Char, Traits > | Checks if the given type is either nullterminated-character-range-compatible or a character range |
| lean::strings::is_range< Type > | Checks if the given type is a range type |
| lean::meta::is_unsigned< Integer > | Checks if the given integer type is unsigned |
| lean::io::raw_file_inserter< BufferSize >::iterator | Iterator type |
| lean::logging::log | Log class |
| lean::logging::log_debugger | Log debugger class that prints any given input to the debug output window |
| lean::logging::log_stream_out | Log stream class |
| lean::logging::log_target | Log target interface |
| lean::io::mapped_file | File class that allows for memory-mapped read/write access to a given file |
| lean::io::mapped_file_base | Base class for mapped files |
| lean::io::max_float_string_length< Float > | Estimates the maximum string length for floating-point values of the given type |
| lean::io::max_int_string_length< Integer > | Estimates the maximum string length for integers of the given type |
| lean::meta::maybe_dereference_once< Type > | Dereferences a given value type once, if the value type is a pointer type |
| lean::containers::move_reallocation_policy< Container, GrowthDenominator > | Allows for custom move semantics on element reallocation |
| lean::properties::named_property_desc< Class, Derived > | Describes a named property |
| lean::tags::nonassignable | Base class that may be used to tag a specific class nonassignable |
| lean::tags::nonassignable_chain< Base > | Base class that may be used to tag a specific class nonassignable |
| lean::tags::nonconstructible | Base class that may be used to tag a specific class nonconstructible |
| lean::tags::noncopyable | Base class that may be used to tag a specific class noncopyable |
| lean::tags::noncopyable_assignable | Base class that may be used to tag a specific class noncopyable but assignable |
| lean::tags::noncopyable_assignable_chain< Base > | Base class that may be used to tag a specific class noncopyable but assignable |
| lean::tags::noncopyable_chain< Base > | Base class that may be used to tag a specific class noncopyable |
| lean::strings::nullterminated< Char, Traits > | Nullterminated character half-range class that may be constructed from arbitrary string classes |
| lean::strings::nullterminated_compatible< Compatible, Char, Traits > | Spezialize this class to make your string class compatible with the nullterminated character range class |
| lean::strings::nullterminated_compatible< std::basic_string< Char, StringTraits, StringAllocator >, Char, NullterminatedTraits > | |
| lean::strings::nullterminated_implicit< Char, Traits > | Nullterminated character half-range class that may be IMPLICITLY constructed from arbitrary string classes. May be used in parameter lists, not recommended elsewhere |
| lean::strings::nullterminated_incompatible | |
| lean::strings::nullterminated_range< Char, Traits > | Nullterminated character range class that may be constructed from arbitrary string classes |
| lean::strings::nullterminated_range_implicit< Char, Traits > | Nullterminated character range class that may be constructed IMPLICITLY from arbitrary string classes. May be used in parameter lists, not recommended elsewhere |
| lean::memory::object_pool< Element, ChunkSize, Heap, StaticChunkSize, Alignment > | Object pool |
| lean::pimpl::opaque_val< OpaqueTypeWrapper, OpaqueTypeWrapperBase > | Opaque value class that stores values of the type wrapped by OpaqueTypeWrapperBase, providing access to these values via the type wrapped by OpaqueTypeWrapper, provided OpaqueTypeWrapper is both fully defined and derived from OpaqueTypeWrapperBase |
| lean::memory::optional_mem_block< Size > | Block of memory that may be zero-sized |
| lean::memory::optional_mem_block< 0 > | |
| lean::pimpl::pimpl_delete_policy | Default PImpl pointer destruction policy |
| lean::pimpl::pimpl_ptr< Implementation, ImplementationBase, DestroyPolicy > | Smart pointer class allowing for secure storage of forward-declared pimpl classes |
| lean::containers::simple_vector_policies::policy< RawMove, NoDestruct, NoConstruct > | Simple vector element construction policy |
| lean::containers::simple_hash_map_policies::policy< RawMove, NoDestruct, RawKeyMove, NoKeyDestruct > | Simple hash map element construction policy |
| lean::properties::property_c_accessor_binder< Class, UnionValueArg, ArgCount, Return, ValueArg, BaseClass > | Property_c_* factory class |
| lean::properties::property_c_getter< Class, UnionValueArg, ArgCount, Return, Getter, ValueArg, BaseClass > | Provides read access to arbitrary object data of the given type using a given multi-parameter getter method |
| lean::properties::property_c_setter< Class, UnionValueArg, ArgCount, Return, Setter, ValueArg, BaseClass > | Provides write access to arbitrary object data of the given type using a given multi-parameter setter method |
| lean::properties::property_collection< Class, Description, Vector > | Container class that may be used to store information on class / object properties |
| lean::properties::property_constant< Class, Value > | Holds a constant array of values, returning a matching subset of these on getter access |
| lean::properties::property_desc< Class, Derived > | Destribes a property |
| lean::properties::property_getter< Class > | Fetches data from a specific source |
| lean::properties::property_n_accessor_binder< Class, UnionValue, Count, Return, Value, BaseClass > | Property_n_* factory class |
| lean::properties::property_n_getter< Class, UnionValue, Count, Return, Getter, Value, BaseClass > | Provides read access to arbitrary object data of the given type using a given getter method |
| lean::properties::property_n_setter< Class, UnionValue, Count, Return, Setter, Value, BaseClass > | Provides write access to arbitrary object data of the given type using a given setter method |
| lean::properties::property_r_accessor_binder< Class, UnionValueReturn, ValueReturn, BaseClass > | Property_r_* factory class |
| lean::properties::property_r_getter< Class, UnionValueReturn, Getter, ValueReturn, BaseClass > | Provides read access to arbitrary object data of the given type using a given return-value getter method |
| lean::properties::property_setter< Class > | Passes data to a specific destination |
| lean::properties::property_type | |
| lean::strings::range< Iterator > | Iterator range |
| lean::strings::range_char_type2< Char *, Chars2 > | |
| lean::strings::range_char_type2< Char1 *, Char2 * > | |
| lean::strings::range_char_type2< Chars1, Char * > | |
| lean::strings::range_char_type< Char * > | |
| lean::io::raw_file | File class that allows for raw read/write operations on a given file |
| lean::io::raw_file_inserter< BufferSize > | File inserter class that follows the STL output iterator concept to allow for convenient buffered file output |
| lean::memory::heap_allocator< Element, Heap, Alignment >::rebind< Other > | Allows for the creation of differently-typed equivalent allocators |
| lean::meta::rec_strip_modifiers< Type > | Recursively strips all modifiers from the given type |
| lean::smart::ref_counter< Counter, Allocator > | Reference counter class that maintains strong and weak reference counts |
| lean::smart::ref_counter< Counter, Allocator >::ref_counts | Reference counter structure |
| lean::smart::release_ptr_policy< Type > | Release scoped pointer policy |
| lean::smart::resource< Counter, Allocator, Lazy > | Base class that may be used to tag a specific class as a resource |
| lean::smart::resource_interface< Counter, Allocator > | Interface that may be used to tag a specific class as a resource |
| lean::smart::resource_ptr< Resource, Critical > | Resource pointer class that performs strong reference counting on the given resource type |
| lean::containers::Impl::reverse_iterators< Container > | Redefines reverse iterator types, if available |
| lean::containers::Impl::reverse_iterators_impl< HasReverseIterators, Container > | Redefines reverse iterator types, if available |
| lean::containers::Impl::reverse_iterators_impl< true, Container > | |
| lean::io::rmapped_file | File class that allows for memory-mapped read access to a given file |
| lean::pimpl::safe_pimpl_base | Base class that permits safe destruction for incomplete private implementation classes |
| lean::smart::scope_annex_base | Stores and calls a callable object on destruction |
| lean::smart::scope_annex_impl< Callable > | Stores and calls a callable object on destruction |
| lean::smart::scope_guard_base | Stores and calls a callable object on destruction, if not disarmed |
| lean::smart::scope_guard_impl< Callable > | Stores and calls a callable object on destruction, if not disarmed |
| lean::smart::scoped_lock< Lockable, Policy > | Automatic lock management class that locks a given object on construction to be unlocked on destruction |
| lean::properties::scoped_property_data< Polocy > | |
| lean::smart::scoped_ptr< Type, ReleasePolicy > | Scoped pointer class that releases the object pointed to on destruction |
| lean::concurrent::semaphore | Implements a semaphore |
| lean::io::serializer | Value serializer |
| lean::concurrent::shareable_spin_lock< Counter > | Implements a shareable spin lock that is NOT reentrant |
| lean::concurrent::shared_lock_policy< Lockable > | Shared locking policy |
| lean::containers::simple_hash_map< Key, Element, Policy, Hash, KeyValues, Pred, Allocator > | Simple and fast hash map class, partially implementing the STL hash map interface |
| lean::containers::simple_vector< Element, Policy, Allocator > | Simple and fast vector class, partially implementing the STL vector interface |
| lean::types::size_info< Type > | Provides enhanced type size information |
| lean::concurrent::spin_lock< Counter > | Implements a simple binary spin lock that is NOT reentrant |
| lean::memory::stack_aligned< Alignment > | Aligns derived classes according to the given alignment template argument when instances are created on the stack |
| lean::strings::string_traits< String > | Provides common string functionality for the given string type |
| lean::meta::strip_array< Type > | Strips a array from the given type |
| lean::meta::strip_const< Type > | Strips a const modifier from the given type |
| lean::meta::strip_modifiers< Type > | Strips cv-modifiers from the given type |
| lean::meta::strip_modref< Type > | Strips cv-modifiers and references from the given type |
| lean::meta::strip_pointer< Type > | Strips a pointer from the given type |
| lean::meta::strip_reference< Type > | Strips a reference from the given type |
| lean::meta::strip_volatile< Type > | Strips a volatile modifier from the given type |
| lean::smart::terminate_guard | Terminates the application on destruction, if not disarmed |
| lean::containers::test_value | |
| lean::concurrent::thread | Manages a simple thread |
| lean::time::timer | Default timer class |
| lean::tags::transitive_ptr< Type, Immutable > | Transitive pointer class that applies pointer const modifiers to the objects pointed to |
| lean::types::type_info | Enhanced type info |
| lean::properties::ui_property_desc< Class, Widget, Derived > | Describes a UI property |
| lean::meta::strip_reference< Type >::undo< Other > | Adds any reference stripped |
| lean::meta::strip_const< Type >::undo< Other > | Adds any modifiers stripped |
| lean::meta::strip_array< Type >::undo< Other > | Adds any array stripped |
| lean::meta::strip_modref< Type >::undo< Other > | Adds any modifiers and references stripped |
| lean::meta::strip_volatile< Type >::undo< Other > | Adds any modifiers stripped |
| lean::meta::strip_pointer< Type >::undo< Other > | Adds any pointer stripped |
| lean::meta::strip_modifiers< Type >::undo< Other > | Adds any modifiers stripped |
| lean::pimpl::unsafe_pimpl_base | Base class that permits unsafe destruction for incomplete private implementation classes, ONLY USE IF CORRECT DESTRUCTION NOT REQUIRED |
| lean::concurrent::upgrade_lock_policy< Lockable > | Shared lock upgrade locking policy |
| lean::io::wcharcvt | Encodes wchar_t strings as true 16-byte strings |
| lean::smart::weak_resource_ptr< Resource > | Resource pointer class that performs weak reference counting on the given resource type |
| lean::memory::win_heap | Windows heap |
| lean::xml::xml_file< Char > | This convenience class wraps up the most common xml file functionality |
1.7.6.1