Aleph-w 3.0
A C++ Library for Data Structures and Algorithms
Loading...
Searching...
No Matches
Aleph::FixedQueue< T > Class Template Reference

Very simple queue implemented with a contiguous array. More...

#include <tpl_arrayQueue.H>

Inheritance diagram for Aleph::FixedQueue< T >:
[legend]
Collaboration diagram for Aleph::FixedQueue< T >:
[legend]

Classes

struct  Iterator
 Simple iterator on elements of a queue. More...
 

Public Types

using Item_Type = T
 
- Public Types inherited from StlAlephIterator< FixedQueue< T > >
using iterator = StlIterator< FixedQueue< T > >
 
using const_iterator = StlConstIterator< FixedQueue< T > >
 

Public Member Functions

void swap (FixedQueue &q) noexcept
 
void empty () noexcept
 empty the queue
 
 FixedQueue (size_t d=1024)
 Construct a queue of capacity the immediately two power of d
 
 ~FixedQueue ()
 
 FixedQueue (const FixedQueue &q)
 Copy constructor.
 
 FixedQueue (FixedQueue &&q) noexcept
 Move constructor.
 
template<template< typename > class List>
 FixedQueue (const List< T > &l)
 
template<class It >
 FixedQueue (It b, It e)
 
 FixedQueue (std::initializer_list< T > l)
 
FixedQueueoperator= (const FixedQueue &q)
 Copy assign.
 
FixedQueueoperator= (FixedQueue &&q) noexcept
 Move assign.
 
Tput (const T &item) noexcept
 Put an item into the queue by copy.
 
Tput (T &&item) noexcept
 
Tappend (const T &item) noexcept
 
Tappend (T &&item) noexcept
 
Tinsert (const T &item) noexcept
 
Tinsert (T &&item) noexcept
 
Tputn (const size_t n) noexcept
 Put n cells to the queue in constant time.
 
T get () noexcept
 Remove the oldest item of the queue.
 
Tgetn (const size_t n) noexcept
 Remove in constant time the n oldest items of the queue.
 
Tfront (const size_t i=0) const noexcept
 Return the i-th oldest item.
 
Trear (const size_t i=0) const noexcept
 Return the i-th youngest item.
 
constexpr size_t size () const noexcept
 Return the number of items.
 
constexpr bool is_empty () const noexcept
 Return true if the queue is empty.
 
constexpr size_t capacity () const noexcept
 Return the queue capacity (maximum number of element to be stored)
 
template<class Operation >
bool traverse (Operation &operation)
 Traverse all the elements from the youngest to the oldest and execute operation on each on them.
 
template<class Operation >
bool traverse (Operation &operation) const
 
template<class Operation >
bool traverse (Operation &&operation=Operation()) const
 
template<class Operation >
bool traverse (Operation &&operation=Operation())
 
- Public Member Functions inherited from LocateFunctions< FixedQueue< T >, T >
auto get_it () const
 Return a properly initialized iterator positioned at the first item on the container.
 
auto get_it (const size_t pos) const
 Return a properly initialized iterator positioned at the pos item on the container.
 
auto get_itor () const
 Alias of get_it().
 
T & nth_ne (const size_t n) noexcept
 Return the n‑th element without bounds checking.
 
const T & nth_ne (const size_t n) const noexcept
 Const overload of nth_ne(size_t).
 
T & nth (const size_t n)
 Return the n-th item of container.
 
const T & nth (const size_t n) const
 Const overload of nth(size_t).
 
T * find_ptr (Operation &operation) noexcept(operation_is_noexcept< Operation >())
 Find a pointer to an item in the container according to a searching criteria.
 
const T * find_ptr (Operation &operation) const noexcept(operation_is_noexcept< Operation >())
 Const overload of find_ptr(Operation&).
 
const T * find_ptr (Operation &&operation) const noexcept(operation_is_noexcept< Operation >())
 Overload of find_ptr(Operation&) const that accepts rvalues.
 
T * find_ptr (Operation &&operation) noexcept(operation_is_noexcept< Operation >())
 Overload of find_ptr(Operation&) that accepts rvalues.
 
size_t find_index (Operation &operation) const noexcept(operation_is_noexcept< Operation >())
 Find the position of an item in the container according to a searching criteria.
 
