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

Revert "feature/add utils compare equality operator (#865)" (#866)

Browse Source 
This reverts commit d40c5be796f30efd426b83535c078065a62d9bca.
This commit is contained in:
John Wellbelove 2024-03-16 11:35:08 +00:00 committed by GitHub
parent d40c5be796
commit f1133d5bbc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 10 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
include/etl/compare.h
View File

@ -44,7 +44,7 @@ SOFTWARE.
namespace etl
{
//***************************************************************************
/// Defines <=, >, >=, ==, !=, <=> in terms of <
/// Defines <=, >, >= in terms of <
/// Default
//***************************************************************************
template <typename T, typename TLess = etl::less<T> >
@ -54,13 +54,6 @@ namespace etl
typedef typename etl::parameter_type<T>::type second_argument_type;
typedef bool result_type;
enum cmp_result
{
LESS = -1,
EQUAL = 0,
GREATER = 1
};
static result_type lt(first_argument_type lhs, second_argument_type rhs)
{
return TLess()(lhs, rhs);
@ -80,31 +73,6 @@ namespace etl
{
return !lt(lhs, rhs);
}
static result_type eq(first_argument_type lhs, second_argument_type rhs)
{
return gte(lhs, rhs) && lte(lhs, rhs);
}
static result_type ne(first_argument_type lhs, second_argument_type rhs)
{
return !eq(lhs, rhs);
}
static cmp_result cmp(first_argument_type lhs, second_argument_type rhs)
{
if (lt(lhs, rhs))
{
return LESS;
}
if (gt(lhs, rhs))
{
return GREATER;
}
return EQUAL;
}
};
}

63
test/test_compare.cpp
View File

@ -37,61 +37,49 @@ namespace
typedef etl::compare<int> CompareInt;
struct Object
struct Test
{
int a;
int b;
};
Object ta = { 1, 2 };
Object tb = { 2, 3 };
Test ta = { 1, 2 };
Test tb = { 2, 3 };
//***********************************
bool operator <(const Object& lhs, const Object& rhs)
bool operator <(const Test& lhs, const Test& rhs)
{
return (lhs.a + lhs.b) < (rhs.a + rhs.b);
}
//***********************************
bool operator >(const Object& lhs, const Object& rhs)
bool operator >(const Test& lhs, const Test& rhs)
{
return (lhs.a + lhs.b) > (rhs.a + rhs.b);
}
//***********************************
bool operator <=(const Object& lhs, const Object& rhs)
bool operator <=(const Test& lhs, const Test& rhs)
{
return (lhs.a + lhs.b) <= (rhs.a + rhs.b);
}
//***********************************
bool operator >=(const Object& lhs, const Object& rhs)
bool operator >=(const Test& lhs, const Test& rhs)
{
return (lhs.a + lhs.b) >= (rhs.a + rhs.b);
}
//***********************************
bool operator ==(const Object& lhs, const Object& rhs)
{
return (lhs.a + lhs.b) == (rhs.a + rhs.b);
}
//***********************************
bool operator !=(const Object& lhs, const Object& rhs)
{
return (lhs.a + lhs.b) != (rhs.a + rhs.b);
}
//***********************************
struct LessTest
{
bool operator()(const Object& lhs, const Object& rhs) const
bool operator()(const Test& lhs, const Test& rhs) const
{
return (lhs.a + lhs.b) < (rhs.a + rhs.b);
}
};
typedef etl::compare<Object, LessTest> CompareTest;
typedef etl::compare<Test, LessTest> CompareTest;
SUITE(test_compare)
{
@ -138,38 +126,5 @@ namespace
CHECK_EQUAL(tb >= ta, (CompareTest::gte(tb, ta)));
CHECK_EQUAL(ta >= ta, (CompareTest::gte(ta, ta)));
}
//*************************************************************************
TEST(test_eq)
{
CHECK_EQUAL(a == b, (CompareInt::eq(a, b)));
CHECK_EQUAL(b == a, (CompareInt::eq(b, a)));
CHECK_EQUAL(a == a, (CompareInt::eq(a, a)));
CHECK_EQUAL(ta == tb, (CompareTest::eq(ta, tb)));
CHECK_EQUAL(tb == ta, (CompareTest::eq(tb, ta)));
CHECK_EQUAL(ta == ta, (CompareTest::eq(ta, ta)));
}
//*************************************************************************
TEST(test_ne)
{
CHECK_EQUAL(a != b, (CompareInt::ne(a, b)));
CHECK_EQUAL(b != a, (CompareInt::ne(b, a)));
CHECK_EQUAL(a != a, (CompareInt::ne(a, a)));
CHECK_EQUAL(ta != tb, (CompareTest::ne(ta, tb)));
CHECK_EQUAL(tb != ta, (CompareTest::ne(tb, ta)));
CHECK_EQUAL(ta != ta, (CompareTest::ne(ta, ta)));
}
//*************************************************************************
TEST(test_cmp)
{
CHECK_EQUAL(CompareInt::LESS, (CompareInt::cmp(2, 4)));
CHECK_EQUAL(CompareInt::GREATER, (CompareInt::cmp(4, 2)));
CHECK_EQUAL(CompareInt::EQUAL, (CompareInt::cmp(0, 0)));
CHECK_EQUAL(CompareTest::LESS, (CompareTest::cmp(Object{0, 1}, Object{2, 4})));
CHECK_EQUAL(CompareTest::GREATER, (CompareTest::cmp(Object{2, 4}, Object{0, 1})));
CHECK_EQUAL(CompareTest::EQUAL, (CompareTest::cmp(Object{2, 4}, Object{2, 4})));
}
};
}