| ►Ntpie | Pipelining/factory_base.h Base class of pipelining factories |
| ►Nami | A version of sort that takes an input stream of elements of type T, and an output stream, and and uses the < operator to sort, see also Sorting in TPIE |
| Cheap_element | This is a heap element |
| Cheap_ptr | This is a record pointer element |
| CInternal_Sorter_Base | The base class for internal sorters |
| CInternal_Sorter_Obj | Comparision object based Internal_Sorter_base subclass implementation; uses quick_sort_obj() |
| Cmerge_heap_obj | |
| Cmerge_heap_op | A merge heap object base class - also serves as the full implementation for objects with a < comparison operator |
| Cmerge_heap_ptr_obj | A record pointer heap that uses a comparison object |
| Cmerge_heap_ptr_op | A record pointer heap base class - also serves as the full implementation for objects with a < comparison operator |
| Cqsort_item | A simple class that facilitates doing key sorting followed by in-memory permuting to sort items in-memory |
| Cstack | An implementation of an external-memory stack compatible with the old AMI interface |
| Cstream | |
| Cstream_old | A Stream<T> object stores an ordered collection of objects of type T on external memory |
| ►Nbbits | |
| Cblock_size_getter | |
| Cblock_size_getter< T, true > | |
| Cbuilder | Augmented btree builder |
| Cenab | |
| CEnable | |
| CEnable< enab, true > | |
| ►Cexternal_store | Storage used for an external btree |
| Cinternal | |
| Cinternal_content | |
| Cinternal_type | |
| Cleaf | |
| Cleaf_type | |
| Cexternal_store_base | |
| Cint_opt | |
| Cinternal_store | Storage used for an internal btree |
| COpt | |
| COptComp | |
| COptComp< btree_augment< A >, T...> | |
| COptComp< btree_blocksize< bs >, T...> | |
| COptComp< btree_comp< C >, T...> | |
| COptComp< btree_fanout< a, b >, T...> | |
| COptComp< btree_key< K >, T...> | |
| COptComp< int_opt< i >, T...> | |
| COptComp<> | |
| Cserialized_store | Serializing store |
| Ctree | Augmented btree |
| ►Ctree_state | |
| Ccombined_augment | |
| Ccombined_augmenter | |
| Ckey_augment | |
| ►Nbits | |
| Callocator_usage | |
| Callocator_usage< T, allocator< T > > | |
| Carray_decode_magic | Helper to facilitate fast unserialization of trivially copyable arrays |
| Carray_decode_magic< D, T, true, true > | |
| Carray_encode_magic | Helper to facilitate fast serialization of trivially copyable arrays |
| Carray_encode_magic< D, T, true, true > | |
| Ccounter | Helper to count the serialized size of objects |
| Cdynamic_specific_selector | |
| Cdynamic_specific_selector< element_t, true > | |
| Cenum_storage_type | |
| Cenum_storage_type_help | |
| Cenum_storage_type_help< 1 > | |
| Cenum_storage_type_help< 2 > | |
| Cenum_storage_type_help< 4 > | |
| Cenum_storage_type_help< 8 > | |
| Cpretty_print | |
| Cremove_pointer | |
| Cremove_pointer< T * > | |
| Crun_positions | Class to maintain the positions where sorted runs start |
| Cserialization_reader_base | |
| Cserialization_writer_base | |
| Cstore_pred | |
| Ctemp_file_inner | |
| Ctest_runner | |
| ►Nblocks | |
| ►Nbits | |
| Cfreespace_collection | |
| Cblock_collection | A class to manage writing and reading of block to disk |
| Cblock_collection_cache | A class to manage writing and reading of block to disk |
| Cblock_handle | |
| ►Nfile_accessor | |
| Cbyte_stream_accessor | |
| Cposix | POSIX-style file accessor |
| Cstdio | Stdio.h-style file accessor |
| Cstream_accessor | |
| Cstream_accessor_base | |
| Cwin32 | Win32 file accessor |
| ►Nlog_bits | |
| Clog_selector | |
| ►Npipelining | TPIE pipelining framework |
| ►Nbits | |
| Caccess | |
| Cami_input_stack_t | |
| Cami_input_t | |
| Cami_output_t | File_stream output terminator |
| Cami_pull_input_stack_t | |
| Cany_noncopyable_cont | |
| Cany_noncopyable_cont< T, true > | |
| Cany_noncopyable_cont_base | |
| Cany_type | |
| Cassert_types_equal_and_return | Helper class that throws an exception on behalf of virtual_chunks that have not been assigned a pipe_middle |
| Cassert_types_equal_and_return< T, T, Result > | Template partial specialization that just returns the parameter given when the input and output types of a virtual chunk are the same (implicit identity function) |
| Cbuffer_input_t | Input node for buffer |
| Cbuffer_output_t | Output node for buffer |
| Cbuffer_pull_output_t | |
| Cchunker_t | |
| Ccount_consecutive_t | |
| ►Cdefault_pred_sort_factory | Sort factory using std::less<T> as comparator |
| Cpredicate | |
| Cdispatch | |
| Cdispatch_gen | |
| Cdispatch_gen< 0, S...> | |
| Cdummydest_t | |
| ►Cexclude_lambda_t | |
| Ctype | |
| Cextract_first_t | |
| ►Cfilter_t | |
| Ctype | |
| ►Cfork_t | |
| Ctype | |
| CForwarder | |
| Cget_impl | |
| Cget_impl< 0, T, TT...> | |
| Cgocontextdel | |
| Cgraph | |
| Chas_argument_type | |
| Chas_itemtype | |
| Chas_pull_method | |
| Chas_push_method | |
| Cinput_t | File_stream input generator |
| Cinput_vector_t | |
| Cinternal_buffer_input_t | |
| Cinternal_buffer_pull_output_t | |
| Cinternal_reverser_input_t | Input node for reverser stored in internal memory |
| Cinternal_reverser_output_t | Output node for reverser stored in internal memory |
| Cinternal_reverser_pull_output_t | Output node for passive reverser stored in internal memory |
| ►Citem_type_t | |
| Ctype | |
| ►Clambda_t | |
| Ctype | |
| Clinear_t | |
| Cmap_sink_t | |
| ►Cmap_t | |
| Ctype | |
| ►Cmap_temp_t | |
| Ctype | |
| Cmaybe_add_const_ref | The maybe_add_const_ref helper struct adds const & to a type unless the type is already const, reference or pointer type |
| Cmaybe_add_const_ref< const T & > | |
| Cmaybe_add_const_ref< const T * > | |
| Cmaybe_add_const_ref< T & > | |
| Cmaybe_add_const_ref< T * > | |
| Cmaybe_check_connected | Contains a method check that calls recursive_connected_check when fact_t is a pair factory, and otherwise does nothing |
| Cmaybe_check_connected< pair_factory< fact1_t, fact2_t > > | For pair factories, recursively check that the nodes created share their node_map |
| Cmaybe_check_connected< termpair_factory< fact1_t, termfact2_t > > | See pair_factory specialization |
| ►Cmerge_t | Merge a pull pipeline into a push pipeline |
| Ctype | |
| Cnamed_input_t | |
| Cnamed_output_t | File_stream output terminator |
| Cnamed_pull_input_t | |
| ►Cnode_map | |
| Cpipe_base_forward_t | |
| Cnode_set_content | |
| Cnull_sink_t | |
| Costream_logger_t | |
| Coutput_t | File_stream output terminator |
| Coutput_vector_t | |
| ►Cpair_factory | |
| Cconstructed | |
| Cpair_factory_base | |
| Cpassive_sorter_factory_input | Factory for the passive sorter input node |
| Cpassive_sorter_factory_output | Factory for the passive sorter output node |
| Cpipe_base | |
| ►Cpipe_nonterm_base | |
| Cconstructed | |
| Cpipe_term_base | |
| Cpipeline_base | Virtual superclass for pipelines and subpipelines |
| Cpipeline_base_base | |
| Cpipeline_impl | |
| ►Cpreparer_t | |
| Ctype | |
| Cprintf_ints_t | |
| ►Cpropagater_t | |
| Ctype | |
| Cproxy_progress_indicator | |
| Cpull_fork_t | |
| Cpull_input_iterator_t | |
| Cpull_input_t | File_stream pull input generator |
| Cpull_input_vector_t | |
| ►Cpull_output_iterator_t | |
| Ctype | |
| Cpull_output_t | File_stream output pull data source |
| Cpull_peek_t | |
| Cpull_reverse_input_t | File_stream pull input generator |
| ►Cpull_source_t | |
| Ctype | |
| Cpull_tee_t | |
| Cpull_traits | |
| Cpull_traits< RetType(ClassType::*)() > | |
| Cpull_type_help | |
| Cpull_type_help< T, default_type, has_pull_method, true > | |
| Cpull_type_help< T, default_type, true, false > | |
| ►Cpush_input_iterator_t | |
| Ctype | |
| Cpush_output_iterator_t | |
| Cpush_output_iterator_t< Iterator, void > | |
| Cpush_traits | |
| Cpush_traits< void(ClassType::*)(ArgType) > | |
| Cpush_type_help | |
| Cpush_type_help< T, default_type, has_push_method, true > | |
| Cpush_type_help< T, default_type, true, false > | |
| Crange_t | |
| Cremove | |
| Cremove< const T > | |
| Cremove< T & > | |
| Cremove< T && > | |
| Creverser_input_t | Input node for reverser stored in external memory |
| Creverser_output_t | Output node for reverser stored in external memory |
| Creverser_pull_output_t | Output node for passive reverser stored in external memory |
| Cruntime | Execute the pipeline contained in a node_map |
| Cscanf_ints_t | |
| Csort_calc_t | Pipe sorter middle node |
| ►Csort_factory | Sort factory using the given predicate as comparator |
| Cpredicate | |
| ►Csort_factory_base | |
| Cconstructed | |
| Csort_input_t | Pipe sorter input node |
| Csort_output_base | |
| Csort_output_t | Pipe sorter push output node |
| Csort_pull_output_t | Pipe sorter pull output node |
| Csubpipeline_base | |
| Csubpipeline_impl | |
| Csubpipeline_virt | |
| Ctee_t | |
| Ctermpair_factory | |
| Cunary_traits | |
| Cunary_traits_imp | |
| Cunary_traits_imp< R(*)(A)> | |
| Cunary_traits_imp< R(C::*)(A) const > | |
| Cunary_traits_imp< R(C::*)(A)> | |
| Cunique_t | |
| ►Cunzip_t | |
| Ctype | |
| ►Cvfork_node | |
| Ctype | |
| Cvirt_node | Ownership of nodes |
| Cvirtrecv | Virtual node that is injected into the end of a virtual chunk |
| Cvirtsrc | Virtual base node that is injected into the beginning of a virtual chunk |
| Cvirtsrc_impl | Concrete implementation of virtsrc |
| Cvirtual_chunk_base | Base class of virtual chunks. Owns a virt_node |
| ►Cvisit_t | |
| Ctype | |
| Cvpush_node | |
| Czero_source_t | |
| ►Czip_t | |
| Ctype | |
| ►Nparallel_bits | |
| Cafter | Accepts output items and sends them to the main thread |
| Cafter_base | Non-templated virtual base class of after |
| Caligned_array | Aligned, uninitialized storage |
| Cbefore | Accepts input items from the main thread and sends them down the pipeline |
| Cbefore_impl | Concrete before class |
| Cconsumer | Node running in main thread, accepting an output buffer from the managing producer and forwards them down the pipe |
| Cconsumer_impl | Concrete consumer implementation |
| ►Cfactory | Factory instantiating a parallel multithreaded pipeline |
| Cconstructed | |
| Coptions | User-supplied options to the parallelism framework |
| Cparallel_input_buffer | Instantiated in each thread |
| Cparallel_output_buffer | Instantiated in each thread |
| Cproducer | Producer, running in main thread, managing the parallel execution |
| Cstate | State subclass containing the item type specific state, i.e |
| Cstate_base | Common state in parallel pipelining library |
| ►Cthreads | Class containing an array of node instances |
| Cprogress_indicator_hook | Factory hook that sets the progress indicator of the nodes run in parallel to the null progress indicator |
| Cthreads_impl | Subclass of threads instantiating and managing the pipelines |
| ►Nserialization_bits | |
| Cbuffer_input_t | |
| Cbuffer_output_t | |
| Cbuffer_pull_output_t | |
| ►Cdefault_pred_sort_factory | Sort factory using std::less<T> as comparator |
| Cpredicate | |
| Cinput_t | |
| Coutput_factory | |
| Coutput_t | |
| Cpassive_sorter_factory_input | Factory for the passive sorter input node |
| Cpassive_sorter_factory_output | Factory for the passive sorter output node |
| Creverser_input_t | |
| Creverser_output_t | |
| Creverser_pull_output_t | |
| Csort_calc_t | Pipe sorter middle node |
| ►Csort_factory | Sort factory using the given predicate as comparator |
| Cpredicate | |
| ►Csort_factory_base | |
| Cconstructed | |
| Csort_input_t | Pipe sorter input node |
| Csort_output_base | |
| Csort_output_t | Pipe sorter push output node |
| Csort_pull_output_t | Pipe sorter pull output node |
| Csorter_traits | |
| Cany_noncopyable | |
| CArgs | |
| Cbad_any_noncopyable_cast | |
| Cbad_any_noncopyable_copy | |
| Ccall_order_exception | |
| Ccontainer | |
| Ccontainer< T, TT...> | |
| Cdestination_kind | |
| Cempty_pipe_middle | A empty_pipe_middle class has no effect |
| ►Cfactory | Node factory for variadic argument generators |
| Cconstructed | |
| Cfactory_base | Base class of all pipelining factories |
| Cfactory_init_hook | |
| Cinternal_passive_buffer | Internal fifo buffer |
| Cinternal_passive_reverser | A passive reverser stored in internal memory |
| ►Cjoin | Joins multiple push streams into one |
| Csink_impl | |
| Csource_base | |
| Csource_impl | |
| Cno_initiator_node | |
| Cnode | Base class of all nodes |
| Cnode_parameters | |
| Cnode_resource_parameters | |
| Cnode_token | |
| Cnon_authoritative_node_map | |
| Cnot_initiator_node | |
| Cpassive_buffer | Plain old file_stream buffer |
| Cpassive_reverser | A passive reverser stored in external memory |
| Cpassive_serialization_buffer | Serialization stream buffer |
| Cpassive_serialization_reverser | A passive serialization reverser stored in external memory |
| Cpassive_sorter | Pipelined sorter with push input and pull output |
| Cpipe_begin | |
| Cpipe_end | |
| Cpipe_middle | A pipe_middle class pushes input down the pipeline |
| Cpipeline | This class is used to avoid writing the template argument in the pipeline_impl type |
| Cpull_type | |
| Cpullpipe_begin | |
| Cpullpipe_end | |
| Cpullpipe_middle | |
| Cpush_type | Class to deduce the item_type of a node of type T |
| Cserialization_passive_sorter | Pipelined sorter with push input and pull output |
| ►Csplit | Split one push streams into multiple |
| Csink_impl | |
| Csource_base | |
| Csource_impl | |
| ►Csplit_factory | Node factory for split nodes, typically used for phase boundary nodes |
| Cconstructed | |
| Csubpipeline | |
| ►Ctempfactory | Node factory for variadic argument templated generators |
| Cconstructed | |
| Ctermfactory | Node factory for variadic argument terminators |
| Ctfactory | Node factory for variadic argument terminators |
| ►Ctfactory< R, Args< TT...>, T...> | |
| Cconstructed | |
| Cvirtual_chunk | Virtual chunk that has input and output |
| Cvirtual_chunk_begin | Virtual chunk that has no input (that is, virtual producer) |
| Cvirtual_chunk_end | Virtual chunk that has no output (that is, virtual consumer) |
| Cvirtual_chunk_missing_begin | |
| Cvirtual_chunk_missing_end | |
| Cvirtual_chunk_missing_middle | |
| Cvirtual_chunk_not_ready | |
| Cvirtual_container | Virtual base class for extra data to go with virtual chunks |
| ►Nserialization_bits | |
| Cfile_handler | File handling for merge sort |
| Cinternal_sort | |
| Cmerger | |
| Csort_parameters | |
| ►Ntiny | |
| ►Nbits | |
| CIdentityExtract | Use the identity function on elements to extract the key |
| ►CMultiInsertHelp | When inserting allow elements with equivalest keys |
| Ctype | |
| CPairExtract | Extract the first element of a pair as the key |
| ►CSingleInsertHelp | When inserting do not allow elements with equivalest keys |
| Ctype | |
| Cmap | A std::map compatible map, useful when we do not have many elements (less then 512) |
| ►Cset_impl | Class implementing a tiny::set, tiny::multiset, and tiny::multimap |
| Cvalue_compare | |
| Callocation_scope_magic | |
| ►Callocator | A allocator object usable in STL containers, using the TPIE memory manager |
| Crebind | |
| Carray | A generic array with a fixed size |
| Carray_allocation_scope_magic | |
| Carray_iter_base | Shared implementation of array iterators |
| Carray_view | Encapsulation of two pointers from any random access container |
| Carray_view< const T > | |
| ►Carray_view_base | Base class for array_view |
| Citerator | |
| Cbinary_argument_swap | A binary functor with the arguments swapped |
| Cbtree_augment | |
| Cbtree_blocksize | |
| Cbtree_comp | |
| Cbtree_fanout | |
| Cbtree_iterator | |
| Cbtree_key | |
| Cbtree_node | Type that is useful for navigating a btree |
| CBufferedHash | |
| Cchaining_hash_table | Hash table handling hash collisions by chaining |
| Cclose_on_fail_guard | Implementation helper that closes the stream if a method exits by throwing an exception |
| ►Ccompressed_stream_base | Base class containing the implementation details that are independent of the item type |
| Cseek_state | |
| Ccompression_scheme | Abstract virtual base class for each compression scheme |
| Ccompressor_buffer | A buffer for elements belonging to a specific stream block |
| Ccompressor_buffer_state | The different states of a compressor buffer |
| Ccompressor_request | Tagged union containing either a read_request or a write_request |
| Ccompressor_request_kind | |
| Ccompressor_response | Response to an I/O request |
| Ccompressor_thread | |
| Ccompressor_thread_lock | |
| Ccpu_timer | |
| Cdefault_comp | Default < comparator for the btree |
| Cdefault_unused | |
| Cdefault_unused< std::pair< T1, T2 > > | |
| Cdisjoint_sets | Internal memory union find implementation |
| Cdummy_fraction_progress | A fractional progress indicator that is conceptually compatible with tpie::fractional_progress |
| Cdummy_progress_indicator | A progress indicator that is conceptually compatible with tpie::progress_indicator_base and tpie::fractional_subindicator |
| ►Cdynamic_store | Fantastic store strategy |
| Celement_type | |
| Cspecific | |
| Cempty_augment | Augmentation struct used in an un-augmented btree |
| Cempty_augmenter | Functor used to augment an un-augmented btree |
| Cempty_key | |
| Cend_of_stream_exception | |
| Cexception | |
| Cexecution_time_predictor | |
| ►Cexplicit_tpie_pointer_store | Sort elements in tpie pointers |
| Celement_type | |
| Cspecific | |
| ►Cexplicit_tpie_unique_pointer_store | Sort elements in tpie unique pointers |
| Celement_type | |
| Cspecific | |
| ►Cfile | Central file abstraction |
| Cstream | Central stream abstraction |
| ►Cfile_base | |
| Cblock_t | This is the type of our block buffers |
| Cstream | Stream in file. We support multiple streams per file |
| Cfile_base_crtp | Base class of classes that access files |
| Cfile_log_target | A simple logger that writes messages to a tpie temporary file |
| Cfile_manager | File management object used to track file usage |
| Cfile_stream | Compressed stream |
| ►Cfile_stream_base | |
| Cblock_t | |
| Cfractional_progress | Fractional progress reporter |
| Cfractional_subindicator | Subindicator for fractional progress reporting |
| Cget_arg_help | |
| Cget_arg_help< bool > | |
| Chash | Default tabulation-hashing function for integral (size_t-castable) types |
| Chash< const char * > | Default hashing function for C-style strings |
| Chash< std::pair< T1, T2 > > | Default hashing function for std::pair |
| Chash< std::string > | Default hashing function for std::string |
| ►Chash_map | Hash map implementation backed by a template parameterized hash table |
| Citerator | Non-const iterator type |
| ►Chash_set | Hash set implementation backed by a template parameterized hash table |
| Citerator | Non-const iterator type |
| CHashReflector | Buffer based hash reflector |
| Cidentity_key | Functor used to extract the key from a value in case keys and values are the same |
| Cinternal_priority_queue | Standard binary internal heap |
| Cinternal_queue | A generic internal circular queue |
| Cinternal_stack | A generic internal stack |
| Cinternal_stack_vector_base | A base class for a generic internal fixed size stack and vector |
| Cinternal_vector | A generic internal vector |
| Cinvalid_argument_exception | |
| Cinvalid_file_exception | |
| Cio_exception | |
| Cis_simple_iterator | Checks if an iterator is simple |
| Cis_simple_iterator_enable_if | |
| Cis_simple_iterator_enable_if< true > | |
| Cis_stream_writable | |
| Cis_stream_writable< std::pair< T1, T2 > > | |
| Cis_stream_writable< std::tuple< TT...> > | |
| Cis_stream_writable< T > | |
| Cis_stream_writable< T1, T2, TT...> | |
| Cis_stream_writable<> | |
| Cis_stream_writable_override | |
| Cis_trivially_serializable | |
| Cis_trivially_serializable2 | |
| Cjob | |
| Cjob_manager_exception | |
| CJSONPrinter | Helper struct for printing |
| CJSONReflector | Refletor for json printing to an ostream |
| Clinear_memory_base | Base class of data structures with linear memory usage |
| Clinear_memory_structure_concept | Check if a structure adheres to the linear_memory_structure concept |
| Clinear_memory_structure_doc | Description of the methods that must be implemented to support the linear_memory_structure_concept |
| Clinear_probing_hash_table | Hash table handling hash collisions by linear probing |
| Clog_group | RAII-style management for log groups |
| Clog_group_mode | |
| Clog_level_manip | |
| Clog_stream_buf | |
| Clog_target | |
| Clogstream | A log is like a regular output stream, but it also supports messages at different priorities, see log_level |
| Cmagic_cast_help | |
| Cmagic_cast_help< bool, std::string > | |
| Cmagic_cast_help< std::string, bool > | |
| Cmaybe | |
| Cmaybe_exception | |
| Cmemory_bucket | Bucket used for memory counting |
| Cmemory_bucket_ref | Class storring a reference to a memory bucket |
| Cmemory_manager | Memory management object used to track memory usage |
| Cmerge_sort_not_ready | |
| Cmerge_sorter | Merge sorting consists of three phases |
| ►Cmerger | |
| Cpredwrap | |
| Cno_key | |
| Cop2TPIE_cmp | Convert a class with a comparison operator < to a TPIE comparison object with a compare() function |
| Copen | |
| Cout_of_files_error | |
| Cout_of_memory_error | |
| Cout_of_resource_error | Thrown when trying to allocate too much of a resource |
| Cout_of_space_exception | |
| Cpacked_array | An array storring elements of type T using B bits to to store a element |
| Cpacked_array_iter_facade | Base class for the iterators |
| ►Cparallel_sort_impl | A simple parallel sort implementation with progress tracking |
| Cqsort_job | Represents quick sort work at a given level |
| ►Cplain_store | Plain old store |
| Celement_type | |
| Cspecific | |
| ►Cpointer_store | Sort elements using pointer indirection |
| Celement_type | |
| Cspecific | |
| Cpq_merge_heap | |
| Cpq_overflow_heap | Overflow Priority Queue, based on a simple Heap |
| Cpriority_queue | External memory priority queue implementation |
| Cpriority_queue_error | |
| Cprogress_indicator_arrow | A class that indicates the progress by expanding an arrow |
| Cprogress_indicator_base | The base class for indicating the progress of some task |
| Cprogress_indicator_null | Dummy progress indicator that produces no output |
| Cprogress_indicator_spin | A class that indicates the progress by a spinning cross |
| Cprogress_indicator_subindicator | |
| Cprogress_indicator_terminal | A class that indicates the progress by a simple counter that is printed to the terminal |
| Cprogress_types | For applications where you wish to disable progress indicators via a template parameter, refer to progress_types<use_progress> members names sub, fp and base |
| Cprogress_types< false > | |
| Cptime | |
| Cqueue | Basic Implementation of I/O Efficient FIFO queue |
| Cread_direction | Class enum designating a read/write direction |
| Cread_request | |
| Creflect_sfinae | |
| Creflect_tag_array_read | |
| Creflect_tag_array_write | |
| Creflect_tag_compute | |
| Creflect_tag_compute< false, false, false, false, false, true > | |
| Creflect_tag_compute< false, false, false, false, true, array_write > | |
| Creflect_tag_compute< false, false, false, true, push_back_array_write, array_write > | |
| Creflect_tag_compute< false, false, true, false, false, false > | |
| Creflect_tag_compute< false, true, array_read, false, false, false > | |
| Creflect_tag_compute< true, trivial_array_read, array_read, trivial_array_write, push_back_array_write, array_write > | |
| Creflect_tag_direct | |
| Creflect_tag_impl | |
| Creflect_tag_push_back_array_write | |
| Creflect_tag_trivial_array_read | |
| Creflect_tag_trivial_array_write | |
| Crequest_base | Base class for read_request and write_request |
| Cresource_manager | Resource management object used to track resource usage |
| Cscoped_log_enabler | |
| Cserialization_error | Class to compute the disjunction between two std true/false types |
| Cserialization_reader | |
| Cserialization_reverse_reader | |
| ►Cserialization_reverse_writer | |
| Cserializer | |
| Cserialization_sorter | |
| ►Cserialization_writer | |
| Cserializer | |
| Cserializer | Class providing binary serialization to a std::ostream |
| Csign | |
| Csign< uint16_t > | |
| Csign< uint32_t > | |
| Csign< uint64_t > | |
| Csign< uint8_t > | |
| Csort_manager | A class of manager objects for merge sorting objects of type T |
| Csort_parameters | |
| Cstack | An implementation of an external-memory stack |
| Cstat_timer | |
| Cstderr_log_target | A simple logger that writes messages to stderr |
| CSTL2TPIE_cmp | Convert STL comparison object with operator() to a TPIE comparison object with a compare() function |
| Cstream_buffer_pool | Pool of shared buffers |
| Cstream_buffers | Buffer manager for a single stream |
| Cstream_crtp | |
| Cstream_exception | |
| Cstream_header_t | |
| Cstream_position | POD object indicating the position of an item in a stream |
| Csysinfo | Class providing system and platform info |
| Ctemp_file | Class representing a reference to a temporary file |
| Ctempfile_error | |
| Ctemplate_log | Computes the least integer strictly greater than log(t) |
| Ctemplate_log< 1 > | |
| Ctempname | Static methods for generating temporary file names and finding temporary file directories |
| Ctestmanip | |
| Ctests | |
| Cteststream | |
| Cteststream_buf | |
| CTPIE2STL_cmp | Convert a TPIE comparison object with a compare() function to STL comparison object with operator() |
| Ctpie_deleter | |
| Ctrivial_same_size | |
| Cuncompressed_stream | Simple class acting both as file and a file::stream |
| Cunique_id_type | |
| Cunserializer | Class for unserializing binary data serialized with the serializer Data can be unserialized using the >> operators |
| Cunsign | |
| Cunsign< int16_t > | |
| Cunsign< int32_t > | |
| Cunsign< int64_t > | |
| Cunsign< int8_t > | |
| Cwrite_request | |