| ►C_disjunction | |
| Ctpie::disjunction< T1, T2 > | Class to compute the disjunction between two boost true/false types |
| 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::bits::any_type | |
| Ctpie::array_allocation_scope_magic< T > | |
| Ctpie::bits::array_decode_magic< D, T, is_simple_itr, is_pod, is_pointer > | Helper to facilitate fast unserialization of trivially copyable arrays |
| Ctpie::bits::array_decode_magic< D, T, true, true, false > | |
| Ctpie::bits::array_encode_magic< D, T, is_simple_itr, is_pod, is_pointer > | Helper to facilitate fast serialization of trivially copyable arrays |
| Ctpie::bits::array_encode_magic< D, T, true, true, false > | |
| ►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) |
| Ctpie::auto_ptr< T > | Like std::auto_ptr, but delete the object with tpie_delete |
| Ctpie::auto_ptr< OPQType > | |
| Ctpie::auto_ptr< tpie::temp_file > | |
| Ctpie::auto_ptr_ref< T > | |
| ►Cbasic_streambuf | |
| Ctpie::log_stream_buf | |
| Ctpie::teststream_buf | |
| ►Cbinary_function | |
| Ctpie::binary_argument_swap< comp > | |
| Ctpie::binary_argument_swap< comp_t > | |
| Ctpie::binary_argument_swap< Comparator > | |
| Ctpie::binary_argument_swap< tpie::merger::predwrap > | |
| Ctpie::binary_argument_swap< T > | A binary functor with the arguments swapped |
| Ctpie::file_stream_base::block_t | |
| Ctpie::chaining_hash_table< value_t, hash_t, equal_t, index_t > | Hash table handling hash collisions by chaining |
| Ctpie::pipelining::factory_0< R >::constructed< dest_t > | |
| Ctpie::pipelining::tempfactory_0< Holder >::constructed< dest_t > | |
| Ctpie::pipelining::factory_1< R, T1 >::constructed< dest_t > | |
| Ctpie::pipelining::tempfactory_1< Holder, T1 >::constructed< dest_t > | |
| Ctpie::pipelining::factory_2< R, T1, T2 >::constructed< dest_t > | |
| Ctpie::pipelining::tempfactory_2< Holder, T1, T2 >::constructed< dest_t > | |
| Ctpie::pipelining::factory_3< R, T1, T2, T3 >::constructed< dest_t > | |
| Ctpie::pipelining::tempfactory_3< Holder, T1, T2, T3 >::constructed< dest_t > | |
| Ctpie::pipelining::factory_4< R, T1, T2, T3, T4 >::constructed< dest_t > | |
| Ctpie::pipelining::tempfactory_4< Holder, T1, T2, T3, T4 >::constructed< dest_t > | |
| Ctpie::pipelining::factory_5< R, T1, T2, T3, T4, T5 >::constructed< dest_t > | |
| Ctpie::pipelining::tempfactory_5< Holder, T1, T2, T3, T4, T5 >::constructed< dest_t > | |
| Ctpie::pipelining::factory_6< R, T1, T2, T3, T4, T5, T6 >::constructed< dest_t > | |
| Ctpie::pipelining::tempfactory_6< Holder, T1, T2, T3, T4, T5, T6 >::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::serialization_bits::sort_factory_base< child_t >::constructed< dest_t > | |
| Ctpie::pipelining::bits::sort_factory_base< child_t >::constructed< dest_t > | |
| Ctpie::bits::counter | Helper to count the serialized size of objects |
| Ctpie::cpu_timer | |
| Ctpie::default_unused< T > | |
| Ctpie::default_unused< std::pair< T1, T2 > > | |
| 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 |
| ►Cstd::exception | STL class |
| ►Cstd::bad_alloc | STL class |
| Ctpie::out_of_memory_error | Thrown when trying to allocate too much memory |
| ►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::merge_sort_not_ready | |
| 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 | |
| Ctpie::tempfile_error | |
| Ctpie::pipelining::bits::exclude_lambda_t< F > | |
| Ctpie::execution_time_predictor | |
| ►Ctpie::pipelining::factory_base | |
| Ctpie::pipelining::serialization_bits::sort_factory_base< default_pred_sort_factory > | |
| ►Ctpie::pipelining::bits::sort_factory_base< default_pred_sort_factory > | |
| Ctpie::pipelining::bits::default_pred_sort_factory | 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 > > | |
| Ctpie::pipelining::bits::passive_sorter_factory< T, pred_t > | Factory for the passive sorter input node |
| Ctpie::pipelining::bits::passive_sorter_factory_2< T, pred_t > | Factory for the passive sorter output node |
| ►Ctpie::pipelining::bits::sort_factory_base< child_t > | |
| Ctpie::pipelining::bits::sort_factory< pred_t > | Sort factory using the given predicate as comparator |
| Ctpie::pipelining::factory_0< R > | Node factory for 0-argument generator |
| Ctpie::pipelining::factory_1< R, T1 > | Node factory for 1-argument generator |
| Ctpie::pipelining::factory_2< R, T1, T2 > | Node factory for 2-argument generator |
| Ctpie::pipelining::factory_3< R, T1, T2, T3 > | Node factory for 3-argument generator |
| Ctpie::pipelining::factory_4< R, T1, T2, T3, T4 > | Node factory for 4-argument generator |
| Ctpie::pipelining::factory_5< R, T1, T2, T3, T4, T5 > | Node factory for 5-argument generator |
| Ctpie::pipelining::factory_6< R, T1, T2, T3, T4, T5, T6 > | Node factory for 6-argument generator |
| Ctpie::pipelining::parallel_bits::factory< fact_t > | Factory instantiating a parallel multithreaded pipeline |
| Ctpie::pipelining::serialization_bits::passive_sorter_factory< Traits > | Factory for the passive sorter input node |
| Ctpie::pipelining::serialization_bits::passive_sorter_factory_2< Traits > | Factory for the passive sorter output node |
| ►Ctpie::pipelining::serialization_bits::sort_factory_base< child_t > | |
| Ctpie::pipelining::serialization_bits::default_pred_sort_factory | Sort factory using std::less<T> as comparator |
| Ctpie::pipelining::tempfactory_0< Holder > | Node factory for 0-argument templated generator |
| Ctpie::pipelining::tempfactory_1< Holder, T1 > | Node factory for 1-argument templated generator |
| Ctpie::pipelining::tempfactory_2< Holder, T1, T2 > | Node factory for 2-argument templated generator |
| Ctpie::pipelining::tempfactory_3< Holder, T1, T2, T3 > | Node factory for 3-argument templated generator |
| Ctpie::pipelining::tempfactory_4< Holder, T1, T2, T3, T4 > | Node factory for 4-argument templated generator |
| Ctpie::pipelining::tempfactory_5< Holder, T1, T2, T3, T4, T5 > | Node factory for 5-argument templated generator |
| Ctpie::pipelining::tempfactory_6< Holder, T1, T2, T3, T4, T5, T6 > | Node factory for 6-argument templated generator |
| Ctpie::pipelining::termfactory_0< R > | Node factory for 0-argument terminator |
| Ctpie::pipelining::termfactory_1< R, T1 > | Node factory for 1-argument terminator |
| Ctpie::pipelining::termfactory_2< R, T1, T2 > | Node factory for 2-argument terminator |
| Ctpie::pipelining::termfactory_3< R, T1, T2, T3 > | Node factory for 3-argument terminator |
| Ctpie::pipelining::termfactory_4< R, T1, T2, T3, T4 > | Node factory for 4-argument terminator |
| Ctpie::pipelining::termfactory_5< R, T1, T2, T3, T4, T5 > | Node factory for 5-argument terminator |
| Ctpie::pipelining::termfactory_6< R, T1, T2, T3, T4, T5, T6 > | Node factory for 6-argument terminator |
| ►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::file_stream< item_type > | |
| Ctpie::file_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::fork_t< fact2_t > | |
| Ctpie::fractional_progress | Fractional progress reporter |
| Ctpie::get_arg_help< T > | |
| Ctpie::get_arg_help< bool > | |
| Ctpie::pipelining::bits::graph_traits | Compute phases and execute pipelining program |
| Ctpie::hash< T > | Default 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::hash_set< key_t, hash_t, equal_t, index_t, table_t > | Hash set implementation backed by a template parameterized hash table |
| 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::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() |
| ►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_trivially_serializable< T > | |
| Ctpie::is_trivially_serializable_enable_if< bool > | |
| Ctpie::is_trivially_serializable_enable_if< true > | |
| 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::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::pipelining::bits::lambda_t< F > | |
| ►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< dest_t::item_type > > | |
| Ctpie::array< dest_t::item_type > | |
| ►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< size_t > > | |
| Ctpie::array< size_t > | |
| ►Ctpie::linear_memory_base< array< std::pair< T, size_t > > > | |
| Ctpie::array< std::pair< T, size_t > > | |
| ►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::file_stream< T > > > | |
| Ctpie::array< tpie::file_stream< T > > | |
| ►Ctpie::linear_memory_base< array< tpie::pipelining::parallel_bits::parallel_input_buffer< dest_t::item_type > * > > | |
| Ctpie::array< tpie::pipelining::parallel_bits::parallel_input_buffer< dest_t::item_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::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< internal_priority_queue< std::pair< T, size_t >, tpie::merger::predwrap > > | |
| Ctpie::internal_priority_queue< std::pair< T, 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< 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_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::logmanip< TP > | The logmanip template is based on the omanip template from iomanip.h in the libg++ sources |
| Ctpie::magic_cast_help< src, dst > | |
| Ctpie::magic_cast_help< bool, std::string > | |
| Ctpie::magic_cast_help< std::string, bool > | |
| 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_manager | Memory management object used to track memory usage |
| Ctpie::ami::merge_base< T > | Superclass for merge management objects |
| 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 > | Merge sorting consists of three phases |
| Ctpie::pipelining::bits::merge_t< fact_t > | Merge a pull pipeline into a push pipeline |
| Ctpie::merger< T, pred_t > | |
| Ctpie::serialization_bits::merger< T, pred_t > | |
| ►Ctpie::pipelining::node | Base class of all nodes |
| ►Ctpie::pipelining::parallel_bits::before< dest_t::item_type > | |
| Ctpie::pipelining::parallel_bits::before_impl< dest_t > | Concrete before class |
| ►Ctpie::pipelining::parallel_bits::consumer< dest_t::item_type > | |
| Ctpie::pipelining::parallel_bits::consumer_impl< Input, Output, dest_t > | Concrete consumer implementation |
| Ctpie::pipelining::parallel_bits::consumer< T2 > | |
| Ctpie::pipelining::bits::delayed_buffer_input_t< item_type > | |
| Ctpie::pipelining::bits::dummydest_t< item_type > | |
| Ctpie::pipelining::serialization_bits::rev_output_t< output_dest_t > | |
| Ctpie::pipelining::bits::reverser_input_t< item_type > | |
| ►Ctpie::pipelining::bits::sort_output_base< dest_t::item_type, pred_t > | |
| Ctpie::pipelining::bits::sort_output_t< pred_t, dest_t > | Pipe sorter push output node |
| ►Ctpie::pipelining::bits::sort_output_base< item_type, pred_t > | |
| Ctpie::pipelining::bits::sort_pull_output_t< item_type, pred_t > | |
| Ctpie::pipelining::bits::bitbucket_t< T > | |
| Ctpie::pipelining::bits::buffer_input_t< T > | Input node for buffer |
| Ctpie::pipelining::bits::buffer_pull_output_t< T > | |
| Ctpie::pipelining::bits::count_consecutive_t< dest_t > | |
| Ctpie::pipelining::bits::delayed_buffer_input_t< T > | Input node for delayed buffer |
| Ctpie::pipelining::bits::delayed_buffer_output_t< dest_t > | Output node for delayed buffer |
| 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::fork_t< fact2_t >::type< dest_t > | |
| Ctpie::pipelining::bits::identity_t< dest_t > | |
| Ctpie::pipelining::bits::input_t< dest_t > | File_stream input generator |
| Ctpie::pipelining::bits::input_vector_t< dest_t > | |
| Ctpie::pipelining::bits::lambda_t< F >::type< dest_t > | |
| Ctpie::pipelining::bits::linear_t< dest_t > | |
| Ctpie::pipelining::bits::merge_t< fact_t >::type< dest_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 > | |
| Ctpie::pipelining::bits::printf_ints_t | |
| Ctpie::pipelining::bits::pull_identity_t< source_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_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_to_push< pullfact_t >::pusher_t< 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::push_to_pull< pushfact_t >::puller_t< source_t > | |
| Ctpie::pipelining::bits::reverser_input_t< T > | |
| Ctpie::pipelining::bits::reverser_output_t< dest_t > | |
| Ctpie::pipelining::bits::reverser_t< dest_t > | |
| Ctpie::pipelining::bits::scanf_ints_t< dest_t > | |
| Ctpie::pipelining::bits::sort_calc_t< T, pred_t > | Pipe sorter middle node |
| Ctpie::pipelining::bits::sort_input_t< T, pred_t > | Pipe sorter input node |
| ►Ctpie::pipelining::bits::sort_output_base< T, pred_t > | |
| Ctpie::pipelining::bits::sort_pull_output_t< T, pred_t > | Pipe sorter pull output node |
| Ctpie::pipelining::bits::tee_t< 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::delayed_buffer_t< 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::passive_reverser< T >::sink_t | |
| Ctpie::pipelining::passive_reverser< T >::source_t< dest_t > | |
| Ctpie::pipelining::serialization_bits::input_t< dest_t > | |
| Ctpie::pipelining::serialization_bits::output_t< T > | |
| Ctpie::pipelining::serialization_bits::rev_input_t< rev_output_t< output_dest_t > > | |
| Ctpie::pipelining::serialization_bits::rev_output_t< dest_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::bits::virtsrc< dest_t::item_type > | |
| Ctpie::pipelining::bits::virtsrc_impl< dest_t > | Concrete implementation of virtsrc |
| Ctpie::pipelining::bits::virtsrc< Output > | |
| Ctpie::pipelining::bits::node_map | |
| Ctpie::pipelining::node_token | |
| ►Cnoncopyable | |
| Ctpie::temp_file | Class representing the existence of a temporary file |
| Ctpie::op2TPIE_cmp< T > | Convert a class with a comparison operator < to a TPIE comparison object with a compare() function |
| 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::pipelining::parallel_bits::parallel_input_buffer< T > | Instantiated in each thread |
| Ctpie::pipelining::parallel_bits::parallel_input_buffer< dest_t::item_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 > | |
| Ctpie::pipelining::passive_sorter< T, pred_t > | Pipelined sorter with push input and pull output |
| Ctpie::pipelining::passive_sorter< Traits > | |
| Ctpie::pipelining::bits::phase | Management of a single pipelining phase |
| ►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< 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::pipeline | This class is used to avoid writing the template argument in the pipeline_impl type |
| ►Ctpie::pipelining::bits::pipeline_base | Virtual superclass for pipelines implementing the function call operator |
| 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::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::predicate< item_type > | |
| Ctpie::pipelining::bits::sort_factory< pred_t >::predicate< Dummy > | |
| Ctpie::merger< T, pred_t >::predwrap | |
| 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::pull_output_iterator_t< IT > | |
| Ctpie::pipelining::bits::pull_to_push< pullfact_t > | |
| Ctpie::pipelining::bits::push_input_iterator_t< IT > | |
| Ctpie::pipelining::bits::push_to_pull< pushfact_t > | |
| 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::allocator< T >::rebind< U > | |
| Ctpie::pipelining::serialization_bits::rev_input_t< typename > | |
| Ctpie::scoped_log_enabler | |
| 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_sort< T, pred_t > | |
| ►Ctpie::bits::serialization_writer_base | |
| Ctpie::serialization_reverse_writer | |
| Ctpie::serialization_writer | |
| Ctpie::serializer | Class providing binary serialization to a std::ostream |
| Ctpie::sign< T > | |
| Ctpie::sign< uint16_t > | |
| Ctpie::sign< uint32_t > | |
| Ctpie::sign< uint64_t > | |
| Ctpie::sign< uint8_t > | |
| Ctpie::sort_manager< T, I, M > | A class of manager objects for merge sorting objects of type T |
| Ctpie::serialization_bits::sort_parameters | |
| Ctpie::sort_parameters | |
| Ctpie::pipelining::serialization_bits::sorter_traits< T, pred_t > | |
| 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::stack< item_type > | |
| ►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::ami::stream< T > | A Stream<T> object stores an ordered collection of objects of type T on external memory |
| Ctpie::file_accessor::stream_accessor< file_accessor_t > | |
| ►Ctpie::stream_crtp< child_t > | |
| ►Ctpie::file_base::stream | Stream in file. We support multiple streams per file |
| Ctpie::file< T >::stream | Central stream abstraction |
| Ctpie::file_stream_base | |
| Ctpie::stream_crtp< file_stream_base > | |
| Ctpie::stream_crtp< stream > | |
| Ctpie::stream_header_t | |
| Ctpie::sysinfo | Class providing system and platform info |
| Ctpie::pipelining::bits::tee_t< T > | |
| 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::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::trivial_same_size< C > | |
| 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::virt_node | Ownership of nodes |
| Ctpie::pipelining::virtual_container | Virtual base class for extra data to go with virtual chunks |
| Ctpie::file_accessor::win32 | Win32 file accessor |