size_t find_index (Operation &&operation) const noexcept(operation_is_noexcept< Operation >())
 Overload of find_index(Operation&) that accepts rvalues.
 
std::tuple< bool, T > find_item (Operation &operation) noexcept(operation_is_noexcept< Operation >())
 Safe sequential searching of an item matching a criteria.
 
std::tuple< bool, T > find_item (Operation &operation) const noexcept(operation_is_noexcept< Operation >())
 
std::tuple< bool, T > find_item (Operation &&operation) noexcept(operation_is_noexcept< Operation >())
 
std::tuple< bool, T > find_item (Operation &&operation) const noexcept(operation_is_noexcept< Operation >())
 
- Public Member Functions inherited from FunctionalMethods< FixedQueue< T >, T >
void emplace (Args &&... args)
 Appends a new element into the container by constructing it in-place with the given args.
 
void emplace_end (Args &&... args)
 
void emplace_ins (Args &&... args)
 Insert a new element into the container by constructing it in-place with the given args.
 
size_t ninsert (Args ... args)
 Insert n variadic items.
 
size_t nappend (Args ... args)
 Append n variadic items.
 
void for_each (Operation &operation)
 Traverse all the container and performs an operation on each element.
 
void for_each (Operation &operation) const
 Const overload of for_each(Operation&).
 
void for_each (Operation &&operation) const
 Overload of for_each(Operation&) const that accepts rvalues.
 
void for_each (Operation &&operation)
 Overload of for_each(Operation&) that accepts rvalues.
 
void each (Operation &operation)
 Alias of for_each(Operation&).
 
void each (Operation &operation) const
 Const alias of for_each(Operation&).
 
void each (Operation &&operation) const
 Const alias of for_each(Operation&) that accepts rvalues.
 
void each (Operation &&operation)
 Alias of for_each(Operation&) that accepts rvalues.
 
void each (size_t pos, const size_t slice, Operation &operation) const
 Traverse the container starting at pos taking one item every slice, performing a mutable operation on each visited element.
 
void each (const size_t pos, const size_t slice, Operation &&operation) const
 
void mutable_for_each (Operation &operation)
 
void mutable_for_each (Operation &&operation)
 
bool all (Operation &operation) const
 Check if all the elements of container satisfy a condition.
 
bool all (Operation &&operation) const
 Overload of all(Operation&) that accepts rvalues.
 
bool exists (Operation &op) const
 Test for existence in the container of an element satisfying a criteria.
 
bool exists (Operation &&op) const
 Overload of exists(Operation&) that accepts rvalues.
 
Aleph::DynList< __T > maps (Operation &op) const
 Map the elements of the container.
 
Aleph::DynList< __T > maps (Operation &&op) const
 Overload of maps(Operation&) that accepts rvalues.
 
Aleph::DynList< __Tmaps_if (Prop prop, Operation &op) const
 Conditional mapping of the elements of the container.
 
Aleph::DynList< __Tmaps_if (Prop prop, Operation &&op) const
 Overload of maps_if(Prop, Operation&) that accepts rvalues.
 
Aleph::DynList< T > to_dynlist () const
 Convert container to DynList.
 
std::vector< T > to_vector () const
 Convert container to std::vector.
 
__T foldl (const __T &init, Op &op) const
 Fold the elements of the container to a specific result.
 
__T foldl (const __T &init, Op &&op=Op()) const
 Overload of foldl(const __T&, Op&) that accepts rvalues.
 
__T fold_left (const __T &init, Op &op) const
 Alias for foldl with the same accumulator type.
 
__T fold_left (const __T &init, Op &&op=Op()) const
 Overload of fold_left(const __T&, Op&) that accepts rvalues.
 
fold (const T &init, Operation &operation) const
 Simplified version of foldl() where the folded type is the same type of elements stored in the container.
 
fold (const T &init, Operation &&operation) const
 Overload of fold(const T&, Operation&) that accepts rvalues.
 
Aleph::DynList< T > filter (Operation &operation) const
 Filter the elements of a container according to a matching criteria.
 
Aleph::DynList< T > filter (Operation &&operation) const
 Overload of filter(Operation&) that accepts rvalues.
 
