Replace boost::equality_comparable with explicit implementation of operator!= in pxr/usd/sdf

pxr/usd/sdf/allowed.h

@@ -32,7 +32,6 @@
 
 #include <string>
 #include <utility>
-#include <boost/operators.hpp>
 #include <boost/optional.hpp>
 
 PXR_NAMESPACE_OPEN_SCOPE
@@ -44,7 +43,7 @@ PXR_NAMESPACE_OPEN_SCOPE
 /// A \c SdfAllowed either evaluates to \c true in a boolean context
 /// or evaluates to \c false and has a string annotation.
 ///
-class SdfAllowed : private boost::equality_comparable<SdfAllowed> {
+class SdfAllowed {
 private:
     typedef boost::optional<std::string> _State;
 
@@ -113,6 +112,11 @@ class SdfAllowed : private boost::equality_comparable<SdfAllowed> {
         return _state == other._state;
     }
 
+    bool operator!=(const SdfAllowed& other) const
+    {
+        return !(*this == other);
+    }
+
 private:
     _State _state;
 };

pxr/usd/sdf/childrenProxy.h

@@ -35,15 +35,14 @@
 
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
-#include <boost/operators.hpp>
 #include <iterator>
 #include <map>
 #include <utility>
 
 PXR_NAMESPACE_OPEN_SCOPE
 
 template <class _View>
-class SdfChildrenProxy : boost::equality_comparable<SdfChildrenProxy<_View> > {
+class SdfChildrenProxy {
 public:
     typedef _View View;
     typedef typename View::Adapter Adapter;
@@ -353,6 +352,11 @@ class SdfChildrenProxy : boost::equality_comparable<SdfChildrenProxy<_View> > {
         return _view == other._view;
     }
 
+    bool operator!=(const This& other) const
+    {
+        return !(*this == other);
+    }
+
     /// Explicit bool conversion operator. The proxy object converts to 
     /// \c true if it is valid, \c false otherwise.
     explicit operator bool() const

pxr/usd/sdf/namespaceEdit.cpp

@@ -665,6 +665,12 @@ SdfNamespaceEdit::operator==(const SdfNamespaceEdit& rhs) const
            index       == rhs.index;
 }
 
+bool
+SdfNamespaceEdit::operator!=(const SdfNamespaceEdit& rhs) const
+{
+    return !(*this == rhs);
+}
+
 std::ostream&
 operator<<(std::ostream& s, const SdfNamespaceEdit& x)
 {
@@ -715,6 +721,12 @@ SdfNamespaceEditDetail::operator==(const SdfNamespaceEditDetail& rhs) const
            reason == rhs.reason;
 }
 
+bool
+SdfNamespaceEditDetail::operator!=(const SdfNamespaceEditDetail& rhs) const
+{
+    return !(*this == rhs);
+}
+
 std::ostream&
 operator<<(std::ostream& s, const SdfNamespaceEditDetail& x)
 {

pxr/usd/sdf/namespaceEdit.h

@@ -30,8 +30,6 @@
 #include "pxr/usd/sdf/api.h"
 #include "pxr/usd/sdf/path.h"
 
-#include <boost/operators.hpp>
-
 #include <functional>
 #include <iosfwd>
 #include <string>
@@ -44,8 +42,7 @@ PXR_NAMESPACE_OPEN_SCOPE
 /// A single namespace edit.  It supports renaming, reparenting, reparenting
 /// with a rename, reordering, and removal.
 ///
-struct SdfNamespaceEdit :
-    boost::equality_comparable<SdfNamespaceEdit> {
+struct SdfNamespaceEdit {
 public:
     typedef SdfNamespaceEdit This;
     typedef SdfPath Path;
@@ -114,6 +111,7 @@ struct SdfNamespaceEdit :
     }
 
     SDF_API bool operator==(const This& rhs) const;
+    SDF_API bool operator!=(const This& rhs) const;
 
 public:
     Path currentPath;   ///< Path of the object when this edit starts.
@@ -131,8 +129,7 @@ SDF_API std::ostream& operator<<(std::ostream&, const SdfNamespaceEditVector&);
 ///
 /// Detailed information about a namespace edit.
 ///
-struct SdfNamespaceEditDetail :
-    boost::equality_comparable<SdfNamespaceEditDetail> {
+struct SdfNamespaceEditDetail {
 public:
     /// Validity of an edit.
     enum Result {
@@ -146,6 +143,7 @@ struct SdfNamespaceEditDetail :
                            const std::string& reason);
 
     SDF_API bool operator==(const SdfNamespaceEditDetail& rhs) const;
+    SDF_API bool operator!=(const SdfNamespaceEditDetail& rhs) const;
 
 public:
     Result result;          ///< Validity.

pxr/usd/sdf/testenv/testSdfBatchNamespaceEdit.py

@@ -31,6 +31,35 @@
 #verbose = True
 
 class TestSdfBatchNamespaceEdit(unittest.TestCase):
+    def test_EqualityOperators(self):
+        self.assertEqual(Sdf.NamespaceEdit('/A', '/B'), Sdf.NamespaceEdit('/A', '/B'))
+        self.assertNotEqual(Sdf.NamespaceEdit('/B', '/A'), Sdf.NamespaceEdit('/A', '/B'))
+
+        # Validate the equality operators by varying a single field from a prototype edit
+        # at a time
+        prototype = Sdf.NamespaceEditDetail(
+            Sdf.NamespaceEditDetail.Okay,
+            Sdf.NamespaceEdit('/A', '/B'),
+            "reason"
+        )
+        self.assertEqual(prototype, Sdf.NamespaceEditDetail(
+            prototype.result,
+            prototype.edit,
+            prototype.reason))
+        self.assertNotEqual(prototype, Sdf.NamespaceEditDetail(
+            Sdf.NamespaceEditDetail.Unbatched,
+            prototype.edit,
+            prototype.reason))
+        self.assertNotEqual(prototype, Sdf.NamespaceEditDetail(
+            prototype.result,
+            Sdf.NamespaceEdit('/C', '/D'),
+            prototype.reason))
+        self.assertNotEqual(prototype, Sdf.NamespaceEditDetail(
+            prototype.result,
+            prototype.edit,
+            "a different reason"))
+
+
     def test_Basic(self):
         print('Test constructors')
 

pxr/usd/sdf/testenv/testSdfTypes.py

@@ -380,6 +380,12 @@ def _TestValueTypeName(attrPath, expectedValueTypeName):
 
     def test_Hash(self):
         self.assertEqual(hash(Sdf.ValueTypeNames.Point3d), hash(Sdf.ValueTypeNames.Point3d))
-
+
+    def test_UnregisteredValueEquality(self):
+        self.assertEqual(Sdf.UnregisteredValue(str(5)),
+                         Sdf.UnregisteredValue(str(5)))
+        self.assertNotEqual(Sdf.UnregisteredValue(str(5)),
+                            Sdf.UnregisteredValue(str(6)))
+
 if __name__ == "__main__":
     unittest.main()

pxr/usd/sdf/types.cpp

@@ -756,6 +756,11 @@ bool SdfUnregisteredValue::operator==(const SdfUnregisteredValue &other) const
     return _value == other._value;
 }
 
+bool SdfUnregisteredValue::operator!=(const SdfUnregisteredValue &other) const
+{
+    return !(*this == other);
+}
+
 std::ostream &operator << (std::ostream &out, const SdfUnregisteredValue &value)
 {
     return out << value.GetValue();

pxr/usd/sdf/types.h

@@ -484,8 +484,7 @@ std::ostream &VtStreamOut(const SdfVariantSelectionMap &, std::ostream &);
 /// well as limited inspection and editing capabilities (e.g., moving
 /// this data to a different spec or field) even when the data type
 /// of the value isn't known.
-class SdfUnregisteredValue : 
-    public boost::equality_comparable<SdfUnregisteredValue>
+class SdfUnregisteredValue
 {
 public:
     /// Wraps an empty VtValue
@@ -513,6 +512,9 @@ class SdfUnregisteredValue :
     /// Returns true if the wrapped VtValues are equal
     SDF_API bool operator==(const SdfUnregisteredValue &other) const;
 
+    /// Returns true if the wrapped VtValues are not equal
+    SDF_API bool operator!=(const SdfUnregisteredValue &other) const;
+
 private:
     VtValue _value;
 };