Replace BOOST_PP_SEQ with TF_PP_SEQ in vt and tf

pxr/base/tf/pyStaticTokens.h

@@ -95,10 +95,10 @@ class _TfPyWrapStaticToken {
     _TF_TOKENS_EXPAND_ARRAY_ELEMENTS(seq)
 
 // Private macros to wrap a single element in a sequence.
-#define _TF_PY_TOKENS_WRAP_ELEMENT(r, key, elem)                            \
+#define _TF_PY_TOKENS_WRAP_ELEMENT(key, elem)                               \
     _TF_PY_TOKENS_WRAP_MEMBER(r, key, _TF_PY_TOKEN_GET_ELEM(elem))
 
-#define _TF_PY_TOKENS_WRAP_ATTR_ELEMENT(r, key, elem)                       \
+#define _TF_PY_TOKENS_WRAP_ATTR_ELEMENT(key, elem)                          \
     _TF_PY_TOKENS_WRAP_ATTR_MEMBER(r, key, _TF_PY_TOKEN_GET_ELEM(elem))
 
 #define _TF_PY_TOKEN_GET_ELEM(elem)                                         \
@@ -107,10 +107,10 @@ class _TfPyWrapStaticToken {
 
 // Private macros to wrap a sequence.
 #define _TF_PY_TOKENS_WRAP_SEQ(key, seq)                                    \
-    BOOST_PP_SEQ_FOR_EACH(_TF_PY_TOKENS_WRAP_ELEMENT, key, seq)
+    TF_PP_SEQ_FOR_EACH(_TF_PY_TOKENS_WRAP_ELEMENT, key, seq)
 
 #define _TF_PY_TOKENS_WRAP_ATTR_SEQ(key, seq)                               \
-    BOOST_PP_SEQ_FOR_EACH(_TF_PY_TOKENS_WRAP_ATTR_ELEMENT, key, seq)
+    TF_PP_SEQ_FOR_EACH(_TF_PY_TOKENS_WRAP_ATTR_ELEMENT, key, seq)
 
 PXR_NAMESPACE_CLOSE_SCOPE
 

pxr/base/tf/staticTokens.h

@@ -148,14 +148,14 @@ PXR_NAMESPACE_OPEN_SCOPE
 // Private macro used to generate TfToken member variables.  elem can either
 // be a tuple on the form (name, value) or just a name.
 //
-#define _TF_TOKENS_DECLARE_MEMBER(r, unused, elem)                          \
+#define _TF_TOKENS_DECLARE_MEMBER(unused, elem)                             \
     TfToken _TF_PP_IFF(TF_PP_IS_TUPLE(elem),                                \
         TF_PP_TUPLE_ELEM(0, elem), elem){                                   \
             _TF_PP_IFF(TF_PP_IS_TUPLE(elem),                                \
                 TF_PP_TUPLE_ELEM(1, elem), TF_PP_STRINGIZE(elem)),          \
             TfToken::Immortal};
 #define _TF_TOKENS_DECLARE_TOKEN_MEMBERS(seq)                               \
-    BOOST_PP_SEQ_FOR_EACH(_TF_TOKENS_DECLARE_MEMBER, ~, seq)
+    TF_PP_SEQ_FOR_EACH(_TF_TOKENS_DECLARE_MEMBER, ~, seq)
 
 #define _TF_TOKENS_FORWARD_ARRAY(elem) TF_PP_TUPLE_ELEM(0, elem),
 #define _TF_TOKENS_DECLARE_ARRAY_MEMBER_IMPL(identifier, ...)               \
@@ -168,10 +168,10 @@ PXR_NAMESPACE_OPEN_SCOPE
 #define _TF_TOKENS_DECLARE_ARRAY_MEMBERS(seq)                               \
     BOOST_PP_SEQ_FOR_EACH(_TF_TOKENS_DECLARE_ARRAY_MEMBER, ~, seq)
 
-#define _TF_TOKENS_FORWARD_TOKEN(r, unused, elem) TF_PP_TUPLE_ELEM(0, elem),
+#define _TF_TOKENS_FORWARD_TOKEN(unused, elem) TF_PP_TUPLE_ELEM(0, elem),
 #define _TF_TOKENS_DECLARE_ALL_TOKENS(seq)                                  \
     std::vector<TfToken> allTokens =                                        \
-        {BOOST_PP_SEQ_FOR_EACH(_TF_TOKENS_FORWARD_TOKEN, ~, seq)};
+        {TF_PP_SEQ_FOR_EACH(_TF_TOKENS_FORWARD_TOKEN, ~, seq)};
 
 // Private macro used to declare the list of members as TfTokens
 //

pxr/base/vt/array.cpp

@@ -26,6 +26,7 @@
 #include "pxr/base/vt/array.h"
 #include "pxr/base/vt/typeHeaders.h"
 #include "pxr/base/tf/envSetting.h"
+#include "pxr/base/tf/preprocessorUtilsLite.h"
 #include "pxr/base/tf/stackTrace.h"
 #include "pxr/base/tf/stringUtils.h"
 
@@ -46,9 +47,9 @@ Vt_ArrayBase::_DetachCopyHook(char const *funcName) const
 }
 
 // Instantiate basic array templates.
-#define VT_ARRAY_EXPLICIT_INST(r, unused, elem) \
+#define VT_ARRAY_EXPLICIT_INST(unused, elem) \
     template class VT_API VtArray< VT_TYPE(elem) >;
-BOOST_PP_SEQ_FOR_EACH(VT_ARRAY_EXPLICIT_INST, ~, VT_SCALAR_VALUE_TYPES)
+TF_PP_SEQ_FOR_EACH(VT_ARRAY_EXPLICIT_INST, ~, VT_SCALAR_VALUE_TYPES)
 
 
 PXR_NAMESPACE_CLOSE_SCOPE

pxr/base/vt/array.h

@@ -37,6 +37,7 @@
 #include "pxr/base/arch/pragmas.h"
 #include "pxr/base/tf/diagnostic.h"
 #include "pxr/base/tf/mallocTag.h"
+#include "pxr/base/tf/preprocessorUtilsLite.h"
 
 #include <algorithm>
 #include <atomic>
@@ -932,9 +933,9 @@ class VtArray : public Vt_ArrayBase {
 
 // Declare basic array instantiations as extern templates.  They are explicitly
 // instantiated in array.cpp.
-#define VT_ARRAY_EXTERN_TMPL(r, unused, elem) \
+#define VT_ARRAY_EXTERN_TMPL(unused, elem) \
     VT_API_TEMPLATE_CLASS(VtArray< VT_TYPE(elem) >);
-BOOST_PP_SEQ_FOR_EACH(VT_ARRAY_EXTERN_TMPL, ~, VT_SCALAR_VALUE_TYPES)
+TF_PP_SEQ_FOR_EACH(VT_ARRAY_EXTERN_TMPL, ~, VT_SCALAR_VALUE_TYPES)
 
 template <class HashState, class ELEM>
 inline std::enable_if_t<VtIsHashable<ELEM>()>

pxr/base/vt/arrayPyBuffer.cpp

@@ -37,7 +37,6 @@
 #include "pxr/base/tf/pyLock.h"
 #include "pxr/base/tf/pyUtils.h"
 
-#include <boost/preprocessor.hpp>
 #include <boost/python.hpp>
 
 #include <numeric>
@@ -547,17 +546,17 @@ VtArrayFromPyBuffer(TfPyObjWrapper const &obj, std::string *err)
     return result;
 }
 
-#define INSTANTIATE(r, unused, elem)                                       \
+#define INSTANTIATE(unused, elem)                                          \
 template boost::optional<VtArray<VT_TYPE(elem)> >                          \
 VtArrayFromPyBuffer<VT_TYPE(elem)>(TfPyObjWrapper const &obj, string *err);
-BOOST_PP_SEQ_FOR_EACH(INSTANTIATE, ~, VT_ARRAY_PYBUFFER_TYPES)
+TF_PP_SEQ_FOR_EACH(INSTANTIATE, ~, VT_ARRAY_PYBUFFER_TYPES)
 #undef INSTANTIATE
 
 VT_API void Vt_AddBufferProtocolSupportToVtArrays()
 {
 
 // Add the buffer protocol support to every array type that we support it for.
-#define VT_ADD_BUFFER_PROTOCOL(r, unused, elem)                      \
+#define VT_ADD_BUFFER_PROTOCOL(unused, elem)                         \
     Vt_AddBufferProtocol<VtArray<VT_TYPE(elem)> >();                 \
     VtValue::RegisterCast<TfPyObjWrapper, VtArray<VT_TYPE(elem)> >(  \
         Vt_CastPyObjToArray<VT_TYPE(elem)>);                         \
@@ -567,7 +566,7 @@ VT_API void Vt_AddBufferProtocolSupportToVtArrays()
                         "ArrayFromBuffer",                           \
                         Vt_WrapArrayFromBuffer<VT_TYPE(elem)>);
 
-BOOST_PP_SEQ_FOR_EACH(VT_ADD_BUFFER_PROTOCOL, ~, VT_ARRAY_PYBUFFER_TYPES)
+TF_PP_SEQ_FOR_EACH(VT_ADD_BUFFER_PROTOCOL, ~, VT_ARRAY_PYBUFFER_TYPES)
 
 #undef VT_ADD_BUFFER_PROTOCOL
 }

