  stxxl::addressable_fifo_queue< swappable_block_identifier_type > | |
| stxxl::addressable_priority_queue< swappable_block_identifier_type, stxxl::block_scheduler_algorithm_offline_lfd::priority > | |
| stxxl::BID< block_size > | |
| stxxl::BID< BlockSize > | |
| stxxl::BID< raw_size > | |
 stxxl::btree::btree_iterator_base< self_type > | |
  stxxl::btree::btree_iterator< self_type > | |
| stxxl::choose_int_types< my_pointer_size > | |
| stxxl::compat_hash_map< bid_type, busy_entry, bid_hash > | |
| stxxl::compat_hash_map< bid_type, unsigned_type, bid_hash > | |
| stxxl::compat_hash_multimap< internal_size_type, iterator_base *, hasher > | |
| stxxl::compat_unique_ptr< buf_istream_type > | |
| stxxl::compat_unique_ptr< stxxl::completion_handler_impl > | |
| stxxl::compat_unique_ptr< stxxl::stxxl::io_error > | |
| stxxl::counting_ptr< request > | |
| stxxl::counting_ptr< sorted_runs_data_type > | |
| stxxl::counting_ptr< swappable_block_matrix_type > | |
| stxxl::dummy_custom_stats_counter< uint64 > | |
| stxxl::mng_local::filler_struct< FillSize > | |
| stxxl::priority_queue_local::internal_bounded_stack< unsigned_type, arity > | |
| stxxl::priority_queue_local::internal_bounded_stack< unsigned_type, MaxArity > | |
| stxxl::priority_queue_local::internal_priority_queue< value_type, std::vector< value_type >, comparator_type > | |
| stxxl::ppq_local::minima_tree< parallel_priority_queue< value_type, compare_type, alloc_strategy, block_size, DefaultMemSize, MaxItems > > | |
| stxxl::random_number< random_uniform_fast > | |
| stxxl::random_number< stxxl::random_uniform_fast > | |
| binary_function | |
| stxxl::btree::normal_leaf< KeyType, DataType, KeyCmp, LogNElem, BTreeType >::value_compare | |
| stxxl::btree::normal_node< KeyType, KeyCmp, RawSize, BTreeType >::value_compare | |
| stxxl::disk_allocator::first_fit | |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, KeyCompareType, SubBlockSize, SubBlocksPerBlock, AllocatorType >::Cmp | Comparator object for values as required by stxxl::sort |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, KeyCompareType, SubBlockSize, SubBlocksPerBlock, AllocatorType >::equal_to | Construct an equality predicate from the comparison operator |
| stxxl::ksort_local::key_comparison< RecordType, KeyExtractor > | |
| stxxl::ksort_local::run_cursor2_cmp< BlockType, prefetcher_type, KeyExtractor > | |
| stxxl::parallel::binary_negate< Predicate, first_argument_type, second_argument_type > | Alternative to std::not2, typedefs first_argument_type and second_argument_type not needed |
| stxxl::parallel::equal_from_less< Comparator, T1, T2 > | Constructs predicate for equality from strict weak ordering predicate |
| stxxl::parallel::equal_to< T1, T2 > | |
| stxxl::parallel::less< T1, T2 > | |
| stxxl::parallel::lexicographic< T1, T2, Comparator > | Compare a pair of types lexcigraphically, ascending |
| stxxl::parallel::lexicographic_rev< T1, T2, Comparator > | Compare a pair of types lexcigraphically, descending |
| stxxl::sort_helper::run_cursor2_cmp< BlockType, PrefetcherType, ValueCmp > | |
| stxxl::sort_helper::trigger_entry_cmp< TriggerEntryType, ValueCmp > | |
| stxxl::wbtl_file::FirstFit | |
| std::exception | STL class |
| std::ios_base::failure | STL class |
| stxxl::io_error | |
 std::runtime_error | STL class |
 stxxl::bad_ext_alloc | |
