coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-06-28 21:38:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/development'

Browse Source
This commit is contained in:
John Wellbelove 2018-06-27 20:46:37 +01:00
parent 4fec129e6c
commit eb676c11ca
10 changed files with 524 additions and 460 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
include/etl/array_view.h
View File

@ -123,8 +123,7 @@ namespace etl
/// Construct from std::array or etl::array or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TArray,
typename TDummy = typename etl::enable_if<!etl::is_same<T, TArray>::value, void>::type>
template <typename TArray>
explicit array_view(TArray& a)
: mbegin(a.data()),
mend(a.data() + a.size())
@ -134,8 +133,7 @@ namespace etl
//*************************************************************************
/// Construct from iterators
//*************************************************************************
template <typename TIterator,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
template <typename TIterator>
array_view(TIterator begin_, TIterator end_)
: mbegin(etl::addressof(*begin_)),
mend(etl::addressof(*begin_) + std::distance(begin_, end_))
@ -146,8 +144,7 @@ namespace etl
/// Construct from C array
//*************************************************************************
template <typename TIterator,
typename TSize,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
typename TSize>
array_view(TIterator begin_, TSize size_)
: mbegin(etl::addressof(*begin_)),
mend(etl::addressof(*begin_) + size_)
@ -354,24 +351,22 @@ namespace etl
//*************************************************************************
/// Assign from iterators
//*************************************************************************
template <typename TIterator,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
template <typename TIterator>
void assign(TIterator begin_, TIterator end_)
{
mbegin = etl::addressof(*begin_);
mend = etl::addressof(*begin_) + std::distance(begin_, end_);
mend = etl::addressof(*begin_) + std::distance(begin_, end_);
}
//*************************************************************************
/// Assign from iterator and size.
//*************************************************************************
template <typename TIterator,
typename TSize,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
typename TSize>
void assign(TIterator begin_, TSize size_)
{
mbegin = etl::addressof(*begin_);
mend = etl::addressof(*begin_) + size_;
mend = etl::addressof(*begin_) + size_;
}
//*************************************************************************
@ -518,8 +513,7 @@ namespace etl
/// Construct from std::array or etl::array or other type that supports
/// data() and size() member functions.
//*************************************************************************
template <typename TArray,
typename TDummy = typename etl::enable_if<!etl::is_same<T, TArray>::value, void>::type>
template <typename TArray>
explicit const_array_view(TArray& a)
: mbegin(a.data()),
mend(a.data() + a.size())
@ -529,8 +523,7 @@ namespace etl
//*************************************************************************
/// Construct from iterators
//*************************************************************************
template <typename TIterator,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
template <typename TIterator>
const_array_view(TIterator begin_, TIterator end_)
: mbegin(etl::addressof(*begin_)),
mend(etl::addressof(*begin_) + std::distance(begin_, end_))
@ -541,7 +534,7 @@ namespace etl
/// Construct from C array
//*************************************************************************
template <typename TIterator,
typename TSize, typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
typename TSize>
const_array_view(TIterator begin_, TSize size_)
: mbegin(etl::addressof(*begin_)),
mend(etl::addressof(*begin_) + size_)
@ -705,8 +698,7 @@ namespace etl
//*************************************************************************
/// Assign from iterators
//*************************************************************************
template <typename TIterator,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
template <typename TIterator>
void assign(TIterator begin_, TIterator end_)
{
mbegin = etl::addressof(*begin_);
@ -717,8 +709,7 @@ namespace etl
/// Assign from iterator and size.
//*************************************************************************
template <typename TIterator,
typename TSize,
typename TDummy = typename etl::enable_if<etl::is_random_iterator<TIterator>::value, void>::type>
typename TSize>
void assign(TIterator begin_, TSize size_)
{
mbegin = etl::addressof(*begin_);
@ -833,7 +824,7 @@ namespace etl
size_t operator()(const etl::array_view<T>& view) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
reinterpret_cast<const uint8_t*>(&view[view.size()]));
reinterpret_cast<const uint8_t*>(&view[view.size()]));
}
};
@ -843,7 +834,7 @@ namespace etl
size_t operator()(const etl::const_array_view<T>& view) const
{
return etl::private_hash::generic_hash<size_t>(reinterpret_cast<const uint8_t*>(&view[0]),
reinterpret_cast<const uint8_t*>(&view[view.size()]));
reinterpret_cast<const uint8_t*>(&view[view.size()]));
}
};
#endif

