|
STXXL
1.4-dev
|
|
STXXL
1.4-dev
|
  std | STL namespace |
   numeric_limits< stxxl::uint_pair< HighType > > | Template class providing some numeric_limits fields for uint_pair types |
 stxxl | STXXL library namespace |
  async_schedule_local | |
| btree | |
| btree | |
| btree_const_iterator | |
| btree_iterator | |
| btree_iterator_base | |
| iterator_map | |
| bid_comp | |
| Key | |
| KeyCmp | |
| node_cache | |
| bid_hash | |
| normal_leaf | |
| metainfo_type | |
| value_compare | |
| normal_node | |
| metainfo_type | |
| value_compare | |
| root_node | |
| compat | |
| remove_const | |
| remove_const< Type const > | |
| hash_map | External memory hash-map |
| block_cache | Cache of blocks contained in an external memory hash map. Uses the stxxl::lru_pager as eviction algorithm |
| bid_eq | |
| bid_hash | |
| block_cache_write_buffer | Used inside block_cache for buffering write requests of cached blocks |
| bucket | |
| buffered_reader | Used to scan external memory with prefetching |
| buffered_writer | Buffered writing of values. New Blocks are allocated as needed |
| hash_map | Main implementation of external memory hash map |
| AddHashStream | |
| Cmp | Comparator object for values as required by stxxl::sort |
| equal_to | Construct an equality predicate from the comparison operator |
| HashedValueExtractor | Functor to extracts the actual value from a HashedValue-struct |
| HashingStream | Will return from its input-stream all values that are to be stored in the given bucket |
| StripHashFunctor | Extracts the value-part (ignoring the hashvalue); required by HashingStream (see above) |
| UniqueValueStream | Stream for filtering duplicates |
| hash_map_const_iterator | |
| hash_map_iterator | |
| hash_map_iterator_base | |
| HashedValue | Additional information about a stored value: |
| HashedValuesStream | Stream interface for all value-pairs currently stored in the map |
| iterator_map | |
| hasher | |
| node | |
| tuning | Tuning parameters for external memory hash map |
| helper | |
| element_iterator_generator | |
| element_iterator_generator< BlockType, SizeType, false > | |
| element_iterator_generator< BlockType, SizeType, true > | |
| ksort_local | |
| key_comparison | |
| run_cursor2_cmp | |
| trigger_entry | |
| type_key | |
| write_completion_handler | |
| matrix_local | Matrix low-level operations and tools |
| feedable_strassen_winograd | |
| feedable_strassen_winograd< ValueType, BlockSideLength, 0, AExists, BExists > | |
| feedable_strassen_winograd_block_grained | |
| feedable_strassen_winograd_block_grained< ValueType, BlockSideLength, 0, AExists, BExists > | |
| low_level_matrix_binary_ass_op | C = a [op] b; for arbitrary entries |
| low_level_matrix_multiply_and_add | 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 |
| low_level_matrix_unary_ass_op | C [op]= a; for arbitrary entries |
| low_level_matrix_unary_op | C =[op] a; for arbitrary entries |
| matrix_operations | |
| addition | |
| scalar_multiplication | |
| subtraction | |
| swappable_block_matrix_approximative_quarterer | |
| swappable_block_matrix_padding_quarterer | |
| swappable_block_matrix_quarterer | |
| matrix_to_quadtree | |
| matrix_to_quadtree< ValueType, BlockSideLength, 0 > | |
| matrix_to_quadtree_block_grained | |
| matrix_to_quadtree_block_grained< ValueType, BlockSideLength, 0, Granularity > | |
| static_quadtree | A static_quadtree holds 4^Level elements arranged in a quad tree |
| static_quadtree< ValueType, 0 > | |
| switch_major_index | |
| switch_major_index< BlockSideLength, false > | |
| switch_major_index< BlockSideLength, true > | |
| mng_local | Block Manager Internals |
| add_filler | Contains per block filler for stxxl::typed_block , not intended for direct use |
| add_filler< BaseType, 0 > | |
| block_w_bids | Contains BID references for stxxl::typed_block , not intended for direct use |
| block_w_bids< Type, Size, RawSize, 0 > | |
| block_w_info | Contains per block information for stxxl::typed_block , not intended for direct use |
| block_w_info< Type, RawSize, NBids, void > | |
| element_block | Contains data elements for stxxl::typed_block , not intended for direct use |
| expand_struct | Helper to compute the size of the filler , not intended for direct use |
| filler_struct | |
| filler_struct< 0 > | |
| parallel | |
| active_tag | |
| binary_negate | Alternative to std::not2, typedefs first_argument_type and second_argument_type not needed |
| equal_from_less | Constructs predicate for equality from strict weak ordering predicate |
| equal_to | |
| guarded_iterator | Iterator wrapper supporting an implicit supremum at the end of the sequence, dominating all comparisons |
| inactive_tag | |
| less | |
| lexicographic | Compare a pair of types lexcigraphically, ascending |
| lexicographic_rev | Compare a pair of types lexcigraphically, descending |
| loser_tree_traits | |
| loser_tree_traits< Stable, char, Comparator > | |
| loser_tree_traits< Stable, int, Comparator > | |
| loser_tree_traits< Stable, long long, Comparator > | |
| loser_tree_traits< Stable, long, Comparator > | |
| loser_tree_traits< Stable, short, Comparator > | |
| loser_tree_traits< Stable, unsigned char, Comparator > | |
| loser_tree_traits< Stable, unsigned int, Comparator > | |
| loser_tree_traits< Stable, unsigned long long, Comparator > | |
| loser_tree_traits< Stable, unsigned long, Comparator > | |
| loser_tree_traits< Stable, unsigned short, Comparator > | |
| loser_tree_traits_unguarded | |
| loser_tree_traits_unguarded< Stable, char, Comparator > | |
| loser_tree_traits_unguarded< Stable, int, Comparator > | |
| loser_tree_traits_unguarded< Stable, long long, Comparator > | |
| loser_tree_traits_unguarded< Stable, long, Comparator > | |
| loser_tree_traits_unguarded< Stable, short, Comparator > | |
| loser_tree_traits_unguarded< Stable, unsigned char, Comparator > | |
| loser_tree_traits_unguarded< Stable, unsigned int, Comparator > | |
| loser_tree_traits_unguarded< Stable, unsigned long long, Comparator > | |
| loser_tree_traits_unguarded< Stable, unsigned long, Comparator > | |
| loser_tree_traits_unguarded< Stable, unsigned short, Comparator > | |
| LoserTreeCopy | |
| LoserTreeCopy< true, ValueType, Comparator > | |
| LoserTreeCopyBase | |
| Loser | Internal representation of a loser tree player/node |
| LoserTreeCopyUnguarded | |
| LoserTreeCopyUnguarded< true, ValueType, Comparator > | |
| LoserTreeCopyUnguardedBase | |
| Loser | Internal representation of a loser tree player/node |
| LoserTreePointer | |
| LoserTreePointer< true, ValueType, Comparator > | |
| LoserTreePointerBase | |
| Loser | Internal representation of a loser tree player/node |
| LoserTreePointerUnguarded | |
| LoserTreePointerUnguarded< true, ValueType, Comparator > | |
| LoserTreePointerUnguardedBase | |
| Loser | Internal representation of a loser tree player/node |
| LoserTreeReference | |
| Loser | |
| NumberOfThreads | |
| Settings | |
| Timing | |
| Timing< inactive_tag, must_be_int > | |
| unguarded_iterator | |
| potentially_parallel | This namespace provides parallel or sequential algorithms depending on the compilation settings. it should be used by all components, where parallelism is optional |
| ppq_local | |
| external_array | External array stores a sorted sequence of values on the hard disk and allows access to the first block (containing the smallest values) |
| external_array_writer | |
| iterator | |
| internal_array | 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 |
| minima_tree | The minima_tree contains minima from all sources inside the PPQ |
| head_comp | WinnerTree-Comparator for the head winner tree. It accesses all relevant data structures from the priority queue |
| heaps_comp | Comparator for the insertion heaps winner tree |
| ia_comp | Comparator for the internal arrays winner tree |
| ppq_iterator | A random-access iterator class for block oriented data |
| priority_queue_local | |
| compute_N | |
| compute_N< 1, X_, CriticalSize_ > | |
| dummy | |
| ext_merger | External merger, based on the loser tree data structure |
| sequence_state | |
| find_B_m | |
| find_B_m< ElementSize, IntMem, MaxItems, 2048, 1, stop > | |
| find_B_m< ElementSize, IntMem, MaxItems, BlockSize, m_, true > | |
| find_settings | |
| int_merger | |
| internal_bounded_stack | Similar to std::stack, with the following differences: |
| internal_priority_queue | Similar to std::priority_queue, with the following differences: |
| invert_order | Inverts the order of a comparison functor by swapping its arguments |
| loser_tree | Loser tree from Knuth, "Sorting and Searching", Section 5.4.1 |
| Entry | Type of nodes in the loser tree |
| Parameters_for_priority_queue_not_found_Increase_IntMem | |
| Parameters_not_found_Try_to_change_the_Tune_parameter | |
| short_sequence | |
| sort_helper | |
| run_cursor2_cmp | |
| trigger_entry | |
| trigger_entry_cmp | |
| sort_local | |
| read_next_after_write_completed | |
| stable_ksort_local | |
| bid_sequence | |
| type_key | |
| stream | Stream package subnamespace |
| basic_runs_creator | Forms sorted runs of data from a stream |
| basic_runs_merger | Merges sorted runs |
| choose | |
| choose< Input, 1 > | Creates stream from a tuple stream taking the first component of each tuple |
| choose< Input, 2 > | Creates stream from a tuple stream taking the second component of each tuple |
| choose< Input, 3 > | Creates stream from a tuple stream taking the third component of each tuple |
| choose< Input, 4 > | Creates stream from a tuple stream taking the fourth component of each tuple |
| choose< Input, 5 > | Creates stream from a tuple stream taking the fifth component of each tuple |
| choose< Input, 6 > | Creates stream from a tuple stream taking the sixth component of each tuple |
| compute_sorted_runs_type | Computes sorted runs type from value type and block size |
| concatenate | |
| counter | |
| dummy_cmp_unique | |
| from_sorted_sequences | Input strategy for runs_creator class |
| generator2stream | A model of stream that outputs data from an adaptable generator functor. For convenience use streamify function instead of direct instantiation of generator2stream |
| iterator2stream | A model of stream that retrieves the data from an input iterator. For convenience use streamify function instead of direct instantiation of iterator2stream |
| make_tuple | Creates stream of 6-tuples from 6 input streams |
| make_tuple< Input1, Input2, Input3, Input4, Input5, Stopper > | Creates stream of 5-tuples from 5 input streams |
| make_tuple< Input1, Input2, Input3, Input4, Stopper, Stopper > | Creates stream of 4-tuples from 4 input streams |
| make_tuple< Input1, Input2, Input3, Stopper, Stopper, Stopper > | Creates stream of 3-tuples from 3 input streams |
| make_tuple< Input1, Input2, Stopper, Stopper, Stopper, Stopper > | Creates stream of 2-tuples (pairs) from 2 input streams |
| runs_creator | Forms sorted runs of data from a stream |
| runs_creator< from_sorted_sequences< ValueType >, CompareType, BlockSize, AllocStr > | Forms sorted runs of data taking elements in sorted order (element by element) |
| runs_creator< use_push< ValueType >, CompareType, BlockSize, AllocStr > | Forms sorted runs of elements passed in push() method |
| runs_merger | Merges sorted runs |
| sort | Produces sorted stream from input stream |
| sorted_runs | All sorted runs of a sort operation |
| Stopper | |
| streamify_traits | Traits class of streamify function |
| streamify_traits< stxxl::const_vector_iterator< ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize > > | |
| streamify_traits< stxxl::vector_iterator< ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize > > | |
| transform | Processes (up to) 6 input streams using given operation functor |
| transform< Operation, Input1, Input2, Input3, Input4, Input5, Stopper > | Processes 5 input streams using given operation functor |
| transform< Operation, Input1, Input2, Input3, Input4, Stopper, Stopper > | Processes 4 input streams using given operation functor |
| transform< Operation, Input1, Input2, Input3, Stopper, Stopper, Stopper > | Processes 3 input streams using given operation functor |
| transform< Operation, Input1, Input2, Stopper, Stopper, Stopper, Stopper > | Processes 2 input streams using given operation functor |
| transform< Operation, Input1, Stopper, Stopper, Stopper, Stopper, Stopper > | Processes an input stream using given operation functor |
| unique | Equivalent to std::unique algorithms |
| unique< Input, dummy_cmp_unique > | Equivalent to std::unique algorithms |
| use_push | Input strategy for runs_creator class |
| vector_iterator2stream | 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 |
| vector_iterator2stream_sr | Version of iterator2stream. Switches between vector_iterator2stream and iterator2stream |
| addressable_fifo_queue | An internal fifo queue that allows removing elements addressed with (a copy of) themselves |
| addressable_priority_queue | An internal priority queue that allows removing elements addressed with (a copy of) themselves |
| cmp | |
| aligned_alloc_settings | |
| array_of_sequences_iterator | |
| atomic_counted_object | Provides reference counting abilities for use with counting_ptr with mutex locking |
| bad_ext_alloc | |
| bad_parameter | |
| basic_allocation_strategy | Example disk allocation scheme functor |
| BID | Block identifier class |
| BID< 0 > | Specialization of block identifier class (BID) for variable size block size |
| BIDArray | |
| 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 |
| binary_buffer_ref | Binary_buffer_ref represents a memory area as pointer and valid length |
| binary_reader | Binary_reader represents a binary_buffer_ref with an additional cursor with which the memory can be read incrementally |
| block_manager | Block manager class |
| block_prefetcher | Encapsulates asynchronous prefetching engine |
| block_scheduler | Schedules swapping of blocks and provides blocks for temporary storage |
| prediction_sequence_element | |
| block_scheduler_algorithm | Interface of a block scheduling algorithm |
| block_scheduler_algorithm_offline_lfd | Block scheduling algorithm caching via the longest forward distance policy (offline) |
| priority | |
| block_scheduler_algorithm_offline_lru_prefetching | Block scheduling algorithm caching via the least recently used policy (offline), and prefetching in addition |
| read_after_write | |
| scheduled_block_meta | |
| write_read_request | |
| block_scheduler_algorithm_online_lru | Block scheduling algorithm caching via the least recently used policy (online) |
| block_scheduler_algorithm_simulation | Pseudo block scheduling algorithm only recording the request sequence |
| blocked_index | |
| buf_istream | Buffered input stream |
| buf_istream_reverse | Buffered input stream, reading the items in the blocks in reverse order |
| buf_ostream | Buffered output stream |
| buffered_writer | Encapsulates asynchronous buffered block writing engine |
| batch_entry | |
| batch_entry_cmp | |
| CASE | |
| choose_int_types | |
| choose_int_types< 4 > | |
| choose_int_types< 8 > | |
| cmdline_parser | |
| argument | Base class of all options and parameters |
| argument_bytes32 | Specialization of argument for SI/IEC suffixes byte size options or parameters |
| argument_bytes64 | Specialization of argument for SI/IEC suffixes byte size options or parameters |
| argument_double | Specialization of argument for double options or parameters |
| argument_flag | Specialization of argument for boolean flags (can only be set to true) |
| argument_int | Specialization of argument for integer options or parameters |
| argument_string | Specialization of argument for string options or parameters |
| argument_stringlist | Specialization of argument for multiple string options or parameters |
| argument_uint | Specialization of argument for unsigned integer options or parameters |
| column_vector | External column-vector container for matrix multiplication |
| compat_hash | |
| compat_hash_map | |
| compat_hash_multimap | |
| compat_unique_ptr | |
| completion_handler | Completion handler class (Loki-style) |
| completion_handler1 | |
| completion_handler_impl | |
| condition_variable | |
| config | Access point to disks properties. Since 1.4.0: no config files are read automatically! |
| const_counting_ptr | High-performance smart pointer used as a wrapping reference counting pointer |
| const_deque_iterator | |
| const_matrix_col_major_iterator | Column-major const_iterator that points to single elements inside a matrix |
| const_matrix_iterator | General const_iterator type that points to single elements inside a matrix |
| const_matrix_row_major_iterator | Row-major const_iterator that points to single elements inside a matrix |
| const_vector_iterator | Const external vector iterator, model of ext_random_access_iterator concept |
| counted_object | Provides reference counting abilities for use with counting_ptr |
| counting_ptr | High-performance smart pointer used as a wrapping reference counting pointer |
| custom_stats_counter | This class provides a statistical counter that can easily be deactivated using a typedef to dummy_custom_stats_counter |
| deque | A deque container. Introduction to deque container: see STXXL Deque tutorial. Design and Internals of deque container: see Deque |
| deque_iterator | |
| disk_allocator | |
| first_fit | |
| 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 |
| disk_queued_file | Implementation of some file methods based on serving_request |
| disk_queues | Encapsulates disk queues |
| double_blocked_index | |
| dummy_custom_stats_counter | Dummy class for custom_stats_counter |
| element_iterator_traits | |
| external_shared_ptr | 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 |
| fake_timer | Class fake_timer is a drop-in replacement for timer, which does nothing |
| file | Defines interface of file |
| fileperblock_file | Implementation of file based on other files, dynamically allocate one file per block. Allows for dynamic disk space consumption |
| first_disk_only | |
| FR | Fully randomized disk allocation scheme functor |
| grow_shrink_stack | Efficient implementation that uses prefetching and overlapping using internal buffers |
| grow_shrink_stack2 | Efficient implementation that uses prefetching and overlapping using (shared) buffers pools |
| IC35L080AVVA07 | |
| IF | IF template metaprogramming statement |
| IF< false, Type1, Type2 > | |
| IF_N | If Flag is true then IF<>::result is Num1 otherwise of IF<>::result is Num2 |
| IF_N< false, Num1, Num2 > | |
| interleaved_alloc_traits | |
| interleaved_alloc_traits< FR > | |
| interleaved_alloc_traits< RC > | |
| interleaved_alloc_traits< RC_disk > | |
| interleaved_alloc_traits< RC_flash > | |
| interleaved_alloc_traits< single_disk > | |
| interleaved_alloc_traits< SR > | |
| interleaved_alloc_traits< striping > | |
| interleaved_FR | |
| interleaved_RC | |
| interleaved_SR | |
| interleaved_striping | |
| io_error | |
| ksort_defaultkey | |
| linuxaio_file | Implementation of file based on the Linux kernel interface for asynchronous I/O |
| linuxaio_queue | Queue for linuxaio_file(s) |
| linuxaio_request | Request for an linuxaio_file |
| LOG2 | |
| LOG2< 0 > | |
| LOG2< 1 > | |
| LOG2_floor | |
| LOG2_floor< 0 > | |
| LOG2_floor< 1 > | |
| logger | |
| loser_tree | |
| lru_pager | Pager with LRU replacement strategy |
| malloc_setup | |
| malloc_stats | Access to some useful malloc statistics |
| map | External associative container (map). Introduction to map container: see STXXL Map (B+-tree) tutorial. Design and Internals of map container: see Map (B+-tree) |
| matrix | External matrix container. Introduction to matrix container: see STXXL Matrix tutorial. Design and Internals of matrix container: see Matrix |
| matrix_col_major_iterator | Column-major iterator that points to single elements inside a matrix |
| matrix_iterator | General iterator type that points to single elements inside a matrix |
| matrix_operation_statistic | |
| matrix_operation_statistic_data | |
| matrix_operation_statistic_dataset | |
| matrix_row_major_iterator | Row-major iterator that points to single elements inside a matrix |
| matrix_swappable_block | Specialized swappable_block that interprets uninitialized as containing zeros |
| mem_file | Implementation of file based on new[] and memcpy |
| migrating_stack | A stack that migrates from internal memory to external when its size exceeds a certain threshold |
| mmap_file | Implementation of memory mapped access file |
| mutex | |
| new_alloc | |
| rebind | |
| new_alloc_rebind | |
| new_alloc_rebind< Type, Type > | |
| NilCase | |
| noncopyable | |
| normal_stack | 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 |
| offset_allocator | Allocator functor adaptor |
| onoff_switch | |
| parallel_priority_queue | Parallelized External Memory Priority Queue |
| empty_external_array_eraser | Unary operator which returns true if the external array has run empty |
| empty_internal_array_eraser | Unary operator which returns true if the internal array has run empty |
| external_min_comparator | Compares the largest accessible value of two external arrays |
| hint_comparator | Compares the largest value of the block hinted the latest of two external arrays |
| inv_compare_type | Inverse comparison functor |
| ProcessorData | A struct containing the local insertion heap and other information local to a processor |
| s_min_tree_comparator | |
| stats_type | Struct of all statistical counters and timers. Turn on/off statistics using the stats_counter and stats_timer typedefs |
| Plug | |
| prefetch_pool | Implements dynamically resizable prefetching pool |
| bid_hash | |
| priority_queue | 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 |
| priority_queue_config | |
| PRIORITY_QUEUE_GENERATOR | Priority queue type generator. Introduction to priority queue container: see STXXL Priority Queue tutorial. Design and Internals of priority queue container: see Priority Queue |
| queue | External FIFO queue container. Introduction to queue container: see STXXL Queue tutorial Design and Internals of queue container: see Queue |
| random_number | Uniform [0, N) pseudo-random generator |
| random_number32 | Fast uniform [0, 2^32) pseudo-random generator with period 2^32, random bits: 32 |
| 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 |
| random_number64 | Slow and precise uniform [0, 2^64) pseudo-random generator |
| random_number8_r | Fast uniform [0, 255] pseudo-random generator with period 2^8, random bits: 8 (one byte) |
| random_pager | Pager with random replacement strategy |
| random_uniform_fast | Fast uniform [0.0, 1.0) pseudo-random generator |
| random_uniform_slow | Slow and precise uniform [0.0, 1.0) pseudo-random generator period: at least 2^48, random bits: at least 31 |
| RC | Randomized cycling disk allocation scheme functor |
| RC_disk | |
| RC_flash | |
| read_write_pool | Implements dynamically resizable buffered writing and prefetched reading pool |
| request | Request object encapsulating basic properties like file and offset |
| request_interface | Functional interface of a request |
| request_queue | Interface of a request_queue to which requests can be added and canceled |
| 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 |
| 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 |
| 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 |
| request_with_state | Request with completion state |
| request_with_waiters | Request that is aware of threads waiting for it to complete |
| resource_error | |
| row_vector | External row-vector container for matrix multiplication |
| run_cursor | |
| run_cursor2 | |
| runs2bid_array_adaptor | |
| runs2bid_array_adaptor2 | |
| scoped_mutex_lock | Aquire a lock that's valid until the end of scope |
| scoped_print_timer | Simple scoped timer, which takes a text message and prints the duration until the scope is destroyed |
| semaphore | |
| sequence | External sequence or deque container without random access. Introduction to sequence container: see STXXL Sequence tutorial. Design and Internals of sequence container: see Queue |
| reverse_stream | |
| stream | |
| serving_request | Request which serves an I/O by calling the synchronous routine of the file |
| set_switch_handler | |
| settings | |
| sim_disk_file | Implementation of disk emulation |
| simdisk_geometry | |
| Zone | |
| ZoneCmp | |
| simple_vector | Simpler non-growing vector without initialization |
| single_disk | 'Single disk' disk allocation scheme functor |
| singleton | |
| sorter | External sorter container. Introduction to sorter container: see STXXL Sorter tutorial. Design and Internals of sorter container: see Sorter |
| SR | Simple randomized disk allocation scheme functor |
| stack_config_generator | |
| STACK_GENERATOR | Stack type generator Introduction to stack container: see STXXL Stack tutorial. Design and Internals of stack container: see Stack |
| state | |
| stats | Collects various I/O statistics |
| scoped_read_timer | |
| scoped_read_write_timer | |
| scoped_wait_timer | |
| scoped_write_timer | |
| stats_data | |
| striping | Striping disk allocation scheme functor |
| swap_vector | Vector that avoids copying of ValueType objects in push_back() (here: swap_back()) and resize() operations |
| swappable_block | Virtualization of a block of data. Holds information for allocating and swapping. To use in cooperation with block_scheduler |
| swappable_block_matrix | External container for a (sub)matrix. Not intended for direct use |
| SWITCH | |
| SWITCH< tag, NilCase > | |
| syscall_file | Implementation of file based on UNIX syscalls |
| timer | Class timer is a simple stop watch timer |
| trigger_entry_iterator | |
| tuple | K-Tuple data type |
| item_type | |
| tuple< T1, Plug, Plug, Plug, Plug > | Partial specialization for 1- tuple |
| item_type | |
| tuple< T1, T2, Plug, Plug, Plug, Plug > | Partial specialization for 2- tuple (equivalent to std::pair) |
| item_type | |
| tuple< T1, T2, T3, Plug, Plug, Plug > | Partial specialization for 3- tuple (triple) |
| item_type | |
| tuple< T1, T2, T3, T4, Plug, Plug > | Partial specialization for 4- tuple |
| item_type | |
| tuple< T1, T2, T3, T4, T5, Plug > | Partial specialization for 5- tuple |
| item_type | |
| tuple_base | |
| item_type | |
| tuple_greater1st | |
| tuple_less1st | |
| tuple_less1st_less2nd | |
| tuple_less2nd | |
| tuple_less2nd_less1st | |
| two2one_dim_array_adapter_base | |
| typed_block | Block containing elements of fixed length |
| ufs_file_base | Base for UNIX file system implementations |
| uint_pair | Construct an 40-bit or 48-bit unsigned integer stored in five or six bytes |
| unordered_map | An external memory implementation of the STL unordered_map container, which is based on an external memory hash map |
| unreachable | |
| vector | External vector container. Introduction to vector container: see STXXL Vector tutorial. Design and Internals of vector container: see Vector |
| bid_vector | |
| vector_bufreader | Buffered sequential reader from a vector using overlapped I/O |
| vector_bufreader_iterator | Adapter for vector_bufreader to match iterator requirements of C++11 range-based loop construct |
| vector_bufreader_reverse | Buffered sequential reverse reader from a vector using overlapped I/O |
| vector_bufwriter | Buffered sequential writer to a vector using overlapped I/O |
| VECTOR_GENERATOR | External vector type generator |
| vector_iterator | External vector iterator, model of ext_random_access_iterator concept |
| wbtl_file | Implementation of file based on buffered writes and block remapping via a translation layer |
| FirstFit | |
| wfs_file_base | Base for Windows file system implementations |
| wincall_file | Implementation of file based on Windows native I/O calls |
| winner_tree | The class winner_tree is a binary tournament tree |
| stats_type | Collection of stats from the winner_tree |
| write_pool | Implements dynamically resizable buffered writing pool |
| busy_entry |
1.8.5 