| stxxl::bad_parameter | |
| stxxl::resource_error | |
| stxxl::unreachable | |
| iterator | |
| stxxl::array_of_sequences_iterator< ArrayType, ValueType, modulo > | |
| stxxl::two2one_dim_array_adapter_base< OneDimArrayType, DataType, PosType > | |
| stxxl::two2one_dim_array_adapter_base< RunType *, BID< BlockSize >, PosType > | |
| stxxl::runs2bid_array_adaptor< BlockSize, RunType, PosType > | |
| stxxl::runs2bid_array_adaptor2< BlockSize, RunType, PosType > | |
| std::numeric_limits< stxxl::uint_pair< HighType > > | Template class providing some numeric_limits fields for uint_pair types |
| pair | |
| stxxl::priority_queue_local::short_sequence< Iterator > | |
| std::vector< T > | STL class |
| stxxl::vector< ValueType, PageSize, PagerType, BlockSize, AllocStr, SizeType >::bid_vector | |
| stxxl::addressable_fifo_queue< KeyType > | An internal fifo queue that allows removing elements addressed with (a copy of) themselves |
| stxxl::addressable_priority_queue< KeyType, PriorityType, Cmp > | An internal priority queue that allows removing elements addressed with (a copy of) themselves |
| stxxl::addressable_priority_queue< KeyType, PriorityType, Cmp >::cmp | |
| stxxl::aligned_alloc_settings< MustBeInt > | |
| stxxl::atomic_counted_object | Provides reference counting abilities for use with counting_ptr with mutex locking |
| stxxl::request | Request object encapsulating basic properties like file and offset |
| stxxl::request_with_waiters | Request that is aware of threads waiting for it to complete |
| stxxl::request_with_state | Request with completion state |
| stxxl::linuxaio_request | Request for an linuxaio_file |
| stxxl::serving_request | Request which serves an I/O by calling the synchronous routine of the file |
| stxxl::swappable_block_matrix< ValueType, BlockSideLength > | External container for a (sub)matrix. Not intended for direct use |
| stxxl::basic_allocation_strategy | Example disk allocation scheme functor |
| stxxl::BID< Size > | Block identifier class |
| stxxl::BID< 0 > | Specialization of block identifier class (BID) for variable size block size |
| stxxl::binary_buffer | Binary_buffer represents a dynamically growable area of memory, which can be modified by appending integral data types via put() and other basic operations |
| stxxl::binary_buffer_ref | Binary_buffer_ref represents a memory area as pointer and valid length |
| stxxl::binary_reader | Binary_reader represents a binary_buffer_ref with an additional cursor with which the memory can be read incrementally |
| stxxl::block_scheduler< SwappableBlockType >::prediction_sequence_element | |
| stxxl::block_scheduler_algorithm_offline_lfd< SwappableBlockType >::priority | |
| stxxl::block_scheduler_algorithm_offline_lru_prefetching< SwappableBlockType >::read_after_write | |
| stxxl::block_scheduler_algorithm_offline_lru_prefetching< SwappableBlockType >::scheduled_block_meta | |
| stxxl::block_scheduler_algorithm_offline_lru_prefetching< SwappableBlockType >::write_read_request | |
| stxxl::blocked_index< modulo > | |
| stxxl::btree::btree_iterator_base< BTreeType > | |
| stxxl::btree::btree_const_iterator< BTreeType > | |
| stxxl::btree::btree_iterator< BTreeType > | |
| stxxl::btree::iterator_map< BTreeType >::bid_comp | |
| stxxl::btree::iterator_map< BTreeType >::Key | |
| stxxl::btree::iterator_map< BTreeType >::KeyCmp | |
| stxxl::btree::node_cache< NodeType, BTreeType >::bid_hash | |
| stxxl::btree::normal_leaf< KeyType, DataType, KeyCmp, LogNElem, BTreeType >::metainfo_type | |
| stxxl::btree::normal_node< KeyType, KeyCmp, RawSize, BTreeType >::metainfo_type | |
| stxxl::btree::root_node< KeyType, BIDType > | |
| stxxl::buffered_writer< BlockType >::batch_entry | |
| stxxl::buffered_writer< BlockType >::batch_entry_cmp | |
| stxxl::CASE< tag_, Type_, Next_ > | |
| stxxl::choose_int_types< PtrSize > | |
| stxxl::choose_int_types< 4 > | |
| stxxl::choose_int_types< 8 > | |
| stxxl::cmdline_parser::argument | Base class of all options and parameters |
| stxxl::cmdline_parser::argument_bytes32 | Specialization of argument for SI/IEC suffixes byte size options or parameters |
| stxxl::cmdline_parser::argument_bytes64 | Specialization of argument for SI/IEC suffixes byte size options or parameters |
| stxxl::cmdline_parser::argument_double | Specialization of argument for double options or parameters |
| stxxl::cmdline_parser::argument_flag | Specialization of argument for boolean flags (can only be set to true) |
| stxxl::cmdline_parser::argument_int | Specialization of argument for integer options or parameters |
| stxxl::cmdline_parser::argument_string | Specialization of argument for string options or parameters |
| stxxl::cmdline_parser::argument_stringlist | Specialization of argument for multiple string options or parameters |
| stxxl::cmdline_parser::argument_uint | Specialization of argument for unsigned integer options or parameters |
| stxxl::compat::remove_const< Type > | |
| stxxl::compat::remove_const< Type const > | |
| stxxl::compat_hash< KeyType > | |
| stxxl::compat_hash_map< KeyType, MappedType, HashType > | |
| stxxl::compat_hash_multimap< KeyType, MappedType, HashType > | |
| stxxl::compat_unique_ptr< Type > | |
| stxxl::completion_handler | Completion handler class (Loki-style) |
| stxxl::completion_handler_impl | |
| stxxl::completion_handler1< HandlerType > | |
| stxxl::const_counting_ptr< Type > | High-performance smart pointer used as a wrapping reference counting pointer |
| stxxl::const_deque_iterator< DequeType > | |
| stxxl::const_matrix_iterator< ValueType, BlockSideLength > | General const_iterator type that points to single elements inside a matrix |
| stxxl::const_matrix_col_major_iterator< ValueType, BlockSideLength > | Column-major const_iterator that points to single elements inside a matrix |
| stxxl::const_matrix_row_major_iterator< ValueType, BlockSideLength > | Row-major const_iterator that points to single elements inside a matrix |
| stxxl::const_vector_iterator< ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize > | Const external vector iterator, model of ext_random_access_iterator concept |
| stxxl::counted_object | Provides reference counting abilities for use with counting_ptr |
| stxxl::stream::sorted_runs< TriggerEntryType, CompareType > | All sorted runs of a sort operation |
| stxxl::counting_ptr< Type > | High-performance smart pointer used as a wrapping reference counting pointer |
| stxxl::custom_stats_counter< ValueType > | This class provides a statistical counter that can easily be deactivated using a typedef to dummy_custom_stats_counter |
| stxxl::deque_iterator< DequeType > | |
| stxxl::disk_config | Encapsulate the configuration of one "disk". The disk is actually a file I/O object which block_manager uses to read/write blocks |
| stxxl::double_blocked_index< SizeType, modulo2, modulo1 > | |
| stxxl::dummy_custom_stats_counter< ValueType > | Dummy class for custom_stats_counter |
| stxxl::element_iterator_traits< BlockType, SizeType > | |
| stxxl::external_shared_ptr< P > | This class takes a shared pointer, increments its reference count and wraps it in a way that the resulting object can be copied, dumped to disk, and destroyed without affecting the refcount |
| stxxl::fake_timer | Class fake_timer is a drop-in replacement for timer, which does nothing |
| stxxl::hash_map::block_cache< BlockType >::bid_eq | |
| stxxl::hash_map::block_cache< BlockType >::bid_hash | |
| stxxl::hash_map::bucket< NodeType > | |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, KeyCompareType, SubBlockSize, SubBlocksPerBlock, AllocatorType >::AddHashStream< InputStream > | |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, KeyCompareType, SubBlockSize, SubBlocksPerBlock, AllocatorType >::HashedValueExtractor | Functor to extracts the actual value from a HashedValue-struct |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, KeyCompareType, SubBlockSize, SubBlocksPerBlock, AllocatorType >::HashingStream< InputStream, ValueExtractor > | Will return from its input-stream all values that are to be stored in the given bucket |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, KeyCompareType, SubBlockSize, SubBlocksPerBlock, AllocatorType >::StripHashFunctor | Extracts the value-part (ignoring the hashvalue); required by HashingStream (see above) |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, KeyCompareType, SubBlockSize, SubBlocksPerBlock, AllocatorType >::UniqueValueStream< InputStream > | Stream for filtering duplicates |
| stxxl::hash_map::hash_map_iterator_base< HashMap > | |
| stxxl::hash_map::hash_map_const_iterator< HashMap > | |
| stxxl::hash_map::hash_map_iterator< HashMap > | |
| stxxl::hash_map::HashedValue< HashMap > | Additional information about a stored value: |
| stxxl::hash_map::HashedValuesStream< HashMap, Reader > | Stream interface for all value-pairs currently stored in the map |
| stxxl::hash_map::iterator_map< HashMap >::hasher | |
| stxxl::hash_map::node< ValueType > | |
| stxxl::helper::element_iterator_generator< BlockType, SizeType, CanUseTrivialPointer > | |
| stxxl::helper::element_iterator_generator< BlockType, SizeType, false > | |
| stxxl::helper::element_iterator_generator< BlockType, SizeType, true > | |
| stxxl::IF< Flag, Type1, Type2 > | IF template metaprogramming statement |
| stxxl::IF< false, Type1, Type2 > | |
| stxxl::IF_N< Flag, Num1, Num2 > | If Flag is true then IF<>::result is Num1 otherwise of IF<>::result is Num2 |
| stxxl::IF_N< false, Num1, Num2 > | |
| stxxl::interleaved_alloc_traits< scheme > | |
| stxxl::interleaved_alloc_traits< FR > | |
| stxxl::interleaved_alloc_traits< RC > | |
| stxxl::interleaved_alloc_traits< RC_disk > | |
| stxxl::interleaved_alloc_traits< RC_flash > | |
| stxxl::interleaved_alloc_traits< single_disk > | |
| stxxl::interleaved_alloc_traits< SR > | |
| stxxl::interleaved_alloc_traits< striping > | |
| stxxl::interleaved_striping | |
| stxxl::first_disk_only | |
| stxxl::interleaved_FR | |
| stxxl::interleaved_RC | |
| stxxl::interleaved_SR | |
| stxxl::ksort_defaultkey< RecordType > | |
| stxxl::ksort_local::trigger_entry< BIDType, KeyType > | |
| stxxl::ksort_local::type_key< Type, KeyType > | |
| stxxl::ksort_local::write_completion_handler< BlockType, BidType > | |
| stxxl::LOG2< Input > | |
| stxxl::LOG2< 0 > | |
| stxxl::LOG2< 1 > | |
| stxxl::LOG2_floor< Input > | |
| stxxl::LOG2_floor< 0 > | |
| stxxl::LOG2_floor< 1 > | |
| stxxl::malloc_setup | |
| stxxl::malloc_stats | Access to some useful malloc statistics |
| stxxl::matrix< ValueType, BlockSideLength > | External matrix container.
Introduction to matrix container: see STXXL Matrix tutorial.
Design and Internals of matrix container: see Matrix |
| stxxl::matrix_iterator< ValueType, BlockSideLength > | General iterator type that points to single elements inside a matrix |
| stxxl::matrix_col_major_iterator< ValueType, BlockSideLength > | Column-major iterator that points to single elements inside a matrix |
| stxxl::matrix_row_major_iterator< ValueType, BlockSideLength > | Row-major iterator that points to single elements inside a matrix |
| stxxl::matrix_local::feedable_strassen_winograd< ValueType, BlockSideLength, Level, AExists, BExists > | |
| stxxl::matrix_local::feedable_strassen_winograd< ValueType, BlockSideLength, 0, AExists, BExists > | |
| stxxl::matrix_local::feedable_strassen_winograd_block_grained< ValueType, BlockSideLength, Level, AExists, BExists > | |
| stxxl::matrix_local::feedable_strassen_winograd_block_grained< ValueType, BlockSideLength, 0, AExists, BExists > | |
| stxxl::matrix_local::low_level_matrix_binary_ass_op< ValueType, BlockSideLength, a_transposed, b_transposed, Op > | C = a [op] b; for arbitrary entries |
| stxxl::matrix_local::low_level_matrix_multiply_and_add< ValueType, BlockSideLength > | Multiplies matrices A and B, adds result to C, for arbitrary entries param pointer to blocks of A,B,C; elements in blocks have to be in row-major |
| stxxl::matrix_local::low_level_matrix_unary_ass_op< ValueType, BlockSideLength, a_transposed, Op > | C [op]= a; for arbitrary entries |
| stxxl::matrix_local::low_level_matrix_unary_op< ValueType, BlockSideLength, a_transposed, Op > | C =[op] a; for arbitrary entries |
| stxxl::matrix_local::matrix_operations< ValueType, BlockSideLength > | |
| stxxl::matrix_local::matrix_operations< ValueType, BlockSideLength >::addition | |
| stxxl::matrix_local::matrix_operations< ValueType, BlockSideLength >::scalar_multiplication | |
| stxxl::matrix_local::matrix_operations< ValueType, BlockSideLength >::subtraction | |
| stxxl::matrix_local::matrix_operations< ValueType, BlockSideLength >::swappable_block_matrix_approximative_quarterer | |
| stxxl::matrix_local::matrix_operations< ValueType, BlockSideLength >::swappable_block_matrix_padding_quarterer | |
| stxxl::matrix_local::matrix_operations< ValueType, BlockSideLength >::swappable_block_matrix_quarterer | |
| stxxl::matrix_local::matrix_to_quadtree< ValueType, BlockSideLength, Level > | |
| stxxl::matrix_local::matrix_to_quadtree< ValueType, BlockSideLength, 0 > | |
| stxxl::matrix_local::matrix_to_quadtree_block_grained< ValueType, BlockSideLength, Level, Granularity > | |
| stxxl::matrix_local::matrix_to_quadtree_block_grained< ValueType, BlockSideLength, 0, Granularity > | |
| stxxl::matrix_local::static_quadtree< ValueType, Level > | A static_quadtree holds 4^Level elements arranged in a quad tree |
| stxxl::matrix_local::static_quadtree< ValueType, 0 > | |
| stxxl::matrix_local::switch_major_index< BlockSideLength, transposed > | |
| stxxl::matrix_local::switch_major_index< BlockSideLength, false > | |
| stxxl::matrix_local::switch_major_index< BlockSideLength, true > | |
| stxxl::matrix_operation_statistic_dataset | |
| stxxl::matrix_operation_statistic | |
| stxxl::matrix_operation_statistic_data | |
| stxxl::mng_local::element_block< Type, Size > | Contains data elements for stxxl::typed_block , not intended for direct use |
| stxxl::mng_local::block_w_bids< Type,((RawSize-sizeof(BID< RawSize >)*NBids)/sizeof(Type)), RawSize, NBids > | |
| stxxl::mng_local::block_w_info< Type, RawSize, NBids, void > | |
| stxxl::mng_local::block_w_bids< Type,((RawSize-sizeof(BID< RawSize >)*NBids-sizeof(MetaInfoType))/sizeof(Type)), RawSize, NBids > | |
| stxxl::mng_local::block_w_info< Type, RawSize, NRef, MetaInfoType > | |
| stxxl::mng_local::add_filler< mng_local::block_w_info< Type, RawSize, NRef, MetaInfoType >, RawSize-sizeof(mng_local::block_w_info< Type, RawSize, NRef, MetaInfoType >)> | |
| stxxl::mng_local::expand_struct< mng_local::block_w_info< Type, RawSize, NRef, MetaInfoType >, RawSize > | |
| stxxl::typed_block< RawSize, Type, NRef, MetaInfoType > | Block containing elements of fixed length |
| stxxl::mng_local::block_w_info< Type, RawSize, NBids, MetaInfoType > | Contains per block information for stxxl::typed_block , not intended for direct use |
| stxxl::mng_local::block_w_bids< Type, Size, RawSize, NBids > | Contains BID references for stxxl::typed_block , not intended for direct use |
| stxxl::mng_local::block_w_bids< Type, Size, RawSize, 0 > | |
| stxxl::mng_local::filler_struct< Bytes > | |
| stxxl::mng_local::filler_struct< 0 > | |
| stxxl::new_alloc< Type > | |
| stxxl::new_alloc< Type >::rebind< Rebind > | |
| stxxl::new_alloc_rebind< Type, Rebind > | |
| stxxl::new_alloc_rebind< Type, Type > | |
| stxxl::NilCase | |
| stxxl::noncopyable | |
| stxxl::stream::basic_runs_creator< stream::use_push< ValueType >, cmp_type, BlockSize, alloc_strategy_type > | |
| stxxl::stream::runs_creator< stream::use_push< ValueType >, cmp_type, block_size, alloc_strategy_type > | |
| stxxl::stream::basic_runs_merger< sorted_runs_type, CompareType, AllocStr > | |
| stxxl::stream::runs_merger< sorted_runs_type, CompareType, AllocStr > | |
| stxxl::stream::basic_runs_merger< typename runs_creator_type::sorted_runs_type, cmp_type, alloc_strategy_type > | |
| stxxl::stream::runs_merger< typename runs_creator_type::sorted_runs_type, cmp_type, alloc_strategy_type > | |
| stxxl::hash_map::block_cache< block_type > | |
| stxxl::hash_map::block_cache_write_buffer< block_type > | |
| stxxl::buffered_writer< block_type > | |
| stxxl::buffered_writer< stxxl::typed_block > | |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, CompareType, SubBlockSize, SubBlocksPerBlock, AllocType > | |
| stxxl::priority_queue_local::int_merger< value_type, comparator_type, IntKMAX > | |
| stxxl::hash_map::iterator_map< self_type > | |
| stxxl::btree::iterator_map< self_type > | |
| stxxl::priority_queue_local::loser_tree< self_type, comparator_type, MaxArity > | |
| stxxl::priority_queue_local::loser_tree< self_type, comparator_type, MaxArity > | |
| stxxl::priority_queue_local::loser_tree< self_type, CompareType, Arity > | |
| stxxl::priority_queue_local::loser_tree< self_type, CompareType, Arity > | |
| stxxl::priority_queue_local::loser_tree< self_type, CompareType, MaxArity > | |
| stxxl::priority_queue_local::loser_tree< self_type, CompareType, MaxArity > | |
| stxxl::btree::node_cache< leaf_type, self_type > | |
| stxxl::btree::node_cache< node_type, self_type > | |
| stxxl::read_write_pool< block_type > | |
| stxxl::simple_vector< BID< BlockSize > > | |
| stxxl::BIDArray< block_type::raw_size > | |
| stxxl::BIDArray< BlockSize > | |
| stxxl::simple_vector< bid_type > | |
| stxxl::simple_vector< int_type > | |
| stxxl::simple_vector< list_type::iterator > | |
| stxxl::simple_vector< stxxl::counting_ptr > | |
| stxxl::simple_vector< stxxl::typed_block > | |
| stxxl::singleton< block_manager > | |
| stxxl::block_manager | Block manager class |
| stxxl::singleton< config > | |
| stxxl::config | Access point to disks properties. Since 1.4.0: no config files are read automatically! |
| stxxl::singleton< disk_queues > | |
| stxxl::disk_queues | Encapsulates disk queues |
| stxxl::singleton< logger > | |
| stxxl::logger | |
| stxxl::singleton< matrix_operation_statistic > | |
| stxxl::matrix_operation_statistic | |
| stxxl::singleton< stats > | |
| stxxl::stats | Collects various I/O statistics |
| stxxl::singleton< tuning > | |
| stxxl::hash_map::tuning | Tuning parameters for external memory hash map |
| stxxl::state< request_state > | |
| stxxl::state< thread_state > | |
| stxxl::block_prefetcher< BlockType, BidIteratorType > | Encapsulates asynchronous prefetching engine |
| stxxl::block_scheduler< SwappableBlockType > | Schedules swapping of blocks and provides blocks for temporary storage |
| stxxl::block_scheduler_algorithm< SwappableBlockType > | Interface of a block scheduling algorithm |
| stxxl::block_scheduler_algorithm_offline_lfd< SwappableBlockType > | Block scheduling algorithm caching via the longest forward distance policy (offline) |
| stxxl::block_scheduler_algorithm_offline_lru_prefetching< SwappableBlockType > | Block scheduling algorithm caching via the least recently used policy (offline), and prefetching in addition |
| stxxl::block_scheduler_algorithm_online_lru< SwappableBlockType > | Block scheduling algorithm caching via the least recently used policy (online) |
| stxxl::block_scheduler_algorithm_simulation< SwappableBlockType > | Pseudo block scheduling algorithm only recording the request sequence |
| stxxl::btree::btree< KeyType, DataType, CompareType, RawNodeSize, RawLeafSize, PDAllocStrategy > | |
| stxxl::btree::iterator_map< BTreeType > | |
| stxxl::btree::node_cache< NodeType, BTreeType > | |
| stxxl::btree::normal_leaf< KeyType, DataType, KeyCmp, LogNElem, BTreeType > | |
| stxxl::btree::normal_node< KeyType, KeyCmp, RawSize, BTreeType > | |
| stxxl::buf_istream< BlockType, BidIteratorType > | Buffered input stream |
| stxxl::buf_istream_reverse< BlockType, BidIteratorType > | Buffered input stream, reading the items in the blocks in reverse order |
| stxxl::buf_ostream< BlockType, BidIteratorType > | Buffered output stream |
| stxxl::buffered_writer< BlockType > | Encapsulates asynchronous buffered block writing engine |
| stxxl::cmdline_parser | |
| stxxl::condition_variable | |
| stxxl::deque< ValueType, VectorType > | A deque container.
Introduction to deque container: see STXXL Deque tutorial.
Design and Internals of deque container: see Deque |
| stxxl::disk_allocator | |
| stxxl::file | Defines interface of file |
| stxxl::disk_queued_file | Implementation of some file methods based on serving_request |
| stxxl::fileperblock_file< base_file_type > | Implementation of file based on other files, dynamically allocate one file per block. Allows for dynamic disk space consumption |
| stxxl::linuxaio_file | Implementation of file based on the Linux kernel interface for asynchronous I/O |
| stxxl::mem_file | Implementation of file based on new[] and memcpy |
| stxxl::mmap_file | Implementation of memory mapped access file |
| stxxl::sim_disk_file | Implementation of disk emulation |
| stxxl::syscall_file | Implementation of file based on UNIX syscalls |
| stxxl::wbtl_file | Implementation of file based on buffered writes and block remapping via a translation layer |
| stxxl::wincall_file | Implementation of file based on Windows native I/O calls |
| stxxl::ufs_file_base | Base for UNIX file system implementations |
| stxxl::linuxaio_file | Implementation of file based on the Linux kernel interface for asynchronous I/O |
| stxxl::mmap_file | Implementation of memory mapped access file |
| stxxl::sim_disk_file | Implementation of disk emulation |
| stxxl::syscall_file | Implementation of file based on UNIX syscalls |
| stxxl::wfs_file_base | Base for Windows file system implementations |
| stxxl::wincall_file | Implementation of file based on Windows native I/O calls |
| stxxl::grow_shrink_stack< StackConfig > | Efficient implementation that uses prefetching and overlapping using internal buffers |
| stxxl::grow_shrink_stack2< StackConfig > | Efficient implementation that uses prefetching and overlapping using (shared) buffers pools |
| stxxl::hash_map::block_cache< BlockType > | Cache of blocks contained in an external memory hash map. Uses the stxxl::lru_pager as eviction algorithm |
| stxxl::hash_map::block_cache_write_buffer< BlockType > | Used inside block_cache for buffering write requests of cached blocks |
| stxxl::hash_map::buffered_reader< CacheType, BidIterator > | Used to scan external memory with prefetching |
| stxxl::hash_map::buffered_writer< BlockType, BidContainer > | Buffered writing of values. New Blocks are allocated as needed |
| stxxl::hash_map::hash_map< KeyType, MappedType, HashType, KeyCompareType, SubBlockSize, SubBlocksPerBlock, AllocatorType > | Main implementation of external memory hash map |
| stxxl::hash_map::iterator_map< HashMap > | |
| stxxl::loser_tree< RunCursorType, RunCursorCmpType > | |
| stxxl::lru_pager< npages_ > | Pager with LRU replacement strategy |
| stxxl::map< KeyType, DataType, CompareType, RawNodeSize, RawLeafSize, PDAllocStrategy > | External associative container (map).
Introduction to map container: see STXXL Map (B+-tree) tutorial.
Design and Internals of map container: see Map (B+-tree) |
| stxxl::migrating_stack< CritSize, ExternalStack, InternalStack > | A stack that migrates from internal memory to external when its size exceeds a certain threshold |
| stxxl::mutex | |
| stxxl::normal_stack< StackConfig > | External stack container. Introduction to stack container: see STXXL Stack tutorial.
Design and Internals of stack container: see Stack Conservative implementation. Fits best if your access pattern consists of irregularly mixed push'es and pop's. For semantics of the methods see documentation of the STL std::stack.
To gain full bandwidth of disks StackConfig::BlocksPerPage must >= number of disks
|
| stxxl::onoff_switch | |
| stxxl::parallel::LoserTreeCopyUnguardedBase< ValueType, Comparator > | |
| stxxl::parallel::LoserTreeCopyUnguarded< Stable, ValueType, Comparator > | |
| stxxl::parallel::LoserTreeCopyUnguarded< true, ValueType, Comparator > | |
| stxxl::parallel::LoserTreePointerUnguardedBase< ValueType, Comparator > | |
| stxxl::parallel::LoserTreePointerUnguarded< Stable, ValueType, Comparator > | |
| stxxl::parallel::LoserTreePointerUnguarded< true, ValueType, Comparator > | |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems > | Parallelized External Memory Priority Queue |
| stxxl::ppq_local::external_array< ValueType, BlockSize, AllocStrategy > | External array stores a sorted sequence of values on the hard disk and allows access to the first block (containing the smallest values) |
| stxxl::ppq_local::external_array_writer< ExternalArrayType > | |
| stxxl::ppq_local::internal_array< ValueType > | Internal arrays store a sorted sequence of values in RAM, which will be merged together into the deletion buffer when it needs to be refilled |
| stxxl::prefetch_pool< BlockType > | Implements dynamically resizable prefetching pool |
| stxxl::priority_queue< ConfigType > | External priority queue data structure
Introduction to priority queue container: see STXXL Priority Queue tutorial.
Design and Internals of priority queue container: see Priority Queue |
| stxxl::priority_queue_local::ext_merger< BlockType, CompareType, Arity, AllocStr > | External merger, based on the loser tree data structure |
| stxxl::priority_queue_local::ext_merger< BlockType, CompareType, Arity, AllocStr >::sequence_state | |
| stxxl::priority_queue_local::int_merger< ValueType, CompareType, MaxArity > | |
| stxxl::priority_queue_local::loser_tree< ValueType, CompareType, MaxArity > | Loser tree from Knuth, "Sorting and Searching", Section 5.4.1 |
| stxxl::priority_queue_local::loser_tree< ValueType, CompareType, MaxArity > | Loser tree from Knuth, "Sorting and Searching", Section 5.4.1 |
| stxxl::queue< ValueType, BlockSize, AllocStr, SizeType > | External FIFO queue container.
Introduction to queue container: see STXXL Queue tutorial
Design and Internals of queue container: see Queue |
| stxxl::read_write_pool< BlockType > | Implements dynamically resizable buffered writing and prefetched reading pool |
| stxxl::request_interface | Functional interface of a request |
| stxxl::request | Request object encapsulating basic properties like file and offset |
| stxxl::request_queue | Interface of a request_queue to which requests can be added and canceled |
| stxxl::request_queue_impl_worker | Implementation of request queue worker threads. Worker threads can be started by start_thread and stopped with stop_thread. The queue state is checked before termination and updated afterwards |
| stxxl::linuxaio_queue | Queue for linuxaio_file(s) |
| stxxl::request_queue_impl_1q | Implementation of a local request queue having only one queue for both read and write requests, thus having only one thread |
| stxxl::request_queue_impl_qwqr | Implementation of a local request queue having two queues, one for read and one for write requests, thus having two threads. This is the default implementation |
| stxxl::semaphore | |
| stxxl::sequence< ValueType, BlockSize, AllocStr, SizeType > | External sequence or deque container without random access.
Introduction to sequence container: see STXXL Sequence tutorial.
Design and Internals of sequence container: see Queue |
| stxxl::simdisk_geometry | |
| stxxl::IC35L080AVVA07 | |
| stxxl::sim_disk_file | Implementation of disk emulation |
| stxxl::simple_vector< ValueType > | Simpler non-growing vector without initialization |
| stxxl::singleton< INSTANCE, destroy_on_exit > | |
| stxxl::sorter< ValueType, CompareType, BlockSize, AllocStrategy > | External sorter container.
Introduction to sorter container: see STXXL Sorter tutorial.
Design and Internals of sorter container: see Sorter |
| stxxl::state< ValueType > | |
| stxxl::stream::basic_runs_creator< Input, CompareType, BlockSize, AllocStr > | Forms sorted runs of data from a stream |
| stxxl::stream::runs_creator< Input, CompareType, BlockSize, AllocStr > | Forms sorted runs of data from a stream |
| stxxl::stream::basic_runs_merger< RunsType, CompareType, AllocStr > | Merges sorted runs |
| stxxl::stream::runs_merger< RunsType, CompareType, AllocStr > | Merges sorted runs |
| stxxl::stream::runs_creator< from_sorted_sequences< ValueType >, CompareType, BlockSize, AllocStr > | Forms sorted runs of data taking elements in sorted order (element by element) |
| stxxl::stream::runs_creator< use_push< ValueType >, CompareType, BlockSize, AllocStr > | Forms sorted runs of elements passed in push() method |
| stxxl::stream::sort< Input, CompareType, BlockSize, AllocStr, RunsCreatorType > | Produces sorted stream from input stream |
| stxxl::stream::sorted_runs< TriggerEntryType, CompareType > | All sorted runs of a sort operation |
| stxxl::swap_vector< ValueType > | Vector that avoids copying of ValueType objects in push_back() (here: swap_back()) and resize() operations |
| stxxl::unordered_map< KeyType, MappedType, HashType, CompareType, SubBlockSize, SubBlocksPerBlock, AllocType > | An external memory implementation of the STL unordered_map container, which is based on an external memory hash map |
| stxxl::vector_bufreader< VectorIteratorType > | Buffered sequential reader from a vector using overlapped I/O |
| stxxl::vector_bufreader_reverse< VectorIteratorType > | Buffered sequential reverse reader from a vector using overlapped I/O |
| stxxl::vector_bufwriter< VectorIteratorType > | Buffered sequential writer to a vector using overlapped I/O |
| stxxl::write_pool< BlockType > | Implements dynamically resizable buffered writing pool |
| stxxl::swap_vector< external_array_type > | |
| stxxl::swap_vector< internal_array_type > | |
| stxxl::offset_allocator< BaseAllocator > | Allocator functor adaptor |
| stxxl::parallel::active_tag | |
| stxxl::parallel::guarded_iterator< RandomAccessIterator, Comparator > | Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons |
| stxxl::parallel::inactive_tag | |
| stxxl::parallel::loser_tree_traits< Stable, ValueType, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, char, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, int, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, long long, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, long, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, short, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, unsigned char, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, unsigned int, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, unsigned long long, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, unsigned long, Comparator > | |
| stxxl::parallel::loser_tree_traits< Stable, unsigned short, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, ValueType, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, char, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, int, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, long long, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, long, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, short, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, unsigned char, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, unsigned int, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, unsigned long long, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, unsigned long, Comparator > | |
| stxxl::parallel::loser_tree_traits_unguarded< Stable, unsigned short, Comparator > | |
| stxxl::parallel::LoserTreeCopyBase< ValueType, Comparator > | |
| stxxl::parallel::LoserTreeCopy< Stable, ValueType, Comparator > | |
| stxxl::parallel::LoserTreeCopy< true, ValueType, Comparator > | |
| stxxl::parallel::LoserTreeCopyBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| stxxl::parallel::LoserTreeCopyUnguardedBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| stxxl::parallel::LoserTreePointerBase< ValueType, Comparator > | |
| stxxl::parallel::LoserTreePointer< Stable, ValueType, Comparator > | |
| stxxl::parallel::LoserTreePointer< true, ValueType, Comparator > | |
| stxxl::parallel::LoserTreePointerBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| stxxl::parallel::LoserTreePointerUnguardedBase< ValueType, Comparator >::Loser | Internal representation of a loser tree player/node |
| stxxl::parallel::LoserTreeReference< T, Comparator > | |
| stxxl::parallel::LoserTreeReference< T, Comparator >::Loser | |
| stxxl::parallel::NumberOfThreads | |
| stxxl::parallel::Settings< must_be_int > | |
| stxxl::parallel::Timing< tag, must_be_int > | |
| stxxl::parallel::Timing< inactive_tag, must_be_int > | |
| stxxl::parallel::unguarded_iterator< RandomAccessIterator, Comparator > | |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems >::empty_external_array_eraser | Unary operator which returns true if the external array has run empty |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems >::empty_internal_array_eraser | Unary operator which returns true if the internal array has run empty |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems >::external_min_comparator | Compares the largest accessible value of two external arrays |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems >::hint_comparator | Compares the largest value of the block hinted the latest of two external arrays |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems >::inv_compare_type | Inverse comparison functor |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems >::ProcessorData | A struct containing the local insertion heap and other information local to a processor |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems >::s_min_tree_comparator | |
| stxxl::parallel_priority_queue< ValueType, CompareType, AllocStrategy, BlockSize, DefaultMemSize, MaxItems >::stats_type | Struct of all statistical counters and timers. Turn on/off statistics using the stats_counter and stats_timer typedefs |
| stxxl::Plug | |
| stxxl::ppq_local::external_array_writer< ExternalArrayType >::iterator | |
| stxxl::ppq_local::minima_tree< ParentType > | The minima_tree contains minima from all sources inside the PPQ |
| stxxl::ppq_local::minima_tree< ParentType >::head_comp | WinnerTree-Comparator for the head winner tree. It accesses all relevant data structures from the priority queue |
| stxxl::ppq_local::minima_tree< ParentType >::heaps_comp | Comparator for the insertion heaps winner tree |
| stxxl::ppq_local::minima_tree< ParentType >::ia_comp | Comparator for the internal arrays winner tree |
| stxxl::ppq_local::ppq_iterator< ValueType > | A random-access iterator class for block oriented data |
| stxxl::prefetch_pool< BlockType >::bid_hash | |
| stxxl::priority_queue_config< ValueType, CompareType, BufferSize1_, N_, IntKMAX_, IntLevels_, BlockSize_, ExtKMAX_, ExtLevels_, AllocStr_ > | |
| stxxl::PRIORITY_QUEUE_GENERATOR< ValueType, CompareType, IntMemory, MaxItems, Tune > | Priority queue type generator.
Introduction to priority queue container: see STXXL Priority Queue tutorial.
Design and Internals of priority queue container: see Priority Queue |
| stxxl::priority_queue_local::compute_N< AI_, X_, CriticalSize > | |
| stxxl::priority_queue_local::compute_N< 1, X_, CriticalSize_ > | |
| stxxl::priority_queue_local::dummy | |
| stxxl::priority_queue_local::find_B_m< ElementSize, IntMem, MaxItems, BlockSize, m_, stop > | |
| stxxl::priority_queue_local::find_B_m< ElementSize, IntMem, MaxItems, 2048, 1, stop > | |
| stxxl::priority_queue_local::find_B_m< ElementSize, IntMem, MaxItems, BlockSize, m_, true > | |
| stxxl::priority_queue_local::find_settings< ElementSize, IntMem, MaxItems > | |
| stxxl::priority_queue_local::internal_bounded_stack< ValueType, MaxSize > | Similar to std::stack, with the following differences: |
| stxxl::priority_queue_local::internal_priority_queue< ValueType, ContainerType, CompareType > | Similar to std::priority_queue, with the following differences: |
| stxxl::priority_queue_local::invert_order< Predicate, FirstType, SecondType > | Inverts the order of a comparison functor by swapping its arguments |
| stxxl::priority_queue_local::loser_tree< ValueType, CompareType, MaxArity >::Entry | Type of nodes in the loser tree |
| stxxl::priority_queue_local::Parameters_for_priority_queue_not_found_Increase_IntMem | |
| stxxl::priority_queue_local::Parameters_not_found_Try_to_change_the_Tune_parameter | |
| stxxl::random_number< UniformRGen > | Uniform [0, N) pseudo-random generator |
| stxxl::random_number32 | Fast uniform [0, 2^32) pseudo-random generator with period 2^32, random bits: 32 |
| stxxl::random_number32_r | Fast uniform [0, 2^32) pseudo-random generator with period 2^32, random bits: 32. Reentrant variant of random_number32 that keeps it's private state |
| stxxl::random_number64 | Slow and precise uniform [0, 2^64) pseudo-random generator |
| stxxl::random_number8_r | Fast uniform [0, 255] pseudo-random generator with period 2^8, random bits: 8 (one byte) |
| stxxl::random_pager< npages_ > | Pager with random replacement strategy |
| stxxl::random_uniform_fast | Fast uniform [0.0, 1.0) pseudo-random generator |
| stxxl::random_uniform_slow | Slow and precise uniform [0.0, 1.0) pseudo-random generator period: at least 2^48, random bits: at least 31 |
| stxxl::run_cursor< BlockType > | |
| stxxl::run_cursor2< BlockType, PrefetcherType > | |
| stxxl::scoped_mutex_lock | Aquire a lock that's valid until the end of scope |
| stxxl::scoped_print_timer | Simple scoped timer, which takes a text message and prints the duration until the scope is destroyed |
| stxxl::sequence< ValueType, BlockSize, AllocStr, SizeType >::reverse_stream | |
| stxxl::sequence< ValueType, BlockSize, AllocStr, SizeType >::stream | |
| stxxl::set_switch_handler | |
| stxxl::settings< MustBeInt > | |
| stxxl::simdisk_geometry::Zone | |
| stxxl::simdisk_geometry::ZoneCmp | |
| stxxl::single_disk | 'Single disk' disk allocation scheme functor |
| stxxl::sort_helper::trigger_entry< BlockType, ValueType > | |
| stxxl::sort_local::read_next_after_write_completed< BlockType, BidType > | |
| stxxl::stable_ksort_local::bid_sequence< BIDType, AllocStrategy > | |
| stxxl::stable_ksort_local::type_key< Type > | |
| stxxl::stack_config_generator< ValueType, BlocksPerPage, BlockSize, AllocStr, SizeType > | |
| stxxl::STACK_GENERATOR< ValueType, Externality, Behaviour, BlocksPerPage, BlockSize, IntStackType, MigrCritSize, AllocStr, SizeType > | Stack type generator
Introduction to stack container: see STXXL Stack tutorial.
Design and Internals of stack container: see Stack |
| stxxl::stats::scoped_read_timer | |
| stxxl::stats::scoped_read_write_timer | |
| stxxl::stats::scoped_wait_timer | |
| stxxl::stats::scoped_write_timer | |
| stxxl::stats_data | |
| stxxl::stream::choose< Input, Which > | |
| stxxl::stream::choose< Input, 1 > | Creates stream from a tuple stream taking the first component of each tuple |
| stxxl::stream::choose< Input, 2 > | Creates stream from a tuple stream taking the second component of each tuple |
| stxxl::stream::choose< Input, 3 > | Creates stream from a tuple stream taking the third component of each tuple |
| stxxl::stream::choose< Input, 4 > | Creates stream from a tuple stream taking the fourth component of each tuple |
| stxxl::stream::choose< Input, 5 > | Creates stream from a tuple stream taking the fifth component of each tuple |
| stxxl::stream::choose< Input, 6 > | Creates stream from a tuple stream taking the sixth component of each tuple |
| stxxl::stream::compute_sorted_runs_type< ValueType, BlockSize > | Computes sorted runs type from value type and block size |
| stxxl::stream::concatenate< StreamA, StreamB > | |
| stxxl::stream::counter< ValueType > | |
| stxxl::stream::dummy_cmp_unique | |
| stxxl::stream::from_sorted_sequences< ValueType > | Input strategy for runs_creator class |
| stxxl::stream::generator2stream< Generator, T > | A model of stream that outputs data from an adaptable generator functor. For convenience use streamify function instead of direct instantiation of generator2stream |
| stxxl::stream::iterator2stream< InputIterator > | A model of stream that retrieves the data from an input iterator. For convenience use streamify function instead of direct instantiation of iterator2stream |
| stxxl::stream::make_tuple< Input1, Input2, Input3, Input4, Input5, Input6 > | Creates stream of 6-tuples from 6 input streams |
| stxxl::stream::make_tuple< Input1, Input2, Input3, Input4, Input5, Stopper > | Creates stream of 5-tuples from 5 input streams |
| stxxl::stream::make_tuple< Input1, Input2, Input3, Input4, Stopper, Stopper > | Creates stream of 4-tuples from 4 input streams |
| stxxl::stream::make_tuple< Input1, Input2, Input3, Stopper, Stopper, Stopper > | Creates stream of 3-tuples from 3 input streams |
| stxxl::stream::make_tuple< Input1, Input2, Stopper, Stopper, Stopper, Stopper > | Creates stream of 2-tuples (pairs) from 2 input streams |
| stxxl::stream::Stopper | |
| stxxl::stream::streamify_traits< InputIterator > | Traits class of streamify function |
| stxxl::stream::streamify_traits< stxxl::const_vector_iterator< ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize > > | |
| stxxl::stream::streamify_traits< stxxl::vector_iterator< ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize > > | |
| stxxl::stream::transform< Operation, Input1, Input2, Input3, Input4, Input5, Input6 > | Processes (up to) 6 input streams using given operation functor |
| stxxl::stream::transform< Operation, Input1, Input2, Input3, Input4, Input5, Stopper > | Processes 5 input streams using given operation functor |
| stxxl::stream::transform< Operation, Input1, Input2, Input3, Input4, Stopper, Stopper > | Processes 4 input streams using given operation functor |
| stxxl::stream::transform< Operation, Input1, Input2, Input3, Stopper, Stopper, Stopper > | Processes 3 input streams using given operation functor |
| stxxl::stream::transform< Operation, Input1, Input2, Stopper, Stopper, Stopper, Stopper > | Processes 2 input streams using given operation functor |
| stxxl::stream::transform< Operation, Input1, Stopper, Stopper, Stopper, Stopper, Stopper > | Processes an input stream using given operation functor |
| stxxl::stream::unique< Input, BinaryPredicate > | Equivalent to std::unique algorithms |
| stxxl::stream::unique< Input, dummy_cmp_unique > | Equivalent to std::unique algorithms |
| stxxl::stream::use_push< ValueType > | Input strategy for runs_creator class |
| stxxl::stream::vector_iterator2stream< InputIterator > | A model of stream that retrieves data from an external stxxl::vector iterator. It is more efficient than generic iterator2stream thanks to use of overlapping For convenience use streamify function instead of direct instantiation of vector_iterator2stream |
| stxxl::stream::vector_iterator2stream_sr< InputIterator > | Version of iterator2stream. Switches between vector_iterator2stream and iterator2stream |
| stxxl::striping | Striping disk allocation scheme functor |
| stxxl::FR | Fully randomized disk allocation scheme functor |
| stxxl::RC | Randomized cycling disk allocation scheme functor |
| stxxl::RC_disk | |
| stxxl::RC_flash | |
| stxxl::SR | Simple randomized disk allocation scheme functor |
| stxxl::swappable_block< ValueType, BlockSize > | Virtualization of a block of data. Holds information for allocating and swapping. To use in cooperation with block_scheduler |
| stxxl::SWITCH< tag, Case > | |
| stxxl::SWITCH< tag, NilCase > | |
| stxxl::timer | Class timer is a simple stop watch timer |
| stxxl::trigger_entry_iterator< trigger_iterator_type > | |
| stxxl::tuple< T1, T2, T3, T4, T5, T6 > | K-Tuple data type |
| stxxl::tuple< T1, T2, T3, T4, T5, T6 >::item_type< I > | |
| stxxl::tuple< T1, Plug, Plug, Plug, Plug > | Partial specialization for 1- tuple |
| stxxl::tuple< T1, Plug, Plug, Plug, Plug >::item_type< I > | |
| stxxl::tuple< T1, T2, Plug, Plug, Plug, Plug > | Partial specialization for 2- tuple (equivalent to std::pair) |
| stxxl::tuple< T1, T2, Plug, Plug, Plug, Plug >::item_type< I > | |
| stxxl::tuple< T1, T2, T3, Plug, Plug, Plug > | Partial specialization for 3- tuple (triple) |
| stxxl::tuple< T1, T2, T3, Plug, Plug, Plug >::item_type< I > | |
| stxxl::tuple< T1, T2, T3, T4, Plug, Plug > | Partial specialization for 4- tuple |
| stxxl::tuple< T1, T2, T3, T4, Plug, Plug >::item_type< I > | |
| stxxl::tuple< T1, T2, T3, T4, T5, Plug > | Partial specialization for 5- tuple |
| stxxl::tuple< T1, T2, T3, T4, T5, Plug >::item_type< I > | |
| stxxl::tuple_base< T1, T2, T3, T4, T5, T6 > | |
| stxxl::tuple_base< T1, T2, T3, T4, T5, T6 >::item_type< I > | |
| stxxl::tuple_greater1st< TupleType > | |
| stxxl::tuple_less1st< TupleType > | |
| stxxl::tuple_less1st_less2nd< TupleType > | |
| stxxl::tuple_less2nd< TupleType > | |
| stxxl::tuple_less2nd_less1st< TupleType > | |
| stxxl::uint_pair< HighType > | Construct an 40-bit or 48-bit unsigned integer stored in five or six bytes |
| stxxl::vector< ValueType, PageSize, PagerType, BlockSize, AllocStr, SizeType > | External vector container.
Introduction to vector container: see STXXL Vector tutorial.
Design and Internals of vector container: see Vector |
| stxxl::vector_bufreader_iterator< VectorBufReaderType > | Adapter for vector_bufreader to match iterator requirements of C++11 range-based loop construct |
| stxxl::VECTOR_GENERATOR< ValueType, PageSize, CachePages, BlockSize, AllocStr, Pager > | External vector type generator |
| stxxl::vector_iterator< ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize > | External vector iterator, model of ext_random_access_iterator concept |
| stxxl::winner_tree< Comparator > | The class winner_tree is a binary tournament tree |
| stxxl::winner_tree< Comparator >::stats_type | Collection of stats from the winner_tree |
| stxxl::write_pool< BlockType >::busy_entry | |
| stxxl::swappable_block< ValueType, BlockSideLength *BlockSideLength > | |
| stxxl::matrix_swappable_block< ValueType, BlockSideLength > | Specialized swappable_block that interprets uninitialized as containing zeros |
| stxxl::tuple< typename Input1::value_type, typename Input2::value_type > | |
| stxxl::tuple< typename Input1::value_type, typename Input2::value_type, typename Input3::value_type > | |
| stxxl::tuple< typename Input1::value_type, typename Input2::value_type, typename Input3::value_type, typename Input4::value_type > | |
| stxxl::tuple< typename Input1::value_type, typename Input2::value_type, typename Input3::value_type, typename Input4::value_type, typename Input5::value_type > | |
| stxxl::tuple< typename Input1::value_type, typename Input2::value_type, typename Input3::value_type, typename Input4::value_type, typename Input5::value_type, typename Input6::value_type > | |
| stxxl::vector< ValueType > | |
| stxxl::column_vector< ValueType > | External column-vector container for matrix multiplication |
| stxxl::row_vector< ValueType > | External row-vector container for matrix multiplication |
| stxxl::winner_tree< stxxl::parallel_priority_queue::external_min_comparator > | |
| stxxl::winner_tree< stxxl::parallel_priority_queue::hint_comparator > | |
| stxxl::winner_tree< stxxl::ppq_local::minima_tree::head_comp > | |
| stxxl::winner_tree< stxxl::ppq_local::minima_tree::heaps_comp > | |
| stxxl::winner_tree< stxxl::ppq_local::minima_tree::ia_comp > | |
| BaseType | |
| stxxl::mng_local::add_filler< BaseType, FillSize > | Contains per block filler for stxxl::typed_block , not intended for direct use |
| stxxl::mng_local::add_filler< BaseType, 0 > | |
| Type | |
| stxxl::mng_local::add_filler< Type, RawSize-sizeof(Type)> | |
| stxxl::mng_local::expand_struct< Type, RawSize > | Helper to compute the size of the filler , not intended for direct use |
1.8.5 
