comparator: add comparator for indexed compound types

compares each index of the two parameters in sequence, returning true if
the first parameter has the first value that compares less than the
second.

CMakeLists.txt

@@ -451,6 +451,7 @@ if (TESTS)
         bitwise
         cmdopt
         colour
+        comparator
         coord
         crypto/arc4
         crypto/ice

test/comparator.cpp

@@ -0,0 +1,24 @@
+#include "tap.hpp"
+
+#include "types/comparator.hpp"
+
+int
+main (int, char**)
+{
+    util::TAP::logger tap;
+
+    const auto a = { 1, 2, 3 };
+    const auto b = { 1, 2, 4 };
+
+    tap.expect (
+        util::comparator::indexed<decltype(a)> ()(a, b),
+        "compare initializer_list as a coordinate, success"
+    );
+
+    tap.expect (
+        !util::comparator::indexed<decltype(a)> ()(b, a),
+        "compare initializer_list as a coordinate, failure"
+    );
+
+    return tap.status ();
+}

types/comparator.hpp

@@ -11,7 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2012 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #ifndef __UTIL_TYPES_COMPARATOR_HPP
@@ -19,14 +19,41 @@
 
 #include <memory>
 
-namespace util {
+#include "./iterator.hpp"
+
+namespace util::comparator {
     template <typename T>
     struct pointer_comparator {
         bool operator() (const std::unique_ptr<T> &lhs, const std::unique_ptr<T> &rhs);
         bool operator() (const T                  *lhs, const std::unique_ptr<T> &rhs);
         bool operator() (const std::unique_ptr<T> &lhs, const T                  *rhs);
     };
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    /// Provides a comparison interface for types exposing an index operator.
+    ///
+    /// Will return true if the first parameter has the first index that
+    /// compares less than the second parameter. Useful for providing a total
+    /// order of coordinate types where this doesn't make sense by default.
+    ///
+    /// \tparam T The container data type to compare. Must provide an index
+    /// operator.
+    template <typename T>
+    struct indexed {
+        constexpr
+        bool operator() (const T &a, const T &b)
+        {
+            for (auto x: util::zip (a, b)) {
+                const auto &[i,j] = x; // clang-4.0: workaround for segfault.
+                if (i  < j) return true;
+                if (i != j) return false;
             }
 
-#include "util/types/comparator.ipp"
+            return false;
+        }
+    };
+}
+
+#include "./comparator.ipp"
 #endif

types/comparator.ipp

@@ -11,7 +11,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
- * Copyright 2012 Danny Robson <danny@nerdcruft.net>
+ * Copyright 2012-2017 Danny Robson <danny@nerdcruft.net>
  */
 
 #ifdef __UTIL_TYPES_COMPARATOR_IPP
@@ -22,7 +22,7 @@
 
 
 //-----------------------------------------------------------------------------
-namespace util {
+namespace util::comparator {
     template <typename T>
     bool
     pointer_comparator<T>::operator() (const std::unique_ptr<T> &lhs,