| 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 >::AlignmentHelper | Union to enforce alignment of buffer area |
| ►CAllocatorBase< Type > | |
| CStackAllocator< Type, Size > | |
| ►CArgument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentBool final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentBytes32 final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentBytes64 final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentDouble final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentFloat final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentInt final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentSizeT final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentString final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentStringlist final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| ►CArgumentUnsigned final public Argument | |
| CCmdlineParser | Base class of all options and parameters |
| 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 |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::const_iterator | STL-like read-only iterator object for B+ tree items |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::const_reverse_iterator | STL-like read-only reverse iterator object for B+ tree items |
| CCountingPtr< Type, Deleter > | High-performance smart pointer used as a wrapping reference counting pointer |
| CCountingPtrDefaultDeleter | Default deleter for CountingPtr |
| CCountingPtrNoOperationDeleter | Dummy deleter for CountingPtr |
| CCS_IfSwap< Comparator > | Conditional swap implementation used for sorting networks: trivial portable C++ implementation with custom comparison method and std::swap() |
| 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 |
| CDelegate< void(size_t)> | |
| Cenable_if< bool, T > | SFINAE enable_if – copy of std::enable_if<> with less extra cruft |
| Cenable_if< true, T > | |
| CMultiTimer::Entry | |
| ►Cexception | STL class |
| ►Cruntime_error | STL class |
| CDieException | Exception thrown by die_with_message() if |
| ►Cfalse_type | |
| CDelegate< R(A...), Allocator >::IsConstMemberPair< typename > | Template for const class::function selector |
| CDelegate< R(A...), Allocator >::IsMemberPair< typename > | Template for class::function selector |
| Cis_std_array< T > | Test if is std::array<T, N> |
| Cis_std_pair< T > | Test if is a std::pair<...> |
| Cis_std_tuple< T > | Test if is a std::tuple<...> |
| Cis_std_vector< T > | Test if is std::vector<T> |
| 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 |
| CGenericCharStringSet< CharType > | 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 |
| Chas_ostream_operator< typename, typename > | SFINAE magic helper for wrap_unprintable() |
| Chash< tlx::StringView > | |
| Cindex_sequence< Indexes > | |
| CIntegerRank< Int > | Compute the rank of an integer x (i.e |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::iterator | STL-like iterator object for B+ tree items |
| Cbtree_map< Key_, Data_, Compare_, Traits_, Alloc_ >::key_of_value | Key Extractor Struct |
| Cbtree_multimap< Key_, Data_, Compare_, Traits_, Alloc_ >::key_of_value | Key Extractor Struct |
| Cbtree_multiset< Key_, Compare_, Traits_, Alloc_ >::key_of_value | Key Extractor Struct |
| Cbtree_set< Key_, Compare_, Traits_, Alloc_ >::key_of_value | Key Extractor Struct |
| Cless_icase_asc | Case-insensitive less order relation functional class for std::map, etc |
| Cless_icase_desc | Descending case-insensitive less order relation functional class for std::map, etc |
| CLevenshteinStandardICaseParameters | Standard parameters to Levenshtein distance function |
| CLevenshteinStandardParameters | Standard parameters to levenshtein distance function |
| Clexicographic< T1, T2, Comparator > | Compare a pair of types lexicographically, ascending |
| Clexicographic< T1, T2, Comparator > | Compare a pair of types lexicographically, ascending |
| Clexicographic_rev< T1, T2, Comparator > | Compare a pair of types lexicographically, descending |
| Clexicographic_rev< T1, T2, Comparator > | Compare a pair of types lexicographically, descending |
| CLog2< Input > | |
| CLog2< 0 > | |
| CLog2< 1 > | |
| CLog2Floor< Input > | |
| CLog2Floor< 0 > | |
| CLog2Floor< 1 > | |
| CLogger | LOG 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 > > | |
| ►CLoggerOutputHook | Abstract class to implement output hooks for logging |
| CDefaultLoggerOutputCErr | Default output logger to cerr |
| CDefaultLoggerOutputCOut | Default output logger to cout |
| CLoggerCollectOutput | Class to hook logger output in the local thread |
| CLoggerPrefixHook | Abstract class to implement prefix output hooks for logging |
| CLoggerTupleFormatter | |
| CLoggerVoidify | |
| CLoserTreePointerUnguardedBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| CLoserTreeCopyBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| CLoserTreePointerBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| CLoserTreeCopyUnguardedBase< ValueType, Comparator >::Loser | Internal 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 |
| CLoserTreeCopy< Stable, ValueType, Comparator > | Guarded loser tree/tournament tree, either copying the whole element into the tree structure, or looking up the element via the index |
| CLoserTreeCopy< true, 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 |
| CLoserTreeCopyUnguarded< Stable, ValueType, Comparator > | |
| CLoserTreeCopyUnguarded< true, ValueType, Comparator > | |
| ►CLoserTreePointerBase< ValueType, Comparator > | Guarded loser tree, using pointers to the elements instead of copying them into the tree nodes |
| CLoserTreePointer< Stable, ValueType, Comparator > | Guarded loser tree, using pointers to the elements instead of copying them into the tree nodes |
| CLoserTreePointer< true, 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 |
| CLoserTreePointerUnguarded< Stable, ValueType, Comparator > | |
| CLoserTreePointerUnguarded< true, ValueType, Comparator > | |
| 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... > | |
| CMD5 | MD-5 processor without external dependencies |
| CPS5SmallsortJob< Context, StringPtr, BktSizeType >::MKQSStep | |
| CMultiTimer | MultiTimer can be used to measure time usage of different phases in a program or algorithm |
| ►CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::node | The header structure of each node in-memory |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::InnerNode | Extended structure of a inner node in-memory |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::LeafNode | Extended structure of a leaf node in memory |
| CSplayTree< Key, Compare, Duplicates, Allocator >::Node | Splay tree node, also seen as public iterator |
| CNoOperation< ReturnType > | The noop functor, which takes any arguments and does nothing |
| CNoOperation< void > | Specialized noop functor which returns a void |
| CPairKeyExtract< KeyType, DataType > | Used as an adapter to implement RadixHeapPair on top of RadixHeap |
| ►CParameters | |
| CPS5Context< Parameters > | Parallel Super Scalar String Sample Sort Context |
| 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 >::Point | 2D 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 |
| CPS5ParametersDefault | Parallel Super Scalar String Sample Sort Parameter Struct |
| ►CPS5SortStep | PS5SortStep Top-Level Class to Keep Track of Substeps |
| CPS5BigSortStep< Context, StringPtr > | PS5BigSortStep Out-of-Place Parallel Sample Sort with Separate Jobs |
| CPS5SmallsortJob< Context, StringPtr, BktSizeType > | SampleSort: Non-Recursive In-Place Sequential Sample Sort for Small Sorts |
| 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 |
| CReferenceCounter | Provides reference counting abilities for use with CountingPtr |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::result_t | B+ tree recursive deletion has much information which is needs to be passed upward |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::reverse_iterator | STL-like mutable reverse iterator object for B+ tree items |
| CRingBuffer< Type, Allocator > | A ring (circular) buffer of static (non-growing) size |
| CScopedMultiTimer | Independent RAII Scoped MultiTimer: contains a MultiTimer which is started with the given timer, and added to the base MultiTimer on destruction |
| CScopedMultiTimerSwitch | RAII Scoped MultiTimer switcher: switches the timer of a MultiTimer on construction and back to old one on destruction |
| CSemaphore | A simple semaphore implementation using C++11 synchronization methods |
| CPS5SmallsortJob< Context, StringPtr, BktSizeType >::SeqSampleSortStep | Stack of Recursive Sample Sort Steps |
| CSHA1 | SHA-1 processor without external dependencies |
| CSHA256 | SHA-256 processor without external dependencies |
| CSHA512 | SHA-512 processor without external dependencies |
| CSimpleVector< ValueType, Mode > | Simpler non-growing vector without initialization |
| CSimpleVector< DiffType > | |
| CSimpleVector< std::thread > | |
| CSimpleVector< tlx::LoserTreeCopyBase::Loser > | |
| CSimpleVector< tlx::LoserTreeCopyUnguardedBase::Loser > | |
| CSimpleVector< tlx::LoserTreePointerBase::Loser > | |
| CSimpleVector< tlx::LoserTreePointerUnguardedBase::Loser > | |
| CSimpleVector< tlx::SimpleVector< size_t > > | |
| CSimpleVector< tlx::SimpleVector< tlx::parallel_mergesort_detail::PMWMSPiece< DiffType > > > | |
| CSimpleVector< tlx::SimpleVector< uint16_t > > | |
| CSimpleVector< uint8_t > | |
| CSimpleVector< ValueType * > | |
| CSimpleVector< ValueType > | |
| CSpacingLogger | A 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 |
| ►CStdStringSetTraits | Class implementing StringSet concept for a std::string objects |
| CStdStringSet | Class implementing StringSet concept for arrays of 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 > > | |
| CGenericCharStringSet< CharType > | Class implementing StringSet concept for char* and unsigned char* strings |
| ►CStringSetBase< StdStringSet, StdStringSetTraits > | |
| CStdStringSet | Class implementing StringSet concept for arrays of std::string objects |
| ►CStringSetBase< StringSuffixSet, StringSuffixSetTraits > | |
| CStringSuffixSet | Class implementing StringSet concept for suffix sorting indexes of a std::string text object |
| ►CStringSetBase< UPtrStdStringSet, UPtrStdStringSetTraits > | |
| CUPtrStdStringSet | Class implementing StringSet concept for a std::vector containing std::string objects |
| 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 |
| ►CStringSuffixSetTraits | Class implementing StringSet concept for suffix sorting indexes of a std::string text object |
| CStringSuffixSet | Class implementing StringSet concept for suffix sorting indexes of a std::string text object |
| CStringView | StringView is a reference to a part of a string, consisting of only a char pointer and a length |
| CThreadBarrierMutex | Implements a thread barrier using mutex locking and condition variables that can be used to synchronize threads |
| CThreadBarrierSpin | Implements a thread barrier using atomics and a spin lock that can be used to synchronize threads |
| CThreadPool | ThreadPool 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_stats | A small struct containing basic statistics about the B+ tree |
| ►Ctrue_type | |
| CDelegate< R(A...), Allocator >::IsConstMemberPair< ConstMemberPair< C > > | Specialization for const class::function selector |
| CDelegate< R(A...), Allocator >::IsMemberPair< MemberPair< C > > | Specialization for class::function selector |
| Cis_std_array< std::array< T, N > > | |
| Cis_std_pair< std::pair< S, T > > | |
| Cis_std_tuple< std::tuple< Ts... > > | |
| Cis_std_vector< std::vector< T > > | |
| ►Ctype | |
| Cmake_index_sequence< Size > | |
| Cunguarded_iterator< RandomAccessIterator, Comparator > | |
| ►CUPtrStdStringSetTraits | Class implementing StringSet concept for a std::unique_ptr<std::string objects, which are non-copyable |
| CUPtrStdStringSet | Class implementing StringSet concept for a std::vector containing std::string objects |
| CBTree< Key, Value, KeyOfValue, Compare, Traits, Duplicates, Allocator >::value_compare | Function class to compare value_type objects. Required by the STL |
| ►Cvector< T > | STL class |
| CPolynomialRegression< Type, WithStore >::Coefficients | Polynomial stored as the coefficients of \( a_0+a_1 x^1+a_2 x^2+\cdots+a_n x^n \) |
| CVMapForRangeImpl< Index, Size, Functor > | Helper for vmap_for_range: general recursive case |
| CVMapForRangeImpl< Index, 0, Functor > | Helper for vmap_for_range: base case |
1.8.11 
