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

Added fixes for deque operator-(). Removed redundant operator that was causing compile errors for C++20

Browse Source 
# Conflicts:
#	test/test_deque.cpp
This commit is contained in:
John Wellbelove 2024-03-04 12:54:05 +00:00
parent 134f8e4209
commit 7f13eeb06c
3 changed files with 164 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
include/etl/circular_buffer.h
View File

@ -246,6 +246,22 @@ namespace etl
return &picb->pbuffer[current];
}
//*************************************************************************
/// [] operator
//*************************************************************************
reference operator [](size_t index)
{
return pbuffer[(current + index) % picb->buffer_size];
}
//*************************************************************************
/// [] operator
//*************************************************************************
const_reference operator [](size_t index) const
{
return pbuffer[(current + index) % picb->buffer_size];
}
//*************************************************************************
/// Pre-increment.
//*************************************************************************
@ -335,6 +351,18 @@ namespace etl
return temp;
}
//*************************************************************************
/// Add offset.
//*************************************************************************
friend iterator operator +(int n, const iterator& rhs)
{
iterator temp = rhs;
temp += n;
return temp;
}
//*************************************************************************
/// Subtract offset.
//*************************************************************************
@ -517,6 +545,14 @@ namespace etl
return &(picb->pbuffer[current]);
}
//*************************************************************************
/// [] operator
//*************************************************************************
const_reference operator [](size_t index) const
{
return pbuffer[(current + index) % picb->buffer_size];
}
//*************************************************************************
/// Pre-increment.
//*************************************************************************
@ -998,22 +1034,6 @@ namespace etl
return distance(rhs, lhs);
}
//*************************************************************************
/// - operator for reverse_iterator
//*************************************************************************
friend difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs)
{
return distance(lhs.base(), rhs.base());
}
//*************************************************************************
/// - operator for const_reverse_iterator
//*************************************************************************
friend difference_type operator -(const const_reverse_iterator& lhs, const const_reverse_iterator& rhs)
{
return distance(lhs.base(), rhs.base());
}
protected:
//*************************************************************************

70
include/etl/deque.h
View File

@ -41,7 +41,6 @@ SOFTWARE.
#include "debug_count.h"
#include "algorithm.h"
#include "type_traits.h"
#include "iterator.h"
#include "placement_new.h"
#include "initializer_list.h"
@ -258,17 +257,17 @@ namespace etl
//***************************************************
iterator(const iterator& other)
: index(other.index),
p_deque(other.p_deque),
p_buffer(other.p_buffer)
: index(other.index)
, p_deque(other.p_deque)
, p_buffer(other.p_buffer)
{
}
//***************************************************
iterator& operator =(const iterator& other)
{
index = other.index;
p_deque = other.p_deque;
index = other.index;
p_deque = other.p_deque;
p_buffer = other.p_buffer;
return *this;
@ -352,6 +351,24 @@ namespace etl
return &p_buffer[index];
}
//***************************************************
reference operator [](size_t index)
{
iterator result(*this);
result += index;
return *result;
}
//***************************************************
const_reference operator [](size_t index) const
{
iterator result(*this);
result += index;
return *result;
}
//***************************************************
friend iterator operator +(const iterator& lhs, difference_type offset)
{
@ -360,6 +377,14 @@ namespace etl
return result;
}
//***************************************************
friend iterator operator +(difference_type offset, const iterator& lhs)
{
iterator result(lhs);
result += offset;
return result;
}
//***************************************************
friend iterator operator -(const iterator& lhs, difference_type offset)
{
@ -596,6 +621,15 @@ namespace etl
return &p_buffer[index];
}
//***************************************************
reference operator [](size_t index)
{
iterator result(*this);
result += index;
return *result;
}
//***************************************************
friend const_iterator operator +(const const_iterator& lhs, difference_type offset)
{
@ -604,6 +638,14 @@ namespace etl
return result;
}
//***************************************************
friend const_iterator operator +(difference_type offset, const const_iterator& lhs)
{
const_iterator result(lhs);
result += offset;
return result;
}
//***************************************************
friend const_iterator operator -(const const_iterator& lhs, difference_type offset)
{
@ -2054,22 +2096,6 @@ namespace etl
return distance(rhs, lhs);
}
//*************************************************************************
/// - operator for reverse_iterator
//*************************************************************************
friend difference_type operator -(const reverse_iterator& lhs, const reverse_iterator& rhs)
{
return distance(lhs.base(), rhs.base());
}
//*************************************************************************
/// - operator for const_reverse_iterator
//*************************************************************************
friend difference_type operator -(const const_reverse_iterator& lhs, const const_reverse_iterator& rhs)
{
return distance(lhs.base(), rhs.base());
}
//*************************************************************************
/// Assignment operator.
//*************************************************************************

