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

This reverts commit d40c5be.
ETLCPP · Mar 16, 2024 · ccac643 · ccac643
1 parent d40c5be
commit ccac643
Show file tree

Hide file tree

Showing 2 changed files with 10 additions and 87 deletions.
diff --git a/include/etl/compare.h b/include/etl/compare.h
@@ -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;
-    }
   };
 }
 

diff --git a/test/test_compare.cpp b/test/test_compare.cpp
@@ -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})));
-    }
   };
 }