operators: add simple ue2::totally_ordered class

CMakeLists.txt

@@ -1003,6 +1003,7 @@ SET (hs_SRCS
     src/util/math.h
     src/util/multibit_build.cpp
     src/util/multibit_build.h
+    src/util/operators.h
     src/util/order_check.h
     src/util/partial_store.h
     src/util/partitioned_set.h

src/util/operators.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2017, Intel Corporation
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of Intel Corporation nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * \brief Ordered operators: provides all the other compare operators for types
+ * that provide equal and less-than.
+ *
+ * This is similar to Boost's totally_ordered class, but much simpler and
+ * without injecting the boost namespace into ADL lookup.
+ */
+
+#ifndef UTIL_OPERATORS_H
+#define UTIL_OPERATORS_H
+
+namespace ue2 {
+
+/**
+ * \brief Ordered operators: provides all the other compare operators for types
+ * that provide equal and less-than.
+ *
+ * Simply inherit from this class with your class name as its template
+ * parameter.
+ */
+template<typename T>
+class totally_ordered {
+public:
+    friend bool operator!=(const T &a, const T &b) { return !(a == b); }
+    friend bool operator<=(const T &a, const T &b) { return !(b < a); }
+    friend bool operator>(const T &a, const T &b) { return b < a; }
+    friend bool operator>=(const T &a, const T &b) { return !(a < b); }
+};
+
+} // namespace
+
+#endif // UTIL_OPERATORS_H

src/util/ue2_containers.h

@@ -30,6 +30,7 @@
 #define UTIL_UE2_CONTAINERS_H_
 
 #include "ue2common.h"
+#include "util/operators.h"
 #include "util/small_vector.h"
 
 #include <algorithm>
@@ -39,7 +40,6 @@
 
 #include <boost/functional/hash/hash_fwd.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/operators.hpp>
 #include <boost/unordered/unordered_map.hpp>
 #include <boost/unordered/unordered_set.hpp>
 
@@ -159,7 +159,7 @@ template <class T, class Compare = std::less<T>,
           class Allocator = std::allocator<T>>
 class flat_set
     : public flat_detail::flat_base<T, Compare, Allocator>,
-      public boost::totally_ordered<flat_set<T, Compare, Allocator>> {
+      public totally_ordered<flat_set<T, Compare, Allocator>> {
     using base_type = flat_detail::flat_base<T, Compare, Allocator>;
     using storage_type = typename base_type::storage_type;
     using base_type::data;
@@ -324,7 +324,7 @@ public:
         return comp();
     }
 
-    // Operators. All others provided by boost::totally_ordered.
+    // Operators. All others provided by ue2::totally_ordered.
 
     bool operator==(const flat_set &a) const {
         return data() == a.data();
@@ -362,7 +362,7 @@ template <class Key, class T, class Compare = std::less<Key>,
           class Allocator = std::allocator<std::pair<Key, T>>>
 class flat_map
     : public flat_detail::flat_base<std::pair<Key, T>, Compare, Allocator>,
-      public boost::totally_ordered<flat_map<Key, T, Compare, Allocator>> {
+      public totally_ordered<flat_map<Key, T, Compare, Allocator>> {
 public:
     // Member types.
     using key_type = Key;
@@ -590,7 +590,7 @@ public:
         return value_compare(comp());
     }
 
-    // Operators. All others provided by boost::totally_ordered.
+    // Operators. All others provided by ue2::totally_ordered.
 
     bool operator==(const flat_map &a) const {
         return data() == a.data();

src/util/ue2_graph.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, Intel Corporation
+ * Copyright (c) 2016-2017, Intel Corporation
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
@@ -31,8 +31,8 @@
 
 #include "ue2common.h"
 #include "util/graph_range.h"
+#include "util/operators.h"
 
-#include <boost/operators.hpp>
 #include <boost/functional/hash.hpp>
 #include <boost/graph/properties.hpp> /* vertex_index_t, ... */
 #include <boost/pending/property.hpp> /* no_property */
@@ -292,7 +292,7 @@ public:
     using vertex_bundled = VertexPropertyType;
     using edge_bundled = EdgePropertyType;
 
-    class vertex_descriptor : boost::totally_ordered<vertex_descriptor> {
+    class vertex_descriptor : totally_ordered<vertex_descriptor> {
     public:
         vertex_descriptor() : p(nullptr), serial(0) { }
         explicit vertex_descriptor(vertex_node *pp)
@@ -324,7 +324,7 @@ public:
         friend ue2_graph;
     };
 
-    class edge_descriptor : boost::totally_ordered<edge_descriptor> {
+    class edge_descriptor : totally_ordered<edge_descriptor> {
     public:
         edge_descriptor() : p(nullptr), serial(0) { }
         explicit edge_descriptor(edge_node *pp) : p(pp), serial(pp->serial) { }