84
test/test_deque.cpp
View File

@ -29,6 +29,7 @@ SOFTWARE.
#include "unit_test_framework.h"
#include "etl/deque.h"
#include "etl/vector.h"
#include "data.h"
@ -106,11 +107,20 @@ namespace
//*************************************************************************
TEST(test_constructor_fill)
{
Compare_Data compare_data(SIZE, N999);
DataNDC data(SIZE, N999);
//Compare_Data compare_data(SIZE, N999);
//DataNDC data(SIZE, N999);
CHECK_EQUAL(compare_data.size(), data.size());
CHECK(std::equal(compare_data.begin(), compare_data.end(), data.begin()));
etl::deque<int, 10> data;
using iter_type = etl::deque<int, 10>::iterator;
bool b1 = std::random_access_iterator<iter_type>;
bool b2 = std::sentinel_for<iter_type, iter_type>;
//bool b = std::equal(data.begin(), data.end(), data.begin());
//CHECK_EQUAL(compare_data.size(), data.size());
//CHECK(std::equal(compare_data.begin(), compare_data.end(), data.begin()));
}
//*************************************************************************
@ -700,6 +710,72 @@ namespace
CHECK(!(second < first));
}
//*************************************************************************
TEST(test_reverse_iterator_difference)
{
DataNDC data(SIZE, N0);
DataNDC::reverse_iterator first = data.rbegin() + 1;
DataNDC::reverse_iterator second = data.rbegin() + 4;
CHECK_EQUAL(-3, first - second);
CHECK_EQUAL( 3, second - first);
}
//*************************************************************************
TEST(test_const_reverse_iterator_difference)
{
DataNDC data(SIZE, N0);
DataNDC::const_reverse_iterator first = data.crbegin() + 1;
DataNDC::const_reverse_iterator second = data.crbegin() + 4;
CHECK_EQUAL(-3, first - second);
CHECK_EQUAL( 3, second - first);
}
//*************************************************************************
TEST(test_reverse_iterator_difference_rollover)
{
DataNDC data(SIZE, N0);
data.pop_back();
data.pop_back();
data.pop_back();
data.pop_back();
data.push_front(N1);
data.push_front(N1);
data.push_front(N1);
data.push_front(N1);
DataNDC::reverse_iterator first = data.rbegin() + 1;
DataNDC::reverse_iterator second = data.rbegin() + 4;
CHECK_EQUAL(-3, first - second);
CHECK_EQUAL( 3, second - first);
}
//*************************************************************************
TEST(test_const_reverse_iterator_difference_rollover)
{
DataNDC data(SIZE, N0);
data.pop_back();
data.pop_back();
data.pop_back();
data.pop_back();
data.push_front(N1);
data.push_front(N1);
data.push_front(N1);
data.push_front(N1);
DataNDC::const_reverse_iterator first = data.crbegin() + 1;
DataNDC::const_reverse_iterator second = data.crbegin() + 4;
CHECK_EQUAL(-3, first - second);
CHECK_EQUAL( 3, second - first);
}
//*************************************************************************
TEST(test_reverse_iterator_comparison)
{