pxr/base/vt/testenv/testVtCpp.cpp

@@ -63,6 +63,7 @@
 #include "pxr/base/tf/stopwatch.h"
 #include "pxr/base/tf/token.h"
 #include "pxr/base/tf/enum.h"
+#include "pxr/base/tf/preprocessorUtilsLite.h"
 #include "pxr/base/tf/stringUtils.h"
 #include "pxr/base/tf/type.h"
 #include "pxr/base/tf/fileUtils.h"
@@ -1524,7 +1525,7 @@ static void testValue() {
         m.Clear();
     }
 
-#define _VT_TEST_ZERO_VALUE(r, unused, elem)                            \
+#define _VT_TEST_ZERO_VALUE(unused, elem)                               \
     {                                                                   \
         VtValue empty;                                                  \
         TfErrorMark m;                                                  \
@@ -1533,8 +1534,7 @@ static void testValue() {
         m.Clear();                                                      \
     }
 
-    BOOST_PP_SEQ_FOR_EACH(_VT_TEST_ZERO_VALUE,
-        unused, 
+    TF_PP_SEQ_FOR_EACH(_VT_TEST_ZERO_VALUE, ~,
         VT_VEC_VALUE_TYPES
         VT_MATRIX_VALUE_TYPES
         VT_QUATERNION_VALUE_TYPES

pxr/base/vt/types.cpp

@@ -29,12 +29,11 @@
 #include "pxr/base/vt/array.h"
 #include "pxr/base/vt/value.h"
 
+#include "pxr/base/tf/preprocessorUtilsLite.h"
 #include "pxr/base/tf/type.h"
 
 #include <algorithm>
 
-#include <boost/preprocessor/seq/for_each.hpp>
-
 PXR_NAMESPACE_OPEN_SCOPE
 
 // The following preprocessor code generates specializations for free functions
@@ -46,37 +45,37 @@ PXR_NAMESPACE_OPEN_SCOPE
 // VtZero<double>()
 // VtZero<GfVec3d>()
 // etc.
-#define VT_ZERO_0_CONSTRUCTOR(r, unused, elem)      \
+#define VT_ZERO_0_CONSTRUCTOR(unused, elem)         \
 template<>                                          \
 VT_API VT_TYPE(elem) VtZero() {                     \
     return (VT_TYPE(elem))(0);                      \
 }
-#define VT_ZERO_0FLOAT_CONSTRUCTOR(r, unused, elem) \
+#define VT_ZERO_0FLOAT_CONSTRUCTOR(unused, elem)    \
 template<>                                          \
 VT_API VT_TYPE(elem) VtZero() {                     \
     return VT_TYPE(elem)(0.0f);                     \
 }
-#define VT_ZERO_0DOUBLE_CONSTRUCTOR(r, unused, elem)\
+#define VT_ZERO_0DOUBLE_CONSTRUCTOR(unused, elem)   \
 template<>                                          \
 VT_API VT_TYPE(elem) VtZero() {                     \
     return VT_TYPE(elem)(0.0);                      \
 }
-#define VT_ZERO_EMPTY_CONSTRUCTOR(r, unused, elem)  \
+#define VT_ZERO_EMPTY_CONSTRUCTOR(unused, elem)     \
 template<>                                          \
 VT_API VT_TYPE(elem) VtZero() {                     \
     return VT_TYPE(elem)() ;                        \
 }
 
-BOOST_PP_SEQ_FOR_EACH(VT_ZERO_0_CONSTRUCTOR , ~,    \
+TF_PP_SEQ_FOR_EACH(VT_ZERO_0_CONSTRUCTOR , ~,       \
     VT_BUILTIN_NUMERIC_VALUE_TYPES                  \
     VT_VEC_VALUE_TYPES                              \
     VT_QUATERNION_VALUE_TYPES                       \
     VT_DUALQUATERNION_VALUE_TYPES)
-BOOST_PP_SEQ_FOR_EACH(VT_ZERO_0FLOAT_CONSTRUCTOR , ~, \
+TF_PP_SEQ_FOR_EACH(VT_ZERO_0FLOAT_CONSTRUCTOR , ~,  \
     VT_MATRIX_FLOAT_VALUE_TYPES)
-BOOST_PP_SEQ_FOR_EACH(VT_ZERO_0DOUBLE_CONSTRUCTOR , ~, \
+TF_PP_SEQ_FOR_EACH(VT_ZERO_0DOUBLE_CONSTRUCTOR , ~, \
     VT_MATRIX_DOUBLE_VALUE_TYPES)
-BOOST_PP_SEQ_FOR_EACH(VT_ZERO_EMPTY_CONSTRUCTOR, ~, \
+TF_PP_SEQ_FOR_EACH(VT_ZERO_EMPTY_CONSTRUCTOR, ~,    \
     VT_RANGE_VALUE_TYPES                            \
     VT_STRING_VALUE_TYPES                           \
     VT_NONARRAY_VALUE_TYPES)
@@ -87,10 +86,10 @@ TF_REGISTRY_FUNCTION(TfType)
     // The following preprocessor code instantiates TfTypes for VtArray holding
     // various scalar value types.
 
-#   define _INSTANTIATE_ARRAY(r, unused, elem) \
+#   define _INSTANTIATE_ARRAY(unused, elem) \
         TfType::Define< VtArray<VT_TYPE(elem)> >();
 
-    BOOST_PP_SEQ_FOR_EACH(_INSTANTIATE_ARRAY, ~, VT_SCALAR_VALUE_TYPES)
+    TF_PP_SEQ_FOR_EACH(_INSTANTIATE_ARRAY, ~, VT_SCALAR_VALUE_TYPES)
 }
 
 // Floating point conversions... in future, we might hope to use SSE here.

pxr/base/vt/types.h

@@ -36,7 +36,6 @@
 #include "pxr/base/tf/preprocessorUtilsLite.h"
 #include "pxr/base/tf/token.h"
 
-#include <boost/preprocessor/seq/for_each.hpp>
 #include <boost/preprocessor/seq/for_each_i.hpp>
 
 #include <cstddef>
@@ -170,18 +169,18 @@ VT_SCALAR_CLASS_VALUE_TYPES VT_BUILTIN_VALUE_TYPES
 // typedef VtArray<int> VtIntArray;
 // typedef VtArray<double> VtDoubleArray;
 template<typename T> class VtArray;
-#define VT_ARRAY_TYPEDEF(r, unused, elem) \
+#define VT_ARRAY_TYPEDEF(unused, elem) \
 typedef VtArray< VT_TYPE(elem) > \
 TF_PP_CAT(Vt, TF_PP_CAT(VT_TYPE_NAME(elem), Array)) ;
-BOOST_PP_SEQ_FOR_EACH(VT_ARRAY_TYPEDEF, ~, VT_SCALAR_VALUE_TYPES)
+TF_PP_SEQ_FOR_EACH(VT_ARRAY_TYPEDEF, ~, VT_SCALAR_VALUE_TYPES)
 
 // The following preprocessor code generates the boost pp sequence for
 // all array value types (VT_ARRAY_VALUE_TYPES)
-#define VT_ARRAY_TYPE_TUPLE(r, unused, elem) \
+#define VT_ARRAY_TYPE_TUPLE(unused, elem) \
 (( TF_PP_CAT(Vt, TF_PP_CAT(VT_TYPE_NAME(elem), Array)) , \
    TF_PP_CAT(VT_TYPE_NAME(elem), Array) ))
 #define VT_ARRAY_VALUE_TYPES \
-BOOST_PP_SEQ_FOR_EACH(VT_ARRAY_TYPE_TUPLE, ~, VT_SCALAR_VALUE_TYPES)
+TF_PP_SEQ_FOR_EACH(VT_ARRAY_TYPE_TUPLE, ~, VT_SCALAR_VALUE_TYPES)
 
 #define VT_CLASS_VALUE_TYPES \
 VT_ARRAY_VALUE_TYPES VT_SCALAR_CLASS_VALUE_TYPES VT_NONARRAY_VALUE_TYPES
@@ -215,7 +214,7 @@ BOOST_PP_SEQ_FOR_EACH_I(VT_SET_VALUE_TYPE_INDEX, ~, VT_VALUE_TYPES)
 // Total number of 'known' value types.
 constexpr int
 VtGetNumKnownValueTypes() {
-    return BOOST_PP_SEQ_SIZE(VT_VALUE_TYPES);
+    return TF_PP_SEQ_SIZE(VT_VALUE_TYPES);
 }
 
 /// Provide compile-time value type indexes for types that are "known" to Vt --
@@ -259,14 +258,14 @@ struct VtIsKnownValueType_Workaround
 // None of the VT_VALUE_TYPES are value proxies.  We want to specialize these
 // templates here, since otherwise the VtIsTypedValueProxy will require a
 // complete type to check if it derives VtTypedValueProxyBase.
-#define VT_SPECIALIZE_IS_VALUE_PROXY(r, unused, elem)                          \
+#define VT_SPECIALIZE_IS_VALUE_PROXY(unused, elem)                             \
     template <> struct                                                         \
     VtIsValueProxy< VT_TYPE(elem) > : std::false_type {};                      \
     template <> struct                                                         \
     VtIsTypedValueProxy< VT_TYPE(elem) > : std::false_type {};                 \
     template <> struct                                                         \
     VtIsErasedValueProxy< VT_TYPE(elem) > : std::false_type {};
-BOOST_PP_SEQ_FOR_EACH(VT_SPECIALIZE_IS_VALUE_PROXY, ~, VT_VALUE_TYPES)
+TF_PP_SEQ_FOR_EACH(VT_SPECIALIZE_IS_VALUE_PROXY, ~, VT_VALUE_TYPES)
 #undef VT_SPECIALIZE_IS_VALUE_PROXY
 
 // Free functions to represent "zero" for various base types.  See

pxr/base/vt/value.cpp

@@ -33,11 +33,11 @@
 #include "pxr/base/tf/instantiateSingleton.h"
 #include "pxr/base/tf/iterator.h"
 #include "pxr/base/tf/mallocTag.h"
+#include "pxr/base/tf/preprocessorUtilsLite.h"
 #include "pxr/base/tf/singleton.h"
 #include "pxr/base/tf/staticData.h"
 #include "pxr/base/tf/token.h"
 
-#include <boost/preprocessor.hpp>
 #include <boost/numeric/conversion/cast.hpp>
 #include <tbb/spin_mutex.h>
 #include <tbb/concurrent_unordered_map.h>
@@ -576,19 +576,19 @@ VtStreamOut(vector<VtValue> const &val, std::ostream &stream) {
     return stream;
 }    
 
-#define _VT_IMPLEMENT_ZERO_VALUE_FACTORY(r, unused, elem)                \
+#define _VT_IMPLEMENT_ZERO_VALUE_FACTORY(unused, elem)                   \
 template <>                                                              \
 Vt_DefaultValueHolder Vt_DefaultValueFactory<VT_TYPE(elem)>::Invoke()    \
 {                                                                        \
     return Vt_DefaultValueHolder::Create(VtZero<VT_TYPE(elem)>());       \
 }                                                                        \
 template struct Vt_DefaultValueFactory<VT_TYPE(elem)>;
 
-BOOST_PP_SEQ_FOR_EACH(_VT_IMPLEMENT_ZERO_VALUE_FACTORY,
-                      unused,
-                      VT_VEC_VALUE_TYPES
-                      VT_MATRIX_VALUE_TYPES
-                      VT_QUATERNION_VALUE_TYPES
-                      VT_DUALQUATERNION_VALUE_TYPES)
+TF_PP_SEQ_FOR_EACH(_VT_IMPLEMENT_ZERO_VALUE_FACTORY,
+                   ~,
+                   VT_VEC_VALUE_TYPES
+                   VT_MATRIX_VALUE_TYPES
+                   VT_QUATERNION_VALUE_TYPES
+                   VT_DUALQUATERNION_VALUE_TYPES)
 
 PXR_NAMESPACE_CLOSE_SCOPE

pxr/base/vt/value.h

@@ -37,6 +37,7 @@
 #include "pxr/base/arch/pragmas.h"
 #include "pxr/base/tf/anyUniquePtr.h"
 #include "pxr/base/tf/pointerAndBits.h"
+#include "pxr/base/tf/preprocessorUtilsLite.h"
 #include "pxr/base/tf/safeTypeCompare.h"
 #include "pxr/base/tf/stringUtils.h"
 #include "pxr/base/tf/tf.h"
@@ -1536,16 +1537,15 @@ Vt_DefaultValueFactory<T>::Invoke() {
 // to construct zeroed out vectors, matrices, and quaternions by
 // explicitly instantiating the factory for these types. 
 //
-#define _VT_DECLARE_ZERO_VALUE_FACTORY(r, unused, elem)                 \
+#define _VT_DECLARE_ZERO_VALUE_FACTORY(unused, elem)                    \
 template <>                                                             \
 VT_API Vt_DefaultValueHolder Vt_DefaultValueFactory<VT_TYPE(elem)>::Invoke();
 
-BOOST_PP_SEQ_FOR_EACH(_VT_DECLARE_ZERO_VALUE_FACTORY,
-                      unused,
-                      VT_VEC_VALUE_TYPES
-                      VT_MATRIX_VALUE_TYPES
-                      VT_QUATERNION_VALUE_TYPES
-                      VT_DUALQUATERNION_VALUE_TYPES)
+TF_PP_SEQ_FOR_EACH(_VT_DECLARE_ZERO_VALUE_FACTORY, ~,
+                   VT_VEC_VALUE_TYPES
+                   VT_MATRIX_VALUE_TYPES
+                   VT_QUATERNION_VALUE_TYPES
+                   VT_DUALQUATERNION_VALUE_TYPES)
 
 #undef _VT_DECLARE_ZERO_VALUE_FACTORY
 

pxr/base/vt/wrapArray.cpp

@@ -34,12 +34,12 @@ namespace Vt_WrapArray {
 // GetVtArrayName (declared above) for each VtArray type.  The function bodies
 // simply return the "common name" for the VtArray.  For instance,
 // GetVtArrayName<VtArray<int> >() -> "VtIntArray".
-#define MAKE_NAME_FUNC(r, unused, elem) \
+#define MAKE_NAME_FUNC(unused, elem) \
 template <> \
 VT_API string GetVtArrayName< VT_TYPE(elem) >() { \
     return TF_PP_STRINGIZE(VT_TYPE_NAME(elem)); \
 }
-BOOST_PP_SEQ_FOR_EACH(MAKE_NAME_FUNC, ~, VT_ARRAY_VALUE_TYPES)
+TF_PP_SEQ_FOR_EACH(MAKE_NAME_FUNC, ~, VT_ARRAY_VALUE_TYPES)
 #undef MAKE_NAME_FUNC
 
 }

pxr/base/vt/wrapArray.h

@@ -52,7 +52,6 @@
 
 #include <boost/preprocessor/punctuation/comma_if.hpp>
 #include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
 
 #include <boost/python/class.hpp>
 #include <boost/python/copy_const_reference.hpp>
@@ -642,9 +641,9 @@ void VtRegisterValueCastsFromPythonSequencesToArray()
     VtValue::RegisterCast<std::vector<VtValue>, Array>(Vt_CastToArray<Array>);
 }
 
-#define VT_WRAP_ARRAY(r, unused, elem)          \
+#define VT_WRAP_ARRAY(unused, elem)          \
     VtWrapArray< VtArray< VT_TYPE(elem) > >();
-#define VT_WRAP_COMPARISON(r, unused, elem)        \
+#define VT_WRAP_COMPARISON(unused, elem)        \
     VtWrapComparisonFunctions< VtArray< VT_TYPE(elem) > >();
 
 PXR_NAMESPACE_CLOSE_SCOPE