2
include/etl/map.h
View File

@ -458,7 +458,7 @@ namespace etl
/// A templated base for all etl::map types.
///\ingroup map
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
template <typename TKey, typename TMapped, typename TKeyCompare = std::less<TKey> >
class imap : public etl::map_base
{
public:

2
include/etl/multimap.h
View File

@ -614,7 +614,7 @@ namespace etl
/// A templated base for all etl::multimap types.
///\ingroup map
//***************************************************************************
template <typename TKey, typename TMapped, typename TKeyCompare>
template <typename TKey, typename TMapped, typename TKeyCompare = std::less<TKey> >
class imultimap : public etl::multimap_base
{
public:

2
include/etl/multiset.h
View File

@ -614,7 +614,7 @@ namespace etl
/// A templated base for all etl::multiset types.
///\ingroup set
//***************************************************************************
template <typename T, typename TCompare>
template <typename T, typename TCompare = std::less<T> >
class imultiset : public etl::multiset_base
{
public:

2
include/etl/priority_queue.h
View File

@ -113,7 +113,7 @@ namespace etl
/// \tparam TContainer to hold the T queue values
/// \tparam TCompare to use in comparing T values
//***************************************************************************
template <typename T, typename TContainer, typename TCompare>
template <typename T, typename TContainer, typename TCompare = std::less<T> >
class ipriority_queue
{
public:

471
include/etl/private/pvoidvector.h
View File

@ -74,246 +74,41 @@ namespace etl
public:
//*********************************************************************
/// Returns an iterator to the beginning of the vector.
///\return An iterator to the beginning of the vector.
//*********************************************************************
iterator begin()
{
return p_buffer;
}
iterator begin();
const_iterator begin() const;
//*********************************************************************
/// 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(p_buffer);
}
iterator end();
const_iterator end() const;
//*********************************************************************
/// Returns an iterator to the end of the vector.
///\return An iterator to the end of the vector.
//*********************************************************************
iterator end()
{
return p_end;
}
const_iterator cbegin() const;
const_iterator cend() const;
//*********************************************************************
/// 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(p_end);
}
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
//*********************************************************************
/// 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(p_buffer);
}
reverse_iterator rend();
const_reverse_iterator rend() const;
//*********************************************************************
/// 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(p_end);
}
const_reverse_iterator crbegin() const;
const_reverse_iterator crend() const;
//*********************************************************************
/// 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(end());
}
void resize(size_t new_size);
void resize(size_t new_size, value_type value);
//*********************************************************************
/// 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(end());
}
reference operator [](size_t i);
const_reference operator [](size_t i) const;
//*********************************************************************
/// 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(begin());
}
reference at(size_t i);
const_reference at(size_t i) const;
//*********************************************************************
/// 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(begin());
}
reference front();
const_reference front() const;
//*********************************************************************
/// 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(cend());
}
reference back();
const_reference back() const;
//*********************************************************************
/// 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(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)
{
ETL_ASSERT(new_size <= CAPACITY, ETL_ERROR(vector_full));
p_end = p_buffer + 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)
{
ETL_ASSERT(new_size <= CAPACITY, ETL_ERROR(vector_full));
pointer p_new_end = p_buffer + new_size;
// Size up if necessary.
if (p_end < p_new_end)
{
std::fill(p_end, p_new_end, value);
}
p_end = p_new_end;
}
//*********************************************************************
/// 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 p_buffer[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(p_buffer[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)
{
ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
return p_buffer[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
{
ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
return const_reference(p_buffer[i]);
}
//*********************************************************************
/// Returns a reference to the first element.
///\return A reference to the first element.
//*********************************************************************
reference front()
{
return p_buffer[0];
}
//*********************************************************************
/// Returns a const reference to the first element.
///\return A const reference to the first element.
//*********************************************************************
const_reference front() const
{
return const_reference(p_buffer[0]);
}
//*********************************************************************
/// Returns a reference to the last element.
///\return A reference to the last element.
//*********************************************************************
reference back()
{
return *(p_end -1);
}
//*********************************************************************
/// Returns a const reference to the last element.
///\return A const reference to the last element.
//*********************************************************************
const_reference back() const
{
return const_reference(*(p_end - 1));
}
//*********************************************************************
/// Returns a pointer to the beginning of the vector data.
///\return A pointer to the beginning of the vector data.
//*********************************************************************
pointer data()
{
return p_buffer;
}
//*********************************************************************
/// 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(p_buffer);
}
pointer data();
const_pointer data() const;
//*********************************************************************
/// Assigns values to the vector.
@ -338,110 +133,17 @@ namespace etl
}
}
//*********************************************************************
/// 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, value_type value)
{
initialise();
void assign(size_t n, value_type value);
ETL_ASSERT(n <= CAPACITY, ETL_ERROR(vector_full));
void clear();
for (size_t current_size = 0; current_size < n; ++current_size)
{
*p_end++ = value;
}
}
void push_back();
void push_back(value_type value);
//*************************************************************************
/// Clears the vector.
//*************************************************************************
void clear()
{
initialise();
}
void pop_back();
//*************************************************************************
/// Increases the size of the vector by one, but does not initialise the new element.
/// If asserts or exceptions are enabled, throws a vector_full if the vector is already full.
//*************************************************************************
void push_back()
{
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
#endif
++p_end;
}
//*********************************************************************
/// 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(value_type value)
{
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
#endif
*p_end++ = value;
}
//*************************************************************************
/// Removes an element from the end of the vector.
/// Does nothing if the vector is empty.
//*************************************************************************
void pop_back()
{
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(size() > 0, ETL_ERROR(vector_empty));
#endif
--p_end;
}
//*********************************************************************
/// 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(iterator position, value_type value)
{
ETL_ASSERT(size() + 1 <= CAPACITY, ETL_ERROR(vector_full));
if (position != end())
{
++p_end;
std::copy_backward(position, end() - 1, end());
*position = value;
}
else
{
*p_end++ = value;
}
return position;
}
//*********************************************************************
/// 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(iterator position, size_t n, value_type value)
{
ETL_ASSERT((size() + 1) <= CAPACITY, ETL_ERROR(vector_full));
std::copy_backward(position, p_end, p_end + n);
std::fill_n(position, n, value);
p_end += n;
}
iterator insert(iterator position, value_type value);
void insert(iterator position, size_t n, value_type value);
//*********************************************************************
/// Inserts a range of values to the vector.
@ -463,117 +165,26 @@ namespace etl
p_end += count;
}
//*********************************************************************
/// 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)
{
std::copy(i_element + 1, end(), i_element);
--p_end;
iterator erase(iterator i_element);
iterator erase(iterator first, iterator last);
return i_element;
}
pvoidvector& operator = (const pvoidvector& rhs);
//*********************************************************************
/// 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(iterator first, iterator last)
{
std::copy(last, end(), first);
size_t n_delete = std::distance(first, last);
size_type size() const;
// Just adjust the count.
p_end -= n_delete;
bool empty() const;
return first;
}
bool full() const;
//*************************************************************************
/// Assignment operator.
//*************************************************************************
pvoidvector& operator = (const pvoidvector& rhs)
{
if (&rhs != this)
{
assign(rhs.cbegin(), rhs.cend());
}
return *this;
}
//*************************************************************************
/// Gets the current size of the vector.
///\return The current size of the vector.
//*************************************************************************
size_type size() const
{
return size_t(p_end - p_buffer);
}
//*************************************************************************
/// Checks the 'empty' state of the vector.
///\return <b>true</b> if empty.
//*************************************************************************
bool empty() const
{
return (p_end == p_buffer);
}
//*************************************************************************
/// Checks the 'full' state of the vector.
///\return <b>true</b> if full.
//*************************************************************************
bool full() const
{
return size() == CAPACITY;
}
//*************************************************************************
/// Returns the remaining capacity.
///\return The remaining capacity.
//*************************************************************************
size_t available() const
{
return max_size() - size();
}
size_t available() const;
protected:
//*********************************************************************
/// Constructor.
//*********************************************************************
pvoidvector(void** p_buffer_, size_t MAX_SIZE)
: vector_base(MAX_SIZE),
p_buffer(p_buffer_),
p_end(p_buffer_)
{
}
pvoidvector(void** p_buffer_, size_t MAX_SIZE);
//*********************************************************************
/// Initialise the vector.
//*********************************************************************
void initialise()
{
p_end = p_buffer;
}
void initialise();
//*************************************************************************
/// Fix the internal pointers after a low level memory copy.
//*************************************************************************
void repair(void** p_buffer_)
{
uintptr_t length = p_end - p_buffer;
p_buffer = p_buffer_;
p_end = p_buffer_ + length;
}
void repair(void** p_buffer_);
void** p_buffer;
void** p_end;

