1046 lines
42 KiB
C++
1046 lines
42 KiB
C++
///\file
|
|
|
|
/******************************************************************************
|
|
The MIT License(MIT)
|
|
|
|
Embedded Template Library.
|
|
https://github.com/ETLCPP/etl
|
|
https://www.etlcpp.com
|
|
|
|
Copyright(c) 2016 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_IVECTOR_POINTER_INCLUDED
|
|
#define ETL_IVECTOR_POINTER_INCLUDED
|
|
|
|
#ifndef ETL_IN_VECTOR_H
|
|
#error This header is a private element of etl::ivector
|
|
#endif
|
|
|
|
#include "pvoidvector.h"
|
|
|
|
namespace etl
|
|
{
|
|
//***************************************************************************
|
|
/// The base class for specifically sized vectors.
|
|
/// Can be used as a reference type for all vectors containing a specific pointer type.
|
|
///\ingroup vector
|
|
//***************************************************************************
|
|
template <typename T>
|
|
class ivector<T*> : public pvoidvector
|
|
{
|
|
public:
|
|
|
|
typedef T* value_type;
|
|
typedef value_type& reference;
|
|
typedef const value_type& const_reference;
|
|
typedef value_type* pointer;
|
|
typedef const value_type* const_pointer;
|
|
typedef value_type* iterator;
|
|
typedef const value_type* 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;
|
|
|
|
protected:
|
|
|
|
typedef value_type parameter_t;
|
|
|
|
private:
|
|
|
|
typedef pvoidvector base_t;
|
|
|
|
public:
|
|
|
|
//*********************************************************************
|
|
/// Returns an iterator to the beginning of the vector.
|
|
///\return An iterator to the beginning of the vector.
|
|
//*********************************************************************
|
|
iterator begin()
|
|
{
|
|
return iterator(base_t::begin());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const_iterator to the beginning of the vector.
|
|
///\return A const iterator to the beginning of the vector.
|
|
//*********************************************************************
|
|
const_iterator begin() const
|
|
{
|
|
return const_iterator(base_t::begin());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns an iterator to the end of the vector.
|
|
///\return An iterator to the end of the vector.
|
|
//*********************************************************************
|
|
iterator end()
|
|
{
|
|
return iterator(base_t::end());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const_iterator to the end of the vector.
|
|
///\return A const iterator to the end of the vector.
|
|
//*********************************************************************
|
|
const_iterator end() const
|
|
{
|
|
return const_iterator(base_t::end());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const_iterator to the beginning of the vector.
|
|
///\return A const iterator to the beginning of the vector.
|
|
//*********************************************************************
|
|
const_iterator cbegin() const
|
|
{
|
|
return const_iterator(base_t::cbegin());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const_iterator to the end of the vector.
|
|
///\return A const iterator to the end of the vector.
|
|
//*********************************************************************
|
|
const_iterator cend() const
|
|
{
|
|
return const_iterator(base_t::cend());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns an reverse iterator to the reverse beginning of the vector.
|
|
///\return Iterator to the reverse beginning of the vector.
|
|
//*********************************************************************
|
|
reverse_iterator rbegin()
|
|
{
|
|
return reverse_iterator(iterator(base_t::end()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reverse iterator to the reverse beginning of the vector.
|
|
///\return Const iterator to the reverse beginning of the vector.
|
|
//*********************************************************************
|
|
const_reverse_iterator rbegin() const
|
|
{
|
|
return const_reverse_iterator(const_iterator(base_t::end()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reverse iterator to the end + 1 of the vector.
|
|
///\return Reverse iterator to the end + 1 of the vector.
|
|
//*********************************************************************
|
|
reverse_iterator rend()
|
|
{
|
|
return reverse_iterator(iterator(base_t::begin()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reverse iterator to the end + 1 of the vector.
|
|
///\return Const reverse iterator to the end + 1 of the vector.
|
|
//*********************************************************************
|
|
const_reverse_iterator rend() const
|
|
{
|
|
return const_reverse_iterator(const_iterator(base_t::begin()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reverse iterator to the reverse beginning of the vector.
|
|
///\return Const reverse iterator to the reverse beginning of the vector.
|
|
//*********************************************************************
|
|
const_reverse_iterator crbegin() const
|
|
{
|
|
return const_reverse_iterator(const_iterator(base_t::cend()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reverse iterator to the end + 1 of the vector.
|
|
///\return Const reverse iterator to the end + 1 of the vector.
|
|
//*********************************************************************
|
|
const_reverse_iterator crend() const
|
|
{
|
|
return const_reverse_iterator(const_iterator(base_t::cbegin()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Resizes the vector.
|
|
/// If asserts or exceptions are enabled and the new size is larger than the
|
|
/// maximum then a vector_full is thrown.
|
|
///\param new_size The new size.
|
|
//*********************************************************************
|
|
void resize(size_t new_size)
|
|
{
|
|
base_t::resize(new_size);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Resizes the vector.
|
|
/// If asserts or exceptions are enabled and the new size is larger than the
|
|
/// maximum then a vector_full is thrown.
|
|
///\param new_size The new size.
|
|
///\param value The value to fill new elements with. Default = default constructed value.
|
|
//*********************************************************************
|
|
void resize(size_t new_size, value_type value)
|
|
{
|
|
base_t::resize(new_size, value);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Resizes the vector, but does not initialise new entries.
|
|
///\param new_size The new size.
|
|
//*********************************************************************
|
|
void uninitialized_resize(size_t new_size)
|
|
{
|
|
base_t::uninitialized_resize(new_size);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reference to the value at index 'i'
|
|
///\param i The index.
|
|
///\return A reference to the value at index 'i'
|
|
//*********************************************************************
|
|
reference operator [](size_t i)
|
|
{
|
|
return reference(base_t::operator[](i));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reference to the value at index 'i'
|
|
///\param i The index.
|
|
///\return A const reference to the value at index 'i'
|
|
//*********************************************************************
|
|
const_reference operator [](size_t i) const
|
|
{
|
|
return const_reference(base_t::operator[](i));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reference to the value at index 'i'
|
|
/// If asserts or exceptions are enabled, emits an etl::vector_out_of_bounds if the index is out of range.
|
|
///\param i The index.
|
|
///\return A reference to the value at index 'i'
|
|
//*********************************************************************
|
|
reference at(size_t i)
|
|
{
|
|
return reference(base_t::at(i));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reference to the value at index 'i'
|
|
/// If asserts or exceptions are enabled, emits an etl::vector_out_of_bounds if the index is out of range.
|
|
///\param i The index.
|
|
///\return A const reference to the value at index 'i'
|
|
//*********************************************************************
|
|
const_reference at(size_t i) const
|
|
{
|
|
return const_reference(base_t::at(i));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reference to the first element.
|
|
///\return A reference to the first element.
|
|
//*********************************************************************
|
|
reference front()
|
|
{
|
|
return reference(base_t::front());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reference to the first element.
|
|
///\return A const reference to the first element.
|
|
//*********************************************************************
|
|
const_reference front() const
|
|
{
|
|
return const_reference(base_t::front());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reference to the last element.
|
|
///\return A reference to the last element.
|
|
//*********************************************************************
|
|
reference back()
|
|
{
|
|
return reference(base_t::back());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reference to the last element.
|
|
///\return A const reference to the last element.
|
|
//*********************************************************************
|
|
const_reference back() const
|
|
{
|
|
return const_reference(base_t::back());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a pointer to the beginning of the vector data.
|
|
///\return A pointer to the beginning of the vector data.
|
|
//*********************************************************************
|
|
pointer data()
|
|
{
|
|
return pointer(base_t::data());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const pointer to the beginning of the vector data.
|
|
///\return A const pointer to the beginning of the vector data.
|
|
//*********************************************************************
|
|
const_pointer data() const
|
|
{
|
|
return const_pointer(base_t::data());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Assigns values to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector does not have enough free space.
|
|
/// If asserts or exceptions are enabled, emits vector_iterator if the iterators are reversed.
|
|
///\param first The iterator to the first element.
|
|
///\param last The iterator to the last element + 1.
|
|
//*********************************************************************
|
|
template <typename TIterator>
|
|
void assign(TIterator first, TIterator last)
|
|
{
|
|
base_t::assign(first, last);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Assigns values to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector does not have enough free space.
|
|
///\param n The number of elements to add.
|
|
///\param value The value to insert for each element.
|
|
//*********************************************************************
|
|
void assign(size_t n, parameter_t value)
|
|
{
|
|
base_t::assign(n, value);
|
|
}
|
|
|
|
//*************************************************************************
|
|
/// Clears the vector.
|
|
//*************************************************************************
|
|
void clear()
|
|
{
|
|
base_t::clear();
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Inserts a value at the end of the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector is already full.
|
|
///\param value The value to add.
|
|
//*********************************************************************
|
|
void push_back(parameter_t value)
|
|
{
|
|
base_t::push_back(value);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Constructs a value at the end of the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector is already full.
|
|
///\param value The value to add.
|
|
//*********************************************************************
|
|
reference emplace_back()
|
|
{
|
|
base_t::emplace_back(ETL_NULLPTR);
|
|
|
|
return back();
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Constructs a value at the end of the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector is already full.
|
|
///\param value The value to add.
|
|
//*********************************************************************
|
|
reference emplace_back(parameter_t value)
|
|
{
|
|
base_t::emplace_back(value);
|
|
|
|
return back();
|
|
}
|
|
|
|
//*************************************************************************
|
|
/// Removes an element from the end of the vector.
|
|
/// Does nothing if the vector is empty.
|
|
//*************************************************************************
|
|
void pop_back()
|
|
{
|
|
base_t::pop_back();
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Inserts a value to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector is already full.
|
|
///\param position The position to insert before.
|
|
///\param value The value to insert.
|
|
//*********************************************************************
|
|
iterator insert(const_iterator position, parameter_t value)
|
|
{
|
|
return iterator(base_t::insert(base_t::iterator(position), value));
|
|
}
|
|
|
|
//*************************************************************************
|
|
/// Emplaces a value to the vector at the specified position.
|
|
//*************************************************************************
|
|
iterator emplace(const_iterator position)
|
|
{
|
|
return iterator(base_t::emplace(base_t::iterator(position), ETL_NULLPTR));
|
|
}
|
|
|
|
//*************************************************************************
|
|
/// Emplaces a value to the vector at the specified position.
|
|
//*************************************************************************
|
|
iterator emplace(const_iterator position, parameter_t value)
|
|
{
|
|
return iterator(base_t::emplace(base_t::iterator(position), value));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Inserts 'n' values to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector does not have enough free space.
|
|
///\param position The position to insert before.
|
|
///\param n The number of elements to add.
|
|
///\param value The value to insert.
|
|
//*********************************************************************
|
|
void insert(const_iterator position, size_t n, parameter_t value)
|
|
{
|
|
base_t::insert(base_t::iterator(position), n, value);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Inserts a range of values to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector does not have enough free space.
|
|
///\param position The position to insert before.
|
|
///\param first The first element to add.
|
|
///\param last The last + 1 element to add.
|
|
//*********************************************************************
|
|
template <class TIterator>
|
|
void insert(const_iterator position, TIterator first, TIterator last)
|
|
{
|
|
base_t::insert(base_t::iterator(position), first, last);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Erases an element.
|
|
///\param i_element Iterator to the element.
|
|
///\return An iterator pointing to the element that followed the erased element.
|
|
//*********************************************************************
|
|
iterator erase(iterator i_element)
|
|
{
|
|
return iterator(base_t::erase(base_t::iterator(i_element)));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Erases an element.
|
|
///\param i_element Iterator to the element.
|
|
///\return An iterator pointing to the element that followed the erased element.
|
|
//*********************************************************************
|
|
iterator erase(const_iterator i_element)
|
|
{
|
|
return iterator(base_t::erase(base_t::const_iterator(i_element)));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Erases a range of elements.
|
|
/// The range includes all the elements between first and last, including the
|
|
/// element pointed by first, but not the one pointed by last.
|
|
///\param first Iterator to the first element.
|
|
///\param last Iterator to the last element.
|
|
///\return An iterator pointing to the element that followed the erased element.
|
|
//*********************************************************************
|
|
iterator erase(const_iterator first, const_iterator last)
|
|
{
|
|
return iterator(base_t::erase(base_t::const_iterator(first), base_t::const_iterator(last)));
|
|
}
|
|
|
|
//*************************************************************************
|
|
/// Assignment operator.
|
|
//*************************************************************************
|
|
ivector& operator = (const ivector& rhs)
|
|
{
|
|
base_t::operator = (rhs);
|
|
|
|
return *this;
|
|
}
|
|
|
|
#if ETL_USING_CPP11
|
|
//*************************************************************************
|
|
/// Move assignment operator.
|
|
//*************************************************************************
|
|
ivector& operator = (ivector&& rhs)
|
|
{
|
|
(void)base_t::operator = (etl::move(rhs));
|
|
|
|
return *this;
|
|
}
|
|
#endif
|
|
|
|
#ifdef ETL_IVECTOR_REPAIR_ENABLE
|
|
//*************************************************************************
|
|
/// Fix the internal pointers after a low level memory copy.
|
|
//*************************************************************************
|
|
virtual void repair() = 0;
|
|
#endif
|
|
|
|
protected:
|
|
|
|
//*********************************************************************
|
|
/// Constructor.
|
|
//*********************************************************************
|
|
ivector(T** p_buffer_, size_t MAX_SIZE_)
|
|
: pvoidvector(reinterpret_cast<void**>(p_buffer_), MAX_SIZE_)
|
|
{
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
class ivector<const T*> : public pvoidvector
|
|
{
|
|
public:
|
|
|
|
typedef const T* value_type;
|
|
typedef value_type& reference;
|
|
typedef const value_type& const_reference;
|
|
typedef value_type* pointer;
|
|
typedef const value_type* const_pointer;
|
|
typedef value_type* iterator;
|
|
typedef const value_type* 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;
|
|
|
|
protected:
|
|
|
|
typedef value_type parameter_t;
|
|
|
|
private:
|
|
|
|
typedef pvoidvector base_t;
|
|
|
|
public:
|
|
|
|
//*********************************************************************
|
|
/// Returns an iterator to the beginning of the vector.
|
|
///\return An iterator to the beginning of the vector.
|
|
//*********************************************************************
|
|
iterator begin()
|
|
{
|
|
return iterator(base_t::begin());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const_iterator to the beginning of the vector.
|
|
///\return A const iterator to the beginning of the vector.
|
|
//*********************************************************************
|
|
const_iterator begin() const
|
|
{
|
|
return const_iterator(base_t::begin());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns an iterator to the end of the vector.
|
|
///\return An iterator to the end of the vector.
|
|
//*********************************************************************
|
|
iterator end()
|
|
{
|
|
return iterator(base_t::end());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const_iterator to the end of the vector.
|
|
///\return A const iterator to the end of the vector.
|
|
//*********************************************************************
|
|
const_iterator end() const
|
|
{
|
|
return const_iterator(base_t::end());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const_iterator to the beginning of the vector.
|
|
///\return A const iterator to the beginning of the vector.
|
|
//*********************************************************************
|
|
const_iterator cbegin() const
|
|
{
|
|
return const_iterator(base_t::cbegin());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const_iterator to the end of the vector.
|
|
///\return A const iterator to the end of the vector.
|
|
//*********************************************************************
|
|
const_iterator cend() const
|
|
{
|
|
return const_iterator(base_t::cend());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns an reverse iterator to the reverse beginning of the vector.
|
|
///\return Iterator to the reverse beginning of the vector.
|
|
//*********************************************************************
|
|
reverse_iterator rbegin()
|
|
{
|
|
return reverse_iterator(iterator(base_t::end()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reverse iterator to the reverse beginning of the vector.
|
|
///\return Const iterator to the reverse beginning of the vector.
|
|
//*********************************************************************
|
|
const_reverse_iterator rbegin() const
|
|
{
|
|
return const_reverse_iterator(const_iterator(base_t::end()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reverse iterator to the end + 1 of the vector.
|
|
///\return Reverse iterator to the end + 1 of the vector.
|
|
//*********************************************************************
|
|
reverse_iterator rend()
|
|
{
|
|
return reverse_iterator(iterator(base_t::begin()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reverse iterator to the end + 1 of the vector.
|
|
///\return Const reverse iterator to the end + 1 of the vector.
|
|
//*********************************************************************
|
|
const_reverse_iterator rend() const
|
|
{
|
|
return const_reverse_iterator(const_iterator(base_t::begin()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reverse iterator to the reverse beginning of the vector.
|
|
///\return Const reverse iterator to the reverse beginning of the vector.
|
|
//*********************************************************************
|
|
const_reverse_iterator crbegin() const
|
|
{
|
|
return const_reverse_iterator(const_iterator(base_t::cend()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reverse iterator to the end + 1 of the vector.
|
|
///\return Const reverse iterator to the end + 1 of the vector.
|
|
//*********************************************************************
|
|
const_reverse_iterator crend() const
|
|
{
|
|
return const_reverse_iterator(const_iterator(base_t::cbegin()));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Resizes the vector.
|
|
/// If asserts or exceptions are enabled and the new size is larger than the
|
|
/// maximum then a vector_full is thrown.
|
|
///\param new_size The new size.
|
|
//*********************************************************************
|
|
void resize(size_t new_size)
|
|
{
|
|
base_t::resize(new_size);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Resizes the vector.
|
|
/// If asserts or exceptions are enabled and the new size is larger than the
|
|
/// maximum then a vector_full is thrown.
|
|
///\param new_size The new size.
|
|
///\param value The value to fill new elements with. Default = default constructed value.
|
|
//*********************************************************************
|
|
void resize(size_t new_size, value_type value)
|
|
{
|
|
base_t::resize(new_size, const_cast<T*>(value));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Resizes the vector, but does not initialise new entries.
|
|
///\param new_size The new size.
|
|
//*********************************************************************
|
|
void uninitialized_resize(size_t new_size)
|
|
{
|
|
base_t::uninitialized_resize(new_size);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reference to the value at index 'i'
|
|
///\param i The index.
|
|
///\return A reference to the value at index 'i'
|
|
//*********************************************************************
|
|
reference operator [](size_t i)
|
|
{
|
|
return reference(base_t::operator[](i));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reference to the value at index 'i'
|
|
///\param i The index.
|
|
///\return A const reference to the value at index 'i'
|
|
//*********************************************************************
|
|
const_reference operator [](size_t i) const
|
|
{
|
|
return const_reference(base_t::operator[](i));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reference to the value at index 'i'
|
|
/// If asserts or exceptions are enabled, emits an etl::vector_out_of_bounds if the index is out of range.
|
|
///\param i The index.
|
|
///\return A reference to the value at index 'i'
|
|
//*********************************************************************
|
|
reference at(size_t i)
|
|
{
|
|
return reference(base_t::at(i));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reference to the value at index 'i'
|
|
/// If asserts or exceptions are enabled, emits an etl::vector_out_of_bounds if the index is out of range.
|
|
///\param i The index.
|
|
///\return A const reference to the value at index 'i'
|
|
//*********************************************************************
|
|
const_reference at(size_t i) const
|
|
{
|
|
return const_reference(base_t::at(i));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reference to the first element.
|
|
///\return A reference to the first element.
|
|
//*********************************************************************
|
|
reference front()
|
|
{
|
|
return reference(base_t::front());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reference to the first element.
|
|
///\return A const reference to the first element.
|
|
//*********************************************************************
|
|
const_reference front() const
|
|
{
|
|
return const_reference(base_t::front());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a reference to the last element.
|
|
///\return A reference to the last element.
|
|
//*********************************************************************
|
|
reference back()
|
|
{
|
|
return reference(base_t::back());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const reference to the last element.
|
|
///\return A const reference to the last element.
|
|
//*********************************************************************
|
|
const_reference back() const
|
|
{
|
|
return const_reference(base_t::back());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a pointer to the beginning of the vector data.
|
|
///\return A pointer to the beginning of the vector data.
|
|
//*********************************************************************
|
|
pointer data()
|
|
{
|
|
return pointer(base_t::data());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Returns a const pointer to the beginning of the vector data.
|
|
///\return A const pointer to the beginning of the vector data.
|
|
//*********************************************************************
|
|
const_pointer data() const
|
|
{
|
|
return const_pointer(base_t::data());
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Assigns values to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector does not have enough free space.
|
|
/// If asserts or exceptions are enabled, emits vector_iterator if the iterators are reversed.
|
|
///\param first The iterator to the first element.
|
|
///\param last The iterator to the last element + 1.
|
|
//*********************************************************************
|
|
template <typename TIterator>
|
|
void assign(TIterator first, TIterator last)
|
|
{
|
|
base_t::assign(first, last);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Assigns values to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector does not have enough free space.
|
|
///\param n The number of elements to add.
|
|
///\param value The value to insert for each element.
|
|
//*********************************************************************
|
|
void assign(size_t n, parameter_t value)
|
|
{
|
|
base_t::assign(n, const_cast<T*>(value));
|
|
}
|
|
|
|
//*************************************************************************
|
|
/// Clears the vector.
|
|
//*************************************************************************
|
|
void clear()
|
|
{
|
|
base_t::clear();
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Inserts a value at the end of the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector is already full.
|
|
///\param value The value to add.
|
|
//*********************************************************************
|
|
void push_back(parameter_t value)
|
|
{
|
|
base_t::push_back(const_cast<T*>(value));
|
|
}
|
|
|
|
//*************************************************************************
|
|
/// Removes an element from the end of the vector.
|
|
/// Does nothing if the vector is empty.
|
|
//*************************************************************************
|
|
void pop_back()
|
|
{
|
|
base_t::pop_back();
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Inserts a value to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector is already full.
|
|
///\param position The position to insert before.
|
|
///\param value The value to insert.
|
|
//*********************************************************************
|
|
iterator insert(const_iterator position, parameter_t value)
|
|
{
|
|
return iterator(base_t::insert(base_t::iterator(position), const_cast<T*>(value)));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Inserts 'n' values to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector does not have enough free space.
|
|
///\param position The position to insert before.
|
|
///\param n The number of elements to add.
|
|
///\param value The value to insert.
|
|
//*********************************************************************
|
|
void insert(const_iterator position, size_t n, parameter_t value)
|
|
{
|
|
base_t::insert(base_t::iterator(position), n, const_cast<T*>(value));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Inserts a range of values to the vector.
|
|
/// If asserts or exceptions are enabled, emits vector_full if the vector does not have enough free space.
|
|
///\param position The position to insert before.
|
|
///\param first The first element to add.
|
|
///\param last The last + 1 element to add.
|
|
//*********************************************************************
|
|
template <class TIterator>
|
|
void insert(const_iterator position, TIterator first, TIterator last)
|
|
{
|
|
base_t::insert(base_t::iterator(position), first, last);
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Erases an element.
|
|
///\param i_element Iterator to the element.
|
|
///\return An iterator pointing to the element that followed the erased element.
|
|
//*********************************************************************
|
|
iterator erase(iterator i_element)
|
|
{
|
|
return iterator(base_t::erase(base_t::iterator(i_element)));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Erases an element.
|
|
///\param i_element Iterator to the element.
|
|
///\return An iterator pointing to the element that followed the erased element.
|
|
//*********************************************************************
|
|
iterator erase(const_iterator i_element)
|
|
{
|
|
return iterator(base_t::erase(base_t::iterator(i_element)));
|
|
}
|
|
|
|
//*********************************************************************
|
|
/// Erases a range of elements.
|
|
/// The range includes all the elements between first and last, including the
|
|
/// element pointed by first, but not the one pointed by last.
|
|
///\param first Iterator to the first element.
|
|
///\param last Iterator to the last element.
|
|
///\return An iterator pointing to the element that followed the erased element.
|
|
//*********************************************************************
|
|
iterator erase(const_iterator first, const_iterator last)
|
|
{
|
|
return iterator(base_t::erase(base_t::iterator(first), base_t::iterator(last)));
|
|
}
|
|
|
|
//*************************************************************************
|
|
/// Assignment operator.
|
|
//*************************************************************************
|
|
ivector& operator = (const ivector& rhs)
|
|
{
|
|
base_t::operator = (rhs);
|
|
|
|
return *this;
|
|
}
|
|
|
|
#if ETL_USING_CPP11
|
|
//*************************************************************************
|
|
/// Move assignment operator.
|
|
//*************************************************************************
|
|
ivector& operator = (ivector&& rhs)
|
|
{
|
|
(void)base_t::operator = (etl::move(rhs));
|
|
|
|
return *this;
|
|
}
|
|
#endif
|
|
|
|
#ifdef ETL_IVECTOR_REPAIR_ENABLE
|
|
//*************************************************************************
|
|
/// Fix the internal pointers after a low level memory copy.
|
|
//*************************************************************************
|
|
virtual void repair() = 0;
|
|
#endif
|
|
|
|
protected:
|
|
|
|
//*********************************************************************
|
|
/// Constructor.
|
|
//*********************************************************************
|
|
ivector(const T** p_buffer_, size_t MAX_SIZE_)
|
|
: pvoidvector(reinterpret_cast<void**>(const_cast<T**>(p_buffer_)), MAX_SIZE_)
|
|
{
|
|
}
|
|
};
|
|
|
|
//***************************************************************************
|
|
/// Equal operator.
|
|
///\param lhs Reference to the first vector.
|
|
///\param rhs Reference to the second vector.
|
|
///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
|
|
///\ingroup vector
|
|
//***************************************************************************
|
|
template <typename T>
|
|
bool operator ==(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
|
|
{
|
|
return pvoidvector_equal(lhs, rhs);
|
|
}
|
|
|
|
//***************************************************************************
|
|
/// Not equal operator.
|
|
///\param lhs Reference to the first vector.
|
|
///\param rhs Reference to the second vector.
|
|
///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
|
|
///\ingroup vector
|
|
//***************************************************************************
|
|
template <typename T>
|
|
bool operator !=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
|
|
{
|
|
return pvoidvector_not_equal(lhs, rhs);
|
|
}
|
|
|
|
//***************************************************************************
|
|
/// Less than operator.
|
|
///\param lhs Reference to the first vector.
|
|
///\param rhs Reference to the second vector.
|
|
///\return <b>true</b> if the first vector is lexicographically less than the second, otherwise <b>false</b>
|
|
///\ingroup vector
|
|
//***************************************************************************
|
|
template <typename T>
|
|
bool operator <(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
|
|
{
|
|
return pvoidvector_less_than(lhs, rhs);
|
|
}
|
|
|
|
//***************************************************************************
|
|
/// Greater than operator.
|
|
///\param lhs Reference to the first vector.
|
|
///\param rhs Reference to the second vector.
|
|
///\return <b>true</b> if the first vector is lexicographically greater than the second, otherwise <b>false</b>
|
|
///\ingroup vector
|
|
//***************************************************************************
|
|
template <typename T>
|
|
bool operator >(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
|
|
{
|
|
return pvoidvector_greater_than(lhs, rhs);
|
|
}
|
|
|
|
//***************************************************************************
|
|
/// Less than or equal operator.
|
|
///\param lhs Reference to the first vector.
|
|
///\param rhs Reference to the second vector.
|
|
///\return <b>true</b> if the first vector is lexicographically less than or equal to the second, otherwise <b>false</b>
|
|
///\ingroup vector
|
|
//***************************************************************************
|
|
template <typename T>
|
|
bool operator <=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
|
|
{
|
|
return pvoidvector_less_than_equal(lhs, rhs);
|
|
}
|
|
|
|
//***************************************************************************
|
|
/// Greater than or equal operator.
|
|
///\param lhs Reference to the first vector.
|
|
///\param rhs Reference to the second vector.
|
|
///\return <b>true</b> if the first vector is lexicographically greater than or equal to the second, otherwise <b>false</b>
|
|
///\ingroup vector
|
|
//***************************************************************************
|
|
template <typename T>
|
|
bool operator >=(const etl::ivector<T*>& lhs, const etl::ivector<T*>& rhs)
|
|
{
|
|
return pvoidvector_greater_than_equal(lhs, rhs);
|
|
}
|
|
|
|
//***************************************************************************
|
|
// Helper functions
|
|
//***************************************************************************
|
|
inline bool pvoidvector_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
|
|
{
|
|
return operator ==(lhs, rhs);
|
|
}
|
|
|
|
inline bool pvoidvector_not_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
|
|
{
|
|
return operator !=(lhs, rhs);
|
|
}
|
|
|
|
inline bool pvoidvector_less_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
|
|
{
|
|
return operator <(lhs, rhs);
|
|
}
|
|
|
|
inline bool pvoidvector_greater_than(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
|
|
{
|
|
return operator >(lhs, rhs);
|
|
}
|
|
|
|
inline bool pvoidvector_less_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
|
|
{
|
|
return operator <=(lhs, rhs);
|
|
}
|
|
|
|
inline bool pvoidvector_greater_than_equal(const etl::pvoidvector& lhs, const etl::pvoidvector& rhs)
|
|
{
|
|
return operator >=(lhs, rhs);
|
|
}
|
|
}
|
|
|
|
#endif
|