Move some compile-time dispatch to runtime

The runtime performance is likely to be negligible,
but compile times need every improvement they can get.

CMakeLists.txt

@@ -204,6 +204,7 @@ set(IMPL_SOURCES
         ${HEADER_DIR}/internal/catch_context.cpp
         ${HEADER_DIR}/internal/catch_debugger.cpp
         ${HEADER_DIR}/internal/catch_errno_guard.cpp
+        ${HEADER_DIR}/internal/catch_evaluate.cpp
         ${HEADER_DIR}/internal/catch_exception_translator_registry.cpp
         ${HEADER_DIR}/internal/catch_fatal_condition.cpp
         ${HEADER_DIR}/internal/catch_list.cpp

include/internal/catch_evaluate.cpp

@@ -0,0 +1,38 @@
+/*
+ *  Created by Martin on 01/08/2017.
+ *
+ *  Distributed under the Boost Software License, Version 1.0. (See accompanying
+ *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#include "catch_evaluate.hpp"
+
+#include "catch_enforce.h"
+
+namespace Catch {
+namespace Internal {
+
+    const char* operatorName(Operator op) {
+        switch (op) {
+            case IsEqualTo:
+                return "==";
+            case IsNotEqualTo:
+                return "!=";
+            case IsLessThan:
+                return "<";
+            case IsGreaterThan:
+                return ">";
+            case IsLessThanOrEqualTo:
+                return "<=";
+            case IsGreaterThanOrEqualTo:
+                return ">=";
+            default:
+                CATCH_ERROR("Attempting to translate unknown operator!");
+        }
+    }
+
+    // nullptr_t support based on pull request #154 from Konstantin Baumann
+    std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+
+} // end of namespace Internal
+} // end of namespace Catch

include/internal/catch_evaluate.hpp

@@ -28,19 +28,11 @@ namespace Internal {
         IsGreaterThanOrEqualTo
     };
 
-    template<Operator Op> struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
-    template<> struct OperatorTraits<IsEqualTo>             { static const char* getName(){ return "=="; } };
-    template<> struct OperatorTraits<IsNotEqualTo>          { static const char* getName(){ return "!="; } };
-    template<> struct OperatorTraits<IsLessThan>            { static const char* getName(){ return "<"; } };
-    template<> struct OperatorTraits<IsGreaterThan>         { static const char* getName(){ return ">"; } };
-    template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
-    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
+    const char* operatorName(Operator op);
 
     template<typename T>
     T& opCast(T const& t) { return const_cast<T&>(t); }
-
-    // nullptr_t support based on pull request #154 from Konstantin Baumann
-    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
+    std::nullptr_t opCast(std::nullptr_t);
 
 
     // So the compare overloads can be operator agnostic we convey the operator as a template

include/internal/catch_expression_lhs.hpp

@@ -134,7 +134,7 @@ public:
                    // 1 for negation (conditionally added later)
         dest = lhs;
         dest += delim;
-        dest += Internal::OperatorTraits<Op>::getName();
+        dest += Internal::operatorName(Op);
         dest += delim;
         dest += rhs;
     }