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

forward_list

A fixed capacity forward list.
STL equivalent: std::forward_list

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

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

Note: Does not support the member function swap.

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                Bi-directional iterator
const_iterator          Constant bi-directional iterator

Constructor

etl::forward_list<typename T, const size_t SIZE>();
etl::forward_list<typename T, const size_t SIZE>(size_t initialSize, parameter_t value = T());
template <typename TIterator>
etl::forward_list<typename T, const size_t SIZE>(TIterator begin, TIterator end);
Emits an etl::forward_list_iterator if the iterators are invalid. Emits an etl::forward_list_full if the list
becomes full. If asserts or exceptions are disabled then undefined behaviour occurs.

Element access

T& front()
const T& front() const
Returns a reference or const reference to the first element.
Undefined behaviour if the list is empty.

Iterators

iterator begin()
const_iterator begin() const
const_iterator cbegin() const
Returns an iterator to the beginning of the forward list.
Undefined behaviour if the list is empty.

iterator end()
const_iterator end() const
const_iterator cend() const
Returns an iterator to the end of the forward list.
Undefined behaviour if the list is empty.

iterator before_begin()
const_iterator before_begin() const
const_iterator cbefore_begin() const
Returns an iterator to before the beginning of the forward list.

Capacity

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

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

size_t size() const
Returns the size of the forward list.

size_t available() const
Returns the remaining available capacity in the forward list.

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

Modifiers

template <typename TIterator>
void assign(TIterator begin, TIterator end);
void assign(size_t n, parameter_t value);
Fills the forward list with the values.
Emits an etl::forward_list_iterator if the iterators are invalid. Emits an etl::forward_list_full if the list
becomes full. If asserts or exceptions are disabled then undefined behaviour occurs.

void push_front(parameter_t value);
void push_front();
Pushes a value to the front of the forward list. The first pushes a value, the second allocates the new element but does
not initialise it. If the forward list is full and ETL_CHECK_PUSH_POP is defined then emits an etl::forward_list_full
error, otherwise undefined behaviour occurs.

void emplace_front(const T1& value1);
void emplace_front(const T1& value1, const T2& value2);
void emplace_front(const T1& value1, const T2& value2, const T3& value3);
void emplace_front(const T1& value1, const T2& value2, const T3& value3, const T4& value4);
Constructs an item at the front of the the list 'in place'.
Supports up to four constructor parameters.
If the forward list is full and ETL_CHECK_PUSH_POP is defined then emits an etl::forward_list_full error, otherwise
undefined behaviour occurs.

void pop_front();
Pop a value from the front of the forward list.
If the forward list is empty and ETL_CHECK_PUSH_POP is defined then emits an etl::forward_list_empty error,
otherwise undefined behaviour occurs.

template <typename TIterator>
void insert_after(iterator position, TIterator begin, TIterator end);
iterator insert_after(iterator position, parameter_t value);
void insert_after(iterator position, size_t n, parameter_t value);
Inserts values in to the forward list after the specified position.
If the forward list is full then emits an etl::forward_list_full error. If asserts or exceptions are disabled then
undefined behaviour occurs.

iterator erase_after(iterator position);
iterator erase_after(iterator position, const_iterator end);
Erases elements after the specified position.
The second version erases up to, but not including end.

void resize(size_t n);
void resize(size_t n, parameter_t value);
Resizes the forward list. If the new size is larger then the first assigns default constructed values, the second assigns the
supplied value.
If n is larger than the capacity then emits an etl::forward_list_full error, if asserts or exceptions are not enabled
then undefined behaviour occurs.

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

Operations

void remove(const T& value);
Removes from the container all the elements that compare equal to value.

template <typename TPredicate>
void remove_if(TPredicate predicate);
Removes from the container all the elements that satisfy predicate.

void unique();
template <typename TPredicate>
void unique(TPredicate predicate);
The first version removes all but the first element from every group of consecutive elements.
The second removes all but the first element from every group of consecutive elements that satisfy the binary
predicate.

void sort();
template <typename TCompare>
void sort(TCompare compare);
The first version sorts using the < operator.
The second uses the supplied compare function.

void reverse();
Reverses the order of the container.

Non-member functions

==  true if the contents of the lists are equal, otherwise false.
!=  true if the contents of the lists 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.
forward_list.h