2
include/etl/set.h
View File

@ -453,7 +453,7 @@ namespace etl
/// A templated base for all etl::set types.
///\ingroup set
//***************************************************************************
template <typename T, typename TCompare>
template <typename T, typename TCompare = std::less<T> >
class iset : public etl::set_base
{
public:

4
include/etl/version.h
View File

@ -37,10 +37,10 @@ SOFTWARE.
/// Definitions of the ETL version
///\ingroup utilities
#define ETL_VERSION "11.12.1"
#define ETL_VERSION "11.12.2"
#define ETL_VERSION_MAJOR 11
#define ETL_VERSION_MINOR 12
#define ETL_VERSION_PATCH 1
#define ETL_VERSION_PATCH 2
#endif

456
src/private/pvoidvector.cpp
View File

@ -31,6 +31,462 @@ SOFTWARE.
#include "../../include/etl/platform.h"
#include "../../include/etl/private/pvoidvector.h"
//*********************************************************************
/// Returns an iterator to the beginning of the vector.
///\return An iterator to the beginning of the vector.
//*********************************************************************
etl::pvoidvector::iterator etl::pvoidvector::begin()
{
return p_buffer;
}
//*********************************************************************
/// Returns a const_iterator to the beginning of the vector.
///\return A const iterator to the beginning of the vector.
//*********************************************************************
etl::pvoidvector::const_iterator etl::pvoidvector::begin() const
{
return const_iterator(p_buffer);
}
//*********************************************************************
/// Returns an iterator to the end of the vector.
///\return An iterator to the end of the vector.
//*********************************************************************
etl::pvoidvector::iterator etl::pvoidvector::end()
{
return p_end;
}
//*********************************************************************
/// Returns a const_iterator to the end of the vector.
///\return A const iterator to the end of the vector.
//*********************************************************************
etl::pvoidvector::const_iterator etl::pvoidvector::end() const
{
return const_iterator(p_end);
}
//*********************************************************************
/// Returns a const_iterator to the beginning of the vector.
///\return A const iterator to the beginning of the vector.
//*********************************************************************
etl::pvoidvector::const_iterator etl::pvoidvector::cbegin() const
{
return const_iterator(p_buffer);
}
//*********************************************************************
/// Returns a const_iterator to the end of the vector.
///\return A const iterator to the end of the vector.
//*********************************************************************
etl::pvoidvector::const_iterator etl::pvoidvector::cend() const
{
return const_iterator(p_end);
}
//*********************************************************************
/// Returns an reverse iterator to the reverse beginning of the vector.
///\return Iterator to the reverse beginning of the vector.
//*********************************************************************
etl::pvoidvector::reverse_iterator etl::pvoidvector::rbegin()
{
return reverse_iterator(end());
}
//*********************************************************************
/// Returns a const reverse iterator to the reverse beginning of the vector.
///\return Const iterator to the reverse beginning of the vector.
//*********************************************************************
etl::pvoidvector::const_reverse_iterator etl::pvoidvector::rbegin() const
{
return const_reverse_iterator(end());
}
//*********************************************************************
/// Returns a reverse iterator to the end + 1 of the vector.
///\return Reverse iterator to the end + 1 of the vector.
//*********************************************************************
etl::pvoidvector::reverse_iterator etl::pvoidvector::rend()
{
return reverse_iterator(begin());
}
//*********************************************************************
/// Returns a const reverse iterator to the end + 1 of the vector.
///\return Const reverse iterator to the end + 1 of the vector.
//*********************************************************************
etl::pvoidvector::const_reverse_iterator etl::pvoidvector::rend() const
{
return const_reverse_iterator(begin());
}
//*********************************************************************
/// Returns a const reverse iterator to the reverse beginning of the vector.
///\return Const reverse iterator to the reverse beginning of the vector.
//*********************************************************************
etl::pvoidvector::const_reverse_iterator etl::pvoidvector::crbegin() const
{
return const_reverse_iterator(cend());
}
//*********************************************************************
/// Returns a const reverse iterator to the end + 1 of the vector.
///\return Const reverse iterator to the end + 1 of the vector.
//*********************************************************************
etl::pvoidvector::const_reverse_iterator etl::pvoidvector::crend() const
{
return const_reverse_iterator(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 etl::pvoidvector::resize(size_t new_size)
{
ETL_ASSERT(new_size <= CAPACITY, ETL_ERROR(vector_full));
p_end = p_buffer + 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 etl::pvoidvector::resize(size_t new_size, etl::pvoidvector::value_type value)
{
ETL_ASSERT(new_size <= CAPACITY, ETL_ERROR(vector_full));
pointer p_new_end = p_buffer + new_size;
// Size up if necessary.
if (p_end < p_new_end)
{
std::fill(p_end, p_new_end, value);
}
p_end = p_new_end;
}
//*********************************************************************
/// Returns a reference to the value at index 'i'
///\param i The index.
///\return A reference to the value at index 'i'
//*********************************************************************
etl::pvoidvector::reference etl::pvoidvector::operator [](size_t i)
{
return p_buffer[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'
//*********************************************************************
etl::pvoidvector::const_reference etl::pvoidvector::operator [](size_t i) const
{
return const_reference(p_buffer[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'
//*********************************************************************
etl::pvoidvector::reference etl::pvoidvector::at(size_t i)
{
ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
return p_buffer[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'
//*********************************************************************
etl::pvoidvector::const_reference etl::pvoidvector::at(size_t i) const
{
ETL_ASSERT(i < size(), ETL_ERROR(vector_out_of_bounds));
return const_reference(p_buffer[i]);
}
//*********************************************************************
/// Returns a reference to the first element.
///\return A reference to the first element.
//*********************************************************************
etl::pvoidvector::reference etl::pvoidvector::front()
{
return p_buffer[0];
}
//*********************************************************************
/// Returns a const reference to the first element.
///\return A const reference to the first element.
//*********************************************************************
etl::pvoidvector::const_reference etl::pvoidvector::front() const
{
return const_reference(p_buffer[0]);
}
//*********************************************************************
/// Returns a reference to the last element.
///\return A reference to the last element.
//*********************************************************************
etl::pvoidvector::reference etl::pvoidvector::back()
{
return *(p_end - 1);
}
//*********************************************************************
/// Returns a const reference to the last element.
///\return A const reference to the last element.
//*********************************************************************
etl::pvoidvector::const_reference etl::pvoidvector::back() const
{
return const_reference(*(p_end - 1));
}
//*********************************************************************
/// Returns a pointer to the beginning of the vector data.
///\return A pointer to the beginning of the vector data.
//*********************************************************************
etl::pvoidvector::pointer etl::pvoidvector::data()
{
return p_buffer;
}
//*********************************************************************
/// Returns a const pointer to the beginning of the vector data.
///\return A const pointer to the beginning of the vector data.
//*********************************************************************
etl::pvoidvector::const_pointer etl::pvoidvector::data() const
{
return const_pointer(p_buffer);
}
//*********************************************************************
/// 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 etl::pvoidvector::assign(size_t n, etl::pvoidvector::value_type value)
{
initialise();
ETL_ASSERT(n <= CAPACITY, ETL_ERROR(vector_full));
for (size_t current_size = 0; current_size < n; ++current_size)
{
*p_end++ = value;
}
}
//*************************************************************************
/// Clears the vector.
//*************************************************************************
void etl::pvoidvector::clear()
{
initialise();
}
//*************************************************************************
/// Increases the size of the vector by one, but does not initialise the new element.
/// If asserts or exceptions are enabled, throws a vector_full if the vector is already full.
//*************************************************************************
void etl::pvoidvector::push_back()
{
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
#endif
++p_end;
}
//*********************************************************************
/// 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 etl::pvoidvector::push_back(etl::pvoidvector::value_type value)
{
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(size() != CAPACITY, ETL_ERROR(vector_full));
#endif
*p_end++ = value;
}
//*************************************************************************
/// Removes an element from the end of the vector.
/// Does nothing if the vector is empty.
//*************************************************************************
void etl::pvoidvector::pop_back()
{
#if defined(ETL_CHECK_PUSH_POP)
ETL_ASSERT(size() > 0, ETL_ERROR(vector_empty));
#endif
--p_end;
}
//*********************************************************************
/// 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.
//*********************************************************************
etl::pvoidvector::iterator etl::pvoidvector::insert(etl::pvoidvector::iterator position, etl::pvoidvector::value_type value)
{
ETL_ASSERT(size() + 1 <= CAPACITY, ETL_ERROR(vector_full));
if (position != end())
{
++p_end;
std::copy_backward(position, end() - 1, end());
*position = value;
}
else
{
*p_end++ = value;
}
return position;
}
//*********************************************************************
/// 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 etl::pvoidvector::insert(etl::pvoidvector::iterator position, size_t n, etl::pvoidvector::value_type value)
{
ETL_ASSERT((size() + 1) <= CAPACITY, ETL_ERROR(vector_full));
std::copy_backward(position, p_end, p_end + n);
std::fill_n(position, n, value);
p_end += n;
}
//*********************************************************************
/// Erases an element.
///\param i_element Iterator to the element.
///\return An iterator pointing to the element that followed the erased element.
//*********************************************************************
etl::pvoidvector::iterator etl::pvoidvector::erase(etl::pvoidvector::iterator i_element)
{
std::copy(i_element + 1, end(), i_element);
--p_end;
return 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.
//*********************************************************************
etl::pvoidvector::iterator etl::pvoidvector::erase(etl::pvoidvector::iterator first, etl::pvoidvector::iterator last)
{
std::copy(last, end(), first);
size_t n_delete = std::distance(first, last);
// Just adjust the count.
p_end -= n_delete;
return first;
}
//*************************************************************************
/// Assignment operator.
//*************************************************************************
etl::pvoidvector& etl::pvoidvector::operator = (const etl::pvoidvector& rhs)
{
if (&rhs != this)
{
assign(rhs.cbegin(), rhs.cend());
}
return *this;
}
//*************************************************************************
/// Gets the current size of the vector.
///\return The current size of the vector.
//*************************************************************************
etl::pvoidvector::size_type etl::pvoidvector::size() const
{
return size_t(p_end - p_buffer);
}
//*************************************************************************
/// Checks the 'empty' state of the vector.
///\return <b>true</b> if empty.
//*************************************************************************
bool etl::pvoidvector::empty() const
{
return (p_end == p_buffer);
}
//*************************************************************************
/// Checks the 'full' state of the vector.
///\return <b>true</b> if full.
//*************************************************************************
bool etl::pvoidvector::full() const
{
return size() == CAPACITY;
}
//*************************************************************************
/// Returns the remaining capacity.
///\return The remaining capacity.
//*************************************************************************
size_t etl::pvoidvector::available() const
{
return max_size() - size();
}
//*********************************************************************
/// Constructor.
//*********************************************************************
etl::pvoidvector::pvoidvector(void** p_buffer_, size_t MAX_SIZE)
: vector_base(MAX_SIZE),
p_buffer(p_buffer_),
p_end(p_buffer_)
{
}
//*********************************************************************
/// Initialise the vector.
//*********************************************************************
void etl::pvoidvector::initialise()
{
p_end = p_buffer;
}
//*************************************************************************
/// Fix the internal pointers after a low level memory copy.
//*************************************************************************
void etl::pvoidvector::repair(void** p_buffer_)
{
uintptr_t length = p_end - p_buffer;
p_buffer = p_buffer_;
p_end = p_buffer_ + length;
}
namespace etl
{
//***************************************************************************

6
support/Release notes.txt
View File

@ -1,3 +1,9 @@
===============================================================================
11.12.2
Remove SFINAE from array_view.
Added default etl::less compare type appropriate map and set classes.
Moved non-template code in pvoidvector to cpp file.
===============================================================================
11.12.1
Made atomic load const for non STL vesions