A C++ template library for embedded applications
Designed and maintained by
Aster Consulting Ltd

deque

A fixed capacity deque.
STL equivalent: std::deque

etl::deque<typename T, const size_t SIZE>

Inherits from etl::ideque<T>
etl::ideque may be used as a size independent pointer or reference type for any etl::deque instance.

Has the ability to be copied by low level functions such as memcpy by use of a repair() function.
See the function reference for an example of use.

Member types

value_type              T
size_type               std::size_t
difference_type         std::ptrdiff_t
reference               value_type&
const_reference         const value_type&
pointer                 value_type*
const_pointer           const value_type*
iterator                Random access iterator
const_iterator          Constant random access iterator
reverse_iterator        std::reverse_iterator<iterator>
const_reverse_iterator  std::reverse_iterator<const_iterator>

Constructor

etl::deque<typename T, const size_t SIZE>();
etl::deque<typename T, const size_t SIZE>(size_t initialSize);
etl::deque<typename T, const size_t SIZE>(size_t initialSize, parameter_t value);
template <typename TIterator>
etl::deque<typename T, const size_t SIZE>(TIterator begin, TIterator end);


Element access

T& at(size_t i)
const T& at(size_t i) const
Returns a reference or const reference to the indexed element. Emits an etl::vector_out_of_range if the index is out of
range of the array.

T& operator[](size_t i)
const T& operator[](size_t i) const
Returns a reference or const reference to the indexed element.

T& front()
const T& front() const
Returns a reference or const reference to the first element.

T& back()
const T& back() const
Returns a reference or const reference to the last element.

Iterators

iterator begin()
const_iterator begin() const
const_iterator cbegin() const
Returns an iterator to the beginning of the deque.

iterator end()
const_iterator end() const
const_iterator cend() const
Returns an iterator to the end of the deque.

iterator rbegin()
const_reverse_iterator rbegin() const
const_reverse_iterator crbegin() const
Returns a reverse iterator to the beginning of the deque.

iterator rend()
const_reverse_iterator rend() const
const_reverse_iterator crend() const
Returns a reverse iterator to the end of the deque.


Capacity

bool empty() const
Returns true if the size of the deque is zero, otherwise false.

bool full() const
Returns true if the size of the deque is SIZE, otherwise false.

size_t size() const
Returns the size of the deque.

void resize(size_t new_size, T value - T())
Resizes the deque, up to the maximum capacity. Emits an etl::deque_full if the deque does not have the capacity.

size_t max_size() const
Returns the maximum possible size of the deque.

size_t capacity() const
Returns the maximum possible size of the deque.

size_t available() const
Returns the remaining available capacity in the deque.

Modifiers

template <typename TIterator>
void assign(TIterator begin, TIterator end);

void assign(size_t n, parameter_t value);
Fills the deque with the values. Emits etl::deque_iterator if the distance between begin and end is illegal.

void push_front(parameter_t value);
void push_front();
Pushes a value to the back of the deque. The first pushes a value, the second allocates the new element but does not
initialise it. If the deque is full then emits an etl::deque_full.

void push_back(parameter_t value);
void push_back();
Pushes a value to the back of the deque. The first pushes a value, the second allocates the new element but does not
initialise it. If the deque is full then emits an etl::deque_full.

void pop_front();
Pop a value from the front of the deque.

void pop_back();
Pop a value from the back of the deque.

template <typename TIterator>
void insert(iterator position, TIterator begin, TIterator end);

iterator insert(iterator position, parameter_t value);

void insert(iterator position, size_t n, parameter_t value);
Inserts values in to the deque. If the deque is full then emits an etl::deque_full exception.

template <typename TIterator>
iterator erase(TIterator begin, TIterator end);

iterator erase(iterator position);
Erases values in the deque.

void clear();
Clears the deque to a size of zero.

void repair()
This function must be called if the deque has been copied via a low level method such as memcpy.
This can only be called from an etl::deque instance, unless ETL_IDEQUE_REPAIR_ENABLE is defined. Be aware that doing
this introduces a virtual function to the class.

Has no effect if the object has not been copied in this way.

NOTE:
The contained type must be trivially copyable.
Compilers that satisfy the C++11 type traits support check in platform.h will generate an assert if the type is
incompatible.

Example:
typedef etl::deque<int, 10> Data;

Data data(8, 1);

char buffer[sizeof(Data)];

memcpy(&buffer, &data, sizeof(Data));

Data& rdata(*reinterpret_cast<Data*>(buffer));

// Do not access the copied object in any way until you have called this.
rdata.repair();

Non-member functions

==  true if the contents of the vectors are equal, otherwise false.
!=  true if the contents of the vectors are not equal, otherwise false.
<   true if the contents of the lhs are lexicographically less than the contents of the rhs,  otherwise false.
<=  true if the contents of the lhs are lexicographically less than or equal to the contents of the rhs, otherwise false.
>   true if the contents of the lhs are lexicographically greater than the contents of the rhs,  otherwise false.
>=  true if the contents of the lhs are lexicographically greater than or equal to the contents of the rhs, otherwise false.

deque.h