Replace boost::variant with std::variant in sdf

pxr/usd/sdf/namespaceEdit.cpp

@@ -31,10 +31,10 @@
 #include "pxr/base/tf/stringUtils.h"
 
 #include <boost/ptr_container/ptr_set.hpp>
-#include <boost/variant.hpp>
 
 #include <memory>
 #include <ostream>
+#include <variant>
 
 PXR_NAMESPACE_OPEN_SCOPE
 
@@ -91,7 +91,7 @@ class SdfNamespaceEdit_Namespace {
     // A key for a _Node.  _RootKey is for the root, SdfPath is for attribute
     // connections and relationship targets, and TfToken for prim and property
     // children.
-    typedef boost::variant<_RootKey, TfToken, SdfPath> _Key;
+    using _Key = std::variant<_RootKey, TfToken, SdfPath>;
 
     struct _TargetKey {
         _TargetKey(const SdfPath& path) : key(path) { }
@@ -161,7 +161,7 @@ class SdfNamespaceEdit_Namespace {
         // Test if the node was removed.  This returns true for key nodes.
         bool IsRemoved() const
         {
-            return !_parent && _key.which() != 0;
+            return !_parent && _key.index() != 0;
         }
 
         // Remove the node from its parent.  After this call returns \c true
@@ -567,7 +567,7 @@ SdfNamespaceEdit_Namespace::_FixBackpointers(
     for (_BackpointerMap::iterator j = i; j != n; ++j) {
         for (auto node : j->second) {
             node->SetKey(
-                boost::get<SdfPath>(node->GetKey()).
+                std::get<SdfPath>(node->GetKey()).
                     ReplacePrefix(currentPath, newPath, !fixTargetPaths));
         }
     }

pxr/usd/sdf/parserHelpers.h

@@ -31,12 +31,13 @@
 #include "pxr/base/vt/value.h"
 
 #include <boost/numeric/conversion/cast.hpp>
-#include <boost/variant.hpp>
+#include <boost/variant/get.hpp>
 
 #include <functional>
 #include <limits>
 #include <string>
 #include <type_traits>
+#include <variant>
 #include <vector>
 
 PXR_NAMESPACE_OPEN_SCOPE
@@ -46,8 +47,8 @@ bool Sdf_BoolFromString(const std::string &, bool *parseOk);
 namespace Sdf_ParserHelpers {
 
 // Internal variant type.
-typedef boost::variant<uint64_t, int64_t, double,
-                       std::string, TfToken, SdfAssetPath> _Variant;
+using _Variant = std::variant<uint64_t, int64_t, double,
+                              std::string, TfToken, SdfAssetPath>;
 
 ////////////////////////////////////////////////////////////////////////
 // Utilities that implement the Sdf_ParserHelpers::Value::Get<T>() method.  The
@@ -61,7 +62,7 @@ struct _GetImpl
 {
     typedef const T &ResultType;
     static const T &Visit(_Variant const &variant) {
-        return boost::get<T>(variant);
+        return std::get<T>(variant);
     }
 };
 
@@ -72,12 +73,11 @@ struct _GetImpl
 template <class T>
 struct _GetImpl<
     T, std::enable_if_t<std::is_integral<T>::value>>
-    : public boost::static_visitor<T>
 {
     typedef T ResultType;
 
     T Visit(_Variant const &variant) {
-        return boost::apply_visitor(*this, variant);
+        return std::visit(*this, variant);
     }
 
     // Fallback case: throw bad_get.
@@ -114,12 +114,11 @@ struct _GetImpl<
 template <class T>
 struct _GetImpl<
     T, std::enable_if_t<std::is_floating_point<T>::value>>
-    : public boost::static_visitor<T>
 {
     typedef T ResultType;
 
     T Visit(_Variant const &variant) {
-        return boost::apply_visitor(*this, variant);
+        return std::visit(*this, variant);
     }
 
     // Fallback case: throw bad_get.
@@ -167,22 +166,22 @@ struct _GetImpl<SdfAssetPath>
     typedef SdfAssetPath ResultType;
 
     SdfAssetPath Visit(_Variant const &variant) {
-        if (std::string const *str = boost::get<std::string>(&variant))
+        if (std::string const *str = std::get_if<std::string>(&variant))
             return SdfAssetPath(*str);
-        return boost::get<SdfAssetPath>(variant);
+        return std::get<SdfAssetPath>(variant);
     }
 };
 
 // Get a bool.  Numbers are considered true if nonzero, false otherwise.
 // Strings and tokens get parsed via Sdf_BoolFromString.  Otherwise throw
 // bad_get.
 template <>
-struct _GetImpl<bool> : public boost::static_visitor<bool>
+struct _GetImpl<bool>
 {
     typedef bool ResultType;
 
     bool Visit(_Variant const &variant) {
-        return boost::apply_visitor(*this, variant);
+        return std::visit(*this, variant);
     }
 
     // Parse string via Sdf_BoolFromString.
@@ -270,33 +269,37 @@ struct Value
     // boost::bad_get.
     template <class T>
     typename _GetImpl<T>::ResultType Get() const {
-        return _GetImpl<T>().Visit(_variant);
+        try {
+            return _GetImpl<T>().Visit(_variant);
+        } catch (std::bad_variant_access& e) {
+            throw boost::bad_get();
+        }
     }
 
     // Hopefully short-lived API that applies an external visitor to the held
     // variant type.
     template <class Visitor>
-    typename Visitor::result_type
+    auto
     ApplyVisitor(const Visitor &visitor) {
-        return boost::apply_visitor(visitor, _variant);
+        return std::visit(visitor, _variant);
     }
 
     template <class Visitor>
-    typename Visitor::result_type
+    auto
     ApplyVisitor(Visitor &visitor) {
-        return boost::apply_visitor(visitor, _variant);
+        return std::visit(visitor, _variant);
     }
 
     template <class Visitor>
-    typename Visitor::result_type
+    auto
     ApplyVisitor(const Visitor &visitor) const {
-        return _variant.apply_visitor(visitor);
+        return std::visit(visitor, _variant);
     }
 
     template <class Visitor>
-    typename Visitor::result_type
+    auto
     ApplyVisitor(Visitor &visitor) const {
-        return _variant.apply_visitor(visitor);
+        return std::visit(visitor, _variant);
     }
 
 private:

pxr/usd/sdf/parserValueContext.cpp

@@ -30,7 +30,7 @@
 
 PXR_NAMESPACE_OPEN_SCOPE
 
-struct Sdf_ToStringVisitor : boost::static_visitor<std::string>
+struct Sdf_ToStringVisitor
 {
     template <typename T>
     std::string operator () (const T &value)