Aleph::DynList< const T * > ptr_filter (Operation &operation) const
 Filter the elements of a container according to a matching criteria and return a pointer to the matched items in the container.
 
Aleph::DynList< const T * > ptr_filter (Operation &&operation) const
 Overload of ptr_filter(Operation&) that accepts rvalues.
 
Aleph::DynList< std::tuple< T, size_t > > pfilter (Operation &operation) const
 Filter the elements of a container according to a matching criteria and determine its positions respect to the traversal of container.
 
Aleph::DynList< std::tuple< T, size_t > > pfilter (Operation &&operation) const
 Overload of pfilter(Operation&) that accepts rvalues.
 
std::pair< Aleph::DynList< T >, Aleph::DynList< T > > partition (Operation &op) const
 Exclusive partition of container according to a filter criteria.
 
std::pair< Aleph::DynList< T >, Aleph::DynList< T > > partition (Operation &&op) const
 Overload of partition(Operation&) that accepts rvalues.
 
std::pair< Aleph::DynList< T >, Aleph::DynList< T > > partition (size_t n) const
 Exclusive partition of container in the nth item.
 
std::pair< Aleph::DynList< T >, Aleph::DynList< T > > split_half () const
 Split the container into two halves by alternating elements.
 
std::tuple< Aleph::DynList< T >, Aleph::DynList< T > > tpartition (Operation &op) const
 Exclusive partition of container according to a filter criteria.
 
std::tuple< Aleph::DynList< T >, Aleph::DynList< T > > tpartition (Operation &&op) const
 Overload of tpartition(Operation&) that accepts rvalues.
 
size_t length () const noexcept
 Count the number of elements of a container.
 
Aleph::DynList< T > rev () const
 Return a list with the elements of container in reverse order respect to its traversal order.
 
Aleph::DynList< T > take (const size_t n) const
 Return a list with the first n elements seen in the container during its traversal.
 
Aleph::DynList< T > take (size_t i, const size_t j, const size_t step=1) const
 Return a list with elements seen in the container between i and j position respect to its traversal.
 
Aleph::DynList< T > drop (const size_t n) const
 Drop the first n elements seen in the container during its traversal.
 
void mutable_drop (const size_t n)
 Drop the first n elements seen from container.
 
- Public Member Functions inherited from GenericItems< Container, T >
Aleph::DynList< T > items () const
 Return a list of all the elements of a container sorted by traversal order.
 
Aleph::DynList< T > keys () const
 
- Public Member Functions inherited from EqualToMethod< FixedQueue< T > >
bool equal_to (const FixedQueue< T > &r) const noexcept
 Test if elements of this are exactly contained in another container.
 
bool operator== (const FixedQueue< T > &r) const noexcept
 
bool operator!= (const FixedQueue< T > &r) const noexcept
 Negation of equal_to()
 
- Public Member Functions inherited from StlAlephIterator< FixedQueue< T > >
iterator begin () noexcept
 Return an STL-compatible iterator to the first element.
 
const_iterator begin () const noexcept
 Return a const iterator to the first element.
 
iterator end () noexcept
 Return an STL-compatible end iterator.
 
const_iterator end () const noexcept
 Return a const end iterator.
 
const_iterator cbegin () const noexcept
 Return a const iterator to the first element.
 
const_iterator cend () const noexcept
 Return a const end iterator.
 

Private Member Functions

void increase_index (size_t &i, const size_t inc=1) const noexcept
 
Trear_item (const size_t i=0) const noexcept
 

Private Attributes

size_t dim
 
Tarray
 
size_t front_index
 
size_t rear_index
 
size_t mask
 
size_t num_items
 

Additional Inherited Members

Detailed Description

template<typename T>
class Aleph::FixedQueue< T >

Very simple queue implemented with a contiguous array.

The capacity is given in construction time, but this is adjusted to the next two power immediately greater.

This queue is the fastest of Aleph-w ( \(\aleph_\omega\)), but take in account that no bound_statics cheks are performed. You must be sure that you usage is correct.

See also
ArrayQueue DynListQueue

Definition at line 385 of file tpl_arrayQueue.H.

Member Typedef Documentation

◆ Item_Type

Definition at line 418 of file tpl_arrayQueue.H.

