tlx
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123]
 CAggregate< Type_ >Calculate running aggregate statistics: feed it with values, and it will keep the minimum, the maximum, the average, the value number, and the standard deviation is values
 CAggregateMinMax< Type_ >Calculate running aggregate statistics: feed it with values, and it will keep the minimum and the maximum values
 CStackArena< Size >::AlignmentHelperUnion to enforce alignment of buffer area
 CAllocatorBase< Type >
 CCmdlineParser::ArgumentBase class of all options and parameters
 Cbinary_function
 CBitArray< Size >A BitArray of fixed size supporting reading, setting, and clearing of individual bits
 CBitArray< num_buckets >
 CBitArrayRecursive< Size, SizeIsAtmost64 >Internal implementation of BitArray; do not invoke directly
 CBitArrayRecursive< Size, false >
 CBitArrayRecursive< Size, true >
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >Basic class implementing a B+ tree data structure in memory
 CBTree< key_type, value_type, key_of_value, key_compare, traits, false, allocator_type >
 CBTree< key_type, value_type, key_of_value, key_compare, traits, true, allocator_type >
 Cbtree_default_traits< Key, Value >Generates default traits for a B+ tree used as a set or map
 Cbtree_map< Key_, Data_, Compare_, Traits_, Alloc_ >Specialized B+ tree template class implementing STL's map container
 Cbtree_multimap< Key_, Data_, Compare_, Traits_, Alloc_ >Specialized B+ tree template class implementing STL's multimap container
 Cbtree_multiset< Key_, Compare_, Traits_, Alloc_ >Specialized B+ tree template class implementing STL's multiset container
 Cbtree_set< Key_, Compare_, Traits_, Alloc_ >Specialized B+ tree template class implementing STL's set container
 CBucketComputation< Radix, Int >
 CBucketComputation< Radix, ranked_key_type >
 CCallForRangeImpl< Index, Size, Functor >Helper for call_for_range: general recursive case
 CCallForRangeImpl< Index, 0, Functor >Helper for call_for_range: base case
 CCmdlineParserCommand line parser which automatically fills variables and prints nice usage messages
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::const_iteratorSTL-like read-only iterator object for B+ tree items
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::const_reverse_iteratorSTL-like read-only reverse iterator object for B+ tree items
 CCountingPtr< Type, Deleter >High-performance smart pointer used as a wrapping reference counting pointer
 CCountingPtrDefaultDeleterDefault deleter for CountingPtr
 CCountingPtrNoOperationDeleterDummy deleter for CountingPtr
 CDAryAddressableIntHeap< KeyType, Arity, Compare >This class implements an addressable integer priority queue, precisely a d-ary heap
 CDAryHeap< KeyType, Arity, Compare >This class implements a d-ary comparison-based heap usable as a priority queue
 CDelegate< T, Allocator >
 CDelegate< R(A...), Allocator >This is a faster replacement than std::function
 Cenable_if< bool, T >SFINAE enable_if – copy of std::enable_if<> with less extra cruft
 Cenable_if< true, T >
 CMultiTimer::EntryTimer entry
 CexceptionSTL class
 Cfalse_type
 CFunctionChain< Functors >A FunctionChain is a chain of functors that can be folded to a single functors
 CFunctionStack< Input_, Functors >A FunctionStack is a chain of functor that can be folded to a single functor (which is usually optimize by the compiler)
 CGenericCharStringSetTraits< CharType >Traits class implementing StringSet concept for char* and unsigned char* strings
 Cguarded_iterator< RandomAccessIterator, Comparator >Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons
 Cindex_sequence< Indexes >
 CIntegerRank< Int >Compute the rank of an integer x (i.e
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::iteratorSTL-like iterator object for B+ tree items
 Cbtree_map< Key_, Data_, Compare_, Traits_, Alloc_ >::key_of_valueKey Extractor Struct
 Cbtree_multimap< Key_, Data_, Compare_, Traits_, Alloc_ >::key_of_valueKey Extractor Struct
 Cbtree_multiset< Key_, Compare_, Traits_, Alloc_ >::key_of_valueKey Extractor Struct
 Cbtree_set< Key_, Compare_, Traits_, Alloc_ >::key_of_valueKey Extractor Struct
 CLevenshteinStandardICaseParametersStandard parameters to Levenshtein distance function
 CLevenshteinStandardParametersStandard parameters to levenshtein distance function
 CLog2< Input >
 CLog2< 0 >
 CLog2< 1 >
 CLog2Floor< Input >
 CLog2Floor< 0 >
 CLog2Floor< 1 >
 CLoggerLOG and sLOG for development and debugging
 CLoggerFormatter< AnyType, Enable >Template class for formatting. contains a print() method
 CLoggerFormatter< AnyType >
 CLoggerFormatter< std::array< T, N > >
 CLoggerFormatter< std::deque< T, A > >
 CLoggerFormatter< std::map< K, V, C, A > >
 CLoggerFormatter< std::multimap< K, V, C, A > >
 CLoggerFormatter< std::multiset< T, C, A > >
 CLoggerFormatter< std::pair< A, B > >
 CLoggerFormatter< std::set< T, C, A > >
 CLoggerFormatter< std::tuple< Args... > >
 CLoggerFormatter< std::tuple<> >
 CLoggerFormatter< std::unordered_map< K, V, H, E, A > >
 CLoggerFormatter< std::unordered_multimap< K, V, H, E, A > >
 CLoggerFormatter< std::unordered_multiset< T, H, E, A > >
 CLoggerFormatter< std::unordered_set< T, H, E, A > >
 CLoggerFormatter< std::vector< T, A > >
 CLoggerOutputHookAbstract class to implement output hooks for logging
 CLoggerPrefixHookAbstract class to implement prefix output hooks for logging
 CLoggerTupleFormatter
 CLoggerVoidify
 CLoserTreePointerUnguardedBase< ValueType, Comparator >::LoserInternal representation of a loser tree player/node
 CLoserTreeCopyBase< ValueType, Comparator >::LoserInternal representation of a loser tree player/node
 CLoserTreePointerBase< ValueType, Comparator >::LoserInternal representation of a loser tree player/node
 CLoserTreeCopyUnguardedBase< ValueType, Comparator >::LoserInternal representation of a loser tree player/node
 CLoserTreeCopyBase< ValueType, Comparator >Guarded loser tree/tournament tree, either copying the whole element into the tree structure, or looking up the element via the index
 CLoserTreeCopyUnguardedBase< ValueType, Comparator >Unguarded loser tree, copying the whole element into the tree structure
 CLoserTreePointerBase< ValueType, Comparator >Guarded loser tree, using pointers to the elements instead of copying them into the tree nodes
 CLoserTreePointerUnguardedBase< ValueType, Comparator >Unguarded loser tree, keeping only pointers to the elements in the tree structure
 CLoserTreeSwitch< Stable, ValueType, Comparator, Enable >
 CLruCacheMap< Key, Value, Alloc >This is an expected O(1) LRU cache which contains a map of (key -> value) elements
 CLruCacheSet< Key, Alloc >This is an expected O(1) LRU cache which contains a set of key-only elements
 Cmake_index_sequence_helper< CurrentIndex, Indexes >
 Cmake_index_sequence_helper< 0, Indexes... >
 CMD5MD-5 processor without external dependencies
 CPS5SmallsortJob< Context, StringPtr, BktSizeType >::MKQSStep
 CMultiTimerMultiTimer can be used to measure time usage of different phases in a program or algorithm
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::nodeThe header structure of each node in-memory
 CSplayTree< Key, Compare, Duplicates, Allocator >::NodeSplay tree node, also seen as public iterator
 CPairKeyExtract< KeyType, DataType >Used as an adapter to implement RadixHeapPair on top of RadixHeap
 CParameters
 CPerfectTreeCalculations< TreeBits >Class to transform in-order to level-order indexes in a perfect binary tree
 CPMWMSPiece< DiffType >Subsequence description
 CPMWMSSortingData< RandomAccessIterator >Data accessed by all threads
 CPolynomialRegression< Type, WithStore >::Point2D point
 CPolynomialRegression< Type, WithStore >Calculate the regression polynomial \( a_0+a_1x^1+a_2x^2+\cdots+a_nx^n \) from a list of 2D points
 CPS5ParametersDefaultParallel Super Scalar String Sample Sort Parameter Struct
 CPS5SortStepPS5SortStep Top-Level Class to Keep Track of Substeps
 CRadixHeap< ValueType, KeyExtract, KeyType, Radix >This class implements a monotonic integer min priority queue, more specific a multi-level radix heap
 CRadixStep_CE0< StringShadowPtr >
 CRadixStep_CE2< StringShadowPtr >
 CRadixStep_CE3< StringShadowPtr >
 CRadixStep_CI2< StringPtr >
 CRadixStep_CI3< StringPtr >
 CStackAllocator< Type, Size >::rebind< Other >Required rebind
 CReferenceCounterProvides reference counting abilities for use with CountingPtr
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::result_tB+ tree recursive deletion has much information which is needs to be passed upward
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::reverse_iteratorSTL-like mutable reverse iterator object for B+ tree items
 CRingBuffer< Type, Allocator >A ring (circular) buffer of static (non-growing) size
 CScopedMultiTimerIndependent RAII Scoped MultiTimer: contains a MultiTimer which is started with the given timer, and added to the base MultiTimer on destruction
 CScopedMultiTimerSwitchRAII Scoped MultiTimer switcher: switches the timer of a MultiTimer on construction and back to old one on destruction
 CSemaphoreA simple semaphore implementation using C++11 synchronization methods
 CPS5SmallsortJob< Context, StringPtr, BktSizeType >::SeqSampleSortStepStack of Recursive Sample Sort Steps
 CSHA1SHA-1 processor without external dependencies
 CSHA256SHA-256 processor without external dependencies
 CSHA512SHA-512 processor without external dependencies
 CSimpleVector< ValueType, Mode >Simpler non-growing vector without initialization
 CSimpleVector< DiffType >
 CSimpleVector< std::thread >
 CSimpleVector< std::vector< tlx::parallel_mergesort_detail::PMWMSPiece< DiffType > > >
 CSimpleVector< tlx::LoserTreeCopyBase::Loser >
 CSimpleVector< tlx::LoserTreeCopyUnguardedBase::Loser >
 CSimpleVector< tlx::LoserTreePointerBase::Loser >
 CSimpleVector< tlx::LoserTreePointerUnguardedBase::Loser >
 CSimpleVector< tlx::SimpleVector< size_t > >
 CSimpleVector< tlx::SimpleVector< uint16_t > >
 CSimpleVector< uint8_t >
 CSimpleVector< ValueType * >
 CSimpleVector< ValueType >
 CSpacingLoggerA logging class which outputs spaces between elements pushed via operator<<
 CSplayTree< Key, Compare, Duplicates, Allocator >
 CSSClassifyEqualUnroll< key_type, TreeBits >Sample Sort Classification Tree Unrolled with Equal Comparisons
 CSSClassifyTreeCalcUnrollInterleave< key_type, TreeBits, Rollout >Sample Sort Classification Tree Unrolled, Interleaved, and with Perfect Tree Index Calculations
 CSSClassifyTreeUnrollInterleave< key_type, TreeBits, Rollout >Sample Sort Classification Tree Unrolled and Interleaved
 CSSTreeBuilderLevelOrder< key_type, num_splitters >Recursive TreeBuilder for full-descent and unrolled variants, constructs only a level-order binary tree of splitters
 CSSTreeBuilderPreAndLevelOrder< key_type, num_splitters >Recursive TreeBuilder for full-descent and unrolled variants, constructs a both a pre-order and level-order array of splitters and the corresponding LCPs
 CStackArena< Size >Storage area allocated on the stack and usable by a StackAllocator
 CStaticIndex< Index >Helper for call_foreach_with_index() to save the index as a compile-time index
 CStdStringSetTraitsClass implementing StringSet concept for a std::string objects
 CStringLcpPtr< StringSet_, LcpType_ >Objectified string and LCP array pointer arrays
 CStringPtr< StringSet_ >Objectified string array pointer array
 CStringSetBase< StringSet, Traits >Base class for common string set functions, included via CRTP
 CStringSetBase< GenericCharStringSet< CharType >, GenericCharStringSetTraits< CharType > >
 CStringSetBase< StdStringSet, StdStringSetTraits >
 CStringSetBase< StringSuffixSet, StringSuffixSetTraits >
 CStringSetBase< UPtrStdStringSet, UPtrStdStringSetTraits >
 CStringShadowLcpPtr< StringSet_, LcpType_ >Objectified string array pointer and shadow pointer array for out-of-place swapping of pointers
 CStringShadowPtr< StringSet_ >Objectified string array pointer and shadow pointer array for out-of-place swapping of pointers
 CStringSuffixSetTraitsClass implementing StringSet concept for suffix sorting indexes of a std::string text object
 CThreadPoolThreadPool starts a fixed number p of std::threads which process Jobs that are enqueued into a concurrent job queue
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::tree_statsA small struct containing basic statistics about the B+ tree
 Ctrue_type
 Ctype
 Cunguarded_iterator< RandomAccessIterator, Comparator >
 CUPtrStdStringSetTraitsClass implementing StringSet concept for a std::unique_ptr<std::string objects, which are non-copyable
 CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::value_compareFunction class to compare value_type objects. Required by the STL
 Cvector< T >STL class
 CVMapForRangeImpl< Index, Size, Functor >Helper for vmap_for_range: general recursive case
 CVMapForRangeImpl< Index, 0, Functor >Helper for vmap_for_range: base case