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

Modified parameter types

Browse Source
This commit is contained in:
jwellbelove 2014-11-19 18:38:39 +00:00
parent 6ac2a3c6ec
commit 896ec105dc
5 changed files with 521 additions and 498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
deque.h
View File

@ -102,7 +102,7 @@ namespace etl
//*************************************************************************
/// Assigns data to the deque.
//*************************************************************************
explicit deque(size_t n, const value_type& value = value_type())
explicit deque(size_t n, typename ideque<T>::parameter_t value = value_type())
: ideque<T>(&buffer[0], MAX_SIZE, BUFFER_SIZE)
{
ideque<T>::assign(n, value);

675
ideque.h
View File

@ -35,6 +35,7 @@ SOFTWARE.
#include "type_traits.h"
#include "deque_base.h"
#include "parameter_type.h"
namespace etl
{
@ -48,15 +49,17 @@ namespace etl
{
public:
typedef T* pointer;
typedef const T* const_pointer;
typedef T value_type;
typedef size_t size_type;
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef typename std::iterator_traits<pointer>::difference_type difference_type;
private:
protected:
typedef typename parameter_type<T, is_fundamental<T>::value || is_pointer<T>::value>::type parameter_t;
//*************************************************************************
/// Test for an iterator.
@ -453,109 +456,13 @@ namespace etl
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Clears the deque.
/// Assignment operator.
//*************************************************************************
void clear()
ideque& operator =(const ideque& other)
{
first = iterator(0, *this, p_buffer);
last = iterator(0, *this, p_buffer);
current_size = 0;
}
assign(other.begin(), other.end());
//*************************************************************************
/// Gets an iterator to the beginning of the deque.
//*************************************************************************
iterator begin()
{
return first;
}
//*************************************************************************
/// Gets an iterator to the end of the deque.
//*************************************************************************
iterator end()
{
return ++iterator(last);
}
//*************************************************************************
/// Gets a const iterator to the beginning of the deque.
//*************************************************************************
const_iterator begin() const
{
return first;
}
//*************************************************************************
/// Gets a const iterator to the end of the deque.
//*************************************************************************
const_iterator end() const
{
return ++iterator(last);
}
//*************************************************************************
/// Gets a const iterator to the beginning of the deque.
//*************************************************************************
const_iterator cbegin() const
{
return first;
}
//*************************************************************************
/// Gets a const iterator to the end of the deque.
//*************************************************************************
const_iterator cend() const
{
return ++const_iterator(last);
}
//*************************************************************************
/// Gets a reverse iterator to the end of the deque.
//*************************************************************************
reverse_iterator rbegin()
{
return reverse_iterator(end());
}
//*************************************************************************
/// Gets a reverse iterator to the beginning of the deque.
//*************************************************************************
reverse_iterator rend()
{
return reverse_iterator(begin());
}
//*************************************************************************
/// Gets a const reverse iterator to the end of the deque.
//*************************************************************************
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(end());
}
//*************************************************************************
/// Gets a const reverse iterator to the beginning of the deque.
//*************************************************************************
const_reverse_iterator rend() const
{
return const_reverse_iterator(begin());
}
//*************************************************************************
/// Gets a const reverse iterator to the end of the deque.
//*************************************************************************
const_reverse_iterator crbegin() const
{
return const_reverse_iterator(cend());
}
//*************************************************************************
/// Gets a const reverse iterator to the beginning of the deque.
//*************************************************************************
const_reverse_iterator crend() const
{
return const_reverse_iterator(cbegin());
return *this;
}
//*************************************************************************
@ -563,7 +470,7 @@ namespace etl
//*************************************************************************
template<typename TIterator>
typename etl::enable_if<is_iterator<TIterator>::value, void>::type
assign(TIterator range_begin, TIterator range_end)
assign(TIterator range_begin, TIterator range_end)
{
clear();
@ -593,170 +500,74 @@ namespace etl
std::fill_n(p_buffer, n, value);
first.index = 0;
last.index = n - 1;
current_size = n;
last.index = n - 1;
current_size = n;
}
//*************************************************************************
/// Resizes the deque.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is 'new_size' is too large.
///\param new_size The new size of the deque.
///\param value The value to assign if the new size is larger. Default = Default constructed value.
/// Gets a reference to the item at the index.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_out_of_bounds if the index is out of range.
///\return A reference to the item at the index.
//*************************************************************************
void resize(size_t new_size, const value_type& value = value_type())
reference at(size_t index)
{
if (new_size <= MAX_SIZE)
{
// Make it smaller?
if (new_size < current_size)
{
last -= (current_size - new_size);
}
// Make it larger?
else if (new_size > current_size)
{
size_t count = new_size - current_size;
for (size_t i = 0; i < count; ++i)
{
*(++last) = value;
}
}
current_size = new_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
if (index >= current_size)
{
throw deque_out_of_bounds();
}
#endif
iterator result(first);
result += index;
return *result;
}
//*************************************************************************
/// Adds an item to the front of the deque.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is the deque is already full.
///\param item The item to push to the deque.
/// Gets a const reference to the item at the index.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_out_of_bounds if the index is out of range.
///\return A const reference to the item at the index.
//*************************************************************************
void push_front(const_reference item)
const_reference at(size_t index) const
{
if (!full())
{
if (!empty())
{
--first;
}
*first = item;
++current_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
if (index >= current_size)
{
throw deque_full();
}
#endif
}
//*************************************************************************
/// Adds one to the front of the deque and returns a reference to the new element.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is the deque is already full.
///\return A reference to the item to assign to.
//*************************************************************************
reference push_front()
{
if (!full())
{
if (!empty())
{
--first;
}
++current_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
{
throw deque_full();
throw deque_out_of_bounds();
}
#endif
return *first;
iterator result(first);
result += index;
return *result;
}
//*************************************************************************
/// Gets a reference to the item at the index.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_out_of_bounds if the index is out of range.
///\return A reference to the item at the index.
//*************************************************************************
reference operator [](size_t index)
{
iterator result(first);
result += index;
return *result;
}
//*************************************************************************
/// Adds an item to the back of the deque.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is the deque is already full.
///\param "item The item to push to the deque.
/// Gets a const reference to the item at the index.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_out_of_bounds if the index is out of range.
///\return A const reference to the item at the index.
//*************************************************************************
void push_back(const_reference item)
const_reference operator [](size_t index) const
{
if (!full())
{
if (!empty())
{
++last;
}
iterator result(first);
result += index;
*last = item;
++current_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
{
throw deque_full();
}
#endif
}
//*************************************************************************
/// Adds one to the front of the deque and returns a reference to the new element.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is the deque is already full.
///\return A reference to the item to assign to.
//*************************************************************************
reference push_back()
{
if (!full())
{
if (!empty())
{
++last;
}
++current_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
{
throw deque_full();
}
#endif
return *last;
}
//*************************************************************************
/// Removes the oldest item from the deque.
//*************************************************************************
void pop_front()
{
if (!empty())
{
++first;
--current_size;
}
}
//*************************************************************************
/// Removes the oldest item from the deque.
//*************************************************************************
void pop_back()
{
if (!empty())
{
--last;
--current_size;
}
return *result;
}
//*************************************************************************
@ -828,43 +639,109 @@ namespace etl
}
//*************************************************************************
/// Gets a reference to the item at the index.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_out_of_bounds if the index is out of range.
///\return A reference to the item at the index.
/// Gets an iterator to the beginning of the deque.
//*************************************************************************
reference operator [](size_t index)
iterator begin()
{
#ifdef ETL_USE_EXCEPTIONS
if (index >= current_size)
{
throw deque_out_of_bounds();
}
#endif
iterator result(first);
result += index;
return *result;
return first;
}
//*************************************************************************
/// Gets a const reference to the item at the index.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_out_of_bounds if the index is out of range.
///\return A const reference to the item at the index.
/// Gets a const iterator to the beginning of the deque.
//*************************************************************************
const_reference operator [](size_t index) const
const_iterator begin() const
{
#ifdef ETL_USE_EXCEPTIONS
if (index >= current_size)
{
throw deque_out_of_bounds();
}
#endif
return first;
}
//*************************************************************************
/// Gets a const iterator to the beginning of the deque.
//*************************************************************************
const_iterator cbegin() const
{
return first;
}
iterator result(first);
result += index;
//*************************************************************************
/// Gets an iterator to the end of the deque.
//*************************************************************************
iterator end()
{
return ++iterator(last);
}
return *result;
//*************************************************************************
/// Gets a const iterator to the end of the deque.
//*************************************************************************
const_iterator end() const
{
return ++iterator(last);
}
//*************************************************************************
/// Gets a const iterator to the end of the deque.
//*************************************************************************
const_iterator cend() const
{
return ++const_iterator(last);
}
//*************************************************************************
/// Gets a reverse iterator to the end of the deque.
//*************************************************************************
reverse_iterator rbegin()
{
return reverse_iterator(end());
}
//*************************************************************************
/// Gets a const reverse iterator to the end of the deque.
//*************************************************************************
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(end());
}
//*************************************************************************
/// Gets a const reverse iterator to the end of the deque.
//*************************************************************************
const_reverse_iterator crbegin() const
{
return const_reverse_iterator(cend());
}
//*************************************************************************
/// Gets a reverse iterator to the beginning of the deque.
//*************************************************************************
reverse_iterator rend()
{
return reverse_iterator(begin());
}
//*************************************************************************
/// Gets a const reverse iterator to the beginning of the deque.
//*************************************************************************
const_reverse_iterator rend() const
{
return const_reverse_iterator(begin());
}
//*************************************************************************
/// Gets a const reverse iterator to the beginning of the deque.
//*************************************************************************
const_reverse_iterator crend() const
{
return const_reverse_iterator(cbegin());
}
//*************************************************************************
/// Clears the deque.
//*************************************************************************
void clear()
{
first = iterator(0, *this, p_buffer);
last = iterator(0, *this, p_buffer);
current_size = 0;
}
//*************************************************************************
@ -1177,7 +1054,7 @@ namespace etl
position += length;
}
else
// Must be closer to the back.
// Must be closer to the back.
{
// Move the items.
std::copy(position + length, last + 1, position);
@ -1198,13 +1075,173 @@ namespace etl
}
//*************************************************************************
/// Assignment operator.
/// Adds an item to the back of the deque.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is the deque is already full.
///\param item The item to push to the deque.
//*************************************************************************
ideque& operator =(const ideque& other)
void push_back(parameter_t item)
{
assign(other.begin(), other.end());
if (!full())
{
if (!empty())
{
++last;
}
return *this;
*last = item;
++current_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
{
throw deque_full();
}
#endif
}
//*************************************************************************
/// Adds one to the front of the deque and returns a reference to the new element.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is the deque is already full.
///\return A reference to the item to assign to.
//*************************************************************************
reference push_back()
{
if (!full())
{
if (!empty())
{
++last;
}
++current_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
{
throw deque_full();
}
#endif
return *last;
}
//*************************************************************************
/// Removes the oldest item from the deque.
//*************************************************************************
void pop_back()
{
if (!empty())
{
--current_size;
if (!empty())
{
--last;
}
}
}
//*************************************************************************
/// Adds an item to the front of the deque.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is the deque is already full.
///\param item The item to push to the deque.
//*************************************************************************
void push_front(parameter_t item)
{
if (!full())
{
if (!empty())
{
--first;
}
*first = item;
++current_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
{
throw deque_full();
}
#endif
}
//*************************************************************************
/// Adds one to the front of the deque and returns a reference to the new element.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is the deque is already full.
///\return A reference to the item to assign to.
//*************************************************************************
reference push_front()
{
if (!full())
{
if (!empty())
{
--first;
}
++current_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
{
throw deque_full();
}
#endif
return *first;
}
//*************************************************************************
/// Removes the oldest item from the deque.
//*************************************************************************
void pop_front()
{
if (!empty())
{
--current_size;
if (!empty())
{
++first;
}
}
}
//*************************************************************************
/// Resizes the deque.
/// If ETL_USE_EXCEPTIONS is defined, throws an etl::deque_full is 'new_size' is too large.
///\param new_size The new size of the deque.
///\param value The value to assign if the new size is larger. Default = Default constructed value.
//*************************************************************************
void resize(size_t new_size, const value_type& value = value_type())
{
if (new_size <= MAX_SIZE)
{
// Make it smaller?
if (new_size < current_size)
{
last -= (current_size - new_size);
}
// Make it larger?
else if (new_size > current_size)
{
size_t count = new_size - current_size;
for (size_t i = 0; i < count; ++i)
{
*(++last) = value;
}
}
current_size = new_size;
}
#ifdef ETL_USE_EXCEPTIONS
else
{
throw deque_out_of_bounds();
}
#endif
}
//*************************************************************************
@ -1239,37 +1276,21 @@ namespace etl
return distance(lhs.base(), rhs.base());
}
//*************************************************************************
/// Equality operator.
//*************************************************************************
friend bool operator ==(const ideque& lhs, const ideque& rhs)
{
return (lhs.size() == rhs.size()) && std::equal(lhs.begin(), lhs.end(), rhs.begin());
}
//*************************************************************************
/// Inequality operator.
//*************************************************************************
friend bool operator !=(const ideque& lhs, const ideque& rhs)
{
return !(lhs == rhs);
}
protected:
//*************************************************************************
/// Constructor.
//*************************************************************************
ideque(T* p_buffer, size_t max_size, size_t buffer_size)
ideque(pointer p_buffer, size_t max_size, size_t buffer_size)
: deque_base(max_size, buffer_size),
p_buffer(p_buffer)
{
clear();
}
iterator first; ///Iterator to the first item in the deque.
iterator last; ///Iterator to the last item in the deque.
T* p_buffer; ///The buffer.
iterator first; ///Iterator to the first item in the deque.
iterator last; ///Iterator to the last item in the deque.
pointer p_buffer; ///The buffer for the deque.
private:
@ -1289,11 +1310,11 @@ namespace etl
/// Measures the distance from the first iterator to the specified iterator.
//*************************************************************************
template <typename TIterator>
static difference_type distance(const TIterator& it)
static difference_type distance(const TIterator& other)
{
const difference_type index = it.get_index();
const difference_type reference_index = it.get_deque().first.index;
const size_t buffer_size = it.get_deque().BUFFER_SIZE;
const difference_type index = other.get_index();
const difference_type reference_index = other.get_deque().first.index;
const size_t buffer_size = other.get_deque().BUFFER_SIZE;
if (index < reference_index)
{
@ -1309,8 +1330,8 @@ namespace etl
//***************************************************************************
/// Equal operator.
///\param lhs Reference to the first array.
///\param rhs Reference to the second array.
///\param lhs Reference to the first deque.
///\param rhs Reference to the second deque.
///\return <b>true</b> if the arrays are equal, otherwise <b>false</b>
///\ingroup deque
//***************************************************************************
@ -1322,8 +1343,8 @@ bool operator ==(const etl::ideque<T>& lhs, const etl::ideque<T>& rhs)
//***************************************************************************
/// Not equal operator.
///\param lhs Reference to the first array.
///\param rhs Reference to the second array.
///\param lhs Reference to the first deque.
///\param rhs Reference to the second deque.
///\return <b>true</b> if the arrays are not equal, otherwise <b>false</b>
///\ingroup deque
//***************************************************************************
@ -1335,9 +1356,9 @@ bool operator !=(const etl::ideque<T>& lhs, const etl::ideque<T>& rhs)
//***************************************************************************
/// Less than operator.
///\param lhs Reference to the first array.
///\param rhs Reference to the second array.
///\return <b>true</b> if the first array is lexigraphically less than the second, otherwise <b>false</b>
///\param lhs Reference to the first deque.
///\param rhs Reference to the second deque.
///\return <b>true</b> if the first deque is lexigraphically less than the second, otherwise <b>false</b>
///\ingroup deque
//***************************************************************************
template <typename T>
@ -1349,11 +1370,24 @@ bool operator <(const etl::ideque<T>& lhs, const etl::ideque<T>& rhs)
rhs.end());
}
//***************************************************************************
/// Less than or equal operator.
///\param lhs Reference to the first deque.
///\param rhs Reference to the second deque.
///\return <b>true</b> if the first deque is lexigraphically less than or equal to the second, otherwise <b>false</b>
///\ingroup deque
//***************************************************************************
template <typename T>
bool operator <=(const etl::ideque<T>& lhs, const etl::ideque<T>& rhs)
{
return !operator >(lhs, rhs);
}
//***************************************************************************
/// Greater than operator.
///\param lhs Reference to the first array.
///\param rhs Reference to the second array.
///\return <b>true</b> if the first array is lexigraphically greater than the second, otherwise <b>false</b>
///\param lhs Reference to the first deque.
///\param rhs Reference to the second deque.
///\return <b>true</b> if the first deque is lexigraphically greater than the second, otherwise <b>false</b>
///\ingroup deque
//***************************************************************************
template <typename T>
@ -1366,24 +1400,11 @@ bool operator >(const etl::ideque<T>& lhs, const etl::ideque<T>& rhs)
std::greater<T>());
}
//***************************************************************************
/// Less than or equal operator.
///\param lhs Reference to the first array.
///\param rhs Reference to the second array.
///\return <b>true</b> if the first array is lexigraphically less than or equal to the second, otherwise <b>false</b>
///\ingroup deque
//***************************************************************************
template <typename T>
bool operator <=(const etl::ideque<T>& lhs, const etl::ideque<T>& rhs)
{
return !operator >(lhs, rhs);
}
//***************************************************************************
/// Greater than or equal operator.
///\param "lhs Reference to the first array.
///\param "rhs Reference to the second array.
///\return <b>true</b> if the first array is lexigraphically greater than or equal to the second, otherwise <b>false</b>
///\param "lhs Reference to the first deque.
///\param "rhs Reference to the second deque.
///\return <b>true</b> if the first deque is lexigraphically greater than or equal to the second, otherwise <b>false</b>
///\ingroup deque
//***************************************************************************
template <typename T>

328
ilist.h
View File

@ -41,6 +41,8 @@ SOFTWARE.
#include "nullptr.h"
#include "list_base.h"
#include "type_traits.h"
#include "parameter_type.h"
namespace etl
{
@ -51,8 +53,20 @@ namespace etl
template <typename T>
class ilist : public list_base
{
public:
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
protected:
typedef typename parameter_type<T, is_fundamental<T>::value || is_pointer<T>::value>::type parameter_t;
//*************************************************************************
/// The node element in the list.
//*************************************************************************
@ -146,13 +160,6 @@ namespace etl
public:
typedef T value_type;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
//*************************************************************************
/// iterator.
//*************************************************************************
@ -330,11 +337,6 @@ namespace etl
return ilist::data_cast(p_node)->value;
}
inline Data_Node* operator ->()
{
return p_node;
}
inline const Data_Node* operator ->() const
{
return p_node;
@ -360,6 +362,16 @@ namespace etl
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
//*************************************************************************
/// Assignment operator.
//*************************************************************************
inline ilist& operator = (const ilist& rhs)
{
assign(rhs.cbegin(), rhs.cend());
return *this;
}
//*************************************************************************
/// Gets the beginning of the list.
//*************************************************************************
@ -376,38 +388,6 @@ namespace etl
return const_iterator(get_head());
}
//*************************************************************************
/// Gets the beginning of the list.
//*************************************************************************
inline const_iterator cbegin() const
{
return const_iterator(get_head());
}
//*************************************************************************
/// Gets the reverse beginning of the list.
//*************************************************************************
inline reverse_iterator rbegin()
{
return reverse_iterator(terminal_node);
}
//*************************************************************************
/// Gets the reverse beginning of the list.
//*************************************************************************
inline const_reverse_iterator rbegin() const
{
return const_reverse_iterator(static_cast<const Data_Node&>(terminal_node));
}
//*************************************************************************
/// Gets the reverse beginning of the list.
//*************************************************************************
inline const_reverse_iterator crbegin() const
{
return const_reverse_iterator(static_cast<const Data_Node&>(terminal_node));
}
//*************************************************************************
/// Gets the end of the list.
//*************************************************************************
@ -424,6 +404,14 @@ namespace etl
return const_iterator(static_cast<const Data_Node&>(terminal_node));
}
//*************************************************************************
/// Gets the beginning of the list.
//*************************************************************************
inline const_iterator cbegin() const
{
return const_iterator(get_head());
}
//*************************************************************************
/// Gets the end of the list.
//*************************************************************************
@ -432,6 +420,22 @@ namespace etl
return const_iterator(static_cast<const Data_Node&>(terminal_node));
}
//*************************************************************************
/// Gets the reverse beginning of the list.
//*************************************************************************
inline reverse_iterator rbegin()
{
return reverse_iterator(terminal_node);
}
//*************************************************************************
/// Gets the reverse beginning of the list.
//*************************************************************************
inline const_reverse_iterator rbegin() const
{
return const_reverse_iterator(static_cast<const Data_Node&>(terminal_node));
}
//*************************************************************************
/// Gets the reverse end of the list.
//*************************************************************************
@ -441,11 +445,11 @@ namespace etl
}
//*************************************************************************
/// Gets the reverse end of the list.
/// Gets the reverse beginning of the list.
//*************************************************************************
inline const_reverse_iterator rend() const
inline const_reverse_iterator crbegin() const
{
return const_reverse_iterator(get_head());
return const_reverse_iterator(static_cast<const Data_Node&>(terminal_node));
}
//*************************************************************************
@ -456,24 +460,6 @@ namespace etl
return const_reverse_iterator(get_head());
}
//*************************************************************************
/// Assignment operator.
//*************************************************************************
inline ilist& operator = (const ilist& rhs)
{
assign(rhs.cbegin(), rhs.cend());
return *this;
}
//*************************************************************************
/// Clears the list.
//*************************************************************************
inline void clear()
{
initialise();
}
//*************************************************************************
/// Gets a reference to the first element.
//*************************************************************************
@ -550,7 +536,7 @@ namespace etl
//*************************************************************************
/// Assigns 'n' copies of a value to the list.
//*************************************************************************
void assign(size_t n, const_reference value)
void assign(size_t n, parameter_t value)
{
// Reset the links.
join(terminal_node, terminal_node);
@ -606,7 +592,7 @@ namespace etl
//*************************************************************************
/// Pushes a value to the front of the list.
//*************************************************************************
void push_front(const_reference value)
void push_front(parameter_t value)
{
if (!full())
{
@ -622,6 +608,17 @@ namespace etl
#endif
}
//*************************************************************************
/// Removes a value from the front of the list.
//*************************************************************************
void pop_front()
{
if (!empty())
{
remove_node(get_head());
}
}
//*************************************************************************
/// Adds a node to the back of the list so a new value can be assigned to back().
//*************************************************************************
@ -643,7 +640,7 @@ namespace etl
//*************************************************************************
/// Pushes a value to the back of the list..
//*************************************************************************
void push_back(const_reference value)
void push_back(parameter_t value)
{
if (!full())
{
@ -659,17 +656,6 @@ namespace etl
#endif
}
//*************************************************************************
/// Removes a value from the front of the list.
//*************************************************************************
void pop_front()
{
if (!empty())
{
remove_node(get_head());
}
}
//*************************************************************************
/// Removes a value from the back of the list.
//*************************************************************************
@ -681,64 +667,6 @@ namespace etl
}
}
//*************************************************************************
/// Resizes the list.
//*************************************************************************
void resize(size_t n)
{
resize(n, T());
}
//*************************************************************************
/// Resizes the list.
//*************************************************************************
void resize(size_t n, T value)
{
if (n > MAX_SIZE)
{
#if ETL_USE_EXCEPTIONS
throw list_full();
#else
n = MAX_SIZE;
#endif
}
// Smaller?
if (n < size())
{
iterator i_start = end();
std::advance(i_start, -difference_type(size() - n));
erase(i_start, end());
}
// Larger?
else if (n > size())
{
insert(end(), n - size(), value);
}
}
//*************************************************************************
/// Reverses the list.
//*************************************************************************
void reverse()
{
if (is_trivial_list())
{
return;
}
iterator i_item = begin();
while (i_item != end())
{
i_item.p_node->reverse();
--i_item; // Now we've reversed it, we must decrement it.
}
// Terminal node.
i_item.p_node->reverse();
}
//*************************************************************************
/// Inserts a value to the list at the specified position.
//*************************************************************************
@ -856,6 +784,91 @@ namespace etl
return last;
}
//*************************************************************************
/// Resizes the list.
//*************************************************************************
void resize(size_t n)
{
resize(n, T());
}
//*************************************************************************
/// Resizes the list.
//*************************************************************************
void resize(size_t n, T value)
{
if (n > MAX_SIZE)
{
#if ETL_USE_EXCEPTIONS
throw list_full();
#else
n = MAX_SIZE;
#endif
}
// Smaller?
if (n < size())
{
iterator i_start = end();
std::advance(i_start, -difference_type(size() - n));
erase(i_start, end());
}
// Larger?
else if (n > size())
{
insert(end(), n - size(), value);
}
}
//*************************************************************************
/// Clears the list.
//*************************************************************************
inline void clear()
{
initialise();
}
//*************************************************************************
// Removes the values specified.
//*************************************************************************
void remove(const value_type& value)
{
iterator iValue = begin();
while (iValue != end())
{
if (value == *iValue)
{
iValue = erase(iValue);
}
else
{
++iValue;
}
}
}
//*************************************************************************
/// Removes according to a predicate.
//*************************************************************************
template <typename TPredicate>
void remove_if(TPredicate predicate)
{
iterator iValue = begin();
while (iValue != end())
{
if (predicate(*iValue))
{
iValue = erase(iValue);
}
else
{
++iValue;
}
}
}
//*************************************************************************
/// Removes all but the first element from every consecutive group of equal
/// elements in the container.
@ -1018,44 +1031,25 @@ namespace etl
}
//*************************************************************************
// Removes the values specified.
/// Reverses the list.
//*************************************************************************
void remove(const value_type& value)
void reverse()
{
iterator iValue = begin();
while (iValue != end())
if (is_trivial_list())
{
if (value == *iValue)
{
iValue = erase(iValue);
}
else
{
++iValue;
}
return;
}
}
//*************************************************************************
/// Removes according to a predicate.
//*************************************************************************
template <typename TPredicate>
void remove_if(TPredicate predicate)
{
iterator iValue = begin();
iterator i_item = begin();
while (iValue != end())
while (i_item != end())
{
if (predicate(*iValue))
{
iValue = erase(iValue);
}
else
{
++iValue;
}
i_item.p_node->reverse();
--i_item; // Now we've reversed it, we must decrement it.
}
// Terminal node.
i_item.p_node->reverse();
}
protected:

12
iqueue.h
View File

@ -33,6 +33,8 @@ SOFTWARE.
#include <cstddef>
#include "queue_base.h"
#include "type_traits.h"
#include "parameter_type.h"
namespace etl
{
@ -57,7 +59,13 @@ namespace etl
typedef T& reference; ///< A reference to the type used in the queue.
typedef const T& const_reference; ///< A const reference to the type used in the queue.
typedef T* pointer; ///< A pointer to the type used in the queue.
typedef const T* const_pointer; ///< A const pointer to the type used in the queue.
typedef const T* const_pointer; ///< A const pointer to the type used in the qu
private:
typedef typename parameter_type<T, is_fundamental<T>::value || is_pointer<T>::value>::type parameter_t;
public:
//*************************************************************************
/// Adds an item to the queue.
@ -65,7 +73,7 @@ namespace etl
/// otherwise does nothing if full.
///\param item The item to push to the queue.
//*************************************************************************
void push(const_reference item)
void push(parameter_t item)
{
if (!full())
{

2
vector.h
View File

@ -81,7 +81,7 @@ namespace etl
///\param initialSize The initial size of the vector.
///\param value The value to fill the vector with.
//*************************************************************************
vector(size_t initialSize, const T& value)
vector(size_t initialSize, typename ivector<T>::parameter_t value)
: ivector<T>(buffer, MAX_SIZE)
{
ivector<T>::resize(initialSize, value);