Constructor & Destructor Documentation

◆ FixedQueue() [1/6]

template<typename T >
Aleph::FixedQueue< T >::FixedQueue ( size_t  d = 1024)
inline

Construct a queue of capacity the immediately two power of d

The resulting capacity will be the first number such \(2^k \geq d\),

Parameters
[in]dminimum capacity

Definition at line 443 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::array, Aleph::FixedQueue< T >::dim, Aleph::is_power_of_2(), log2(), FunctionalMethods< FixedQueue< T >, T >::maps(), and Aleph::FixedQueue< T >::mask.

◆ ~FixedQueue()

template<typename T >
Aleph::FixedQueue< T >::~FixedQueue ( )
inline

Definition at line 454 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::array.

◆ FixedQueue() [2/6]

◆ FixedQueue() [3/6]

template<typename T >
Aleph::FixedQueue< T >::FixedQueue ( FixedQueue< T > &&  q)
inlinenoexcept

Move constructor.

Definition at line 470 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::swap().

◆ FixedQueue() [4/6]

template<typename T >
template<template< typename > class List>
Aleph::FixedQueue< T >::FixedQueue ( const List< T > &  l)
inline

Definition at line 475 of file tpl_arrayQueue.H.

◆ FixedQueue() [5/6]

template<typename T >
template<class It >
Aleph::FixedQueue< T >::FixedQueue ( It  b,
It  e 
)
inline

Definition at line 475 of file tpl_arrayQueue.H.

◆ FixedQueue() [6/6]

template<typename T >
Aleph::FixedQueue< T >::FixedQueue ( std::initializer_list< T l)
inline

Definition at line 475 of file tpl_arrayQueue.H.

Member Function Documentation

◆ append() [1/2]

template<typename T >
T & Aleph::FixedQueue< T >::append ( const T item)
inlinenoexcept

Definition at line 522 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::put().

◆ append() [2/2]

template<typename T >
T & Aleph::FixedQueue< T >::append ( T &&  item)
inlinenoexcept

Definition at line 525 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::put().

◆ capacity()

template<typename T >
constexpr size_t Aleph::FixedQueue< T >::capacity ( ) const
inlineconstexprnoexcept

Return the queue capacity (maximum number of element to be stored)

Definition at line 602 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::dim.

Referenced by TEST().

◆ empty()

template<typename T >
void Aleph::FixedQueue< T >::empty ( )
inlinenoexcept

◆ front()

template<typename T >
T & Aleph::FixedQueue< T >::front ( const size_t  i = 0) const
inlinenoexcept

Return the i-th oldest item.

Parameters
[in]iaccess position respect to oldest item
Returns
a modifiable reference to the i-th item

Definition at line 578 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::array, Aleph::FixedQueue< T >::front_index, FunctionalMethods< FixedQueue< T >, T >::maps(), and Aleph::FixedQueue< T >::num_items.

Referenced by TEST().

◆ get()

◆ getn()

template<typename T >
T & Aleph::FixedQueue< T >::getn ( const size_t  n)
inlinenoexcept

Remove in constant time the n oldest items of the queue.

Parameters
[in]nnumber of items to remove
Returns
a modifiable reference to the current oldes item in the queue after the removal of n entries

Definition at line 565 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::array, Aleph::FixedQueue< T >::front_index, Aleph::FixedQueue< T >::increase_index(), FunctionalMethods< FixedQueue< T >, T >::maps(), and Aleph::FixedQueue< T >::num_items.

◆ increase_index()

◆ insert() [1/2]

template<typename T >
T & Aleph::FixedQueue< T >::insert ( const T item)
inlinenoexcept

Definition at line 528 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::put().

◆ insert() [2/2]

template<typename T >
T & Aleph::FixedQueue< T >::insert ( T &&  item)
inlinenoexcept

Definition at line 531 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::put().

◆ is_empty()

template<typename T >
constexpr bool Aleph::FixedQueue< T >::is_empty ( ) const
inlineconstexprnoexcept

Return true if the queue is empty.

Definition at line 599 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::num_items.

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), and WorkersSet< WorkerFct >::worker_handler().

◆ operator=() [1/2]

