| Ctpie::pipelining::bits::access | |
| Ctpie::pipelining::parallel_bits::aligned_array< T, Align > | Aligned, uninitialized storage |
| Ctpie::pipelining::parallel_bits::aligned_array< before_t, alignment > | |
| Ctpie::pipelining::parallel_bits::aligned_array< tpie::progress_indicator_null, alignment > | |
| Ctpie::allocation_scope_magic< T > | |
| Ctpie::allocator< T > | A allocator object usable in STL containers, using the TPIE memory manager |
| Ctpie::bits::allocator_usage< T, Allocator > | |
| Ctpie::bits::allocator_usage< T, allocator< T > > | |
| Ctpie::pipelining::any_noncopyable | |
| ►Ctpie::pipelining::bits::any_noncopyable_cont_base | |
| Ctpie::pipelining::bits::any_noncopyable_cont< T, can_copy > | |
| Ctpie::pipelining::bits::any_noncopyable_cont< T, true > | |
| Ctpie::pipelining::bits::any_type | |
| Ctpie::pipelining::Args<> | |
| Ctpie::array_allocation_scope_magic< T > | |
| Ctpie::bits::array_decode_magic< D, T, is_simple_itr, is_ts > | Helper to facilitate fast unserialization of trivially copyable arrays |
| Ctpie::bits::array_decode_magic< D, T, true, true > | |
| Ctpie::bits::array_encode_magic< D, T, is_simple_itr, is_ts > | Helper to facilitate fast serialization of trivially copyable arrays |
| Ctpie::bits::array_encode_magic< D, T, true, true > | |
| ►Ctpie::array_view_base< T > | Base class for array_view |
| Ctpie::array_view< T > | Encapsulation of two pointers from any random access container |
| ►Ctpie::array_view_base< const T > | |
| Ctpie::array_view< const T > | |
| Ctpie::pipelining::bits::assert_types_equal_and_return< T, U, Result > | Helper class that throws an exception on behalf of virtual_chunks that have not been assigned a pipe_middle |
| Ctpie::pipelining::bits::assert_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) |
| ►Caugment_type | |
| Ctpie::bbits::tree_state< T, O >::combined_augment | |
| ►Cbasic_streambuf | |
| Ctpie::log_stream_buf | |
| Ctpie::teststream_buf | |
| Ctpie::binary_argument_swap< T > | A binary functor with the arguments swapped |
| Ctpie::binary_argument_swap< comp > | |
| Ctpie::binary_argument_swap< comp_t > | |
| Ctpie::binary_argument_swap< Comparator > | |
| Ctpie::binary_argument_swap< tpie::merger::predwrap > | |
| Ctpie::blocks::block_collection | A class to manage writing and reading of block to disk |
| Ctpie::blocks::block_collection_cache | A class to manage writing and reading of block to disk |
| Ctpie::blocks::block_handle | |
| Ctpie::bbits::block_size_getter< typename, bool > | |
| Ctpie::bbits::block_size_getter< T, true > | |
| Ctpie::file_stream_base::block_t | |
| Ctpie::btree_augment< T > | |
| Ctpie::btree_blocksize< bs_ > | |
| Ctpie::btree_comp< T > | |
| Ctpie::btree_fanout< a_, b_ > | |
| Ctpie::btree_key< T > | |
| Ctpie::btree_node< S > | Type that is useful for navigating a btree |
| Ctpie::BufferedHash | |
| Ctpie::bbits::builder< T, O > | Augmented btree builder |
| Ctpie::chaining_hash_table< value_t, hash_t, equal_t, index_t > | Hash table handling hash collisions by chaining |
| Ctpie::close_on_fail_guard | Implementation helper that closes the stream if a method exits by throwing an exception |
| Ctpie::bbits::tree_state< T, O >::combined_augmenter | |
| ►Ctpie::compressed_stream_base | Base class containing the implementation details that are independent of the item type |
| Ctpie::file_stream< element_type > | |
| Ctpie::file_stream< item_type > | |
| Ctpie::file_stream< tpie::blocks::block_handle > | |
| Ctpie::file_stream< tpie::stream_position > | |
| Ctpie::file_stream< T > | Compressed stream |
| Ctpie::compression_scheme | Abstract virtual base class for each compression scheme |
| Ctpie::compressor_buffer | A buffer for elements belonging to a specific stream block |
| Ctpie::compressor_buffer_state | The different states of a compressor buffer |
| Ctpie::compressor_request | Tagged union containing either a read_request or a write_request |
| Ctpie::compressor_request_kind | |
| Ctpie::compressor_response | Response to an I/O request |
| Ctpie::compressor_thread | |
| Ctpie::compressor_thread_lock | |
| Ctpie::pipelining::serialization_bits::sort_factory_base< child_t >::constructed< dest_t > | |
| Ctpie::pipelining::bits::sort_factory_base< child_t, store_t >::constructed< dest_t > | |
| Ctpie::pipelining::factory< R, T >::constructed< dest_t > | |
| Ctpie::pipelining::tempfactory< Holder, T >::constructed< dest_t > | |
| Ctpie::pipelining::tfactory< R, Args< TT...>, T...>::constructed< dest_t > | |
| Ctpie::pipelining::split_factory< I, OB, O >::constructed< dest_t > | |
| Ctpie::pipelining::bits::pair_factory< fact1_t, fact2_t >::constructed< dest_t > | |
| Ctpie::pipelining::parallel_bits::factory< fact_t >::constructed< dest_t > | |
| Ctpie::pipelining::bits::pipe_nonterm_base< child_t >::constructed< dest_t > | |
| Ctpie::pipelining::container< TT > | |
| Ctpie::pipelining::container< T...> | |
| ►Ctpie::pipelining::container< TT...> | |
| Ctpie::pipelining::container< T, TT...> | |
| Ctpie::bits::counter | Helper to count the serialized size of objects |
| Ctpie::cpu_timer | |
| Ctpie::default_comp | Default < comparator for the btree |
| Ctpie::default_unused< T > | |
| Ctpie::default_unused< std::pair< T1, T2 > > | |
| Ctpie::pipelining::destination_kind | |
| Ctpie::pipelining::bits::dispatch< S > | |
| Ctpie::pipelining::bits::dispatch_gen< N, S > | |
| Ctpie::pipelining::bits::dispatch_gen< 0, S...> | |
| Ctpie::dummy_fraction_progress | A fractional progress indicator that is conceptually compatible with tpie::fractional_progress |
| Ctpie::dummy_progress_indicator | A progress indicator that is conceptually compatible with tpie::progress_indicator_base and tpie::fractional_subindicator |
| Ctpie::dynamic_store | Fantastic store strategy |
| Ctpie::plain_store::element_type< outer_t > | |
| Ctpie::explicit_tpie_pointer_store::element_type< outer_t > | |
| Ctpie::explicit_tpie_unique_pointer_store::element_type< outer_t > | |
| Ctpie::pointer_store::element_type< outer_t > | |
| Ctpie::dynamic_store::element_type< outer_t > | |
| Ctpie::empty_augment | Augmentation struct used in an un-augmented btree |
| Ctpie::empty_augmenter | Functor used to augment an un-augmented btree |
| Ctpie::empty_key | |
| Ctpie::bbits::enab | |
| Ctpie::bbits::Enable< X, b > | |
| Ctpie::bbits::Enable< enab, true > | |
| Ctpie::bits::enum_storage_type< T > | |
| Ctpie::bits::enum_storage_type_help< S > | |
| Ctpie::bits::enum_storage_type_help< 1 > | |
| Ctpie::bits::enum_storage_type_help< 2 > | |
| Ctpie::bits::enum_storage_type_help< 4 > | |
| Ctpie::bits::enum_storage_type_help< 8 > | |
| ►Cstd::exception | STL class |
| ►Cstd::bad_cast | STL class |
| Ctpie::pipelining::bad_any_noncopyable_cast | |
| ►Cstd::logic_error | STL class |
| Ctpie::priority_queue_error | |
| ►Cstd::runtime_error | STL class |
| ►Ctpie::exception | |
| Ctpie::invalid_argument_exception | |
| Ctpie::job_manager_exception | |
| Ctpie::maybe_exception | |
| Ctpie::merge_sort_not_ready | |
| ►Ctpie::out_of_resource_error | Thrown when trying to allocate too much of a resource |
| Ctpie::out_of_files_error | |
| Ctpie::out_of_memory_error | |
| Ctpie::pipelining::call_order_exception | |
| Ctpie::pipelining::no_initiator_node | |
| Ctpie::pipelining::non_authoritative_node_map | |
| Ctpie::pipelining::not_initiator_node | |
| Ctpie::pipelining::virtual_chunk_missing_begin | |
| Ctpie::pipelining::virtual_chunk_missing_end | |
| Ctpie::pipelining::virtual_chunk_missing_middle | |
| Ctpie::pipelining::virtual_chunk_not_ready | |
| ►Ctpie::stream_exception | |
| Ctpie::end_of_stream_exception | |
| Ctpie::invalid_file_exception | |
| ►Ctpie::io_exception | |
| Ctpie::out_of_space_exception | |
| Ctpie::serialization_error | Class to compute the disjunction between two std true/false types |
| Ctpie::tempfile_error | |
| Ctpie::pipelining::bad_any_noncopyable_copy | |
| Ctpie::pipelining::bits::exclude_lambda_t< F > | |
| Ctpie::execution_time_predictor | |
| Ctpie::explicit_tpie_pointer_store | Sort elements in tpie pointers |
| Ctpie::explicit_tpie_unique_pointer_store | Sort elements in tpie unique pointers |
| ►Ctpie::bbits::external_store_base | |
| Ctpie::bbits::external_store< T, A, a, b, bs > | Storage used for an external btree |
| ►Ctpie::pipelining::factory_base | Base class of all pipelining factories |
| ►Ctpie::pipelining::serialization_bits::sort_factory_base< default_pred_sort_factory > | |
| Ctpie::pipelining::serialization_bits::default_pred_sort_factory | Sort factory using std::less<T> as comparator |
| ►Ctpie::pipelining::bits::sort_factory_base< default_pred_sort_factory< store_t >, store_t > | |
| Ctpie::pipelining::bits::default_pred_sort_factory< store_t > | Sort factory using std::less<T> as comparator |
| ►Ctpie::pipelining::serialization_bits::sort_factory_base< sort_factory< pred_t > > | |
| Ctpie::pipelining::serialization_bits::sort_factory< pred_t > | Sort factory using the given predicate as comparator |
| ►Ctpie::pipelining::bits::sort_factory_base< sort_factory< pred_t, store_t >, store_t > | |
| Ctpie::pipelining::bits::sort_factory< pred_t, store_t > | Sort factory using the given predicate as comparator |
| Ctpie::pipelining::bits::passive_sorter_factory_input< T, pred_t, store_t > | Factory for the passive sorter input node |
| Ctpie::pipelining::bits::passive_sorter_factory_output< T, pred_t, store_t > | Factory for the passive sorter output node |
| Ctpie::pipelining::bits::sort_factory_base< child_t, store_t > | |
| Ctpie::pipelining::factory< R, T > | Node factory for variadic argument generators |
| Ctpie::pipelining::parallel_bits::factory< fact_t > | Factory instantiating a parallel multithreaded pipeline |
| Ctpie::pipelining::serialization_bits::passive_sorter_factory_input< Traits > | Factory for the passive sorter input node |
| Ctpie::pipelining::serialization_bits::passive_sorter_factory_output< Traits > | Factory for the passive sorter output node |
| Ctpie::pipelining::serialization_bits::sort_factory_base< child_t > | |
| Ctpie::pipelining::split_factory< I, OB, O > | Node factory for split nodes, typically used for phase boundary nodes |
| Ctpie::pipelining::tempfactory< Holder, T > | Node factory for variadic argument templated generators |
| Ctpie::pipelining::termfactory< R, T > | Node factory for variadic argument terminators |
| Ctpie::pipelining::tfactory< R, Args< TT...>, T...> | |
| ►Ctpie::pipelining::factory_init_hook | |
| Ctpie::pipelining::parallel_bits::threads< Input, Output >::progress_indicator_hook | Factory hook that sets the progress indicator of the nodes run in parallel to the null progress indicator |
| ►Cfile_accessor_crtp | |
| Ctpie::file_accessor::stdio | Stdio.h-style file accessor |
| ►Ctpie::file_base_crtp< child_t > | Base class of classes that access files |
| ►Ctpie::file_stream_base | |
| Ctpie::uncompressed_stream< T > | Simple class acting both as file and a file::stream |
| ►Ctpie::file_base_crtp< file_base > | |
| ►Ctpie::file_base | |
| Ctpie::file< T > | Central file abstraction |
| Ctpie::file_base_crtp< file_stream_base > | |
| Ctpie::serialization_bits::file_handler< T > | File handling for merge sort |
| Ctpie::pipelining::bits::filter_t< F > | |
| Ctpie::pipelining::bits::fork_t< fact2_t > | |
| Ctpie::fractional_progress | Fractional progress reporter |
| Ctpie::blocks::bits::freespace_collection | |
| Ctpie::get_arg_help< T > | |
| Ctpie::get_arg_help< bool > | |
| Ctpie::pipelining::bits::get_impl< i, T, TT > | |
| Ctpie::pipelining::bits::get_impl< 0, T, TT...> | |
| Ctpie::pipelining::bits::gocontextdel | |
| Ctpie::pipelining::bits::graph< T > | |
| Ctpie::pipelining::bits::has_argument_type< T > | |
| Ctpie::pipelining::bits::has_itemtype< T > | |
| Ctpie::pipelining::bits::has_pull_method< T > | |
| Ctpie::pipelining::bits::has_push_method< T > | |
| Ctpie::hash< T > | Default tabulation-hashing function for integral (size_t-castable) types |
| Ctpie::hash< const char * > | Default hashing function for C-style strings |
| Ctpie::hash< std::pair< T1, T2 > > | Default hashing function for std::pair |
| Ctpie::hash< std::string > | Default hashing function for std::string |
| Ctpie::hash< T1 > | |
| Ctpie::hash< T2 > | |
| Ctpie::HashReflector< H > | Buffer based hash reflector |
| Ctpie::ami::heap_element< KEY > | This is a heap element |
| Ctpie::ami::heap_element< REC > | |
| Ctpie::ami::heap_ptr< REC > | This is a record pointer element |
| Ctpie::identity_key | Functor used to extract the key from a value in case keys and values are the same |
| Ctpie::tiny::bits::IdentityExtract | Use the identity function on elements to extract the key |
| Ctpie::bbits::int_opt< i > | |
| ►Cintegral_constant | |
| Ctpie::is_stream_writable< T > | |
| Ctpie::is_stream_writable< T1, T2, TT...> | |
| Ctpie::is_stream_writable<> | |
| Ctpie::bbits::external_store< T, A, a, b, bs >::internal | |
| Ctpie::bbits::external_store< T, A, a, b, bs >::internal_content | |
| Ctpie::pipelining::internal_passive_buffer< T > | Internal fifo buffer |
| Ctpie::pipelining::internal_passive_reverser< T > | A passive reverser stored in internal memory |
| Ctpie::serialization_bits::internal_sort< T, pred_t > | |
| ►Ctpie::ami::Internal_Sorter_Base< T > | The base class for internal sorters |
| Ctpie::ami::Internal_Sorter_Obj< T, Compare > | Comparision object based Internal_Sorter_base subclass implementation; uses quick_sort_obj() |
| Ctpie::bbits::internal_store< T, A, a, b > | Storage used for an internal btree |
| Ctpie::bbits::external_store< T, A, a, b, bs >::internal_type | |
| ►Cstd::ios_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_ostream< Char > | STL class |
| ►Cstd::ostream | STL class |
| Ctpie::logstream | A log is like a regular output stream, but it also supports messages at different priorities, see log_level |
| Ctpie::teststream | |
| Ctpie::is_simple_iterator< T > | Checks if an iterator is simple |
| Ctpie::is_simple_iterator_enable_if< bool > | |
| Ctpie::is_simple_iterator_enable_if< true > | |
| Ctpie::is_stream_writable< TT > | |
| ►Ctpie::is_stream_writable< T1, T2 > | |
| Ctpie::is_stream_writable< std::pair< T1, T2 > > | |
| ►Ctpie::is_stream_writable< TT...> | |
| Ctpie::is_stream_writable< std::tuple< TT...> > | |
| Ctpie::is_stream_writable_override< T > | |
| Ctpie::is_trivially_serializable< T > | |
| Ctpie::is_trivially_serializable2< T > | |
| Ctpie::pipelining::bits::item_type_t< T > | |
| Ctpie::hash_map< key_t, data_t, hash_t, equal_t, index_t, table_t >::iterator | Non-const iterator type |
| Ctpie::hash_set< key_t, hash_t, equal_t, index_t, table_t >::iterator | Non-const iterator type |
| ►Citerator_facade | |
| Ctpie::array_iter_base< TT, forward > | Shared implementation of array iterators |
| Ctpie::array_view_base< T >::iterator | |
| Ctpie::btree_iterator< S > | |
| ►Ctpie::job | |
| Ctpie::parallel_sort_impl< iterator_type, comp_type, Progress, min_size >::qsort_job | Represents quick sort work at a given level |
| Ctpie::pipelining::join< T > | Joins multiple push streams into one |
| Ctpie::JSONPrinter< T > | Helper struct for printing |
| Ctpie::JSONReflector | Refletor for json printing to an ostream |
| ►Ctpie::bbits::tree_state< T, O >::key_augment | |
| Ctpie::bbits::tree_state< T, O >::combined_augment | |
| Ctpie::pipelining::bits::lambda_t< F > | |
| Ctpie::bbits::external_store< T, A, a, b, bs >::leaf | |
| Ctpie::bbits::external_store< T, A, a, b, bs >::leaf_type | |
| ►Ctpie::linear_memory_base< child_t > | Base class of data structures with linear memory usage |
| Ctpie::internal_stack_vector_base< T, child_t > | A base class for a generic internal fixed size stack and vector |
| ►Ctpie::linear_memory_base< array< bucket_t > > | |
| Ctpie::array< bucket_t > | |
| ►Ctpie::linear_memory_base< array< char > > | |
| Ctpie::array< char > | |
| ►Ctpie::linear_memory_base< array< index_t > > | |
| Ctpie::array< index_t > | |
| ►Ctpie::linear_memory_base< array< item_type > > | |
| Ctpie::array< item_type > | |
| ►Ctpie::linear_memory_base< array< memory_size_type > > | |
| Ctpie::array< memory_size_type > | |
| ►Ctpie::linear_memory_base< array< push_type< dest_t >::type > > | |
| Ctpie::array< push_type< dest_t >::type > | |
| ►Ctpie::linear_memory_base< array< std::pair< store_type, size_t > > > | |
| Ctpie::array< std::pair< store_type, size_t > > | |
| ►Ctpie::linear_memory_base< array< store_type > > | |
| Ctpie::array< store_type > | |
| ►Ctpie::linear_memory_base< array< stream_size_type > > | |
| Ctpie::array< stream_size_type > | |
| ►Ctpie::linear_memory_base< array< T > > | |
| Ctpie::array< T > | |
| Ctpie::array< T, Allocator > | A generic array with a fixed size |
| ►Ctpie::linear_memory_base< array< T1 > > | |
| Ctpie::array< T1 > | |
| ►Ctpie::linear_memory_base< array< T2 > > | |
| Ctpie::array< T2 > | |
| ►Ctpie::linear_memory_base< array< tpie::ami::heap_element< REC > > > | |
| Ctpie::array< tpie::ami::heap_element< REC > > | |
| ►Ctpie::linear_memory_base< array< tpie::ami::heap_ptr< REC > > > | |
| Ctpie::array< tpie::ami::heap_ptr< REC > > | |
| ►Ctpie::linear_memory_base< array< tpie::blocks::block_handle > > | |
| Ctpie::array< tpie::blocks::block_handle > | |
| ►Ctpie::linear_memory_base< array< tpie::file_stream< element_type > > > | |
| Ctpie::array< tpie::file_stream< element_type > > | |
| ►Ctpie::linear_memory_base< array< tpie::pipelining::parallel_bits::parallel_input_buffer< push_type< dest_t >::type > * > > | |
| Ctpie::array< tpie::pipelining::parallel_bits::parallel_input_buffer< push_type< dest_t >::type > * > | |
| ►Ctpie::linear_memory_base< array< tpie::pipelining::parallel_bits::parallel_input_buffer< T > * > > | |
| Ctpie::array< tpie::pipelining::parallel_bits::parallel_input_buffer< T > * > | |
| ►Ctpie::linear_memory_base< array< tpie::pipelining::parallel_bits::parallel_input_buffer< T1 > * > > | |
| Ctpie::array< tpie::pipelining::parallel_bits::parallel_input_buffer< T1 > * > | |
| ►Ctpie::linear_memory_base< array< tpie::pipelining::parallel_bits::parallel_output_buffer< T > * > > | |
| Ctpie::array< tpie::pipelining::parallel_bits::parallel_output_buffer< T > * > | |
| ►Ctpie::linear_memory_base< array< tpie::pipelining::parallel_bits::parallel_output_buffer< T2 > * > > | |
| Ctpie::array< tpie::pipelining::parallel_bits::parallel_output_buffer< T2 > * > | |
| ►Ctpie::linear_memory_base< array< tpie::serialization_reader > > | |
| Ctpie::array< tpie::serialization_reader > | |
| ►Ctpie::linear_memory_base< array< tpie::stream_position > > | |
| Ctpie::array< tpie::stream_position > | |
| ►Ctpie::linear_memory_base< array< tpie::temp_file > > | |
| Ctpie::array< tpie::temp_file > | |
| ►Ctpie::linear_memory_base< array< value_t > > | |
| Ctpie::array< value_t > | |
| ►Ctpie::linear_memory_base< disjoint_sets< value_t > > | |
| Ctpie::disjoint_sets< value_t > | Internal memory union find implementation |
| ►Ctpie::linear_memory_base< hash_map< key_t, data_t, hash_t, equal_t, index_t, table_t > > | |
| Ctpie::hash_map< key_t, data_t, hash_t, equal_t, index_t, table_t > | Hash map implementation backed by a template parameterized hash table |
| ►Ctpie::linear_memory_base< hash_set< key_t, hash_t, equal_t, index_t, table_t > > | |
| Ctpie::hash_set< key_t, hash_t, equal_t, index_t, table_t > | Hash set implementation backed by a template parameterized hash table |
| ►Ctpie::linear_memory_base< internal_priority_queue< std::pair< store_type, size_t >, tpie::merger::predwrap > > | |
| Ctpie::internal_priority_queue< std::pair< store_type, size_t >, tpie::merger::predwrap > | |
| ►Ctpie::linear_memory_base< internal_priority_queue< T, comp_t > > | |
| Ctpie::internal_priority_queue< T, comp_t > | Standard binary internal heap |
| ►Ctpie::linear_memory_base< internal_priority_queue< T, Comparator > > | |
| Ctpie::internal_priority_queue< T, Comparator > | |
| ►Ctpie::linear_memory_base< internal_priority_queue< tpie::ami::heap_element< REC >, comp > > | |
| Ctpie::internal_priority_queue< tpie::ami::heap_element< REC >, comp > | |
| ►Ctpie::linear_memory_base< internal_priority_queue< tpie::ami::heap_ptr< REC >, comp > > | |
| Ctpie::internal_priority_queue< tpie::ami::heap_ptr< REC >, comp > | |
| ►Ctpie::linear_memory_base< internal_queue< item_type > > | |
| Ctpie::internal_queue< item_type > | |
| ►Ctpie::linear_memory_base< internal_queue< memory_size_type > > | |
| Ctpie::internal_queue< memory_size_type > | |
| ►Ctpie::linear_memory_base< internal_queue< T > > | |
| Ctpie::internal_queue< T > | A generic internal circular queue |
| ►Ctpie::linear_memory_base< internal_stack< T > > | |
| ►Ctpie::internal_stack_vector_base< T, internal_stack< T > > | |
| Ctpie::internal_stack< T > | A generic internal stack |
| ►Ctpie::linear_memory_base< internal_vector< T > > | |
| ►Ctpie::internal_stack_vector_base< T, internal_vector< T > > | |
| Ctpie::internal_vector< T > | A generic internal vector |
| ►Ctpie::linear_memory_base< packed_array< T, B > > | |
| Ctpie::packed_array< T, B > | An array storring elements of type T using B bits to to store a element |
| Ctpie::linear_memory_structure_concept< T > | Check if a structure adheres to the linear_memory_structure concept |
| Ctpie::linear_memory_structure_doc | Description of the methods that must be implemented to support the linear_memory_structure_concept |
| Ctpie::linear_probing_hash_table< value_t, hash_t, equal_t, index_t > | Hash table handling hash collisions by linear probing |
| ►Clist_base_hook | |
| Ctpie::file_base::block_t | This is the type of our block buffers |
| Ctpie::log_group | RAII-style management for log groups |
| Ctpie::log_group_mode | |
| Ctpie::log_level_manip | |
| Ctpie::log_bits::log_selector | |
| ►Ctpie::log_target | |
| Ctpie::file_log_target | A simple logger that writes messages to a tpie temporary file |
| Ctpie::stderr_log_target | A simple logger that writes messages to stderr |
| Ctpie::magic_cast_help< src, dst > | |
| Ctpie::magic_cast_help< bool, std::string > | |
| Ctpie::magic_cast_help< std::string, bool > | |
| Ctpie::pipelining::bits::map_t< F > | |
| Ctpie::pipelining::bits::map_temp_t< F > | |
| Ctpie::maybe< T > | |
| Ctpie::maybe< tpie::file_stream< item_type > > | |
| Ctpie::maybe< tpie::file_stream< T > > | |
| Ctpie::maybe< tpie::stack< item_type > > | |
| Ctpie::maybe< tpie::tpie::temp_file > | |
| Ctpie::pipelining::bits::maybe_add_const_ref< T > | The maybe_add_const_ref helper struct adds const & to a type unless the type is already const, reference or pointer type |
| Ctpie::pipelining::bits::maybe_add_const_ref< const T & > | |
| Ctpie::pipelining::bits::maybe_add_const_ref< const T * > | |
| Ctpie::pipelining::bits::maybe_add_const_ref< T & > | |
| Ctpie::pipelining::bits::maybe_add_const_ref< T * > | |
| Ctpie::pipelining::bits::maybe_check_connected< fact_t > | Contains a method check that calls recursive_connected_check when fact_t is a pair factory, and otherwise does nothing |
| Ctpie::pipelining::bits::maybe_check_connected< pair_factory< fact1_t, fact2_t > > | For pair factories, recursively check that the nodes created share their node_map |
| Ctpie::pipelining::bits::maybe_check_connected< termpair_factory< fact1_t, termfact2_t > > | See pair_factory specialization |
| Ctpie::memory_bucket | Bucket used for memory counting |
| Ctpie::memory_bucket_ref | Class storring a reference to a memory bucket |
| Ctpie::ami::merge_heap_op< REC, comp_t > | A merge heap object base class - also serves as the full implementation for objects with a < comparison operator |
| ►Ctpie::ami::merge_heap_op< REC, Compare > | |
| Ctpie::ami::merge_heap_obj< REC, Compare > | |
| Ctpie::ami::merge_heap_ptr_op< REC, comp_t > | A record pointer heap base class - also serves as the full implementation for objects with a < comparison operator |
| ►Ctpie::ami::merge_heap_ptr_op< REC, CMPR > | |
| Ctpie::ami::merge_heap_ptr_obj< REC, CMPR > | A record pointer heap that uses a comparison object |
| Ctpie::merge_sorter< T, UseProgress, pred_t, store_t > | Merge sorting consists of three phases |
| Ctpie::pipelining::bits::merge_t< fact_t > | Merge a pull pipeline into a push pipeline |
| Ctpie::serialization_bits::merger< T, pred_t > | |
| Ctpie::merger< specific_store_t, pred_t > | |
| Ctpie::tiny::bits::MultiInsertHelp | When inserting allow elements with equivalest keys |
| Ctpie::no_key | |
| ►Ctpie::pipelining::node | Base class of all nodes |
| ►Ctpie::pipelining::parallel_bits::before< push_type< dest_t >::type > | |
| Ctpie::pipelining::parallel_bits::before_impl< dest_t > | Concrete before class |
| ►Ctpie::pipelining::parallel_bits::consumer< push_type< dest_t >::type > | |
| Ctpie::pipelining::parallel_bits::consumer_impl< Input, Output, dest_t > | Concrete consumer implementation |
| Ctpie::pipelining::parallel_bits::consumer< T2 > | |
| ►Ctpie::pipelining::bits::sort_output_base< push_type< dest_t >::type, pred_t, store_t > | |
| Ctpie::pipelining::bits::sort_output_t< pred_t, dest_t, store_t > | Pipe sorter push output node |
| Ctpie::pipelining::bits::ami_input_stack_t< dest_t > | |
| Ctpie::pipelining::bits::ami_input_t< dest_t > | |
| Ctpie::pipelining::bits::ami_output_t< T > | File_stream output terminator |
| Ctpie::pipelining::bits::ami_pull_input_stack_t< T > | |
| Ctpie::pipelining::bits::buffer_input_t< T > | Input node for buffer |
| Ctpie::pipelining::bits::buffer_output_t< dest_t > | Output node for buffer |
| Ctpie::pipelining::bits::buffer_pull_output_t< T > | |
| Ctpie::pipelining::bits::chunker_t< dest_t > | |
| Ctpie::pipelining::bits::count_consecutive_t< dest_t > | |
| Ctpie::pipelining::bits::dummydest_t< T > | |
| Ctpie::pipelining::bits::exclude_lambda_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::extract_first_t< dest_t > | |
| Ctpie::pipelining::bits::filter_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::fork_t< fact2_t >::type< dest_t > | |
| Ctpie::pipelining::bits::Forwarder< dest_t > | |
| Ctpie::pipelining::bits::input_t< dest_t > | File_stream input generator |
| Ctpie::pipelining::bits::input_vector_t< dest_t, T, A > | |
| Ctpie::pipelining::bits::internal_buffer_input_t< T > | |
| Ctpie::pipelining::bits::internal_buffer_pull_output_t< T > | |
| Ctpie::pipelining::bits::internal_reverser_input_t< T > | Input node for reverser stored in internal memory |
| Ctpie::pipelining::bits::internal_reverser_output_t< dest_t > | Output node for reverser stored in internal memory |
| Ctpie::pipelining::bits::internal_reverser_pull_output_t< T > | Output node for passive reverser stored in internal memory |
| Ctpie::pipelining::bits::item_type_t< T >::type< dest_t > | |
| Ctpie::pipelining::bits::lambda_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::linear_t< dest_t > | |
| Ctpie::pipelining::bits::map_sink_t< F > | |
| Ctpie::pipelining::bits::map_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::map_temp_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::merge_t< fact_t >::type< dest_t > | |
| Ctpie::pipelining::bits::named_input_t< dest_t > | |
| Ctpie::pipelining::bits::named_output_t< T > | File_stream output terminator |
| Ctpie::pipelining::bits::named_pull_input_t< T > | |
| Ctpie::pipelining::bits::null_sink_t< T > | |
| Ctpie::pipelining::bits::ostream_logger_t< dest_t > | |
| Ctpie::pipelining::bits::output_t< T > | File_stream output terminator |
| Ctpie::pipelining::bits::output_vector_t< T, A > | |
| Ctpie::pipelining::bits::preparer_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::printf_ints_t | |
| Ctpie::pipelining::bits::propagater_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::pull_fork_t< source_t, dest_fact_t > | |
| Ctpie::pipelining::bits::pull_input_iterator_t< IT > | |
| Ctpie::pipelining::bits::pull_input_t< T > | File_stream pull input generator |
| Ctpie::pipelining::bits::pull_input_vector_t< T, A > | |
| Ctpie::pipelining::bits::pull_output_iterator_t< IT >::type< dest_t > | |
| Ctpie::pipelining::bits::pull_output_t< source_t > | File_stream output pull data source |
| Ctpie::pipelining::bits::pull_peek_t< source_t > | |
| Ctpie::pipelining::bits::pull_reverse_input_t< T > | File_stream pull input generator |
| Ctpie::pipelining::bits::pull_source_t< fact_t >::type< dest_t > | |
| Ctpie::pipelining::bits::push_input_iterator_t< IT >::type< dest_t > | |
| Ctpie::pipelining::bits::push_output_iterator_t< Iterator, Item > | |
| Ctpie::pipelining::bits::push_output_iterator_t< Iterator, void > | |
| Ctpie::pipelining::bits::range_t< dest_t > | |
| Ctpie::pipelining::bits::reverser_input_t< T > | Input node for reverser stored in external memory |
| Ctpie::pipelining::bits::reverser_output_t< dest_t > | Output node for reverser stored in external memory |
| Ctpie::pipelining::bits::reverser_pull_output_t< T > | Output node for passive reverser stored in external memory |
| Ctpie::pipelining::bits::scanf_ints_t< dest_t > | |
| Ctpie::pipelining::bits::sort_calc_t< T, pred_t, store_t > | Pipe sorter middle node |
| Ctpie::pipelining::bits::sort_input_t< T, pred_t, store_t > | Pipe sorter input node |
| ►Ctpie::pipelining::bits::sort_output_base< T, pred_t, store_t > | |
| Ctpie::pipelining::bits::sort_pull_output_t< T, pred_t, store_t > | Pipe sorter pull output node |
| Ctpie::pipelining::bits::tee_t< dest_t, T > | |
| Ctpie::pipelining::bits::unique_t< dest_t, equal_t > | |
| Ctpie::pipelining::bits::unzip_t< fact2_t >::type< dest1_t > | |
| Ctpie::pipelining::bits::vfork_node< T >::type< dest_t > | |
| Ctpie::pipelining::bits::virtrecv< Output > | Virtual node that is injected into the end of a virtual chunk |
| Ctpie::pipelining::bits::virtsrc< Input > | Virtual base node that is injected into the beginning of a virtual chunk |
| Ctpie::pipelining::bits::visit_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::vpush_node< T > | |
| Ctpie::pipelining::bits::zero_source_t< T > | |
| Ctpie::pipelining::bits::zip_t< src_fact_t >::type< dest_t > | |
| Ctpie::pipelining::join< T >::sink_impl | |
| ►Ctpie::pipelining::join< T >::source_base | |
| Ctpie::pipelining::join< T >::source_impl< dest_t > | |
| ►Ctpie::pipelining::parallel_bits::after_base | Non-templated virtual base class of after |
| Ctpie::pipelining::parallel_bits::after< T > | Accepts output items and sends them to the main thread |
| Ctpie::pipelining::parallel_bits::before< T > | Accepts input items from the main thread and sends them down the pipeline |
| Ctpie::pipelining::parallel_bits::consumer< T > | Node running in main thread, accepting an output buffer from the managing producer and forwards them down the pipe |
| Ctpie::pipelining::parallel_bits::producer< T1, T2 > | Producer, running in main thread, managing the parallel execution |
| Ctpie::pipelining::serialization_bits::buffer_input_t< T > | |
| Ctpie::pipelining::serialization_bits::buffer_output_t< dest_t > | |
| Ctpie::pipelining::serialization_bits::buffer_pull_output_t< T > | |
| Ctpie::pipelining::serialization_bits::input_t< dest_t > | |
| Ctpie::pipelining::serialization_bits::output_t< T > | |
| Ctpie::pipelining::serialization_bits::reverser_input_t< T > | |
| Ctpie::pipelining::serialization_bits::reverser_output_t< dest_t > | |
| Ctpie::pipelining::serialization_bits::reverser_pull_output_t< T > | |
| Ctpie::pipelining::serialization_bits::sort_calc_t< Traits > | Pipe sorter middle node |
| Ctpie::pipelining::serialization_bits::sort_input_t< Traits > | Pipe sorter input node |
| ►Ctpie::pipelining::serialization_bits::sort_output_base< Traits > | |
| Ctpie::pipelining::serialization_bits::sort_output_t< Traits, dest_t > | Pipe sorter push output node |
| Ctpie::pipelining::serialization_bits::sort_pull_output_t< Traits > | Pipe sorter pull output node |
| Ctpie::pipelining::split< T >::sink_impl | |
| ►Ctpie::pipelining::split< T >::source_base | |
| Ctpie::pipelining::split< T >::source_impl< dest_t > | |
| Ctpie::pipelining::bits::virtsrc< Output > | |
| ►Ctpie::pipelining::bits::virtsrc< T > | |
| Ctpie::pipelining::bits::virtsrc_impl< dest_t, T > | Concrete implementation of virtsrc |
| Ctpie::pipelining::bits::node_map | |
| Ctpie::pipelining::node_parameters | |
| Ctpie::pipelining::node_resource_parameters | |
| Ctpie::pipelining::bits::node_set_content | |
| Ctpie::pipelining::node_token | |
| Ctpie::op2TPIE_cmp< T > | Convert a class with a comparison operator < to a TPIE comparison object with a compare() function |
| Ctpie::open | |
| Ctpie::bbits::Opt< O_, a_, b_, bs_, C_, K_, A_ > | |
| Ctpie::bbits::OptComp< Opt > | |
| Ctpie::bbits::OptComp< btree_augment< A >, T...> | |
| Ctpie::bbits::OptComp< btree_blocksize< bs >, T...> | |
| Ctpie::bbits::OptComp< btree_comp< C >, T...> | |
| Ctpie::bbits::OptComp< btree_fanout< a, b >, T...> | |
| Ctpie::bbits::OptComp< btree_key< K >, T...> | |
| Ctpie::bbits::OptComp< int_opt< i >, T...> | |
| Ctpie::bbits::OptComp<> | |
| Ctpie::pipelining::parallel_bits::options | User-supplied options to the parallelism framework |
| Ctpie::pipelining::serialization_bits::output_factory< T > | |
| Ctpie::packed_array_iter_facade< CT, forward, RT > | Base class for the iterators |
| Ctpie::packed_array_iter_facade< const_iter_base< forward >, forward, vssucks > | |
| Ctpie::packed_array_iter_facade< iter_base< forward >, forward, iter_return_type > | |
| Ctpie::pipelining::bits::pair_factory_base< child_t > | |
| ►Ctpie::pipelining::bits::pair_factory_base< pair_factory< fact1_t, fact2_t > > | |
| Ctpie::pipelining::bits::pair_factory< fact1_t, fact2_t > | |
| ►Ctpie::pipelining::bits::pair_factory_base< termpair_factory< fact1_t, termfact2_t > > | |
| Ctpie::pipelining::bits::termpair_factory< fact1_t, termfact2_t > | |
| Ctpie::tiny::bits::PairExtract< A, B > | Extract the first element of a pair as the key |
| Ctpie::pipelining::parallel_bits::parallel_input_buffer< T > | Instantiated in each thread |
| Ctpie::pipelining::parallel_bits::parallel_input_buffer< push_type< dest_t >::type > | |
| Ctpie::pipelining::parallel_bits::parallel_input_buffer< T1 > | |
| Ctpie::pipelining::parallel_bits::parallel_output_buffer< T > | Instantiated in each thread |
| Ctpie::pipelining::parallel_bits::parallel_output_buffer< T2 > | |
| Ctpie::parallel_sort_impl< iterator_type, comp_type, Progress, min_size > | A simple parallel sort implementation with progress tracking |
| Ctpie::pipelining::passive_buffer< T > | Plain old file_stream buffer |
| Ctpie::pipelining::passive_reverser< T > | A passive reverser stored in external memory |
| Ctpie::pipelining::passive_serialization_buffer< T > | Serialization stream buffer |
| Ctpie::pipelining::passive_serialization_reverser< T > | A passive serialization reverser stored in external memory |
| Ctpie::pipelining::passive_sorter< T, pred_t, store_t > | Pipelined sorter with push input and pull output |
| ►Ctpie::pipelining::bits::pipe_base< child_t > | |
| Ctpie::pipelining::bits::pipe_nonterm_base< child_t > | |
| Ctpie::pipelining::bits::pipe_term_base< child_t, fact_t > | |
| ►Ctpie::pipelining::bits::pipe_base< empty_pipe_middle > | |
| ►Ctpie::pipelining::bits::pipe_nonterm_base< empty_pipe_middle > | |
| Ctpie::pipelining::empty_pipe_middle | A empty_pipe_middle class has no effect |
| ►Ctpie::pipelining::bits::pipe_base< pipe_begin< fact_t > > | |
| ►Ctpie::pipelining::bits::pipe_nonterm_base< pipe_begin< fact_t > > | |
| Ctpie::pipelining::pipe_begin< fact_t > | |
| ►Ctpie::pipelining::bits::pipe_base< pipe_end< fact_t > > | |
| ►Ctpie::pipelining::bits::pipe_term_base< pipe_end< fact_t >, fact_t > | |
| Ctpie::pipelining::pipe_end< fact_t > | |
| ►Ctpie::pipelining::bits::pipe_base< pipe_middle< fact_t > > | |
| ►Ctpie::pipelining::bits::pipe_nonterm_base< pipe_middle< fact_t > > | |
| Ctpie::pipelining::pipe_middle< fact_t > | A pipe_middle class pushes input down the pipeline |
| ►Ctpie::pipelining::bits::pipe_base< pullpipe_begin< fact_t > > | |
| ►Ctpie::pipelining::bits::pipe_term_base< pullpipe_begin< fact_t >, fact_t > | |
| Ctpie::pipelining::pullpipe_begin< fact_t > | |
| ►Ctpie::pipelining::bits::pipe_base< pullpipe_end< fact_t > > | |
| ►Ctpie::pipelining::bits::pipe_nonterm_base< pullpipe_end< fact_t > > | |
| Ctpie::pipelining::pullpipe_end< fact_t > | |
| ►Ctpie::pipelining::bits::pipe_base< pullpipe_middle< fact_t > > | |
| ►Ctpie::pipelining::bits::pipe_nonterm_base< pullpipe_middle< fact_t > > | |
| Ctpie::pipelining::pullpipe_middle< fact_t > | |
| Ctpie::pipelining::bits::node_map::pipe_base_forward_t | |
| Ctpie::pipelining::pipeline | This class is used to avoid writing the template argument in the pipeline_impl type |
| ►Ctpie::pipelining::bits::pipeline_base_base | |
| ►Ctpie::pipelining::bits::pipeline_base | Virtual superclass for pipelines and subpipelines |
| Ctpie::pipelining::bits::pipeline_impl< fact_t > | |
| ►Ctpie::pipelining::bits::virtual_chunk_base | Base class of virtual chunks. Owns a virt_node |
| Ctpie::pipelining::virtual_chunk< Input, Output > | Virtual chunk that has input and output |
| Ctpie::pipelining::virtual_chunk_begin< Output > | Virtual chunk that has no input (that is, virtual producer) |
| Ctpie::pipelining::virtual_chunk_end< Input > | Virtual chunk that has no output (that is, virtual consumer) |
| ►Ctpie::pipelining::bits::subpipeline_base | |
| ►Ctpie::pipelining::bits::subpipeline_virt< item_type > | |
| Ctpie::pipelining::bits::subpipeline_impl< item_type, fact_t > | |
| Ctpie::plain_store | Plain old store |
| Ctpie::pointer_store | Sort elements using pointer indirection |
| Ctpie::file_accessor::posix | POSIX-style file accessor |
| Ctpie::pq_merge_heap< T, Comparator > | |
| Ctpie::pq_overflow_heap< T, Comparator > | Overflow Priority Queue, based on a simple Heap |
| Ctpie::pipelining::serialization_bits::default_pred_sort_factory::predicate< item_type > | |
| Ctpie::pipelining::serialization_bits::sort_factory< pred_t >::predicate< Dummy > | |
| Ctpie::pipelining::bits::default_pred_sort_factory< store_t >::predicate< item_type > | |
| Ctpie::pipelining::bits::sort_factory< pred_t, store_t >::predicate< Dummy > | |
| Ctpie::merger< specific_store_t, pred_t >::predwrap | |
| Ctpie::pipelining::bits::preparer_t< F > | |
| Ctpie::bits::pretty_print | |
| Ctpie::priority_queue< T, Comparator, OPQType > | External memory priority queue implementation |
| ►Ctpie::progress_indicator_base | The base class for indicating the progress of some task |
| Ctpie::pipelining::bits::proxy_progress_indicator | |
| Ctpie::progress_indicator_null | Dummy progress indicator that produces no output |
| ►Ctpie::progress_indicator_subindicator | |
| Ctpie::fractional_subindicator | Subindicator for fractional progress reporting |
| ►Ctpie::progress_indicator_terminal | A class that indicates the progress by a simple counter that is printed to the terminal |
| Ctpie::progress_indicator_arrow | A class that indicates the progress by expanding an arrow |
| Ctpie::progress_indicator_spin | A class that indicates the progress by a spinning cross |
| Ctpie::progress_types< use_progress > | 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 |
| Ctpie::progress_types< false > | |
| Ctpie::pipelining::bits::propagater_t< F > | |
| Ctpie::ptime | |
| Ctpie::pipelining::bits::pull_output_iterator_t< IT > | |
| Ctpie::pipelining::bits::pull_source_t< fact_t > | |
| Ctpie::pipelining::bits::pull_tee_t< source_t, T > | |
| Ctpie::pipelining::bits::pull_traits< T > | |
| Ctpie::pipelining::bits::pull_traits< RetType(ClassType::*)() > | |
| Ctpie::pipelining::pull_type< T, default_type > | |
| Ctpie::pipelining::pull_type< source_t > | |
| Ctpie::pipelining::bits::pull_type_help< T, default_type, has_push_method, has_item_type > | |
| Ctpie::pipelining::bits::pull_type_help< T, default_type, has_pull_method, true > | |
| Ctpie::pipelining::bits::pull_type_help< T, default_type, true, false > | |
| Ctpie::pipelining::bits::push_input_iterator_t< IT > | |
| Ctpie::pipelining::bits::push_traits< T > | |
| Ctpie::pipelining::bits::push_traits< void(ClassType::*)(ArgType) > | |
| Ctpie::pipelining::push_type< T, default_type > | Class to deduce the item_type of a node of type T |
| Ctpie::pipelining::push_type< dest_t > | |
| Ctpie::pipelining::bits::push_type_help< T, default_type, has_push_method, has_item_type > | |
| Ctpie::pipelining::bits::push_type_help< T, default_type, has_push_method, true > | |
| Ctpie::pipelining::bits::push_type_help< T, default_type, true, false > | |
| Ctpie::ami::qsort_item< Key > | A simple class that facilitates doing key sorting followed by in-memory permuting to sort items in-memory |
| Ctpie::queue< T > | Basic Implementation of I/O Efficient FIFO queue |
| Ctpie::read_direction | Class enum designating a read/write direction |
| Ctpie::allocator< T >::rebind< U > | |
| Ctpie::reflect_sfinae< T > | |
| Ctpie::reflect_tag_array_read | |
| Ctpie::reflect_tag_array_write | |
| Ctpie::reflect_tag_compute< direct, trivial_array_read, array_read, trivial_array_write, push_back_array_write, array_write > | |
| Ctpie::reflect_tag_compute< false, false, false, false, false, true > | |
| Ctpie::reflect_tag_compute< false, false, false, false, true, array_write > | |
| Ctpie::reflect_tag_compute< false, false, false, true, push_back_array_write, array_write > | |
| Ctpie::reflect_tag_compute< false, false, true, false, false, false > | |
| Ctpie::reflect_tag_compute< false, true, array_read, false, false, false > | |
| Ctpie::reflect_tag_compute< true, trivial_array_read, array_read, trivial_array_write, push_back_array_write, array_write > | |
| Ctpie::reflect_tag_direct | |
| Ctpie::reflect_tag_impl | |
| Ctpie::reflect_tag_push_back_array_write | |
| Ctpie::reflect_tag_trivial_array_read | |
| Ctpie::reflect_tag_trivial_array_write | |
| Ctpie::pipelining::bits::remove< T > | |
| Ctpie::pipelining::bits::remove< const T > | |
| Ctpie::pipelining::bits::remove< T & > | |
| Ctpie::pipelining::bits::remove< T && > | |
| Ctpie::bits::remove_pointer< T > | |
| Ctpie::bits::remove_pointer< T * > | |
| ►Ctpie::request_base | Base class for read_request and write_request |
| Ctpie::read_request | |
| Ctpie::write_request | |
| ►Ctpie::resource_manager | Resource management object used to track resource usage |
| Ctpie::file_manager | File management object used to track file usage |
| Ctpie::memory_manager | Memory management object used to track memory usage |
| Ctpie::bits::run_positions | Class to maintain the positions where sorted runs start |
| Ctpie::pipelining::bits::runtime | Execute the pipeline contained in a node_map |
| Ctpie::scoped_log_enabler | |
| Ctpie::compressed_stream_base::seek_state | |
| Ctpie::pipelining::serialization_passive_sorter< T, pred_t > | Pipelined sorter with push input and pull output |
| ►Ctpie::bits::serialization_reader_base | |
| Ctpie::serialization_reader | |
| Ctpie::serialization_reverse_reader | |
| Ctpie::serialization_sorter< T, pred_t > | |
| ►Ctpie::bits::serialization_writer_base | |
| Ctpie::serialization_reverse_writer | |
| Ctpie::serialization_writer | |
| Ctpie::bbits::serialized_store< T, A, a, b, bs > | Serializing store |
| Ctpie::serializer | Class providing binary serialization to a std::ostream |
| Ctpie::serialization_writer::serializer | |
| Ctpie::serialization_reverse_writer::serializer | |
| Ctpie::tiny::set_impl< T, Key, KeyExtract, Comp, Alloc, InsertHelp > | Class implementing a tiny::set, tiny::multiset, and tiny::multimap |
| ►Ctpie::tiny::set_impl< std::pair< Key, T >, T, bits::PairExtract< Key, T >, Comp, Alloc, bits::SingleInsertHelp > | |
| Ctpie::tiny::map< Key, T, Comp, Alloc > | A std::map compatible map, useful when we do not have many elements (less then 512) |
| Ctpie::sign< T > | |
| Ctpie::sign< uint16_t > | |
| Ctpie::sign< uint32_t > | |
| Ctpie::sign< uint64_t > | |
| Ctpie::sign< uint8_t > | |
| Ctpie::tiny::bits::SingleInsertHelp | When inserting do not allow elements with equivalest keys |
| Ctpie::sort_manager< T, I, M > | A class of manager objects for merge sorting objects of type T |
| Ctpie::sort_parameters | |
| Ctpie::serialization_bits::sort_parameters | |
| Ctpie::pipelining::serialization_bits::sorter_traits< T, pred_t > | |
| Ctpie::explicit_tpie_pointer_store::specific< element_t > | |
| Ctpie::explicit_tpie_unique_pointer_store::specific< element_t > | |
| ►Ctpie::pointer_store::specific< element_t > | |
| Ctpie::bits::dynamic_specific_selector< element_t, true > | |
| ►Ctpie::plain_store::specific< element_t > | |
| ►Ctpie::bits::dynamic_specific_selector< element_t > | |
| Ctpie::dynamic_store::specific< element_t > | |
| Ctpie::bits::dynamic_specific_selector< element_t, bool > | |
| Ctpie::pipelining::split< T > | Split one push streams into multiple |
| Ctpie::stack< T > | An implementation of an external-memory stack |
| Ctpie::ami::stack< T > | An implementation of an external-memory stack compatible with the old AMI interface |
| Ctpie::ami::stack< item_type > | |
| Ctpie::stack< item_type > | |
| Ctpie::stack< tpie::blocks::block_handle > | |
| Ctpie::stat_timer | |
| ►Ctpie::pipelining::parallel_bits::state_base | Common state in parallel pipelining library |
| Ctpie::pipelining::parallel_bits::state< T1, T2 > | State subclass containing the item type specific state, i.e |
| Ctpie::STL2TPIE_cmp< T, STLCMP > | Convert STL comparison object with operator() to a TPIE comparison object with a compare() function |
| Ctpie::bits::store_pred< pred_t, specific_store_t > | |
| Ctpie::ami::stream< T > | |
| Ctpie::ami::stream< item_type > | |
| ►Ctpie::file_accessor::stream_accessor_base< file_accessor_t > | |
| Ctpie::file_accessor::byte_stream_accessor< file_accessor_t > | |
| Ctpie::file_accessor::stream_accessor< file_accessor_t > | |
| ►Ctpie::file_accessor::stream_accessor_base< tpie::file_accessor::posix > | |
| Ctpie::file_accessor::byte_stream_accessor< tpie::file_accessor::posix > | |
| Ctpie::stream_buffer_pool | Pool of shared buffers |
| Ctpie::stream_buffers | Buffer manager for a single stream |
| Ctpie::stream_crtp< child_t > | |
| ►Ctpie::stream_crtp< file_stream_base > | |
| Ctpie::file_stream_base | |
| ►Ctpie::stream_crtp< stream > | |
| ►Ctpie::file_base::stream | Stream in file. We support multiple streams per file |
| Ctpie::file< T >::stream | Central stream abstraction |
| Ctpie::stream_header_t | |
| Ctpie::ami::stream_old< T > | A Stream<T> object stores an ordered collection of objects of type T on external memory |
| Ctpie::stream_position | POD object indicating the position of an item in a stream |
| Ctpie::pipelining::subpipeline< item_type > | |
| Ctpie::sysinfo | Class providing system and platform info |
| Ctpie::temp_file | Class representing a reference to a temporary file |
| Ctpie::bits::temp_file_inner | |
| Ctpie::template_log< t > | Computes the least integer strictly greater than log(t) |
| Ctpie::template_log< 1 > | |
| Ctpie::tempname | Static methods for generating temporary file names and finding temporary file directories |
| Ctpie::bits::test_runner | |
| Ctpie::testmanip< TP > | |
| Ctpie::tests | |
| Ctpie::pipelining::tfactory< R, Args, T > | Node factory for variadic argument terminators |
| ►Ctpie::pipelining::parallel_bits::threads< Input, Output > | Class containing an array of node instances |
| Ctpie::pipelining::parallel_bits::threads_impl< Input, Output, fact_t > | Subclass of threads instantiating and managing the pipelines |
| Ctpie::pipelining::parallel_bits::threads< T1, T2 > | |
| Ctpie::TPIE2STL_cmp< T, TPCMP > | Convert a TPIE comparison object with a compare() function to STL comparison object with operator() |
| Ctpie::tpie_deleter | |
| Ctpie::bbits::tree< T, O > | Augmented btree |
| Ctpie::bbits::tree_state< T, O > | |
| Ctpie::trivial_same_size< C > | |
| Ctpie::tiny::bits::MultiInsertHelp::type< Inner > | |
| Ctpie::tiny::bits::SingleInsertHelp::type< Inner > | |
| Ctpie::pipelining::bits::unary_traits_imp< T > | |
| ►Ctpie::pipelining::bits::unary_traits_imp< decltype(&T::operator()) > | |
| Ctpie::pipelining::bits::unary_traits< T > | |
| Ctpie::pipelining::bits::unary_traits_imp< R(*)(A)> | |
| Ctpie::pipelining::bits::unary_traits_imp< R(C::*)(A) const > | |
| Ctpie::pipelining::bits::unary_traits_imp< R(C::*)(A)> | |
| Ctpie::unique_id_type | |
| Ctpie::unserializer | Class for unserializing binary data serialized with the serializer Data can be unserialized using the >> operators |
| Ctpie::unsign< T > | |
| Ctpie::unsign< int16_t > | |
| Ctpie::unsign< int32_t > | |
| Ctpie::unsign< int64_t > | |
| Ctpie::unsign< int8_t > | |
| Ctpie::pipelining::bits::unzip_t< fact2_t > | |
| Ctpie::tiny::set_impl< T, Key, KeyExtract, Comp, Alloc, InsertHelp >::value_compare | |
| Ctpie::pipelining::bits::vfork_node< T > | |
| Ctpie::pipelining::bits::virt_node | Ownership of nodes |
| Ctpie::pipelining::virtual_container | Virtual base class for extra data to go with virtual chunks |
| Ctpie::pipelining::bits::visit_t< F > | |
| Ctpie::file_accessor::win32 | Win32 file accessor |
| Ctpie::pipelining::bits::zip_t< src_fact_t > | |