Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add eq and ne operators for compare utility. #863

Merged
merged 4 commits into from
Mar 15, 2024
Merged

Add eq and ne operators for compare utility. #863

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
aca7b1d
Add eq and ne operators
Mar 13, 2024
3208192
Add three-way comparison to compare utils.
Mar 15, 2024
fc19b12
Three-way comparison test now using own test data.
Mar 15, 2024
baf2eab
Rename test struct for three-way comparison test.
Mar 15, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
34 changes: 33 additions & 1 deletion include/etl/compare.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -44,7 +44,7 @@ SOFTWARE.
namespace etl
{
//***************************************************************************
/// Defines <=, >, >= in terms of <
/// Defines <=, >, >=, ==, !=, <=> in terms of <
/// Default
//***************************************************************************
template <typename T, typename TLess = etl::less<T> >
Expand All @@ -54,6 +54,13 @@ 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);
Expand All @@ -73,6 +80,31 @@ 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;
}
};
}

Expand Down
63 changes: 54 additions & 9 deletions test/test_compare.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,49 +37,61 @@ namespace

typedef etl::compare<int> CompareInt;

struct Test
struct Object
{
int a;
int b;
};

Test ta = { 1, 2 };
Test tb = { 2, 3 };
Object ta = { 1, 2 };
Object tb = { 2, 3 };

//***********************************
bool operator <(const Test& lhs, const Test& rhs)
bool operator <(const Object& lhs, const Object& rhs)
{
return (lhs.a + lhs.b) < (rhs.a + rhs.b);
}

//***********************************
bool operator >(const Test& lhs, const Test& rhs)
bool operator >(const Object& lhs, const Object& rhs)
{
return (lhs.a + lhs.b) > (rhs.a + rhs.b);
}

//***********************************
bool operator <=(const Test& lhs, const Test& rhs)
bool operator <=(const Object& lhs, const Object& rhs)
{
return (lhs.a + lhs.b) <= (rhs.a + rhs.b);
}

//***********************************
bool operator >=(const Test& lhs, const Test& rhs)
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);
}

//***********************************
bool operator !=(const Object& lhs, const Object& rhs)
{
return (lhs.a + lhs.b) != (rhs.a + rhs.b);
}

//***********************************
struct LessTest
{
bool operator()(const Test& lhs, const Test& rhs) const
bool operator()(const Object& lhs, const Object& rhs) const
{
return (lhs.a + lhs.b) < (rhs.a + rhs.b);
}
};

typedef etl::compare<Test, LessTest> CompareTest;
typedef etl::compare<Object, LessTest> CompareTest;

SUITE(test_compare)
{
Expand Down Expand Up @@ -126,5 +138,38 @@ 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))));
}
};
}