Loading...
Searching...
No Matches
vector.h
Go to the documentation of this file.
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2014 John Wellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef ETL_VECTOR_INCLUDED
#define ETL_VECTOR_INCLUDED
#define ETL_IN_VECTOR_H
#include "platform.h"
#include "algorithm.h"
#include "alignment.h"
#include "array.h"
#include "debug_count.h"
#include "error_handler.h"
#include "exception.h"
#include "initializer_list.h"
#include "iterator.h"
#include "memory.h"
#include "placement_new.h"
#include "static_assert.h"
#include "type_traits.h"
#include "private/pvoidvector.h"
#include "private/vector_base.h"
#include <stddef.h>
#include <stdint.h>
//*****************************************************************************
//*****************************************************************************
namespace etl
{
template <typename T, typename Enable = void>
class ivector;
//***************************************************************************
//***************************************************************************
template <typename T>
class ivector<T, typename etl::enable_if<etl::negation<etl::is_object_pointer<T> >::value>::type> : public etl::vector_base
{
public:
typedef T value_type;
typedef T& reference;
typedef const T& const_reference;
#if ETL_USING_CPP11
typedef T&& rvalue_reference;
#endif
typedef T* pointer;
typedef const T* const_pointer;
typedef T* iterator;
typedef const T* const_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef size_t size_type;
typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
public:
//*********************************************************************
//*********************************************************************
iterator begin()
{
return p_buffer;
}
//*********************************************************************
//*********************************************************************
const_iterator begin() const
{
return p_buffer;
}
//*********************************************************************
//*********************************************************************
iterator end()
{
return p_end;
}
//*********************************************************************
//*********************************************************************
const_iterator end() const
{
return p_end;
}
//*********************************************************************
//*********************************************************************
const_iterator cbegin() const
{
return p_buffer;
}
//*********************************************************************
//*********************************************************************
const_iterator cend() const
{
return p_end;
}
//*********************************************************************
//*********************************************************************
reverse_iterator rbegin()
{
return reverse_iterator(end());
}
//*********************************************************************
//*********************************************************************
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(end());
}
//*********************************************************************
//*********************************************************************
reverse_iterator rend()
{
return reverse_iterator(begin());
}
//*********************************************************************
//*********************************************************************
const_reverse_iterator rend() const
{
return const_reverse_iterator(begin());
}
//*********************************************************************
//*********************************************************************
const_reverse_iterator crbegin() const
{
return const_reverse_iterator(cend());
}
//*********************************************************************
//*********************************************************************
const_reverse_iterator crend() const
{
return const_reverse_iterator(cbegin());
}
//*********************************************************************
//*********************************************************************
void resize(size_t new_size)
{
resize(new_size, T());
}
//*********************************************************************
//*********************************************************************
void resize(size_t new_size, const_reference value)
{
ETL_ASSERT_OR_RETURN(new_size <= CAPACITY, ETL_ERROR(vector_full));
const size_t current_size = size();
size_t delta = (current_size < new_size) ? new_size - current_size : current_size - new_size;
if (current_size < new_size)
{
etl::uninitialized_fill_n(p_end, delta, value);
ETL_ADD_DEBUG_COUNT(delta);
}
else
{
etl::destroy_n(p_end - delta, delta);
ETL_SUBTRACT_DEBUG_COUNT(delta);
}
p_end = p_buffer + new_size;
}
//*********************************************************************
//*********************************************************************
void uninitialized_resize(size_t new_size)
{
ETL_ASSERT_OR_RETURN(new_size <= CAPACITY, ETL_ERROR(vector_full));
#if defined(ETL_DEBUG_COUNT)
if (size() < new_size)
{
ETL_ADD_DEBUG_COUNT(new_size - size());
}
else
{
ETL_SUBTRACT_DEBUG_COUNT(size() - new_size);
}
#endif
p_end = p_buffer + new_size;
}
//*********************************************************************
//*********************************************************************
void reserve(size_t n)
{
(void)n; // Stop 'unused parameter' warning in release mode.
ETL_ASSERT(n <= CAPACITY, ETL_ERROR(vector_out_of_bounds));
}
//*********************************************************************
//*********************************************************************
reference operator[](size_t i)
{
ETL_ASSERT_CHECK_INDEX_OPERATOR(i < size(), ETL_ERROR(vector_out_of_bounds));
return p_buffer[i];
}
//*********************************************************************
//*********************************************************************
const_reference operator[](size_t i) const
{
ETL_ASSERT_CHECK_INDEX_OPERATOR(i < size(), ETL_ERROR(vector_out_of_bounds));
return p_buffer[i];
}
//*********************************************************************
//*********************************************************************
reference at(size_t i)
{
ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
return p_buffer[i];
}
//*********************************************************************
//*********************************************************************
const_reference at(size_t i) const
{
ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
return p_buffer[i];
}
//*********************************************************************
//*********************************************************************
reference front()
{
ETL_ASSERT_CHECK_EXTRA(size() > 0, ETL_ERROR(vector_out_of_bounds));
return *p_buffer;
}
//*********************************************************************
//*********************************************************************
const_reference front() const
{
ETL_ASSERT_CHECK_EXTRA(size() > 0, ETL_ERROR(vector_out_of_bounds));
return *p_buffer;
}
//*********************************************************************
//*********************************************************************
reference back()
{
ETL_ASSERT_CHECK_EXTRA(size() > 0, ETL_ERROR(vector_out_of_bounds));
return *(p_end - 1);
}
//*********************************************************************
//*********************************************************************
const_reference back() const
{
ETL_ASSERT_CHECK_EXTRA(size() > 0, ETL_ERROR(vector_out_of_bounds));
return *(p_end - 1);
}
//*********************************************************************
//*********************************************************************
pointer data()
{
return p_buffer;
}
//*********************************************************************
//*********************************************************************
ETL_CONSTEXPR const_pointer data() const
{
return p_buffer;
}
//*********************************************************************
//*********************************************************************
template <typename TIterator>
typename etl::enable_if<!etl::is_integral<TIterator>::value
&& etl::is_convertible<typename etl::iterator_traits<TIterator>::value_type, T>::value,
typename etl::enable_if<!etl::is_integral<TIterator>::value, void>::type>::type
assign(TIterator first, TIterator last) ETL_NOEXCEPT_IF((etl::is_nothrow_copy_constructible<T>::value && ETL_NOT_USING_EXCEPTIONS))
{
#if ETL_USING_CPP11
ETL_STATIC_ASSERT((etl::is_same<typename etl::remove_cv<T>::type,
typename etl::remove_cv<typename etl::remove_reference<decltype(*first)>::type>::type>::value),
"Iterator type does not match container type");
#endif
#if ETL_IS_DEBUG_BUILD
difference_type d = etl::distance(first, last);
ETL_ASSERT_OR_RETURN(static_cast<size_t>(d) <= CAPACITY, ETL_ERROR(vector_full));
#endif
initialise();
p_end = etl::uninitialized_copy(first, last, p_buffer);
ETL_ADD_DEBUG_COUNT(uint32_t(etl::distance(first, last)));
}
//*********************************************************************
//*********************************************************************
void assign(size_t n, const_reference value)
{
ETL_ASSERT_OR_RETURN(n <= CAPACITY, ETL_ERROR(vector_full));
initialise();
p_end = etl::uninitialized_fill_n(p_buffer, n, value);
ETL_ADD_DEBUG_COUNT(uint32_t(n));
}
//*************************************************************************
//*************************************************************************
void clear()
{
initialise();
}
//*************************************************************************
//*************************************************************************
void fill(const T& value)
{
etl::fill(begin(), end(), value);
}
//*********************************************************************
//*********************************************************************
void push_back(const_reference value)
{
ETL_ASSERT_CHECK_PUSH_POP_OR_RETURN(size() != CAPACITY, ETL_ERROR(vector_full));
create_back(value);
}
#if ETL_USING_CPP11
//*********************************************************************
//*********************************************************************
void push_back(rvalue_reference value)
{
ETL_ASSERT_CHECK_PUSH_POP_OR_RETURN(size() != CAPACITY, ETL_ERROR(vector_full));
create_back(etl::move(value));
}
#endif
#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT && !defined(ETL_VECTOR_FORCE_CPP03_IMPLEMENTATION)
//*********************************************************************
//*********************************************************************
template <typename... Args>
reference emplace_back(Args&&... args)
{
ETL_ASSERT_CHECK_PUSH_POP(size() != CAPACITY, ETL_ERROR(vector_full));
#include "private/diagnostic_sign_conversion_push.h"
::new (p_end) T(etl::forward<Args>(args)...);
#include "private/diagnostic_pop.h"
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
return back();
}
#else
//*********************************************************************
//*********************************************************************
reference emplace_back()
{
ETL_ASSERT_CHECK_PUSH_POP(size() != CAPACITY, ETL_ERROR(vector_full));
::new (p_end) T();
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
return back();
}
//*********************************************************************
//*********************************************************************
template <typename T1>
reference emplace_back(const T1& value1)
{
ETL_ASSERT_CHECK_PUSH_POP(size() != CAPACITY, ETL_ERROR(vector_full));
::new (p_end) T(value1);
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
return back();
}
//*********************************************************************
//*********************************************************************
template <typename T1, typename T2>
reference emplace_back(const T1& value1, const T2& value2)
{
ETL_ASSERT_CHECK_PUSH_POP(size() != CAPACITY, ETL_ERROR(vector_full));
::new (p_end) T(value1, value2);
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
return back();
}
//*********************************************************************
//*********************************************************************
template <typename T1, typename T2, typename T3>
reference emplace_back(const T1& value1, const T2& value2, const T3& value3)
{
ETL_ASSERT_CHECK_PUSH_POP(size() != CAPACITY, ETL_ERROR(vector_full));
::new (p_end) T(value1, value2, value3);
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
return back();
}
//*********************************************************************
//*********************************************************************
template <typename T1, typename T2, typename T3, typename T4>
reference emplace_back(const T1& value1, const T2& value2, const T3& value3, const T4& value4)
{
ETL_ASSERT_CHECK_PUSH_POP(size() != CAPACITY, ETL_ERROR(vector_full));
::new (p_end) T(value1, value2, value3, value4);
++p_end;
ETL_INCREMENT_DEBUG_COUNT;
return back();
}
#endif
//*************************************************************************
//*************************************************************************
void pop_back()
{
ETL_ASSERT_CHECK_PUSH_POP_OR_RETURN(size() > 0, ETL_ERROR(vector_empty));
destroy_back();
}
//*********************************************************************
//*********************************************************************
iterator insert(const_iterator position, const_reference value)
{
ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator position_ = to_iterator(position);
if (position_ == end())
{
create_back(value);
}
else
{
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
*position_ = value;
}
return position_;
}
#if ETL_USING_CPP11
//*********************************************************************
//*********************************************************************
iterator insert(const_iterator position, rvalue_reference value)
{
ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator position_ = to_iterator(position);
if (position_ == end())
{
create_back(etl::move(value));
}
else
{
create_back(etl::move(back()));
etl::move_backward(position_, p_end - 2, p_end - 1);
*position_ = etl::move(value);
}
return position_;
}
#endif
//*************************************************************************
//*************************************************************************
#if ETL_USING_CPP11 && ETL_NOT_USING_STLPORT
template <typename... Args>
iterator emplace(const_iterator position, Args&&... args)
{
ETL_ASSERT(!full(), ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
}
#include "private/diagnostic_sign_conversion_push.h"
::new (p) T(etl::forward<Args>(args)...);
#include "private/diagnostic_pop.h"
return position_;
}
#else
template <typename T1>
iterator emplace(const_iterator position, const T1& value1)
{
ETL_ASSERT(!full(), ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
}
::new (p) T(value1);
return position_;
}
template <typename T1, typename T2>
iterator emplace(const_iterator position, const T1& value1, const T2& value2)
{
ETL_ASSERT(!full(), ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
}
::new (p) T(value1, value2);
return position_;
}
template <typename T1, typename T2, typename T3>
iterator emplace(const_iterator position, const T1& value1, const T2& value2, const T3& value3)
{
ETL_ASSERT(!full(), ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
}
::new (p) T(value1, value2, value3);
return position_;
}
template <typename T1, typename T2, typename T3, typename T4>
iterator emplace(const_iterator position, const T1& value1, const T2& value2, const T3& value3, const T4& value4)
{
ETL_ASSERT(!full(), ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator position_ = to_iterator(position);
void* p;
if (position_ == end())
{
p = p_end++;
ETL_INCREMENT_DEBUG_COUNT;
}
else
{
p = etl::addressof(*position_);
create_back(back());
etl::move_backward(position_, p_end - 2, p_end - 1);
(*position_).~T();
}
::new (p) T(value1, value2, value3, value4);
return position_;
}
#endif
//*********************************************************************
//*********************************************************************
void insert(const_iterator position, size_t n, const_reference value)
{
ETL_ASSERT_OR_RETURN((size() + n) <= CAPACITY, ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator position_ = to_iterator(position);
size_t insert_n = n;
size_t insert_begin = static_cast<size_t>(etl::distance(begin(), position_));
size_t insert_end = insert_begin + insert_n;
// Copy old data.
size_t copy_old_n;
size_t construct_old_n;
iterator p_construct_old;
if (insert_end > size())
{
copy_old_n = 0;
construct_old_n = size() - insert_begin;
p_construct_old = p_buffer + insert_end;
}
else
{
copy_old_n = size() - insert_begin - insert_n;
construct_old_n = insert_n;
p_construct_old = p_end;
}
size_t copy_new_n = construct_old_n;
size_t construct_new_n = insert_n - copy_new_n;
// Construct old.
etl::uninitialized_move(p_end - construct_old_n, p_end, p_construct_old);
ETL_ADD_DEBUG_COUNT(construct_old_n);
// Copy old.
etl::move_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n);
// Construct new.
etl::uninitialized_fill_n(p_end, construct_new_n, value);
ETL_ADD_DEBUG_COUNT(construct_new_n);
// Copy new.
etl::fill_n(p_buffer + insert_begin, copy_new_n, value);
p_end += n;
}
//*********************************************************************
//*********************************************************************
template <class TIterator>
typename etl::enable_if<
!etl::is_integral<TIterator>::value && etl::is_convertible<typename etl::iterator_traits<TIterator>::value_type, T>::value, void>::type
insert(const_iterator position, TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
{
size_t count = static_cast<size_t>(etl::distance(first, last));
ETL_ASSERT_OR_RETURN((size() + count) <= CAPACITY, ETL_ERROR(vector_full));
ETL_ASSERT_CHECK_EXTRA(cbegin() <= position && position <= cend(), ETL_ERROR(vector_out_of_bounds));
size_t insert_n = count;
size_t insert_begin = static_cast<size_t>(etl::distance(cbegin(), position));
size_t insert_end = insert_begin + insert_n;
// Move old data.
size_t copy_old_n;
size_t construct_old_n;
iterator p_construct_old;
if (insert_end > size())
{
copy_old_n = 0;
construct_old_n = size() - insert_begin;
p_construct_old = p_buffer + insert_end;
}
else
{
copy_old_n = size() - insert_begin - insert_n;
construct_old_n = insert_n;
p_construct_old = p_end;
}
size_t copy_new_n = construct_old_n;
size_t construct_new_n = insert_n - copy_new_n;
// Move construct old.
etl::uninitialized_move(p_end - construct_old_n, p_end, p_construct_old);
ETL_ADD_DEBUG_COUNT(construct_old_n);
// Move old.
etl::move_backward(p_buffer + insert_begin, p_buffer + insert_begin + copy_old_n, p_buffer + insert_end + copy_old_n);
// Copy construct new.
etl::uninitialized_copy(first + static_cast<ptrdiff_t>(copy_new_n), first + static_cast<ptrdiff_t>(copy_new_n + construct_new_n), p_end);
ETL_ADD_DEBUG_COUNT(construct_new_n);
// Copy new.
etl::copy(first, first + static_cast<ptrdiff_t>(copy_new_n), p_buffer + insert_begin);
p_end += count;
}
//*********************************************************************
//*********************************************************************
iterator erase(iterator i_element)
{
ETL_ASSERT_CHECK_EXTRA(cbegin() <= i_element && i_element < cend(), ETL_ERROR(vector_out_of_bounds));
etl::move(i_element + 1, end(), i_element);
destroy_back();
return i_element;
}
//*********************************************************************
//*********************************************************************
iterator erase(const_iterator i_element)
{
ETL_ASSERT_CHECK_EXTRA(cbegin() <= i_element && i_element < cend(), ETL_ERROR(vector_out_of_bounds));
iterator i_element_ = to_iterator(i_element);
etl::move(i_element_ + 1, end(), i_element_);
destroy_back();
return i_element_;
}
//*********************************************************************
//*********************************************************************
iterator erase(const_iterator first, const_iterator last)
{
ETL_ASSERT_CHECK_EXTRA(cbegin() <= first && first <= last && last <= cend(), ETL_ERROR(vector_out_of_bounds));
iterator first_ = to_iterator(first);
iterator last_ = to_iterator(last);
if (first == begin() && last == end())
{
clear();
}
else
{
etl::move(last_, end(), first_);
size_t n_delete = static_cast<size_t>(etl::distance(first_, last_));
// Destroy the elements left over at the end.
etl::destroy(p_end - n_delete, p_end);
ETL_SUBTRACT_DEBUG_COUNT(n_delete);
p_end -= n_delete;
}
return first_;
}
//*********************************************************************
//*********************************************************************
void swap(ivector<T>& other)
{
if (this == &other)
{
return;
}
ETL_ASSERT_OR_RETURN(this->max_size() >= other.size() && other.max_size() >= this->size(), ETL_ERROR(vector_full));
ivector<T>& smaller = other.size() > this->size() ? *this : other;
ivector<T>& larger = other.size() > this->size() ? other : *this;
etl::swap_ranges(smaller.begin(), smaller.end(), larger.begin());
typename ivector<T>::iterator larger_itr =
etl::next(larger.begin(), static_cast<typename etl::iterator_traits< typename ivector<T>::iterator>::difference_type>(smaller.size()));
etl::move(larger_itr, larger.end(), etl::back_inserter(smaller));
larger.erase(larger_itr, larger.end());
}
//*************************************************************************
//*************************************************************************
ivector& operator=(const ivector& rhs)
{
if (&rhs != this)
{
assign(rhs.cbegin(), rhs.cend());
}
return *this;
}
#if ETL_USING_CPP11
//*************************************************************************
//*************************************************************************
ivector& operator=(ivector&& rhs) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value))
{
if (&rhs != this)
{
clear();
iterator itr = rhs.begin();
while (itr != rhs.end())
{
push_back(etl::move(*itr));
++itr;
}
rhs.initialise();
}
return *this;
}
#endif
//*************************************************************************
//*************************************************************************
size_type size() const
{
return size_t(p_end - p_buffer);
}
//*************************************************************************
//*************************************************************************
bool empty() const
{
return (p_end == p_buffer);
}
//*************************************************************************
//*************************************************************************
bool full() const
{
return size() == CAPACITY;
}
//*************************************************************************
//*************************************************************************
size_t available() const
{
return max_size() - size();
}
#ifdef ETL_IVECTOR_REPAIR_ENABLE
//*************************************************************************
//*************************************************************************
virtual void repair() = 0;
#endif
protected:
//*********************************************************************
//*********************************************************************
ivector(T* p_buffer_, size_t MAX_SIZE) ETL_NOEXCEPT
: vector_base(MAX_SIZE)
, p_buffer(p_buffer_)
, p_end(p_buffer_)
{
}
//*********************************************************************
//*********************************************************************
void initialise()
{
if ETL_IF_CONSTEXPR (etl::is_trivially_destructible<T>::value)
{
ETL_RESET_DEBUG_COUNT;
}
else
{
etl::destroy(p_buffer, p_end);
ETL_SUBTRACT_DEBUG_COUNT(int32_t(etl::distance(p_buffer, p_end)));
}
p_end = p_buffer;
}
//*************************************************************************
//*************************************************************************
void repair_buffer(T* p_buffer_)
{
uintptr_t length = static_cast<uintptr_t>(p_end - p_buffer);
p_buffer = p_buffer_;
p_end = p_buffer_ + length;
}
pointer p_buffer;
pointer p_end;
private:
//*********************************************************************
//*********************************************************************
void create_back(const_reference value)
{
etl::create_copy_at(p_end, value);
ETL_INCREMENT_DEBUG_COUNT;
++p_end;
}
#if ETL_USING_CPP11
//*********************************************************************
//*********************************************************************
void create_back(rvalue_reference value)
{
etl::create_copy_at(p_end, etl::move(value));
ETL_INCREMENT_DEBUG_COUNT;
++p_end;
}
#endif
//*********************************************************************
//*********************************************************************
void destroy_back()
{
--p_end;
etl::destroy_at(p_end);
ETL_DECREMENT_DEBUG_COUNT;
}
// Disable copy construction.
ivector(const ivector&) ETL_DELETE;
private:
//*************************************************************************
//*************************************************************************
ETL_CONSTEXPR iterator to_iterator(const_iterator itr) const
{
return const_cast<iterator>(itr);
}
};
//***************************************************************************
//***************************************************************************
template <typename T>
class ivector<T, typename etl::enable_if<etl::is_object_pointer<T>::value>::type> : public etl::pvoidvector
{
public:
typedef T value_type;
typedef T& reference;
typedef const T& const_reference;
#if ETL_USING_CPP11
typedef T&& rvalue_reference;
#endif
typedef T* pointer;
typedef const T* const_pointer;
typedef T* iterator;
typedef const T* const_iterator;
typedef ETL_OR_STD::reverse_iterator<iterator> reverse_iterator;
typedef ETL_OR_STD::reverse_iterator<const_iterator> const_reverse_iterator;
typedef size_t size_type;
typedef typename etl::iterator_traits<iterator>::difference_type difference_type;
private:
typedef pvoidvector base_t;
typedef typename etl::remove_const<typename etl::remove_pointer<T>::type>::type* element_type;
template <typename TIterator>
struct is_compatible_iterator
: etl::bool_constant<etl::is_pointer<typename etl::iterator_traits<TIterator>::value_type>::value
&& etl::is_convertible<typename etl::iterator_traits<TIterator>::value_type, value_type>::value>
{
};
public:
//*********************************************************************
//*********************************************************************
iterator begin()
{
return iterator(base_t::begin());
}
//*********************************************************************
//*********************************************************************
const_iterator begin() const
{
return const_iterator(base_t::begin());
}
//*********************************************************************
//*********************************************************************
iterator end()
{
return iterator(base_t::end());
}
//*********************************************************************
//*********************************************************************
const_iterator end() const
{
return const_iterator(base_t::end());
}
//*********************************************************************
//*********************************************************************
const_iterator cbegin() const
{
return const_iterator(base_t::cbegin());
}
//*********************************************************************
//*********************************************************************
const_iterator cend() const
{
return const_iterator(base_t::cend());
}
//*********************************************************************
//*********************************************************************
reverse_iterator rbegin()
{
return reverse_iterator(iterator(base_t::end()));
}
//*********************************************************************
//*********************************************************************
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(const_iterator(base_t::end()));
}
//*********************************************************************
//*********************************************************************
reverse_iterator rend()
{
return reverse_iterator(iterator(base_t::begin()));
}
//*********************************************************************
//*********************************************************************
const_reverse_iterator rend() const
{
return const_reverse_iterator(const_iterator(base_t::begin()));
}
//*********************************************************************
//*********************************************************************
const_reverse_iterator crbegin() const
{
return const_reverse_iterator(const_iterator(base_t::cend()));
}
//*********************************************************************
//*********************************************************************
const_reverse_iterator crend() const
{
return const_reverse_iterator(const_iterator(base_t::cbegin()));
}
//*********************************************************************
//*********************************************************************
void resize(size_t new_size)
{
base_t::resize(new_size);
}
//*********************************************************************
//*********************************************************************
void resize(size_t new_size, value_type value)
{
base_t::resize(new_size, to_void_ptr(value));
}
//*********************************************************************
//*********************************************************************
void uninitialized_resize(size_t new_size)
{
base_t::uninitialized_resize(new_size);
}
//*********************************************************************
//*********************************************************************
reference operator[](size_t i)
{
return reference(base_t::operator[](i));
}
//*********************************************************************
//*********************************************************************
const_reference operator[](size_t i) const
{
return const_reference(base_t::operator[](i));
}
//*********************************************************************
//*********************************************************************
reference at(size_t i)
{
return reference(base_t::at(i));
}
//*********************************************************************
//*********************************************************************
const_reference at(size_t i) const
{
return const_reference(base_t::at(i));
}
//*********************************************************************
//*********************************************************************
reference front()
{
return reference(base_t::front());
}
//*********************************************************************
//*********************************************************************
const_reference front() const
{
return const_reference(base_t::front());
}
//*********************************************************************
//*********************************************************************
reference back()
{
return reference(base_t::back());
}
//*********************************************************************
//*********************************************************************
const_reference back() const
{
return const_reference(base_t::back());
}
//*********************************************************************
//*********************************************************************
pointer data()
{
return pointer(base_t::data());
}
//*********************************************************************
//*********************************************************************
const_pointer data() const
{
return const_pointer(base_t::data());
}
//*********************************************************************
//*********************************************************************
template <typename TIterator>
typename etl::enable_if<is_compatible_iterator<TIterator>::value, void>::type assign(TIterator first, TIterator last)
{
base_t::assign(first, last);
}
//*********************************************************************
//*********************************************************************
void assign(size_t n, const_reference value)
{
base_t::assign(n, to_void_ptr(value));
}
//*************************************************************************
//*************************************************************************
void clear()
{
base_t::clear();
}
//*********************************************************************
//*********************************************************************
void push_back(const_reference value)
{
base_t::push_back(to_void_ptr(value));
}
//*********************************************************************
//*********************************************************************
reference emplace_back()
{
base_t::emplace_back(ETL_NULLPTR);
return back();
}
//*********************************************************************
//*********************************************************************
reference emplace_back(const_reference value)
{
base_t::emplace_back(to_void_ptr(value));
return back();
}
//*************************************************************************
//*************************************************************************
void pop_back()
{
base_t::pop_back();
}
//*********************************************************************
//*********************************************************************
iterator insert(const_iterator position, const_reference value)
{
return iterator(base_t::insert(base_t::iterator(position), to_void_ptr(value)));
}
//*************************************************************************
//*************************************************************************
iterator emplace(const_iterator position)
{
return iterator(base_t::emplace(base_t::iterator(position), ETL_NULLPTR));
}
//*************************************************************************
//*************************************************************************
iterator emplace(const_iterator position, const_reference value)
{
return iterator(base_t::emplace(base_t::iterator(position), to_void_ptr(value)));
}
//*********************************************************************
//*********************************************************************
void insert(const_iterator position, size_t n, const_reference value)
{
base_t::insert(base_t::const_iterator(position), n, to_void_ptr(value));
}
//*********************************************************************
//*********************************************************************
template <typename TIterator>
typename etl::enable_if< is_compatible_iterator<TIterator>::value, void>::type insert(const_iterator position, TIterator first, TIterator last)
{
base_t::insert(base_t::const_iterator(position), first, last);
}
//*********************************************************************
//*********************************************************************
iterator erase(iterator i_element)
{
return iterator(base_t::erase(base_t::iterator(i_element)));
}
//*********************************************************************
//*********************************************************************
iterator erase(const_iterator i_element)
{
return iterator(base_t::erase(base_t::const_iterator(i_element)));
}
//*********************************************************************
//*********************************************************************
iterator erase(const_iterator first, const_iterator last)
{
return iterator(base_t::erase(base_t::const_iterator(first), base_t::const_iterator(last)));
}
//*********************************************************************
//*********************************************************************
void swap(ivector<T>& other)
{
if (this == &other)
{
return;
}
ETL_ASSERT_OR_RETURN(this->max_size() >= other.size() && other.max_size() >= this->size(), ETL_ERROR(vector_full));
ivector<T>& smaller = other.size() > this->size() ? *this : other;
ivector<T>& larger = other.size() > this->size() ? other : *this;
etl::swap_ranges(smaller.begin(), smaller.end(), larger.begin());
typename ivector<T>::iterator larger_itr = etl::next(larger.begin(), static_cast<ptrdiff_t>(smaller.size()));
etl::move(larger_itr, larger.end(), etl::back_inserter(smaller));
larger.erase(larger_itr, larger.end());
}
//*************************************************************************
//*************************************************************************
ivector& operator=(const ivector& rhs)
{
base_t::operator=(rhs);
return *this;
}
#if ETL_USING_CPP11
//*************************************************************************
//*************************************************************************
ivector& operator=(ivector&& rhs)
{
(void)base_t::operator=(etl::move(rhs));
return *this;
}
#endif
#ifdef ETL_IVECTOR_REPAIR_ENABLE
//*************************************************************************
//*************************************************************************
virtual void repair() = 0;
#endif
protected:
//*********************************************************************
//*********************************************************************
ivector(pointer p_buffer_, size_t MAX_SIZE) ETL_NOEXCEPT
: pvoidvector(to_void_pptr(p_buffer_), MAX_SIZE)
{
}
//*********************************************************************
//*********************************************************************
void initialise()
{
base_t::initialise();
}
//*************************************************************************
//*************************************************************************
void repair_buffer(pointer p_buffer_)
{
base_t::repair_buffer(to_void_pptr(p_buffer_));
}
private:
// Disable copy construction.
ivector(const ivector&) ETL_DELETE;
// Convert from const_reference to void*
static ETL_CONSTEXPR14 void* to_void_ptr(const_reference value) ETL_NOEXCEPT
{
return const_cast<void*>(static_cast<const void*>(value));
}
// Convert from pointer to void**
static ETL_CONSTEXPR14 void** to_void_pptr(pointer p_buffer) ETL_NOEXCEPT
{
return reinterpret_cast<void**>(const_cast<element_type*>(p_buffer));
}
};
//***************************************************************************
//***************************************************************************
template <typename T>
bool operator==(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
{
return (lhs.size() == rhs.size()) && etl::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//***************************************************************************
//***************************************************************************
template <typename T>
bool operator!=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
{
return !(lhs == rhs);
}
//***************************************************************************
//***************************************************************************
template <typename T>
bool operator<(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
{
return etl::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
//***************************************************************************
//***************************************************************************
template <typename T>
bool operator>(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
{
return (rhs < lhs);
}
//***************************************************************************
//***************************************************************************
template <typename T>
bool operator<=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
{
return !(lhs > rhs);
}
//***************************************************************************
//***************************************************************************
template <typename T>
bool operator>=(const etl::ivector<T>& lhs, const etl::ivector<T>& rhs)
{
return !(lhs < rhs);
}
} // namespace etl
namespace etl
{
//***************************************************************************
template <typename T, const size_t MAX_SIZE_>
class vector;
//***************************************************************************
//***************************************************************************
template <typename T, const size_t MAX_SIZE_>
class vector : public etl::ivector<T>
{
public:
ETL_STATIC_ASSERT((MAX_SIZE_ > 0U), "Zero capacity etl::vector is not valid");
static const size_t MAX_SIZE = MAX_SIZE_;
//*************************************************************************
//*************************************************************************
vector() ETL_NOEXCEPT
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
this->initialise();
}
//*************************************************************************
//*************************************************************************
explicit vector(size_t initial_size)
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
this->initialise();
this->resize(initial_size);
}
//*************************************************************************
//*************************************************************************
vector(size_t initial_size, typename etl::ivector<T>::const_reference value)
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
this->initialise();
this->resize(initial_size, value);
}
//*************************************************************************
//*************************************************************************
template <typename TIterator>
vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
this->assign(first, last);
}
#if ETL_HAS_INITIALIZER_LIST
//*************************************************************************
//*************************************************************************
vector(std::initializer_list<T> init)
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
this->assign(init.begin(), init.end());
}
#endif
//*************************************************************************
//*************************************************************************
vector(const vector& other)
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
this->assign(other.begin(), other.end());
}
//*************************************************************************
//*************************************************************************
vector& operator=(const vector& rhs)
{
if (&rhs != this)
{
this->assign(rhs.cbegin(), rhs.cend());
}
return *this;
}
#if ETL_USING_CPP11
//*************************************************************************
//*************************************************************************
vector(vector&& other) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value))
: etl::ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
{
if (this != &other)
{
this->initialise();
typename etl::ivector<T>::iterator itr = other.begin();
while (itr != other.end())
{
this->push_back(etl::move(*itr));
++itr;
}
other.initialise();
}
}
//*************************************************************************
//*************************************************************************
vector& operator=(vector&& rhs) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value))
{
if (&rhs != this)
{
this->clear();
typename etl::ivector<T>::iterator itr = rhs.begin();
while (itr != rhs.end())
{
this->push_back(etl::move(*itr));
++itr;
}
rhs.initialise();
}
return *this;
}
#endif
//*************************************************************************
//*************************************************************************
#ifdef ETL_IVECTOR_REPAIR_ENABLE
virtual
#endif
~vector() ETL_NOEXCEPT
{
this->clear();
}
//*************************************************************************
//*************************************************************************
#ifdef ETL_IVECTOR_REPAIR_ENABLE
virtual void repair() ETL_OVERRIDE
#else
void repair()
#endif
{
ETL_ASSERT_OR_RETURN(etl::is_trivially_copyable<T>::value, ETL_ERROR(etl::vector_incompatible_type));
etl::ivector<T>::repair_buffer(buffer);
}
private:
typename etl::aligned_storage<sizeof(T) * MAX_SIZE, etl::alignment_of<T>::value>::type buffer;
};
//*************************************************************************
//*************************************************************************
#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST
template <typename... T>
vector(T...) -> vector<typename etl::common_type_t<T...>, sizeof...(T)>;
#endif
//*************************************************************************
//*************************************************************************
#if ETL_USING_CPP11 && ETL_HAS_INITIALIZER_LIST
template <typename... T>
constexpr auto make_vector(T&&... t) -> etl::vector<typename etl::common_type_t<T...>, sizeof...(T)>
{
return {etl::forward<T>(t)...};
}
#endif
//***************************************************************************
//***************************************************************************
template <typename T>
class vector_ext : public etl::ivector<T>
{
public:
//*************************************************************************
//*************************************************************************
vector_ext(void* buffer, size_t max_size) ETL_NOEXCEPT
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
this->initialise();
}
//*************************************************************************
//*************************************************************************
explicit vector_ext(size_t initial_size, void* buffer, size_t max_size)
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
this->initialise();
this->resize(initial_size);
}
//*************************************************************************
//*************************************************************************
vector_ext(size_t initial_size, typename etl::ivector<T>::const_reference value, void* buffer, size_t max_size)
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
this->initialise();
this->resize(initial_size, value);
}
//*************************************************************************
//*************************************************************************
template <typename TIterator>
vector_ext(TIterator first, TIterator last, void* buffer, size_t max_size,
typename etl::enable_if<!etl::is_integral<TIterator>::value, int>::type = 0)
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
this->assign(first, last);
}
#if ETL_HAS_INITIALIZER_LIST
//*************************************************************************
//*************************************************************************
vector_ext(std::initializer_list<T> init, void* buffer, size_t max_size)
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
this->assign(init.begin(), init.end());
}
#endif
//*************************************************************************
//*************************************************************************
vector_ext(const vector_ext& other, void* buffer, size_t max_size)
ETL_NOEXCEPT_IF((etl::is_nothrow_copy_constructible<T>::value && ETL_NOT_USING_EXCEPTIONS))
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
if (&other != this)
{
this->assign(other.begin(), other.end());
}
}
//*************************************************************************
//*************************************************************************
vector_ext& operator=(const vector_ext& rhs) ETL_NOEXCEPT_IF((etl::is_nothrow_copy_constructible<T>::value && ETL_NOT_USING_EXCEPTIONS))
{
if (&rhs != this)
{
this->assign(rhs.cbegin(), rhs.cend());
}
return *this;
}
#if ETL_USING_CPP11
//*************************************************************************
//*************************************************************************
vector_ext(vector_ext&& other, void* buffer, size_t max_size)
ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value && ETL_NOT_USING_EXCEPTIONS))
: etl::ivector<T>(reinterpret_cast<T*>(buffer), max_size)
{
if (&other != this)
{
this->assign(etl::make_move_iterator(other.begin()), etl::make_move_iterator(other.end()));
other.initialise();
}
}
//*************************************************************************
//*************************************************************************
vector_ext& operator=(vector_ext&& rhs) ETL_NOEXCEPT_IF((etl::is_nothrow_move_constructible<T>::value && ETL_NOT_USING_EXCEPTIONS))
{
if (&rhs != this)
{
this->assign(etl::make_move_iterator(rhs.begin()), etl::make_move_iterator(rhs.end()));
rhs.initialise();
}
return *this;
}
#endif
//*************************************************************************
//*************************************************************************
~vector_ext() ETL_NOEXCEPT
{
this->clear();
}
//*************************************************************************
//*************************************************************************
#ifdef ETL_IVECTOR_REPAIR_ENABLE
virtual void repair() ETL_OVERRIDE
#else
void repair()
#endif
{
}
};
//***************************************************************************
//***************************************************************************
template <typename T, typename U>
typename etl::ivector<T>::difference_type erase(etl::ivector<T>& v, const U& value)
{
typename etl::ivector<T>::iterator itr = etl::remove(v.begin(), v.end(), value);
typename etl::ivector<T>::difference_type d = etl::distance(itr, v.end());
v.erase(itr, v.end());
return d;
}
//***************************************************************************
//***************************************************************************
template <typename T, typename TPredicate>
typename etl::ivector<T>::difference_type erase_if(etl::ivector<T>& v, TPredicate predicate)
{
typename etl::ivector<T>::iterator itr = etl::remove_if(v.begin(), v.end(), predicate);
typename etl::ivector<T>::difference_type d = etl::distance(itr, v.end());
v.erase(itr, v.end());
return d;
}
//*********************************************************************
//*********************************************************************
template <typename T>
void swap(ivector<T>& lhs, ivector<T>& rhs)
{
lhs.swap(rhs);
}
} // namespace etl
#endif
algorithm.h
alignment.h
array.h
etl::ivector
Definition vector.h:65
debug_count.h
diagnostic_pop.h
diagnostic_sign_conversion_push.h
error_handler.h
exception.h
etl::remove
ETL_CONSTEXPR14 TIterator remove(TIterator first, TIterator last, const T &value)
Definition algorithm.h:2381
etl::remove_if
ETL_CONSTEXPR14 TIterator remove_if(TIterator first, TIterator last, TUnaryPredicate predicate)
Definition algorithm.h:2406
etl::aligned_storage
Definition alignment.h:251
etl::const_iterator
ETL_ASSERT
#define ETL_ASSERT(b, e)
Definition error_handler.h:511
etl::addressof
ETL_CONSTEXPR17 etl::enable_if<!etl::is_same< T, etl::nullptr_t >::value, T >::type * addressof(T &t)
Definition addressof.h:52
etl::create_copy_at
void create_copy_at(T *p, const T &value)
Definition memory.h:2786
etl::destroy
etl::enable_if< etl::is_trivially_destructible< typenameetl::iterator_traits< TIterator >::value_type >::value, void >::type destroy(TIterator, TIterator)
Definition memory.h:1893
etl::destroy_at
etl::enable_if< etl::is_trivially_destructible< T >::value, void >::type destroy_at(T *)
Definition memory.h:1819
etl::destroy_n
etl::enable_if< etl::is_trivially_destructible< typenameetl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n(TIterator i_begin, TSize n)
Definition memory.h:1979
etl::uninitialized_move
TOutputIterator uninitialized_move(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition memory.h:985
etl::uninitialized_copy
TOutputIterator uninitialized_copy(TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
Definition memory.h:555
etl::uninitialized_fill_n
TOutputIterator uninitialized_fill_n(TOutputIterator o_begin, TSize n, const T &value)
Definition memory.h:528
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::crend
const_reverse_iterator crend() const
Definition vector.h:1329
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::operator[]
reference operator[](size_t i)
Definition vector.h:1372
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::data
pointer data()
Definition vector.h:370
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::rbegin
const_reverse_iterator rbegin() const
Definition vector.h:163
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::emplace_back
reference emplace_back()
Definition vector.h:502
etl::pvoidvector::assign
etl::enable_if<!etl::is_pointer< TIterator >::value, void >::type assign(TIterator first, TIterator last)
Definition pvoidvector.h:342
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::rbegin
const_reverse_iterator rbegin() const
Definition vector.h:1293
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::ivector
ivector(T *p_buffer_, size_t MAX_SIZE) ETL_NOEXCEPT
Constructor.
Definition vector.h:1095
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::resize
void resize(size_t new_size, const_reference value)
Definition vector.h:223
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::operator[]
const_reference operator[](size_t i) const
Definition vector.h:294
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::uninitialized_resize
void uninitialized_resize(size_t new_size)
Definition vector.h:248
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::erase
iterator erase(const_iterator i_element)
Definition vector.h:1617
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::emplace
iterator emplace(const_iterator position, const_reference value)
Emplaces a value to the vector at the specified position.
Definition vector.h:1568
etl::pvoidvector::begin
iterator begin()
Definition pvoidvector.h:76
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::resize
void resize(size_t new_size, value_type value)
Definition vector.h:1353
etl::pvoidvector::emplace_back
void emplace_back(value_type value)
Definition pvoidvector.h:425
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::assign
void assign(size_t n, const_reference value)
Definition vector.h:422
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::cbegin
const_iterator cbegin() const
Definition vector.h:1266
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::begin
const_iterator begin() const
Definition vector.h:109
etl::pvoidvector::erase
iterator erase(iterator i_element)
Definition pvoidvector.h:623
etl::pvoidvector::data
pointer data()
Definition pvoidvector.h:319
etl::vector_base::max_size
size_type max_size() const
Definition vector_base.h:140
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::operator=
ivector & operator=(const ivector &rhs)
Assignment operator.
Definition vector.h:1665
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::push_back
void push_back(const_reference value)
Definition vector.h:1505
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::assign
etl::enable_if<!etl::is_integral< TIterator >::value &&etl::is_convertible< typenameetl::iterator_traits< TIterator >::value_type, T >::value, typenameetl::enable_if<!etl::is_integral< TIterator >::value, void >::type >::type assign(TIterator first, TIterator last) ETL_NOEXCEPT_IF((etl
Definition vector.h:396
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::resize
void resize(size_t new_size)
Definition vector.h:1340
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::emplace_back
reference emplace_back(const T1 &value1, const T2 &value2, const T3 &value3, const T4 &value4)
Definition vector.h:570
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::emplace_back
reference emplace_back(const T1 &value1)
Definition vector.h:519
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::begin
const_iterator begin() const
Definition vector.h:1239
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::data
pointer data()
Definition vector.h:1451
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::operator=
ivector & operator=(const ivector &rhs)
Assignment operator.
Definition vector.h:1014
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::repair_buffer
void repair_buffer(T *p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition vector.h:1123
etl::vector_ext::vector_ext
vector_ext(TIterator first, TIterator last, void *buffer, size_t max_size, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition vector.h:2058
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::end
const_iterator end() const
Definition vector.h:1257
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::insert
iterator insert(const_iterator position, const_reference value)
Definition vector.h:1552
etl::vector::vector
vector(size_t initial_size)
Definition vector.h:1850
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::swap
void swap(ivector< T > &other)
Definition vector.h:989
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::data
const_pointer data() const
Definition vector.h:1460
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::emplace
iterator emplace(const_iterator position, const T1 &value1)
Emplaces a value to the vector at the specified position.
Definition vector.h:687
etl::pvoidvector::initialise
void initialise()
Initialise the vector.
Definition pvoidvector.h:760
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::swap
void swap(ivector< T > &other)
Definition vector.h:1641
etl::vector::repair
void repair()
Fix the internal pointers after a low level memory copy.
Definition vector.h:1976
etl::vector::vector
vector(const vector &other)
Copy constructor.
Definition vector.h:1896
etl::vector_ext::vector_ext
vector_ext(size_t initial_size, void *buffer, size_t max_size)
Definition vector.h:2032
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::rbegin
reverse_iterator rbegin()
Definition vector.h:154
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::cbegin
const_iterator cbegin() const
Definition vector.h:136
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::available
size_t available() const
Definition vector.h:1078
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::back
const_reference back() const
Definition vector.h:1442
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::resize
void resize(size_t new_size)
Definition vector.h:210
etl::vector_base::vector_base
vector_base(size_t max_size_)
Constructor.
Definition vector_base.h:150
etl::vector_base::CAPACITY
const size_type CAPACITY
The maximum number of elements in the vector.
Definition vector_base.h:170
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::rbegin
reverse_iterator rbegin()
Definition vector.h:1284
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::back
reference back()
Definition vector.h:350
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::erase
iterator erase(const_iterator first, const_iterator last)
Definition vector.h:1631
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::emplace
iterator emplace(const_iterator position)
Emplaces a value to the vector at the specified position.
Definition vector.h:1560
etl::pvoidvector::emplace
iterator emplace(const_iterator position)
Definition pvoidvector.h:488
etl::pvoidvector::operator=
etl::pvoidvector & operator=(const etl::pvoidvector &rhs)
Assignment operator.
Definition pvoidvector.h:679
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::rend
reverse_iterator rend()
Definition vector.h:1302
etl::vector_ext::vector_ext
vector_ext(void *buffer, size_t max_size) ETL_NOEXCEPT
Constructor.
Definition vector.h:2022
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::at
const_reference at(size_t i) const
Definition vector.h:1406
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::crend
const_reverse_iterator crend() const
Definition vector.h:199
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::ivector
ivector(pointer p_buffer_, size_t MAX_SIZE) ETL_NOEXCEPT
Constructor.
Definition vector.h:1696
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::clear
void clear()
Clears the vector.
Definition vector.h:435
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::insert
void insert(const_iterator position, size_t n, const_reference value)
Definition vector.h:1581
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::operator[]
const_reference operator[](size_t i) const
Definition vector.h:1382
etl::vector_ext::operator=
vector_ext & operator=(const vector_ext &rhs) ETL_NOEXCEPT_IF((etl
Assignment operator.
Definition vector.h:2092
etl::vector_ext::vector_ext
vector_ext(size_t initial_size, typename etl::ivector< T >::const_reference value, void *buffer, size_t max_size)
Definition vector.h:2044
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::back
reference back()
Definition vector.h:1433
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::rend
reverse_iterator rend()
Definition vector.h:172
etl::pvoidvector::insert
iterator insert(const_iterator position, value_type value)
Definition pvoidvector.h:453
etl::pvoidvector::clear
void clear()
Clears the vector.
Definition pvoidvector.h:401
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::assign
void assign(size_t n, const_reference value)
Definition vector.h:1486
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::begin
iterator begin()
Definition vector.h:100
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::initialise
void initialise()
Initialise the vector.
Definition vector.h:1105
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::at
reference at(size_t i)
Definition vector.h:307
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::erase
iterator erase(const_iterator first, const_iterator last)
Definition vector.h:959
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::initialise
void initialise()
Initialise the vector.
Definition vector.h:1704
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::size
size_type size() const
Definition vector.h:1051
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::empty
bool empty() const
Definition vector.h:1060
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::end
iterator end()
Definition vector.h:118
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::assign
etl::enable_if< is_compatible_iterator< TIterator >::value, void >::type assign(TIterator first, TIterator last)
Definition vector.h:1474
etl::pvoidvector::resize
void resize(size_t new_size)
Definition pvoidvector.h:186
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::crbegin
const_reverse_iterator crbegin() const
Definition vector.h:190
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::full
bool full() const
Definition vector.h:1069
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::erase
iterator erase(iterator i_element)
Definition vector.h:922
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::clear
void clear()
Clears the vector.
Definition vector.h:1494
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::p_end
pointer p_end
Pointer to one past the last element in the buffer.
Definition vector.h:1131
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::erase
iterator erase(iterator i_element)
Definition vector.h:1606
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::insert
etl::enable_if<!etl::is_integral< TIterator >::value &&etl::is_convertible< typenameetl::iterator_traits< TIterator >::value_type, T >::value, void >::type insert(const_iterator position, TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition vector.h:867
etl::vector::vector
vector() ETL_NOEXCEPT
Constructor.
Definition vector.h:1840
etl::vector::vector
vector(TIterator first, TIterator last, typename etl::enable_if<!etl::is_integral< TIterator >::value, int >::type=0)
Definition vector.h:1876
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::reserve
void reserve(size_t n)
Definition vector.h:272
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::at
reference at(size_t i)
Definition vector.h:1394
etl::pvoidvector::pop_back
void pop_back()
Definition pvoidvector.h:436
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::front
const_reference front() const
Definition vector.h:340
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::rend
const_reverse_iterator rend() const
Definition vector.h:181
etl::pvoidvector::repair_buffer
void repair_buffer(void **p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition pvoidvector.h:768
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::front
const_reference front() const
Definition vector.h:1424
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::uninitialized_resize
void uninitialized_resize(size_t new_size)
Definition vector.h:1362
etl::pvoidvector::back
reference back()
Definition pvoidvector.h:299
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::erase
iterator erase(const_iterator i_element)
Definition vector.h:938
etl::pvoidvector::end
iterator end()
Definition pvoidvector.h:94
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::fill
void fill(const T &value)
Fills the vector.
Definition vector.h:443
etl::vector_ext::repair
void repair()
Fix the internal pointers after a low level memory copy.
Definition vector.h:2148
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::crbegin
const_reverse_iterator crbegin() const
Definition vector.h:1320
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::insert
void insert(const_iterator position, size_t n, const_reference value)
Definition vector.h:807
etl::pvoidvector::uninitialized_resize
void uninitialized_resize(size_t new_size)
Definition pvoidvector.h:220
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::insert
etl::enable_if< is_compatible_iterator< TIterator >::value, void >::type insert(const_iterator position, TIterator first, TIterator last)
Definition vector.h:1595
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::data
ETL_CONSTEXPR const_pointer data() const
Definition vector.h:379
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::repair_buffer
void repair_buffer(pointer p_buffer_)
Fix the internal pointers after a low level memory copy.
Definition vector.h:1712
etl::vector::vector
vector(size_t initial_size, typename etl::ivector< T >::const_reference value)
Definition vector.h:1862
etl::pvoidvector::front
reference front()
Definition pvoidvector.h:279
etl::vector::~vector
~vector() ETL_NOEXCEPT
Destructor.
Definition vector.h:1965
etl::pvoidvector::pvoidvector
pvoidvector(void **p_buffer_, size_t MAX_SIZE)
Constructor.
Definition pvoidvector.h:750
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::push_back
void push_back(const_reference value)
Definition vector.h:454
etl::pvoidvector::push_back
void push_back(value_type value)
Definition pvoidvector.h:412
etl::pvoidvector::cend
const_iterator cend() const
Definition pvoidvector.h:121
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::pop_back
void pop_back()
Definition vector.h:587
etl::vector_ext::vector_ext
vector_ext(const vector_ext &other, void *buffer, size_t max_size)
Copy constructor.
Definition vector.h:2079
etl::vector_ext::~vector_ext
~vector_ext() ETL_NOEXCEPT
Destructor.
Definition vector.h:2137
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::cend
const_iterator cend() const
Definition vector.h:145
etl::pvoidvector::cbegin
const_iterator cbegin() const
Definition pvoidvector.h:112
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::front
reference front()
Definition vector.h:330
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::cend
const_iterator cend() const
Definition vector.h:1275
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::end
const_iterator end() const
Definition vector.h:127
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::emplace_back
reference emplace_back(const T1 &value1, const T2 &value2, const T3 &value3)
Definition vector.h:553
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::p_buffer
pointer p_buffer
Pointer to the start of the buffer.
Definition vector.h:1130
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::at
const_reference at(size_t i) const
Definition vector.h:320
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::insert
iterator insert(const_iterator position, const_reference value)
Definition vector.h:601
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::pop_back
void pop_back()
Definition vector.h:1540
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::emplace_back
reference emplace_back(const_reference value)
Definition vector.h:1529
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::operator[]
reference operator[](size_t i)
Definition vector.h:283
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::emplace_back
reference emplace_back(const T1 &value1, const T2 &value2)
Definition vector.h:536
etl::vector::operator=
vector & operator=(const vector &rhs)
Assignment operator.
Definition vector.h:1905
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::emplace_back
reference emplace_back()
Definition vector.h:1516
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::begin
iterator begin()
Definition vector.h:1230
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::front
reference front()
Definition vector.h:1415
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::rend
const_reverse_iterator rend() const
Definition vector.h:1311
etl::pvoidvector::at
reference at(size_t i)
Definition pvoidvector.h:256
etl::ivector< T, typename etl::enable_if< etl::is_object_pointer< T >::value >::type >::end
iterator end()
Definition vector.h:1248
etl::ivector< T, typename etl::enable_if< etl::negation< etl::is_object_pointer< T > >::value >::type >::back
const_reference back() const
Definition vector.h:360
etl::pvoidvector
Definition pvoidvector.h:55
etl::vector
Definition vector.h:1830
etl::vector_base
Definition vector_base.h:122
etl::vector_empty
Definition vector_base.h:80
etl::vector_ext
Template deduction guides.
Definition vector.h:2016
etl::vector_full
Definition vector_base.h:66
etl::vector_incompatible_type
Definition vector_base.h:108
etl::vector_out_of_bounds
Definition vector_base.h:94
initializer_list.h
iterator.h
memory.h
etl
Definition absolute.h:40
etl::swap
ETL_CONSTEXPR14 void swap(etl::typed_storage_ext< T > &lhs, etl::typed_storage_ext< T > &rhs) ETL_NOEXCEPT
Swap two etl::typed_storage_ext.
Definition alignment.h:856
etl::operator==
ETL_CONSTEXPR14 bool operator==(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:1078
etl::operator>
bool operator>(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:1130
etl::cbegin
TContainer::const_iterator cbegin(const TContainer &container)
Definition iterator.h:1156
etl::operator>=
bool operator>=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:1144
etl::erase
etl::ivector< T >::difference_type erase(etl::ivector< T > &v, const U &value)
erase
Definition vector.h:2158
etl::operator!=
ETL_CONSTEXPR14 bool operator!=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:1090
etl::back_inserter
ETL_NODISCARD ETL_CONSTEXPR14 etl::back_insert_iterator< TContainer > back_inserter(TContainer &container)
Creates a back_insert_iterator from a container.
Definition iterator.h:734
etl::size
ETL_CONSTEXPR TContainer::size_type size(const TContainer &container)
Definition iterator.h:1434
etl::end
TContainer::iterator end(TContainer &container)
Definition iterator.h:1166
etl::cend
TContainer::const_iterator cend(const TContainer &container)
Definition iterator.h:1186
etl::begin
TContainer::iterator begin(TContainer &container)
Definition iterator.h:1136
etl::erase_if
etl::ivector< T >::difference_type erase_if(etl::ivector< T > &v, TPredicate predicate)
erase_if
Definition vector.h:2171
etl::operator<
bool operator<(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:1103
etl::operator<=
bool operator<=(const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
Definition array.h:1117
placement_new.h
platform.h
pvoidvector.h
etl::bool_constant
Definition type_traits.h:97
etl::iterator_traits
Definition iterator.h:130
etl::iterator
iterator
Definition iterator.h:482
etl::type
etl::remove_const
remove_const
Definition type_traits.h:233
etl::remove_cv
remove_cv
Definition type_traits.h:325
etl::remove_reference
remove_reference
Definition type_traits.h:122
type_traits.h
vector_base.h