| rpa::__assert_le< IterCat > | Used to check whether an interval iterator is shorter or equal a given size |
| rpa::__assert_le< std::output_iterator_tag > | If the iterator is an output_iterator, we cannot check anything |
| rpa::accumulate_args< RngIn, RetType, BinOp > | For storing the arguments of 'accumulate' |
| rpa::accumulate_args< RngIn, RetType, void_functor > | Specialisation when there is no functor. That is, when 'operator+' is used |
| rpa::accumulate_loop_t< Args, Task, Thread > | |
| rpa::accumulate_t< Range, Type, BinOp > | |
| rpa::accumulate_vec< Args, range_jump< ItIn >, BinOp, ThrIter > | This applies to interleave scheduling |
| rpa::accumulate_vec< Args, range_size< ItIn >, BinOp, ThrIter > | |
| rpa::accumulate_vec< Args, range_step< ItIn, Mutex >, BinOp, ThrIter > | |
| rpa::accumulate_vec< Args, range_step< ItIn, Mutex >, BinOp, ThrIter >::conditional_accumulate_args | |
| adder24< Type > | This functor is used by rpa::accumulate, and is identical to std::plus |
| rpa::adv< Iter, std::bidirectional_iterator_tag > | |
| rpa::adv< Iter, std::forward_iterator_tag > | |
| rpa::adv< Iter, std::random_access_iterator_tag > | |
| rpa::atomic< Iter > | Models a couple of simple atomic operations for an arbitrary datatype |
| rpa::atomic< deque< double >::const_iterator > | |
| rpa::atomic< double_list_const_iter_t > | |
| rpa::atomic< double_vector_const_iter_t > | |
| rpa::atomic< RPA_LIST_ITERATOR(Type) > | This emulates with a mutex, the atomic manipulation of a list iterator |
| rpa::atomic< RPA_LIST_ITERATOR_CONST(Type) > | This emulates with a mutex, the atomic use of a list const iterator |
| rpa::atomic< RPA_SET_ITERATOR(Type) > | |
| rpa::atomic< RPA_SET_ITERATOR_CONST(Type) > | |
| rpa::atomic< RPA_VECTOR_ITERATOR(Type, Alloc) > | |
| rpa::atomic< RPA_VECTOR_ITERATOR_CONST(Type, Alloc) > | |
| rpa::atomic< set< double >::const_iterator > | |
| rpa::atomic< std::back_insert_iterator< Type > > | |
| rpa::atomic< string_vector_const_iter_t > | |
| rpa::atomic< string_vector_iter_t > | |
| rpa::atomic_condition< Mutex, AtomicBool > | |
| rpa::atomic_mutex< Iter, Mutex > | For implementing atomic access to a datatype without atomic operations |
| rpa::atomic_mutex< Iter, Mutex >::atomic_type | Atomic data type associated to 'Iter' |
| rpa::augm_basic_filebuf< DerivStrmBuf > | |
| rpa::augm_basic_streambuf< DerivStrmBuf > | |
| rpa::augm_basic_stringbuf< DerivStrmBuf > | |
| rpa::augm_selector< DerivStrmBuf > | |
| basic_streambuf | |
| rpa::BeginEnd< ContOut > | |
| rpa::BeginEnd< TypeOut[aNb] > | Specialisation, if the container type is a plain C-style array |
| rpa::binary_function_count< Ftor > | |
| rpa::bound_check< Iterator > | |
| rpa::buffer_setter< row_buffer< Type, DerivStrmBuf *, Augm > > | |
| rpa::Carray_to_iterator< IterBuf > | |
| rpa::Carray_to_iterator< Buffer[N] > | If the iterator on buffers is a C-style array, we process it like a pointer |
| rpa::cas1< Iter > | Default version of 'compare_and_swap', in order to be able to compile |
| rpa::cas1< deque< double >::const_iterator > | |
| rpa::cas1< double_list_const_iter_t > | |
| rpa::cas1< double_vector_const_iter_t > | |
| rpa::cas1< RPA_LIST_ITERATOR(Type) > | |
| rpa::cas1< RPA_LIST_ITERATOR_CONST(Type) > | |
| rpa::cas1< RPA_SET_ITERATOR(Type) > | |
| rpa::cas1< RPA_SET_ITERATOR_CONST(Type) > | |
| rpa::cas1< RPA_VECTOR_ITERATOR(Type, Alloc) > | |
| rpa::cas1< RPA_VECTOR_ITERATOR_CONST(Type, Alloc) > | |
| rpa::cas1< set< double >::const_iterator > | |
| rpa::cas1< string_vector_const_iter_t > | |
| rpa::cas1< string_vector_iter_t > | |
| rpa::cas1_mutex< Iter, Mutex > | Emulates a compare-and-swap with a mutex |
| rpa::cas2< Iter1, Iter2 > | Default version of double compare_and_swap, in order to be able to compile |
| rpa::cas2< const Type *, RPA_LIST_ITERATOR(Type) > | |
| rpa::cas2< const Type *, size_t > | |
| rpa::cas2< RPA_LIST_ITERATOR_CONST(Type), RPA_LIST_ITERATOR(Type) > | |
| rpa::cas2< RPA_LIST_ITERATOR_CONST(Type), size_t > | |
| rpa::cas2< RPA_SET_ITERATOR_CONST(Type), size_t > | |
| rpa::cas2< RPA_VECTOR_ITERATOR_CONST(Type, Alloc), size_t > | |
| rpa::cas2< RPA_VECTOR_ITERATOR_CONST(Type, std::allocator< Type >), RPA_LIST_ITERATOR(Type) > | |
| rpa::cas2_mutex< Iter1, Iter2, Mutex > | Emulates a double compare-and-swap with a mutex |
| Char2Data | This functor will be applied to each argument of the command line |
| Char2Str | This because we want to use the algorithm 'transform' |
| CharPtr2String | |
| rpa::chunk_t | Used to store the minimum size of a chunk of elements, for efficiency |
| CmpWithMtx | |
| CmpWithoutMtx | When there is no input mutex, and atomic range_step must be used |
| rpa::Comparer< BeginEndType, ThrBehaviourType, Rnguence > | |
| rpa::Comparer< BeginEndType, thread_traits_def::is_parallel, range_jump< Iter > > | |
| rpa::Comparer< BeginEndType, thread_traits_def::is_sequential, Rnguence > | |
| rpa::Comparer< BeginEndType, thread_traits_def::is_undeterministic, range_jump< Iter > > | |
| rpa::Comparer< BeginEndType, thread_traits_def::is_undeterministic, range_size< Iter > > | |
| rpa::Comparer< BeginEndType, thread_traits_def::is_undeterministic, range_step< Iter, Mutex > > | |
| ConstChar2StdString | This functor will be applied to each argument of the command line |
| ConstChar2String | |
| rpa::container_traits< Container > | For a container type, gives some type information |
| rpa::container_traits< const row_buffer< Type, DerivStrmBuf, Augm > > | The properties of a container and a const-container are similar |
| rpa::container_traits< Container & > | |
| rpa::container_traits< row_buffer< Type, DerivStrmBuf, Augm > > | |
| rpa::container_traits< row_buffer< Type, DerivStrmBuf, Augm > >::local_void | |
| rpa::container_traits< Type(&)[N] > | This is a specialization of container_traits for C-style fixed arrays |
| rpa::container_traits< Type[N] > | If the so-called 'container' is a C-style fixed-size array |
| rpa::ContInBox< ContIn > | |
| rpa::ContInBox< Type[aNb] > | Specialisation, if the input container is a plain C-style array |
| rpa::coroutine_step< AccumulateVec, Ftor > | Used only in the specialisation of accumulate_vec for range_step |
| rpa::coroutine_step< AccumulateVec, void_functor > | If the original functor is in fact 'operator+' |
| rpa::cost_t | |
| counted_ptr< X > | |
| counted_ptr< X >::counter | |
| DataIn | After the template specializations, comes the library |
| DataOut | |
| DataT | |
| Dbl2Int | |
| rpa::dump_row_iterator< Type, OutStrmBuf, ContIn > | |
| rpa::dump_row_iterator< Type, OutStrmBuf, row_buffer< Type, DerivStrmBuf, Augm > > | |
| rpa::effective_streambuf< StrmBuf > | |
| rpa::effective_streambuf< StrmBuf * > | |
| Elt | This acts as two different lists |
| EnumMyTypes | |
| rpa::EnumThr | |
| rpa::exception_errno | A simple exception class for reporting 'errno' errors |
| rpa::false_t | |
| rpa::fd_ctrl | |
| rpa::fd_visitor | For writing memory segments into an integer file descriptor |
| rpa::FILE_ctrl | |
| rpa::file_unlocker | |
| rpa::file_unlocker_adapter< FileGenerator > | |
| rpa::FILE_visitor | For writing memory segments into a POSIX file |
| filebuf_FsTmpNam | Declared as a struct to make compile faster than typedef |
| rpa::filgen_fd_to_FILE< FdGenerator > | |
| rpa::filgen_fd_to_FILE_base | |
| rpa::filgen_FILE_to_fd< FileGenerator > | |
| rpa::filgen_mkstemp< NameGenerator > | |
| rpa::filgen_mkstemp_base | |
| rpa::filgen_mkstemp_default_template | |
| rpa::filgen_name_to_fd< NameGenerator > | |
| rpa::filgen_name_to_fd_base | |
| rpa::filgen_name_to_FILE< NameGenerator > | |
| rpa::filgen_name_to_FILE_base | |
| rpa::filgen_tmpfile | |
| rpa::filgen_tmpnam | For creating temporary file names, for test programs |
| Flt2Int | |
| rpa::fmt_output_to_buffer< Buffer > | |
| rpa::fmt_output_to_buffer< obuf_iterator< orow_iterator< Type, OutStrmBuf >, row_buffer< Type, BufDerivStrmBuf, Augm >, IterBuf, Mutex > > | |
| FtorChar2String | |
| FuncLockSingleType< Mtx > | |
| rpa::functor_traits< Ftor > | Models the fact that some algorithms have an implicit functor |
| rpa::functor_traits< void > | Specialization when there is no functor at all |
| FunctorCharPtr2String | This functor will be applied to each argument of the command line |
| FunctorXXXX< double > | Returns true if square number |
| FunctorXXXX< int > | Returns true if odd integer |
| FunctorYYYY< double > | Returns true if not square number |
| FunctorYYYY< int > | Returns true if even integer |
| rpa::future< Ftor, Thr > | Allows the execution of a functor in a thread |
| rpa::guard< Mutex > | Used to be sure that mutex are properly unlocked after being locked |
| identity22< Type > | |
| identity23< Type > | For debugging how the algorithm 'transform' uses its variables |
| identity24< Type > | |
| identity25< Type > | For debugging how the algorithm 'transform' uses its variables |
| identity26< Type > | |
| rpa::insert_invalidates_iterators< Container > | Tells whether an insertion into an container invalidates iterators or not |
| rpa::insert_invalidates_iterators< std::deque< Type, Alloc > > | |
| rpa::insert_invalidates_iterators< std::list< Type, Alloc > > | |
| rpa::insert_invalidates_iterators< std::vector< Type, Alloc > > | |
| rpa::iota_iterator< Type > | A kind of 'iota, a value behaving like an iterator. For tests |
| rpa::istream_iterator_delimiter< _Tp, _CharT, _Traits, _Dist > | |
| rpa::iterator_buffer_traits< IterBuf > | Given an iterator on buffers, this gives the datatype of individual buffers |
| rpa::iterator_jump_fllw< It > | |
| rpa::iterator_jump_lead< It > | |
| rpa::iterator_lock< It, Mutex > | To protect an output iterator |
| rpa::iterator_lock< It, void > | To specify that an output iterator is lock-free (NOT IMPLEMENTED YET) |
| list_head | |
| LoopIn< ThrTree, Type > | |
| LoopIn< ThrTree, Type >::LoopOut< ContIn > | |
| LoopIn< ThrTree, Type >::LoopOut< ContIn >::LoopRng< ContOut > | |
| LoopIn< ThrTree, Type >::LoopRng< ContIn > | |
| LstDataOut | |
| rpa::mmap_ctrl | |
| rpa::mmap_ctrl::segment | |
| rpa::mover< Type, IsPod > | This template makes a destructive assignment, if 'swap' is available |
| rpa::mover< Type, false > | This applies when the data type does not have 'swap' |
| rpa::mutex_count< Mutex > | Wraps a mutex to count the number of times it is un-/try/-locked |
| rpa::mutex_count_base | Does the actual counting for the template class 'thread_count' |
| rpa::mutex_void | 'Do-nothing' mutex, to be used with fake threads, for testing purpose |
| rpa::mutex_void::exception_t | |
| rpa::no_swap | No_swap::operator,('x') does not return a char, so sizeof returns 2 |
| ObjT | |
| rpa::obuf_base< IterOut, Buffer > | Just for storing some internal data types |
| rpa::obuf_base< orow_iterator< Type, OutStrmBuf >, Buffer > | |
| rpa::obuf_base< std::back_insert_iterator< Container >, Buffer > | |
| rpa::obuf_base< std::back_insert_iterator< std::list< Type, Alloc > >, std::list< Type, Alloc > > | |
| rpa::obuf_guard< Mutex > | Encapsulates the mutex and the maximum size of per-threads buffers |
| rpa::obuf_guard< Mutex >::inner_guard | |
| rpa::obuf_iterator< IterOut, Buffer, IterBuf, Mutex > | 'obuf_iterator' attempts to encapsulate output iterators, |
| rpa::obuf_iterator< IterOut, Buffer, IterBuf, void > | No mutex, so infinite-size buffer |
| rpa::obuf_iterator< IterOut, Buffer, void, Mutex > | Specialization when there is no generator of buffers |
| rpa::obuf_iterator< IterOut, Buffer, void, void > | Specialization for when no iterator on available buffers is provided |
| rpa::obuf_iterator< IterOut, Type[N], IterBuf, void > | |
| rpa::obuf_slice_bounded< RangeOutp > | This is the slice used by an obuf_iterator whose buffers have a size limit |
| rpa::obuf_slice_unbounded< RangeOutp > | This represents the slice of an obuf_iterator with infinite-size buffers |
| rpa::obuf_storage< Buffer, IterBuf > | |
| rpa::obuf_storage< Buffer, IterBuf >::internal_buffer | |
| rpa::obuf_storage< Buffer, void > | |
| rpa::obuf_storage< Buffer, void >::internal_buffer | This contains an actual object allocated on the stack |
| rpa::obuf_storage< Buffer, void >::internal_empty | Empty structure to avoid any memory manipulation |
| rpa::obuf_storage< Type[N], IterBuf > | |
| rpa::obuf_storage< Type[N], IterBuf >::internal_buffer | This shares the same container properties as the physical buffer it points to |
| rpa::obuf_storage< Type[N], void > | |
| rpa::obuf_storage< Type[N], void >::internal_buffer | This contains an actual object allocated on the stack |
| rpa::obuf_storage< Type[N], void >::internal_empty | Empty structure to avoid any memory manipulation |
| oper_dbg< _Tp > | General case. Should never be called |
| oper_dbg< char > | We use only lower-case letters, because it is easier to detect an error |
| oper_dbg< float > | |
| oper_dbg< FLT_TYPE > | |
| rpa::orow_iterator< Type, OutStrmBuf > | Provides output iterator semantics for streams. It is taken and adapted from the GCC library. For us, its role is to gather the ostream and the delimiter into a single object. We do not have the choice because there is no way to access to the internal components of a std::ostream_iterator. We had the same problem with obuf_iterator< std::back_inserter > |
| rpa::output_iterator_traits< It2 > | |
| rpa::output_iterator_traits< std::back_insert_iterator< Container > > | |
| rpa::pipe_arc_aux< Container, CondVar, insertInvalidatesIterators > | |
| rpa::pipe_arc_aux< Container, CondVar, true > | |
| rpa::pipe_arc_base< Container, CondVar > | Base class for pipe_archiver. Does not depend on the container type |
| rpa::pipe_arc_base< Container, CondVar >::reader | Models how to read from a pipe_archiver |
| rpa::pipe_archiver< Container, CondVar > | |
| rpa::pipe_archiver< Container, void > | This very simplified specialization is here only for completeness |
| rpa::pipe_archiver< Container, void >::reader | Template parameter for 'pipe_itr' |
| rpa::pipe_circular< Container, CondVar > | A circular buffer based on any kind of container |
| rpa::pipe_circular< Container, CondVar >::reader | Template param for pipe_itr, an iterator in pipelines'underlying container |
| rpa::pipe_circular< Container, CondVar >::slice | |
| rpa::pipe_circular< Container, void > | This very simplified specialization is here only for completeness |
| rpa::pipe_circular< Container, void >::reader | Models how to read from a circular pipe without condition variable |
| rpa::pipe_container< Container > | |
| rpa::pipe_container< Type[CstNbElts] > | |
| rpa::pipe_itr< ValueType, Reader > | Synchronized iterator for reading from a pipe_circular or pipe_archiver |
| rpa::pipebase< Container, CondVar > | |
| rpa::pipebase< Container, CondVar >::shutter_thread< ThreadBase > | This class behaves like a thread proxy. Its use is optional |
| Plus22< T > | Because of the way this functor is used, some specific checks can be done |
| rpa::posix_condition | |
| rpa::posix_mutex | |
| rpa::posix_mutex_exception | Used locally only, just to report mutex errors |
| rpa::posix_thread | |
| rpa::posix_thread_exception | Used locally, to report errors related to threads |
| rpa::posix_thread_fast_t | |
| rpa::present< ThreadTree, Ftor > | Holds all the data needed to start a thread with a functor into it |
| ProbBase< ThrTree, Type, RangeT > | |
| rpa::probe_aux< Iter, IterCat > | |
| rpa::probe_aux< Iter, std::input_iterator_tag > | |
| rpa::probe_aux< Iter, std::output_iterator_tag > | Testing the content of an output iterator is meaningless |
| rpa::probe_range_aux< Iter, IterCat > | Does the same as 'probe', but repetitively on a range of iterators |
| rpa::probe_range_aux< Iter, std::input_iterator_tag > | |
| rpa::probe_range_aux< Iter, std::output_iterator_tag > | |
| ProbFull< ContOut, ThrTree, Range > | General template |
| ProbFull< std::list< Type >, ThrTree, Range > | |
| ProbFull< std::vector< Type >, ThrTree, Range > | |
| ProbFull< Type[Nb], ThrTree, Range > | When the output container is a fixed-size array |
| rpa::profiler | Created by testing programs to have the same output, and do monitorings |
| proxy_guard< Container, Mutex > | |
| rpa::pthread_exception | Used locally, to report threads runtime errors |
| rpa::range_fwrd< It > | For forward_tag iterators if single-thread access. This is an output range |
| rpa::range_fwrd< It >::slice | |
| rpa::range_jump< It > | |
| rpa::range_jump< It >::range_out< It2, IterCat > | In the general case, we keep the original order |
| rpa::range_jump< It >::range_out< It2, IterCat >::slice | |
| rpa::range_jump< It >::range_out< It2, std::output_iterator_tag > | |
| rpa::range_jump< It >::slice | |
| rpa::range_lambda< It > | |
| rpa::range_outp< It > | General case, for thread-unsafe iterators |
| rpa::range_outp< It >::slice | |
| rpa::range_outp< iterator_lock< It, Mutex > > | |
| rpa::range_outp< iterator_lock< It, Mutex > >::slice | |
| rpa::range_outp< iterator_lock< It, Mutex > >::slice::iterator | |
| rpa::range_outp< iterator_lock< It, void > > | Specialisation for an atomic output iterator |
| rpa::range_outp< iterator_lock< It, void > >::slice | |
| rpa::range_outp< iterator_lock< It, void > >::slice::iterator | The original output iterator is shared by all slices |
| rpa::range_outp< obuf_iterator< IterOut, Buffer, BufIter, Mutex > > | General case of buffering any iterator, with bounded buffers |
| rpa::range_outp< obuf_iterator< IterOut, Buffer, BufIter, void > > | General case of buffering any iterator, with unbounded buffers |
| rpa::range_outp< obuf_iterator< orow_iterator< Type, OutStrmBuf >, Buffer, BufIter, Mutex > > | |
| rpa::range_outp< obuf_iterator< orow_iterator< Type, OutStrmBuf >, Buffer, BufIter, void > > | |
| rpa::range_outp< obuf_iterator< std::back_insert_iterator< std::list< Type, Alloc > >, std::list< Type, Alloc >, BufIter, Mutex > > | |
| rpa::range_outp< obuf_iterator< std::back_insert_iterator< std::list< Type, Alloc > >, std::list< Type, Alloc >, BufIter, Mutex > >::slice | |
| rpa::range_outp< obuf_iterator< std::back_insert_iterator< std::list< Type, Alloc > >, std::list< Type, Alloc >, BufIter, void > > | |
| rpa::range_outp< obuf_iterator< std::back_insert_iterator< std::list< Type, Alloc > >, std::list< Type, Alloc >, BufIter, void > >::slice | |
| rpa::range_size< It > | |
| rpa::range_size< It >::range_out< It2, IterCat > | |
| rpa::range_size< It >::range_out< It2, std::output_iterator_tag > | |
| rpa::range_size< It >::slice | Models a slice begin/end given by 'chop' or 'tail', processed by a single sub-thread |
| rpa::range_step< It, Mutex > | |
| rpa::range_step< It, void > | |
| rpa::range_step< It, void >::chop_atom_t< Rng2 > | |
| rpa::range_step< It, void >::chop_atom_t< range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > > > | |
| rpa::range_step< It, void >::range_out< It2, IterCat2 > | |
| rpa::range_step< It, void >::range_out< It2, IterCat2 >::range_type | This is the class actually used as the output range |
| rpa::range_step< It, void >::range_out< It2, IterCat2 >::range_type::generator_t | In the general case, there cannot be anything unique for the generator |
| rpa::range_step< It, void >::range_out< It2, IterCat2 >::range_type::slice | Given to each sub-thread |
| rpa::range_step< It, void >::range_out< It2, std::bidirectional_iterator_tag > | For exemple, if we write into an output sequence which is already allocated |
| rpa::range_step< It, void >::range_out< It2, std::bidirectional_iterator_tag >::range_type | |
| rpa::range_step< It, void >::range_out< It2, std::bidirectional_iterator_tag >::range_type::generator_t | The unique key if the generator is the iterator itself, which is of course unique |
| rpa::range_step< It, void >::range_out< It2, std::bidirectional_iterator_tag >::range_type::slice | Given to each sub-thread : The amount of work to process on the output |
| rpa::range_step< It, void >::range_out< It2, std::forward_iterator_tag > | |
| rpa::range_step< It, void >::range_out< It2, std::random_access_iterator_tag > | |
| rpa::range_step< It, void >::range_out< It2, std::random_access_iterator_tag >::range_type | |
| rpa::range_step< It, void >::range_out< It2, std::random_access_iterator_tag >::range_type::generator_t | |
| rpa::range_step< It, void >::range_out< It2, std::random_access_iterator_tag >::range_type::slice | Given to each sub-thread so that an algorithm can write into it |
| rpa::range_step< It, void >::range_out< iterator_lock< It2, Mutex >, std::bidirectional_iterator_tag > | This template specialization, to forbid this case to happen |
| rpa::range_step< It, void >::range_out< iterator_lock< It2, Mutex >, std::forward_iterator_tag > | This template specialization, to forbid this case to happen |
| rpa::range_step< It, void >::range_out< iterator_lock< It2, Mutex >, std::input_iterator_tag > | This template specialization, to forbid this case to happen |
| rpa::range_step< It, void >::range_out< iterator_lock< It2, Mutex >, std::output_iterator_tag > | For the moment, just to compile, and reuse the defaut existing range_out |
| rpa::range_step< It, void >::range_out< iterator_lock< It2, Mutex >, std::random_access_iterator_tag > | This template specialization, to forbid this case to happen |
| rpa::range_step< It, void >::range_out< obuf_iterator< IterOut, Buffer, IterBuf, Mutex >, std::bidirectional_iterator_tag > | This template specialization, to forbid this case to happen |
| rpa::range_step< It, void >::range_out< obuf_iterator< IterOut, Buffer, IterBuf, Mutex >, std::forward_iterator_tag > | This template specialization, to forbid this case to happen |
| rpa::range_step< It, void >::range_out< obuf_iterator< IterOut, Buffer, IterBuf, Mutex >, std::input_iterator_tag > | This template specialization, to forbid this case to happen |
| rpa::range_step< It, void >::range_out< obuf_iterator< IterOut, Buffer, IterBuf, Mutex >, std::output_iterator_tag > | |
| rpa::range_step< It, void >::range_out< obuf_iterator< IterOut, Buffer, IterBuf, Mutex >, std::random_access_iterator_tag > | This template specialization, to forbid this case to happen |
| rpa::range_step< It, void >::range_type_iterator_lock< It2, Mutex > | This to avoid an ambiguous template instantiation |
| rpa::range_step< It, void >::range_type_iterator_lock< It2, Mutex >::generator_t | In the general case, there cannot be anything unique for the generator |
| rpa::range_step< pipe_archiver< Container, CondVar >, pipe_archiver< Container, CondVar > > | |
| rpa::range_step< pipe_circular< Container, CondVar >, pipe_circular< Container, CondVar > > | For reading ranges of elements from a pipe_circular |
| rpa::range_step_archiver< Container, CondVar, insertInvalidatesIterators > | |
| rpa::range_step_archiver< Container, CondVar, insertInvalidatesIterators >::slice | |
| rpa::range_step_archiver< Container, CondVar, true > | |
| rpa::range_step_archiver< Container, CondVar, true >::slice | The base slice just contains the beginning and end, plus the size |
| rpa::range_step_aux< It > | |
| rpa::range_step_aux< It >::range_out< It2, IterCat > | |
| rpa::range_step_aux< It >::range_out< It2, std::output_iterator_tag > | Most general case |
| rpa::range_step_base< It > | |
| rpa::range_step_base< It >::slice | Created by 'segmenting' an input range, ie, a range made of a pair of iterators |
| rpa::range_traits< RngIn, IterOut > | |
| rpa::range_void< It > | |
| rpa::range_void< It >::range_out< It2, IterCat > | For selecting the right output sequence |
| rpa::range_void< It >::range_out< It2, IterCat >::slice | |
| rpa::range_void< It >::range_out< It2, IterCat >::slice::iterator | |
| rpa::remove_copy_if_args< RngIn, RngOut, UnaOp, RetType > | For storing the argument of the algorithm, as given by the calling program |
| rpa::remove_copy_if_loop_thr< Args, Task, Thread > | |
| rpa::remove_copy_if_seq_size_jump< RngIn, RngOut, Ftor > | For static and interleaved scheduling (range_size and range_jump) |
| rpa::remove_copy_if_seq_size_jump< RngIn, RngOut, Ftor >::functor_t | The role of this class is to add the method 'reduce' |
| rpa::remove_copy_if_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor > | For static or interleaved scheduling, and limited-size buffers |
| rpa::remove_copy_if_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::BaseRngOut | |
| rpa::remove_copy_if_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::functor_base | |
| rpa::remove_copy_if_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::functor_t | |
| rpa::remove_copy_if_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::functor_t::result_type | |
| rpa::remove_copy_if_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, void > >, Ftor > | For static or interleaved scheduling, with unlimited buffers |
| rpa::remove_copy_if_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, void > >, Ftor >::functor_t | The role of this class is to add to the functor, the method 'reduce' |
| rpa::remove_copy_if_seq_step< RngIn, RngOut, Ftor > | |
| rpa::remove_copy_if_seq_step< RngIn, RngOut, Ftor >::functor_t | |
| rpa::remove_copy_if_seq_step< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor > | |
| rpa::remove_copy_if_seq_step< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::functor_t | |
| rpa::remove_copy_if_seq_step< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, void > >, Ftor > | |
| rpa::remove_copy_if_seq_step< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, void > >, Ftor >::functor_t | |
| rpa::remove_copy_if_t< Range, ItOut, UnaOp > | Represents the STL algorithm 'remove_copy_if', and its several execution modes |
| rpa::remove_copy_if_vec< Args, range_jump< ItIn >, RngOut, UnaOp, ThrIter > | Definition of 'remove_copy_if' for interleaved scheduling |
| rpa::remove_copy_if_vec< Args, range_size< ItIn >, RngOut, UnaOp, ThrIter > | Definition of the algorithm remove_copy_if if the input range is 'range_size' |
| rpa::remove_copy_if_vec< Args, range_step< ItIn, Mutex >, RngOut, UnaOp, ThrIter > | Definition of the algorithm remove_copy_if if the input range is 'range_step' |
| rpa::resizer< Cont > | For reserving room in buffers |
| rpa::resizer< Cont & > | The parameter may be a reference |
| rpa::resizer< row_buffer< Type, DerivStrmBuf, Augm > > | |
| rpa::resizer< std::list< Type, Alloc > > | |
| rpa::resizer< Type[N] > | For a C-style static array, it is not needed to do any resizing |
| rpa::row_buffer< Type, DerivStrmBuf, Augm > | |
| rpa::row_buffer< Type, DerivStrmBuf, Augm >::strm_strmbuf | |
| rpa::row_notype< Char, Traits > | |
| rpa::row_type< Type, Char, Traits > | |
| rpa::rpa_list_head< Struct, Member > | |
| rpa::rpa_list_head< Struct, Member >::iterator | |
| rpa::slice_generator< GeneratorValue > | |
| rpa::slice_generator< void > | |
| rpa::spawn< ThreadTree, Ftor > | |
| Str2Int | |
| Str2Lng | |
| rpa::streambuf_name< std::basic_filebuf< Char, Traits > > | |
| rpa::streambuf_proxy< StrmBuf > | General template |
| rpa::streambuf_proxy< std::basic_filebuf< Char, Traits > > | |
| rpa::streambuf_proxy< std::basic_stringbuf< Char, Traits > > | If the template parameter is stringbuf, adds methods that a basic_streambuf misses |
| rpa::streambuf_proxy_base< StrmBuf > | |
| rpa::streambuf_proxy_base< StrmBuf >::exposer | |
| rpa::streambuf_tmp_name< std::basic_filebuf< Char, Traits >, NameGenerator > | |
| rpa::streambuf_visitor | For writing into an output streambuf |
| StrmTmpFilBuf | Derivation of std::filebuf for test13 |
| rpa::strsorter | |
| rpa::swap_anything | Brillant idea gratefully borrowed from David Abrahams, has_swap.hpp |
| T13_Buf< OutStreamBuf, AutoInternBuf > | |
| T13_Out< OutStreamBuf > | |
| T13TmpNamFilBuf | |
| T14_Box< OutStrmBuf, TmpnamBuf > | |
| T14_Out< TmpNamOutStrmBuf > | |
| T14TmpNamFilBuf | |
| T15_Buf< OutStrmBuf, InternBuf > | |
| T15_Out< OutStrmBuf > | |
| t17_mkstemp< N > | |
| T18In2Out | |
| t22adder< Type > | This is used in the algorithm 'accumulate' for tracking how values |
| t23adder< Type > | For debugging how the algorithm 'accumulate' uses its variables |
| t25adder< Type > | For debugging how the algorithm 'accumulate' uses its variables |
| t_bounded_alloc< ThrTree, IterBuf > | |
| t_bounded_noall< ThrTree > | |
| t_nobuf< ThrTree > | Test without output buffer, but with a mutex to protect the output |
| t_unbounded_alloc< ThrTree, IterBuf > | Test with an output buffer of unlimited size |
| t_unbounded_noall< ThrTree > | |
| rpa::target< ResultType, Allocator > | |
| rpa::target< ResultType, Allocator >::holder< PresentType > | |
| rpa::target< ResultType, Allocator >::holder_base | |
| TestBox< OutStrmBuf, TmpnamBuf > | |
| TestOut< TmpNamOutStrmBuf > | |
| TestRow< OutStrmBuf, RowBufferType > | |
| rpa::thread_array< SubThr > | This makes simpler the allocation of a pool of threads |
| rpa::thread_array< SubThr >::thr_arr | This structure stores the threads. It is accessed with a counted_ptr |
| rpa::thread_array< SubThr >::thr_arr::exception_mem | Thrown if the threads could not be allocated |
| rpa::thread_array< void > | This applies when there are no subthreads |
| rpa::thread_copy< ThrMain > | This stays allocated as long as the thread is running |
| rpa::thread_counter< Thread > | A class wrapper for threads compliant with RPA interface (create/join/cancel) |
| rpa::thread_counter_base | Implementation of the base class of all template 'thread_counter' |
| rpa::thread_crea | Pseudo-parallel thread class for making deterministic tests |
| rpa::thread_exception< Thread > | Signals when a thread could not be started. Specializable on the thread |
| rpa::thread_exec_lock< Thr, Mtx > | |
| rpa::thread_fast_t< Thr, Mtx > | |
| rpa::thread_fast_t< thread_crea, Mtx > | |
| rpa::thread_fast_t< thread_join, Mtx > | Same reason, 'thread_fast_t' is incompatible with 'thread_join' |
| rpa::thread_join | Pseudo-parallel thread class for making deterministic tests |
| rpa::thread_pool< Thr > | |
| rpa::thread_repair_t< Thr > | |
| rpa::thread_replace_t< Thr > | |
| rpa::thread_stack< Ftor, Thr > | Base class for all the objects 'loop' of all algorithms |
| rpa::thread_stack< Ftor, Thr >::iterator | |
| rpa::thread_stack< Ftor, Thr >::node | |
| rpa::thread_traits_def | Thread behaviour types definitions |
| rpa::thread_traits_def::is_parallel | |
| rpa::thread_traits_def::is_sequential | |
| rpa::thread_traits_def::is_undeterministic | Usage with real threads |
| rpa::thread_tree< ThrIter, ThrMain > | Models the sub-threads set given to functors, themselves called by sub-threads |
| rpa::thread_tree< ThrIter, ThrMain * > | Points on a main 'head' thread which is never copied but modified |
| rpa::thread_tree< ThrIter, void > | Runs a functor with several sub-threads, but still controlled by the current thread |
| rpa::thread_tree< void, ThrMain * > | Executes the functor in a single sub-thread |
| rpa::thread_tree< void, ThrMain > | Executes the functor in a single sub-thread |
| rpa::thread_tree< void, void > | Equivalent to void, but makes coding simpler, because homogeneous |
| rpa::thread_tree_base< ThrIter > | Common class for all thread_tree |
| rpa::thread_tree_base< thread_pool< ThrPooled > > | When specialized with 'thread_pool', actually creates a thread pool |
| rpa::thread_tree_base< ThrSub[ThrNb] > | Specialization if sub-threads are stored in a C-array. For simple programs |
| rpa::thread_tree_core | The non-templatized part of thread_tree |
| rpa::thread_void_fail_t | |
| rpa::threadify_t< Ftor, Thr > | 'threadify_t' transforms a 'threadable' functor, into a 'plain functor |
| rpa::threadify_t< Ftor, thread_tree< ThrSubIter, ThrMain > > | Specialization for more than one level of sub-threads |
| rpa::threadify_t< void_functor, Thr > | |
| rpa::ThreadTraits< Thread > | |
| rpa::ThreadTraits< thread_crea > | |
| rpa::ThreadTraits< thread_join > | |
| rpa::ThreadTraits< thread_tree< ThrIter, ThrMain > > | |
| rpa::ThreadTraits< thread_tree< void, ThrMain > > | |
| rpa::tmp_buffer | |
| rpa::transform_args< RngIn, RngOut, UnaOp, RetType > | For storing the argument of the algorithm, as given by the calling program |
| rpa::transform_loop_thr< Args, Task, Thread > | |
| rpa::transform_seq_size_jump< RngIn, RngOut, Ftor > | For static and interleaved scheduling (range_size and range_jump) |
| rpa::transform_seq_size_jump< RngIn, RngOut, Ftor >::functor_t | The role of this class is to add the method 'reduce' |
| rpa::transform_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor > | For static or interleaved scheduling, and limited-size buffers |
| rpa::transform_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::BaseRngOut | |
| rpa::transform_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::functor_base | |
| rpa::transform_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::functor_t | |
| rpa::transform_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::functor_t::result_type | |
| rpa::transform_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, void > >, Ftor > | For static or interleaved scheduling, with unlimited buffers |
| rpa::transform_seq_size_jump< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, void > >, Ftor >::functor_t | The role of this class is to add to the functor, the method 'reduce' |
| rpa::transform_seq_step< RngIn, RngOut, Ftor > | |
| rpa::transform_seq_step< RngIn, RngOut, Ftor >::functor_t | |
| rpa::transform_seq_step< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor > | |
| rpa::transform_seq_step< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, Mutex > >, Ftor >::functor_t | |
| rpa::transform_seq_step< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, void > >, Ftor > | |
| rpa::transform_seq_step< RngIn, range_outp< obuf_iterator< IterOut, Buffer, IterBuf, void > >, Ftor >::functor_t | |
| rpa::transform_t< Range, ItOut, UnaOp > | Represents the STL algorithm 'transform', and its several execution modes |
| rpa::transform_vec< Args, range_jump< ItIn >, RngOut, UnaOp, ThrIter > | Definition of 'transform' for interleaved scheduling |
| rpa::transform_vec< Args, range_size< ItIn >, RngOut, UnaOp, ThrIter > | Definition of the algorithm transform if the input range is 'range_size' |
| rpa::transform_vec< Args, range_step< ItIn, Mutex >, RngOut, UnaOp, ThrIter > | Definition of the algorithm transform if the input range is 'range_step' |
| rpa::true_t | For debugging only |
| tst_bounded_alloc< ThrTree, IterBuf > | In t12, tests with limited buffers, with buffers allocator |
| tst_bounded_noall< ThrTree > | In t12, tests with limited buffers, without allocator |
| tst_nobuf< ThrTree > | Test without output buffer, but with a mutex to protect the output |
| Tst_T18< TmpNamOutStrmBuf > | For an output stream class, tests 'transform' with many output buffers types |
| tst_unbounded_alloc< ThrTree, IterBuf > | Test with an unbounded output buffer |
| tst_unbounded_noall< ThrTree > | In t12, tests with unbounded buffers, without allocator |
| rpa::tuple2< _T1, _T2 > | Tuple2 holds two objects of arbitrary type. This is a subset of std::pair |
| rpa::unary_function_count< Ftor > | Counts the number of times that a functor was called |
| VecDataOut | This is one of the buffer types used in test13 |
| rpa::visitor | Base class for copying a file descirptor into another |
| rpa::void_functor | We need a real type for specifying a kind of 'void' or 'default' functor |