template<typename T >
FixedQueue & Aleph::FixedQueue< T >::operator= ( const FixedQueue< T > &  q)
inline

◆ operator=() [2/2]

template<typename T >
FixedQueue & Aleph::FixedQueue< T >::operator= ( FixedQueue< T > &&  q)
inlinenoexcept

Move assign.

Definition at line 489 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::swap().

◆ put() [1/2]

template<typename T >
T & Aleph::FixedQueue< T >::put ( const T item)
inlinenoexcept

Put an item into the queue by copy.

Parameters
[in]itemto put
Returns
a modifiable reference to the copied item.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 500 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::array, Aleph::FixedQueue< T >::dim, Aleph::FixedQueue< T >::increase_index(), FunctionalMethods< FixedQueue< T >, T >::maps(), Aleph::FixedQueue< T >::num_items, and Aleph::FixedQueue< T >::rear_index.

Referenced by Aleph::FixedQueue< T >::append(), Aleph::FixedQueue< T >::append(), Aleph::FixedQueue< T >::insert(), Aleph::FixedQueue< T >::insert(), WorkersSet< WorkerFct >::schedule_call(), TEST(), TEST(), TEST(), and TEST().

◆ put() [2/2]

◆ putn()

template<typename T >
T & Aleph::FixedQueue< T >::putn ( const size_t  n)
inlinenoexcept

Put n cells to the queue in constant time.

Parameters
[in]nnumber of cells
Returns
a modifiable reference to the last inserted item

Definition at line 538 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::dim, Aleph::FixedQueue< T >::increase_index(), FunctionalMethods< FixedQueue< T >, T >::maps(), Aleph::FixedQueue< T >::num_items, Aleph::FixedQueue< T >::rear_index, and Aleph::FixedQueue< T >::rear_item().

◆ rear()

template<typename T >
T & Aleph::FixedQueue< T >::rear ( const size_t  i = 0) const
inlinenoexcept

Return the i-th youngest item.

Parameters
[in]iaccess position respect to youngest item
Returns
a modifiable reference to the i-th item

Definition at line 589 of file tpl_arrayQueue.H.

References FunctionalMethods< FixedQueue< T >, T >::maps(), Aleph::FixedQueue< T >::num_items, and Aleph::FixedQueue< T >::rear_item().

Referenced by TEST().

◆ rear_item()

◆ size()

template<typename T >
constexpr size_t Aleph::FixedQueue< T >::size ( ) const
inlineconstexprnoexcept

Return the number of items.

Definition at line 596 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::num_items.

Referenced by TEST(), TEST(), TEST(), TEST(), and TEST().

◆ swap()

◆ traverse() [1/4]

template<typename T >
template<class Operation >
bool Aleph::FixedQueue< T >::traverse ( Operation &&  operation = Operation())
inline

Definition at line 638 of file tpl_arrayQueue.H.

References FunctionalMethods< FixedQueue< T >, T >::maps().

◆ traverse() [2/4]

template<typename T >
template<class Operation >
bool Aleph::FixedQueue< T >::traverse ( Operation &&  operation = Operation()) const
inline

Definition at line 631 of file tpl_arrayQueue.H.

References FunctionalMethods< FixedQueue< T >, T >::maps().

◆ traverse() [3/4]

template<typename T >
template<class Operation >
Aleph::FixedQueue< T >::traverse ( Operation operation)
inline

Traverse all the elements from the youngest to the oldest and execute operation on each on them.

Parameters
[in]operationto be performed on each element
Returns
true if operation was executed on all elements; false otherwise.

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 612 of file tpl_arrayQueue.H.

References Aleph::FixedQueue< T >::array, Aleph::FixedQueue< T >::front_index, Aleph::FixedQueue< T >::increase_index(), FunctionalMethods< FixedQueue< T >, T >::maps(), and Aleph::FixedQueue< T >::num_items.

Referenced by TEST(), and Aleph::FixedQueue< T >::traverse().

◆ traverse() [4/4]

template<typename T >
template<class Operation >
bool Aleph::FixedQueue< T >::traverse ( Operation operation) const
inline

Member Data Documentation

◆ array

◆ dim

◆ front_index

◆ mask

◆ num_items

◆ rear_index


The documentation for this class was generated from the following file: