Refactored Evaluator templates to only be specialised on Op, with Lhs/Rhs types templated on method instead

2 files changed, 36 insertions, 40 deletions

diff --git a/include/internal/catch_evaluate.hpp b/include/internal/catch_evaluate.hpp
index 8c9a69f9..91e01908 100644
--- a/include/internal/catch_evaluate.hpp
+++ b/include/internal/catch_evaluate.hpp
@@ -36,72 +36,68 @@ namespace Internal {
 
     // So the compare overloads can be operator agnostic we convey the operator as a template
     // enum, which is used to specialise an Evaluator for doing the comparison.
-    template<typename T1, typename T2, Operator Op>
+    template<Operator Op>
     struct Evaluator{};
 
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsEqualTo> {
+    template<>
+    struct Evaluator<IsEqualTo> {
+        template<typename T1, typename T2>
         static bool evaluate( T1 const& lhs, T2 const& rhs) {
             return bool(removeConst(lhs) == removeConst(rhs) );
         }
+        template<typename T>
+        static bool evaluate( int lhs, T* rhs) {
+            return reinterpret_cast<void const*>( lhs ) ==  rhs;
+        }
+        template<typename T>
+        static bool evaluate( T* lhs, int rhs) {
+            return lhs == reinterpret_cast<void const*>( rhs );
+        }
     };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsNotEqualTo> {
+    template<>
+    struct Evaluator<IsNotEqualTo> {
+        template<typename T1, typename T2>
         static bool evaluate( T1 const& lhs, T2 const& rhs ) {
             return bool(removeConst(lhs) != removeConst(rhs) );
         }
+        template<typename T>
+        static bool evaluate( int lhs, T* rhs) {
+            return reinterpret_cast<void const*>( lhs ) !=  rhs;
+        }
+        template<typename T>
+        static bool evaluate( T* lhs, int rhs) {
+            return lhs != reinterpret_cast<void const*>( rhs );
+        }
     };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsLessThan> {
+    template<>
+    struct Evaluator<IsLessThan> {
+        template<typename T1, typename T2>
         static bool evaluate( T1 const& lhs, T2 const& rhs ) {
             return bool(removeConst(lhs) < removeConst(rhs) );
         }
     };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsGreaterThan> {
+    template<>
+    struct Evaluator<IsGreaterThan> {
+        template<typename T1, typename T2>
         static bool evaluate( T1 const& lhs, T2 const& rhs ) {
             return bool(removeConst(lhs) > removeConst(rhs) );
         }
     };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
+    template<>
+    struct Evaluator<IsGreaterThanOrEqualTo> {
+        template<typename T1, typename T2>
         static bool evaluate( T1 const& lhs, T2 const& rhs ) {
             return bool(removeConst(lhs) >= removeConst(rhs) );
         }
     };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
+    template<>
+    struct Evaluator<IsLessThanOrEqualTo> {
+        template<typename T1, typename T2>
         static bool evaluate( T1 const& lhs, T2 const& rhs ) {
             return bool(removeConst(lhs) <= removeConst(rhs) );
         }
     };
 
-    // Special case for comparing a pointer to an int (deduced for p==0)
-    template<typename T>
-    struct Evaluator<int const&, T* const&, IsEqualTo> {
-        static bool evaluate( int lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) ==  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, int const&, IsEqualTo> {
-        static bool evaluate( T* lhs, int rhs) {
-            return lhs == reinterpret_cast<void const*>( rhs );
-        }
-    };
-    template<typename T>
-    struct Evaluator<int const&, T* const&, IsNotEqualTo> {
-        static bool evaluate( int lhs, T* rhs) {
-            return reinterpret_cast<void const*>( lhs ) !=  rhs;
-        }
-    };
-    template<typename T>
-    struct Evaluator<T* const&, int const&, IsNotEqualTo> {
-        static bool evaluate( T* lhs, int rhs) {
-            return lhs != reinterpret_cast<void const*>( rhs );
-        }
-    };
-
 } // end of namespace Internal
 } // end of namespace Catch
 
diff --git a/include/internal/catch_expression_lhs.hpp b/include/internal/catch_expression_lhs.hpp
index 35675aee..08625019 100644
--- a/include/internal/catch_expression_lhs.hpp
+++ b/include/internal/catch_expression_lhs.hpp
@@ -113,7 +113,7 @@ public:
 
     void endExpression() const {
         m_rb
-            .setResultType(  Internal::Evaluator<LhsT, RhsT, Op>::evaluate( m_lhs, m_rhs ) )
+            .setResultType(  Internal::Evaluator<Op>::evaluate( m_lhs, m_rhs ) )
             .endExpression( *this );
     }