| bulk< n > | |
| bulk< 0 > | |
| noncopyable | |
| iterator | |
| vector | |
| stxxl::add_filler< BaseType_, FillSize_ > | Contains per block filler for stxxl::typed_block , not intended for direct use |
| stxxl::add_filler< BaseType_, 0 > | |
| 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< must_be_int > | |
| stxxl::ArrayOfSequencesIterator< array_type, value_type, modulo > | |
| stxxl::bad_ext_alloc | |
| stxxl::bad_parameter | |
| 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::bid_vector< BlkSize_ > | |
| stxxl::BIDArray< BLK_SIZE > | |
| stxxl::block_manager | Block manager class |
| stxxl::block_prefetcher< block_type, bid_iterator_type > | Encapsulates asynchronous prefetching engine |
| stxxl::block_scheduler< SwappableBlockType > | Schedules swapping of blocks and provides blocks for temporary storage |
| stxxl::block_scheduler< SwappableBlockType >::prediction_sequence_element | |
| 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_lfd< SwappableBlockType >::priority | |
| 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_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::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::block_w_bids< T, Size_, RawSize_, NBids_ > | Contains BID references for stxxl::typed_block , not intended for direct use |
| stxxl::block_w_bids< T, Size_, RawSize_, 0 > | |
| stxxl::block_w_info< T_, RawSize_, NBids_, InfoType_ > | Contains per block information for stxxl::typed_block , not intended for direct use |
| stxxl::block_w_info< T_, RawSize_, NBids_, void > | |
| stxxl::blocked_index< modulo > | |
| stxxl::btree::btree< KeyType, DataType, CompareType, RawNodeSize, RawLeafSize, PDAllocStrategy > | |
| stxxl::btree::btree_const_iterator< BTreeType > | |
| stxxl::btree::btree_iterator< BTreeType > | |
| stxxl::btree::btree_iterator_base< BTreeType > | |
| stxxl::btree::iterator_map< 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 > | |
| stxxl::btree::node_cache< NodeType, BTreeType >::bid_hash | |
| stxxl::btree::normal_leaf< KeyType_, DataType_, KeyCmp_, RawSize_, BTreeType > | |
| stxxl::btree::normal_leaf< KeyType_, DataType_, KeyCmp_, RawSize_, BTreeType >::InfoType | |
| stxxl::btree::normal_leaf< KeyType_, DataType_, KeyCmp_, RawSize_, BTreeType >::value_compare | |
| stxxl::btree::normal_node< KeyType_, KeyCmp_, RawSize_, BTreeType > | |
| stxxl::btree::normal_node< KeyType_, KeyCmp_, RawSize_, BTreeType >::InfoType | |
| stxxl::btree::normal_node< KeyType_, KeyCmp_, RawSize_, BTreeType >::value_compare | |
| stxxl::btree::root_node< KeyType, BIDType > | |
| stxxl::buf_istream< BlkTp_, BIDIteratorTp_ > | Buffered input stream |
| stxxl::buf_ostream< BlkTp_, BIDIteratorTp_ > | Buffered output stream |
| stxxl::buffered_writer< block_type > | Encapsulates asynchronous buffered block writing engine |
| stxxl::buffered_writer< block_type >::batch_entry | |
| stxxl::buffered_writer< block_type >::batch_entry_cmp | |
| stxxl::CASE< tag_, Type_, Next_ > | |
| stxxl::choose_int_types< PtrSize > | |
| stxxl::choose_int_types< 4 > | |
| stxxl::choose_int_types< 8 > | |
| stxxl::column_vector< ValueType > | External column-vector container for matrix multiplication |
| stxxl::compat::remove_const< _Tp > | |
| stxxl::compat::remove_const< _Tp const > | |
| stxxl::completion_handler | Completion handler class (Loki-style) |
| stxxl::completion_handler1< handler_type > | |
| stxxl::completion_handler_impl | |
| stxxl::config | Access point to disks properties |
| stxxl::config::DiskEntry | |
| stxxl::const_deque_iterator< DequeType > | |
| stxxl::const_matrix_col_major_iterator< ValueType, BlockSideLength > | Column-major const_iterator that points to single elements inside a matrix |
| stxxl::const_matrix_iterator< ValueType, BlockSideLength > | General const_iterator type 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_shared_object_pointer< C > | Behaves much like a Pointer, plus deleteing the referred object with it's last reference and ability to unify, i.e. make and refer a copy if the original object was shared |
| stxxl::const_vector_iterator< Tp_, AllocStr_, SzTp_, DiffTp_, BlkSize_, PgTp_, PgSz_ > | Const external vector iterator, model of ext_random_access_iterator concept |
| stxxl::default_completion_handler | Default completion handler class |
| stxxl::deque< T, VectorType > | A deque container |
| stxxl::deque2< ValueType, BlockSize, AllocStrategy, SizeType > | External deque container without random access |
| stxxl::deque2< ValueType, BlockSize, AllocStrategy, SizeType >::reverse_stream | |
| stxxl::deque2< ValueType, BlockSize, AllocStrategy, SizeType >::stream | |
| stxxl::deque_iterator< DequeType > | |
| stxxl::disk_queued_file | Implementation of some file methods based on serving_request |
| stxxl::disk_queues | Encapsulates disk queues |
| stxxl::DiskAllocator | |
| stxxl::DiskAllocator::FirstFit | |
| stxxl::DiskGeometry | |
| stxxl::DiskGeometry::Zone | |
| stxxl::DiskGeometry::ZoneCmp | |
| stxxl::double_blocked_index< size_type, modulo2, modulo1 > | |
| stxxl::element_block< T, Size_ > | Contains data elements for stxxl::typed_block , not intended for direct use |
| stxxl::element_iterator_traits< BlockType > | |
| stxxl::expand_struct< Tp_, RawSize_ > | Helper to compute the size of the filler , not intended for direct use |
| stxxl::feedable_strassen_winograd< ValueType, BlockSideLength, Level, AExists, BExists > | |
| stxxl::feedable_strassen_winograd< ValueType, BlockSideLength, 0, AExists, BExists > | |
| stxxl::feedable_strassen_winograd_block_grained< ValueType, BlockSideLength, Level, AExists, BExists > | |
| stxxl::feedable_strassen_winograd_block_grained< ValueType, BlockSideLength, 0, AExists, BExists > | |
| stxxl::file | Defines interface of file |
| stxxl::FileCreator | |
| 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::filler_struct__< bytes > | |
| stxxl::filler_struct__< 0 > | |
| stxxl::first_disk_only | |
| stxxl::FR | Fully randomized disk allocation scheme functor |
| stxxl::grow_shrink_stack< Config_ > | Efficient implementation that uses prefetching and overlapping using internal buffers |
| stxxl::grow_shrink_stack2< Config_ > | Efficient implementation that uses prefetching and overlapping using (shared) buffers pools |
| stxxl::helper::element_iterator_generator< BlockType, can_use_trivial_pointer > | |
| stxxl::helper::element_iterator_generator< BlockType, false > | |
| stxxl::helper::element_iterator_generator< BlockType, true > | |
| stxxl::IC35L080AVVA07 | |
| stxxl::IF< Flag, Type1, Type2 > | IF template metaprogramming statement |
| stxxl::IF< false, Type1, Type2 > | |
| stxxl::IF_N< Flag, Num1, 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_FR | |
| stxxl::interleaved_RC | |
| stxxl::interleaved_SR | |
| stxxl::interleaved_striping | |
| stxxl::io_error | |
| stxxl::ksort_defaultkey< record_type > | |
| stxxl::ksort_local::key_comparison< record_type, key_extractor > | |
| stxxl::ksort_local::run_cursor2_cmp< block_type, prefetcher_type, key_extractor > | |
| stxxl::ksort_local::trigger_entry< _BIDTp, _KeyTp > | |
| stxxl::ksort_local::type_key< type, key_type1 > | |
| stxxl::ksort_local::write_completion_handler< block_type, bid_type > | |
| stxxl::LOG2< Input > | |
| stxxl::LOG2< 0 > | |
| stxxl::LOG2< 1 > | |
| stxxl::LOG2_floor< Input > | |
| stxxl::LOG2_floor< 0 > | |
| stxxl::LOG2_floor< 1 > | |
| stxxl::logger | |
| stxxl::loser_tree< run_cursor_type, run_cursor_cmp_type > | |
| stxxl::low_level_matrix_binary_ass_op< ValueType, BlockSideLength, a_transposed, b_transposed, Op > | C = a <op> b; for arbitrary entries |
| stxxl::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::low_level_matrix_unary_ass_op< ValueType, BlockSideLength, a_transposed, Op > | C <op>= a; for arbitrary entries |
| stxxl::low_level_matrix_unary_op< ValueType, BlockSideLength, a_transposed, Op > | C = <op>a; for arbitrary entries |
| stxxl::lru_pager< npages_ > | Pager with LRU replacement strategy |
| stxxl::malloc_setup | |
| stxxl::malloc_stats | Access to some useful malloc statistics |
| stxxl::map< KeyType, DataType, CompareType, RawNodeSize, RawLeafSize, PDAllocStrategy > | External associative container |
| stxxl::matrix< ValueType, BlockSideLength > | External matrix container |
| stxxl::matrix_col_major_iterator< ValueType, BlockSideLength > | Column-major iterator that points to single elements inside a matrix |
| stxxl::matrix_iterator< ValueType, BlockSideLength > | General iterator type that points to single elements inside a matrix |
| stxxl::matrix_operation_statistic | |
| stxxl::matrix_operation_statistic_data | |
| stxxl::matrix_operation_statistic_dataset | |
| stxxl::matrix_operations< ValueType, BlockSideLength > | |
| stxxl::matrix_operations< ValueType, BlockSideLength >::addition | |
| stxxl::matrix_operations< ValueType, BlockSideLength >::scalar_multiplication | |
| stxxl::matrix_operations< ValueType, BlockSideLength >::subtraction | |
| stxxl::matrix_operations< ValueType, BlockSideLength >::swappable_block_matrix_approximative_quarterer | |
| stxxl::matrix_operations< ValueType, BlockSideLength >::swappable_block_matrix_padding_quarterer | |
| stxxl::matrix_operations< ValueType, BlockSideLength >::swappable_block_matrix_quarterer | |
| stxxl::matrix_row_major_iterator< ValueType, BlockSideLength > | Row-major iterator that points to single elements inside a matrix |
| stxxl::matrix_swappable_block< ValueType, BlockSideLength > | Specialized swappable_block that interprets uninitialized as containing zeros |
| stxxl::matrix_to_quadtree< ValueType, BlockSideLength, Level > | |
| stxxl::matrix_to_quadtree< ValueType, BlockSideLength, 0 > | |
| stxxl::matrix_to_quadtree_block_grained< ValueType, BlockSideLength, Level, Granularity > | |
| stxxl::matrix_to_quadtree_block_grained< ValueType, BlockSideLength, 0, Granularity > | |
| stxxl::mem_file | Implementation of file based on new[] and memcpy |
| stxxl::migrating_stack< CritSize, ExternalStack, InternalStack > | A stack that migrates from internal memory to external when its size exceeds a certain threshold |
| stxxl::mmap_file | Implementation of memory mapped access file |
| stxxl::mutex | |
| stxxl::new_alloc< T > | |
| stxxl::new_alloc< T >::rebind< U > | |
| stxxl::new_alloc_rebind< T, U > | |
| stxxl::new_alloc_rebind< T, T > | |
| stxxl::NilCase | |
| stxxl::normal_stack< Config_ > | External stack container |
| stxxl::offset_allocator< BaseAllocator_ > | Allocator functor adaptor |
| stxxl::onoff_switch | |
| stxxl::Plug | |
| stxxl::prefetch_pool< BlockType > | Implements dynamically resizable prefetching pool |
| stxxl::prefetch_pool< BlockType >::bid_hash | |
| stxxl::priority_queue< Config_ > | External priority queue data structure |
| stxxl::priority_queue_config< Tp_, Cmp_, BufferSize1_, N_, IntKMAX_, IntLevels_, BlockSize_, ExtKMAX_, ExtLevels_, AllocStr_ > | |
| stxxl::PRIORITY_QUEUE_GENERATOR< Tp_, Cmp_, IntM_, MaxS_, Tune_ > | Priority queue type generator |
| 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::ext_merger< BlockType_, Cmp_, Arity_, AllocStr_ > | External merger, based on the loser tree data structure. ! |
| stxxl::priority_queue_local::ext_merger< BlockType_, Cmp_, Arity_, AllocStr_ >::sequence_state | |
| stxxl::priority_queue_local::find_B_m< E_, IntM_, MaxS_, B_, m_, stop > | |
| stxxl::priority_queue_local::find_B_m< E_, IntM_, MaxS_, 2048, 1, stop > | |
| stxxl::priority_queue_local::find_B_m< E_, IntM_, MaxS_, B_, m_, true > | |
| stxxl::priority_queue_local::find_settings< E_, IntM_, MaxS_ > | |
| stxxl::priority_queue_local::internal_bounded_stack< Tp_, max_size_ > | Similar to std::stack, with the following differences: |
| stxxl::priority_queue_local::internal_priority_queue< _Tp, _Sequence, _Compare > | Similar to std::priority_queue, with the following differences: |
| stxxl::priority_queue_local::invert_order< Predicate, first_argument_type, second_argument_type > | Inverts the order of a comparison functor by swapping its arguments |
| stxxl::priority_queue_local::loser_tree< ValTp_, Cmp_, KNKMAX > | Loser tree from Knuth, "Sorting and Searching", Section 5.4.1 ! |
| stxxl::priority_queue_local::Parameters_for_priority_queue_not_found_Increase_IntM | |
| stxxl::priority_queue_local::Parameters_not_found_Try_to_change_the_Tune_parameter | |
| stxxl::priority_queue_local::short_sequence< Iterator > | |
| stxxl::queue< ValTp, BlkSz, AllocStr, SzTp > | External FIFO queue container |
| 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_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::RC | Randomized cycling disk allocation scheme functor |
| stxxl::RC_disk | |
| stxxl::RC_flash | |
| stxxl::read_write_pool< BlockType > | Implements dynamically resizable buffered writing and prefetched reading pool |
| stxxl::request | Request with basic properties like file and offset |
| stxxl::request_interface | Functional interface of a request |
| stxxl::request_ptr | Implemented as reference counting smart pointer |
| stxxl::request_queue | |
| stxxl::request_queue_impl_1q | |
| stxxl::request_queue_impl_qwqr | |
| stxxl::request_queue_impl_worker | |
| stxxl::request_with_state | Request with completion state |
| stxxl::request_with_waiters | Request that is aware of threads waiting for it to complete |
| stxxl::resource_error | |
| stxxl::row_vector< ValueType > | External row-vector container for matrix multiplication |
| stxxl::run_cursor< block_type > | |
| stxxl::run_cursor2< block_type, prefetcher_type_ > | |
| stxxl::RunsToBIDArrayAdaptor< _blk_sz, _run_type, __pos_type > | |
| stxxl::RunsToBIDArrayAdaptor2< _blk_sz, _run_type, __pos_type > | |
| stxxl::scoped_mutex_lock | Aquire a lock that's valid until the end of scope |
| stxxl::semaphore | |
| stxxl::serving_request | Request which serves an I/O by calling the synchronous routine of the file |
| stxxl::set_switch_handler | |
| stxxl::settings< must_be_int > | |
| stxxl::shared_object | Provides reference counting abilities for use with shared_object_pointer |
| stxxl::shared_object_pointer< C > | Behaves much like a Pointer, plus deleteing the referred object with it's last reference and ability to unify, i.e. make and refer a copy if the original object was shared |
| stxxl::sim_disk_file | Implementation of disk emulation |
| stxxl::simple_vector< _Tp > | |
| stxxl::single_disk | 'single disk' disk allocation scheme functor |
| stxxl::sort_helper::run_cursor2_cmp< block_type, prefetcher_type, value_cmp > | |
| stxxl::sort_helper::trigger_entry< BlockTp_, ValTp_ > | |
| stxxl::sort_helper::trigger_entry_cmp< TriggerEntryTp_, ValueCmp_ > | |
| stxxl::sort_local::read_next_after_write_completed< block_type, bid_type > | |
| stxxl::sorter< ValueType, CompareType, BlockSize, AllocStrategy > | External Sorter: use stream package objects to keep a sorted container |
| stxxl::SR | Simple randomized disk allocation scheme functor |
| stxxl::stable_ksort_local::bid_sequence< BIDType_, AllocStrategy_ > | |
| stxxl::stable_ksort_local::type_key< type > | |
| stxxl::stack_config_generator< ValTp, BlocksPerPage, BlkSz, AllocStr, SzTp > | |
| stxxl::STACK_GENERATOR< ValTp, Externality, Behaviour, BlocksPerPage, BlkSz, IntStackTp, MigrCritSize, AllocStr, SzTp > | Stack type generator |
| stxxl::state< Tp > | |
| stxxl::static_quadtree< ValueType, Level > | A static_quadtree holds 4^Level elements arranged in a quad tree |
| stxxl::static_quadtree< ValueType, 0 > | |
| stxxl::stats | Collects various I/O statistics |
| 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::basic_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::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::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::runs_creator< Input_, CompareType_, BlockSize_, AllocStr_ > | Forms sorted runs of data from a stream |
| 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::runs_merger< RunsType_, CompareType_, AllocStr_ > | Merges sorted runs |
| stxxl::stream::sort< Input_, CompareType_, BlockSize_, AllocStr_, runs_creator_type > | Produces sorted stream from input stream |
| stxxl::stream::sorted_runs< TriggerEntryType, CompareType_ > | All sorted runs of a sort operation |
| stxxl::stream::Stopper | |
| stxxl::stream::streamify_traits< InputIterator_ > | Traits class of streamify function |
| stxxl::stream::streamify_traits< stxxl::const_vector_iterator< Tp_, AllocStr_, SzTp_, DiffTp_, BlkSize_, PgTp_, PgSz_ > > | |
| stxxl::stream::streamify_traits< stxxl::vector_iterator< Tp_, AllocStr_, SzTp_, DiffTp_, BlkSize_, PgTp_, PgSz_ > > | |
| 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::swappable_block< ValueType, BlockSize > | Virtualization of a block of data. Holds information for allocating and swapping. To use in cooperation with block_scheduler |
| stxxl::swappable_block_matrix< ValueType, BlockSideLength > | External container for a (sub)matrix. Not intended for direct use |
| stxxl::SWITCH< tag, Case > | |
| stxxl::SWITCH< tag, NilCase > | |
| stxxl::switch_major_index< BlockSideLength, false > | |
| stxxl::switch_major_index< BlockSideLength, true > | |
| stxxl::syscall_file | Implementation of file based on UNIX syscalls |
| stxxl::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::TwoToOneDimArrayAdaptorBase< one_dim_array_type, data_type, pos_type > | |
| stxxl::typed_block< RawSize_, T_, NRef_, InfoType_ > | Block containing elements of fixed length |
| stxxl::ufs_file_base | Base for UNIX file system implementations |
| stxxl::unreachable | |
| stxxl::vector< Tp_, PgSz_, PgTp_, BlkSize_, AllocStr_, SzTp_ > | External vector container |
| stxxl::vector_bufwriter< VectorType > | Buffered sequential writer to a vector using overlapped I/O |
| stxxl::VECTOR_GENERATOR< Tp_, PgSz_, Pages_, BlkSize_, AllocStr_, Pager_ > | External vector type generator |
| stxxl::vector_iterator< Tp_, AllocStr_, SzTp_, DiffTp_, BlkSize_, PgTp_, PgSz_ > | External vector iterator, model of ext_random_access_iterator concept |
| stxxl::wbtl_file | Implementation of file based on buffered writes and block remapping via a translation layer |
| stxxl::wbtl_file::FirstFit | |
| stxxl::write_pool< BlockType > | Implements dynamically resizable buffered writing pool |
| stxxl::write_pool< BlockType >::busy_entry | |
| zero | |
1.7.6.1
