24#ifndef PXR_USD_SDF_PATH_H
25#define PXR_USD_SDF_PATH_H
28#include "pxr/usd/sdf/api.h"
29#include "pxr/usd/sdf/pool.h"
30#include "pxr/usd/sdf/tokens.h"
31#include "pxr/base/arch/defines.h"
36#include <boost/intrusive_ptr.hpp>
46PXR_NAMESPACE_OPEN_SCOPE
56typedef boost::intrusive_ptr<const Sdf_PathNode> Sdf_PathNodeConstRefPtr;
58void intrusive_ptr_add_ref(Sdf_PathNode
const *);
59void intrusive_ptr_release(Sdf_PathNode
const *);
62struct Sdf_PathPrimTag;
63struct Sdf_PathPropTag;
66static constexpr size_t Sdf_SizeofPrimPathNode =
sizeof(
void *) * 3;
67static constexpr size_t Sdf_SizeofPropPathNode =
sizeof(
void *) * 3;
69using Sdf_PathPrimPartPool = Sdf_Pool<
70 Sdf_PathPrimTag, Sdf_SizeofPrimPathNode, 8>;
72using Sdf_PathPropPartPool = Sdf_Pool<
73 Sdf_PathPropTag, Sdf_SizeofPropPathNode, 8>;
75using Sdf_PathPrimHandle = Sdf_PathPrimPartPool::Handle;
76using Sdf_PathPropHandle = Sdf_PathPropPartPool::Handle;
79template <
class Handle,
bool Counted,
class PathNode=Sdf_PathNode const>
80struct Sdf_PathNodeHandleImpl {
82 typedef Sdf_PathNodeHandleImpl this_type;
85 static constexpr bool IsCounted = Counted;
87 constexpr Sdf_PathNodeHandleImpl() noexcept {};
90 Sdf_PathNodeHandleImpl(Sdf_PathNode
const *p,
bool add_ref =
true)
91 : _poolHandle(Handle::GetHandle(reinterpret_cast<char const *>(p))) {
98 Sdf_PathNodeHandleImpl(Handle h,
bool add_ref =
true)
105 Sdf_PathNodeHandleImpl(Sdf_PathNodeHandleImpl
const &rhs) noexcept
106 : _poolHandle(rhs._poolHandle) {
112 ~Sdf_PathNodeHandleImpl() {
118 Sdf_PathNodeHandleImpl &
119 operator=(Sdf_PathNodeHandleImpl
const &rhs) {
120 if (Counted && *
this == rhs) {
123 this_type(rhs).swap(*
this);
127 Sdf_PathNodeHandleImpl(Sdf_PathNodeHandleImpl &&rhs) noexcept
128 : _poolHandle(rhs._poolHandle) {
129 rhs._poolHandle =
nullptr;
132 Sdf_PathNodeHandleImpl &
133 operator=(Sdf_PathNodeHandleImpl &&rhs)
noexcept {
134 this_type(std::move(rhs)).swap(*
this);
138 Sdf_PathNodeHandleImpl &
139 operator=(Sdf_PathNode
const *rhs)
noexcept {
140 this_type(rhs).swap(*
this);
144 void reset() noexcept {
145 _poolHandle = Handle {
nullptr };
148 inline Sdf_PathNode
const *
149 get() const noexcept {
150 return reinterpret_cast<Sdf_PathNode *
>(_poolHandle.GetPtr());
163 explicit operator bool() const noexcept {
164 return static_cast<bool>(_poolHandle);
167 void swap(Sdf_PathNodeHandleImpl &rhs)
noexcept {
168 _poolHandle.swap(rhs._poolHandle);
171 inline bool operator==(Sdf_PathNodeHandleImpl
const &rhs)
const noexcept {
172 return _poolHandle == rhs._poolHandle;
174 inline bool operator!=(Sdf_PathNodeHandleImpl
const &rhs)
const noexcept {
175 return _poolHandle != rhs._poolHandle;
177 inline bool operator<(Sdf_PathNodeHandleImpl
const &rhs)
const noexcept {
178 return _poolHandle < rhs._poolHandle;
182 inline void _AddRef(Sdf_PathNode
const *p)
const {
184 intrusive_ptr_add_ref(p);
188 inline void _AddRef()
const {
192 inline void _DecRef()
const {
194 intrusive_ptr_release(get());
198 Handle _poolHandle {
nullptr };
201using Sdf_PathPrimNodeHandle =
202 Sdf_PathNodeHandleImpl<Sdf_PathPrimHandle,
true>;
204using Sdf_PathPropNodeHandle =
205 Sdf_PathNodeHandleImpl<Sdf_PathPropHandle,
false>;
209typedef std::set<class SdfPath> SdfPathSet;
211typedef std::vector<class SdfPath> SdfPathVector;
214VT_TYPE_IS_CHEAP_TO_COPY(
class SdfPath);
308#if defined(ARCH_COMPILER_GCC) && ARCH_COMPILER_GCC_MAJOR <= 6
312 memset(
this, 0,
sizeof(*
this));
334 SDF_API
explicit SdfPath(
const std::string &path);
397 return static_cast<bool>(_propPart);
515 SDF_API
void GetPrefixes(SdfPathVector *prefixes,
size_t numPrefixes)
const;
705 const std::string &variant)
const;
769 bool fixTargetPaths=
true)
const;
791 std::pair<SdfPath, SdfPath>
793 bool stopAtRootPrim =
false)
const;
860 const std::string &rhs);
890 static std::pair<std::string, bool>
892 const std::string &matchNamespace);
900 std::string *errMsg = 0);
909 return _AsInt() == rhs._AsInt();
914 return !(*
this == rhs);
922 if (_AsInt() == rhs._AsInt()) {
925 if (!_primPart || !rhs._primPart) {
926 return !_primPart && rhs._primPart;
929 return _LessThanInternal(*
this, rhs);
941 return !(rhs < *
this);
947 return !(*
this < rhs);
950 template <
class HashState>
951 friend void TfHashAppend(HashState &h,
SdfPath const &path) {
954 uint32_t primPart, propPart;
955 memcpy(&primPart, &path._primPart,
sizeof(primPart));
956 memcpy(&propPart, &path._propPart,
sizeof(propPart));
963 inline size_t operator()(
const SdfPath& path)
const {
968 inline size_t GetHash()
const {
969 return Hash()(*this);
974 struct FastLessThan {
975 inline bool operator()(
const SdfPath& a,
const SdfPath& b)
const {
976 return a._AsInt() < b._AsInt();
991 SDF_API
static SdfPathVector
1012 explicit SdfPath(Sdf_PathPrimNodeHandle &&primNode)
1013 : _primPart(
std::move(primNode)) {}
1015 SdfPath(Sdf_PathPrimNodeHandle &&primPart,
1016 Sdf_PathPropNodeHandle &&propPart)
1017 : _primPart(
std::move(primPart))
1018 , _propPart(
std::move(propPart)) {}
1021 SdfPath(Sdf_PathPrimNodeHandle
const &primPart,
1022 Sdf_PathPropNodeHandle
const &propPart)
1023 : _primPart(primPart)
1024 , _propPart(propPart) {}
1027 SdfPath(Sdf_PathNode
const *primPart,
1028 Sdf_PathNode
const *propPart)
1029 : _primPart(primPart)
1030 , _propPart(propPart) {}
1032 friend class Sdf_PathNode;
1033 friend class Sdfext_PathAccess;
1038 _ElementsToString(
bool absolute,
const std::vector<std::string> &elements);
1041 SdfPath const &newPrefix)
const;
1044 SdfPath const &newPrefix)
const;
1048 bool fixTargetPaths)
const;
1054 inline uint64_t _AsInt()
const {
1055 static_assert(
sizeof(*this) ==
sizeof(uint64_t),
"");
1057 std::memcpy(&ret,
this,
sizeof(*
this));
1062 lhs._primPart.swap(rhs._primPart);
1063 lhs._propPart.swap(rhs._propPart);
1066 SDF_API
friend char const *
1067 Sdf_PathGetDebuggerPathText(
SdfPath const &);
1069 Sdf_PathPrimNodeHandle _primPart;
1070 Sdf_PathPropNodeHandle _propPart;
1098 const SdfPath& GetPath()
const {
return _path; }
1101 using iterator_category = std::forward_iterator_tag;
1103 using difference_type = std::ptrdiff_t;
1104 using reference =
const SdfPath&;
1105 using pointer =
const SdfPath*;
1107 iterator(
const SdfPath& path) : _path(path) {}
1109 iterator() =
default;
1112 iterator& operator++();
1114 const SdfPath& operator*()
const {
return _path; }
1116 const SdfPath* operator->()
const {
return &_path; }
1118 bool operator==(
const iterator& o)
const {
return _path == o._path; }
1120 bool operator!=(
const iterator& o)
const {
return _path != o._path; }
1125 SDF_API
friend difference_type
1126 distance(
const iterator& first,
const iterator& last);
1132 iterator begin()
const {
return iterator(_path); }
1134 iterator end()
const {
return iterator(); }
1142inline size_t hash_value(
SdfPath const &path)
1144 return path.GetHash();
1152struct Sdf_PathIdentity {
1164template <
class ForwardIterator,
class GetPathFn = Sdf_PathIdentity>
1165std::pair<ForwardIterator, ForwardIterator>
1166SdfPathFindPrefixedRange(ForwardIterator begin, ForwardIterator end,
1168 GetPathFn
const &getPath = GetPathFn()) {
1170 typename std::iterator_traits<ForwardIterator>::reference;
1173 Compare(GetPathFn
const &getPath) : _getPath(getPath) {}
1174 GetPathFn
const &_getPath;
1175 bool operator()(IterRef a,
SdfPath const &b)
const {
1176 return _getPath(a) < b;
1180 std::pair<ForwardIterator, ForwardIterator> result;
1183 result.first = std::lower_bound(begin, end, prefix, Compare(getPath));
1187 result.second = TfFindBoundary(result.first, end,
1188 [&prefix, &getPath](IterRef iterRef) {
1189 return getPath(iterRef).HasPrefix(prefix);
1195template <
class RandomAccessIterator,
class GetPathFn>
1197Sdf_PathFindLongestPrefixImpl(RandomAccessIterator begin,
1198 RandomAccessIterator end,
1201 GetPathFn
const &getPath)
1204 typename std::iterator_traits<RandomAccessIterator>::reference;
1207 Compare(GetPathFn
const &getPath) : _getPath(getPath) {}
1208 GetPathFn
const &_getPath;
1209 bool operator()(IterRef a,
SdfPath const &b)
const {
1210 return _getPath(a) < b;
1223 Compare comp(getPath);
1226 RandomAccessIterator result = std::lower_bound(begin, end, path, comp);
1230 if (!strictPrefix && result != end && getPath(*result) == path) {
1236 if (result == begin) {
1241 if (path.
HasPrefix(getPath(*--result))) {
1251 result = std::lower_bound(begin, end, newPath, comp);
1253 if (result != end && getPath(*result) == newPath) {
1256 if (result == begin) {
1259 if (newPath.
HasPrefix(getPath(*--result))) {
1273template <
class RandomAccessIterator,
class GetPathFn = Sdf_PathIdentity,
1274 class =
typename std::enable_if<
1276 std::random_access_iterator_tag,
1277 typename std::iterator_traits<
1278 RandomAccessIterator>::iterator_category
1283SdfPathFindLongestPrefix(RandomAccessIterator begin,
1284 RandomAccessIterator end,
1286 GetPathFn
const &getPath = GetPathFn())
1288 return Sdf_PathFindLongestPrefixImpl(
1289 begin, end, path,
false, getPath);
1299template <
class RandomAccessIterator,
class GetPathFn = Sdf_PathIdentity,
1300 class =
typename std::enable_if<
1302 std::random_access_iterator_tag,
1303 typename std::iterator_traits<
1304 RandomAccessIterator>::iterator_category
1309SdfPathFindLongestStrictPrefix(RandomAccessIterator begin,
1310 RandomAccessIterator end,
1312 GetPathFn
const &getPath = GetPathFn())
1314 return Sdf_PathFindLongestPrefixImpl(
1315 begin, end, path,
true, getPath);
1318template <
class Iter,
class MapParam,
class GetPathFn = Sdf_PathIdentity>
1320Sdf_PathFindLongestPrefixImpl(
1321 MapParam map,
SdfPath const &path,
bool strictPrefix,
1322 GetPathFn
const &getPath = GetPathFn())
1329 const Iter mapEnd = map.end();
1336 Iter result = map.lower_bound(path);
1340 if (!strictPrefix && result != mapEnd && getPath(*result) == path)
1345 if (result == map.begin())
1356 return Sdf_PathFindLongestPrefixImpl<Iter, MapParam>(
1365typename std::set<SdfPath>::const_iterator
1366SdfPathFindLongestPrefix(std::set<SdfPath>
const &set,
SdfPath const &path);
1372typename std::map<SdfPath, T>::const_iterator
1373SdfPathFindLongestPrefix(std::map<SdfPath, T>
const &map,
SdfPath const &path)
1375 return Sdf_PathFindLongestPrefixImpl<
1376 typename std::map<SdfPath, T>::const_iterator,
1377 std::map<SdfPath, T>
const &>(map, path,
false,
1381typename std::map<SdfPath, T>::iterator
1382SdfPathFindLongestPrefix(std::map<SdfPath, T> &map,
SdfPath const &path)
1384 return Sdf_PathFindLongestPrefixImpl<
1385 typename std::map<SdfPath, T>::iterator,
1386 std::map<SdfPath, T> &>(map, path,
false,
1394typename std::set<SdfPath>::const_iterator
1395SdfPathFindLongestStrictPrefix(std::set<SdfPath>
const &set,
1402typename std::map<SdfPath, T>::const_iterator
1403SdfPathFindLongestStrictPrefix(
1404 std::map<SdfPath, T>
const &map,
SdfPath const &path)
1406 return Sdf_PathFindLongestPrefixImpl<
1407 typename std::map<SdfPath, T>::const_iterator,
1408 std::map<SdfPath, T>
const &>(map, path,
true,
1412typename std::map<SdfPath, T>::iterator
1413SdfPathFindLongestStrictPrefix(
1414 std::map<SdfPath, T> &map,
SdfPath const &path)
1416 return Sdf_PathFindLongestPrefixImpl<
1417 typename std::map<SdfPath, T>::iterator,
1418 std::map<SdfPath, T> &>(map, path,
true,
1429Sdf_PathGetDebuggerPathText(
SdfPath const &);
1431PXR_NAMESPACE_CLOSE_SCOPE
1436#include "pxr/usd/sdf/pathNode.h"
1438PXR_NAMESPACE_OPEN_SCOPE
1440static_assert(Sdf_SizeofPrimPathNode ==
sizeof(Sdf_PrimPathNode),
"");
1441static_assert(Sdf_SizeofPropPathNode ==
sizeof(Sdf_PrimPropertyPathNode),
"");
1443PXR_NAMESPACE_CLOSE_SCOPE
Range representing a path and ancestors, and providing methods for iterating over them.
A path value used to locate objects in layers or scenegraphs.
SDF_API SdfPath(const std::string &path)
Creates a path from the given string.
SDF_API SdfPath MakeAbsolutePath(const SdfPath &anchor) const
Returns the absolute form of this path using anchor as the relative basis.
SDF_API SdfPath GetParentPath() const
Return the path that identifies this path's namespace parent.
SDF_API const std::string & GetString() const
Return the string representation of this path as a std::string.
SDF_API bool IsPrimVariantSelectionPath() const
Returns whether the path identifies a variant selection for a prim.
static SDF_API std::string JoinIdentifier(const TfTokenVector &names)
Join names into a single identifier using the namespace delimiter.
static SDF_API bool IsValidIdentifier(const std::string &name)
Returns whether name is a legal identifier for any path component.
SDF_API SdfPath ReplaceTargetPath(const SdfPath &newTargetPath) const
Replaces the relational attribute's target path.
SDF_API void GetAllTargetPathsRecursively(SdfPathVector *result) const
Returns all the relationship target or connection target paths contained in this path,...
SDF_API SdfPath GetPrimOrPrimVariantSelectionPath() const
Creates a path by stripping all relational attributes, targets, and properties, leaving the nearest p...
SDF_API std::pair< SdfPath, SdfPath > RemoveCommonSuffix(const SdfPath &otherPath, bool stopAtRootPrim=false) const
Find and remove the longest common suffix from two paths.
SDF_API SdfPath AppendElementString(const std::string &element) const
Creates a path by extracting and appending an element from the given ascii element encoding.
SDF_API bool IsMapperArgPath() const
Returns whether the path identifies a connection mapper arg.
SDF_API bool IsRelationalAttributePath() const
Returns whether the path identifies a relational attribute.
static SDF_API TfToken StripNamespace(const TfToken &name)
Returns name stripped of any namespaces.
SDF_API bool IsAbsoluteRootOrPrimPath() const
Returns whether the path identifies a prim or the absolute root.
static SDF_API const SdfPath & AbsoluteRootPath()
The absolute path representing the top of the namespace hierarchy.
SDF_API const char * GetText() const
Returns the string representation of this path as a c string.
static SDF_API SdfPathVector GetConciseRelativePaths(const SdfPathVector &paths)
Given some vector of paths, get a vector of concise unambiguous relative paths.
SDF_API std::pair< std::string, std::string > GetVariantSelection() const
Returns the variant selection for this path, if this is a variant selection path.
bool operator<=(const SdfPath &rhs) const
Less than or equal operator.
SDF_API SdfPath AppendExpression() const
Creates a path by appending an expression element.
SDF_API SdfPath AppendRelationalAttribute(TfToken const &attrName) const
Creates a path by appending an element for attrName to this path.
SDF_API std::string GetElementString() const
Returns an ascii representation of the "terminal" element of this path, which can be used to reconstr...
bool IsEmpty() const noexcept
Returns true if this is the empty path (SdfPath::EmptyPath()).
SDF_API bool IsAbsolutePath() const
Returns whether the path is absolute.
SDF_API SdfPath GetAbsoluteRootOrPrimPath() const
Creates a path by stripping all properties and relational attributes from this path,...
SDF_API SdfPath AppendPath(const SdfPath &newSuffix) const
Creates a path by appending a given relative path to this path.
SDF_API SdfPath MakeRelativePath(const SdfPath &anchor) const
Returns the relative form of this path using anchor as the relative basis.
static SDF_API const SdfPath & ReflexiveRelativePath()
The relative path representing "self".
bool operator>(const SdfPath &rhs) const
Greater than operator.
static SDF_API std::string JoinIdentifier(const std::string &lhs, const std::string &rhs)
Join lhs and rhs into a single identifier using the namespace delimiter.
static SDF_API std::vector< std::string > TokenizeIdentifier(const std::string &name)
Tokenizes name by the namespace delimiter.
SDF_API bool IsPropertyPath() const
Returns whether the path identifies a property.
SDF_API SdfPath AppendMapper(const SdfPath &targetPath) const
Creates a path by appending a mapper element for targetPath.
SDF_API SdfPath AppendElementToken(const TfToken &elementTok) const
Like AppendElementString() but take the element as a TfToken.
SDF_API bool HasPrefix(const SdfPath &prefix) const
Return true if both this path and prefix are not the empty path and this path has prefix as a prefix.
static SDF_API std::string JoinIdentifier(const std::vector< std::string > &names)
Join names into a single identifier using the namespace delimiter.
SDF_API bool IsTargetPath() const
Returns whether the path identifies a relationship or connection target.
SDF_API size_t GetPathElementCount() const
Returns the number of path elements in this path.
SDF_API TfToken GetElementToken() const
Like GetElementString() but return the value as a TfToken.
static SDF_API const SdfPath & EmptyPath()
The empty path value, equivalent to SdfPath().
SDF_API const std::string & GetName() const
Returns the name of the prim, property or relational attribute identified by the path.
SDF_API TfToken GetAsToken() const
Return the string representation of this path as a TfToken.
SDF_API const SdfPath & GetTargetPath() const
Returns the relational attribute or mapper target path for this path.
SDF_API SdfPathVector GetPrefixes() const
Returns the prefix paths of this path.
static SDF_API std::string StripNamespace(const std::string &name)
Returns name stripped of any namespaces.
SDF_API void GetPrefixes(SdfPathVector *prefixes, size_t numPrefixes) const
Fill prefixes with up to numPrefixes prefixes of this path.
static SDF_API TfTokenVector TokenizeIdentifierAsTokens(const std::string &name)
Tokenizes name by the namespace delimiter.
SDF_API bool IsRootPrimPath() const
Returns whether the path identifies a root prim.
static SDF_API bool IsValidNamespacedIdentifier(const std::string &name)
Returns whether name is a legal namespaced identifier.
SDF_API const TfToken & GetNameToken() const
Returns the name of the prim, property or relational attribute identified by the path,...
SDF_API bool IsPrimPath() const
Returns whether the path identifies a prim.
static SDF_API std::pair< std::string, bool > StripPrefixNamespace(const std::string &name, const std::string &matchNamespace)
Returns (name, true) where name is stripped of the prefix specified by matchNamespace if name indeed ...
SDF_API SdfPath AppendVariantSelection(const std::string &variantSet, const std::string &variant) const
Creates a path by appending an element for variantSet and variant to this path.
SDF_API SdfPath AppendProperty(TfToken const &propName) const
Creates a path by appending an element for propName to this path.
SDF_API bool IsExpressionPath() const
Returns whether the path identifies a connection expression.
SDF_API bool IsNamespacedPropertyPath() const
Returns whether the path identifies a namespaced property.
SDF_API SdfPath AppendMapperArg(TfToken const &argName) const
Creates a path by appending an element for argName.
SDF_API TfToken const & GetToken() const
Return the string representation of this path as a TfToken lvalue.
bool operator<(const SdfPath &rhs) const
Comparison operator.
bool operator>=(const SdfPath &rhs) const
Greater than or equal operator.
SDF_API SdfPath AppendChild(TfToken const &childName) const
Creates a path by appending an element for childName to this path.
bool ContainsPropertyElements() const
Return true if this path contains any property elements, false otherwise.
SDF_API bool IsMapperPath() const
Returns whether the path identifies a connection mapper.
static SDF_API void RemoveDescendentPaths(SdfPathVector *paths)
Remove all elements of paths that are prefixed by other elements in paths.
SDF_API SdfPath GetCommonPrefix(const SdfPath &path) const
Returns a path with maximal length that is a prefix path of both this path and path.
static SDF_API std::string JoinIdentifier(const TfToken &lhs, const TfToken &rhs)
Join lhs and rhs into a single identifier using the namespace delimiter.
static SDF_API bool IsValidPathString(const std::string &pathString, std::string *errMsg=0)
Return true if pathString is a valid path string, meaning that passing the string to the SdfPath cons...
SDF_API SdfPath ReplacePrefix(const SdfPath &oldPrefix, const SdfPath &newPrefix, bool fixTargetPaths=true) const
Returns a path with all occurrences of the prefix path oldPrefix replaced with the prefix path newPre...
SDF_API bool IsAbsoluteRootPath() const
Return true if this path is the AbsoluteRootPath().
bool operator==(const SdfPath &rhs) const
Equality operator.
SDF_API SdfPathAncestorsRange GetAncestorsRange() const
Return a range for iterating over the ancestors of this path.
SDF_API bool ContainsPrimVariantSelection() const
Returns whether the path or any of its parent paths identifies a variant selection for a prim.
SDF_API bool IsPrimPropertyPath() const
Returns whether the path identifies a prim's property.
SDF_API SdfPath StripAllVariantSelections() const
Create a path by stripping all variant selections from all components of this path,...
SDF_API bool ContainsTargetPath() const
Return true if this path is or has a prefix that's a target path or a mapper path.
SDF_API SdfPath ReplaceName(TfToken const &newName) const
Return a copy of this path with its final component changed to newName.
SDF_API void GetPrefixes(SdfPathVector *prefixes) const
Fills prefixes with prefixes of this path.
SDF_API bool IsPrimOrPrimVariantSelectionPath() const
Return true if this path is a prim path or is a prim variant selection path.
SDF_API SdfPath AppendTarget(const SdfPath &targetPath) const
Creates a path by appending an element for targetPath.
SdfPath() noexcept=default
Constructs the default, empty path.
SDF_API SdfPathVector GetPrefixes(size_t numPrefixes) const
Return up to numPrefixes prefix paths of this path.
SDF_API SdfPath GetPrimPath() const
Creates a path by stripping all relational attributes, targets, properties, and variant selections fr...
static SDF_API void RemoveAncestorPaths(SdfPathVector *paths)
Remove all elements of paths that prefix other elements in paths.
bool operator!=(const SdfPath &rhs) const
Inequality operator.
SDF_API std::string GetAsString() const
Return the string representation of this path as a std::string.
Function object for retrieving the N'th element of a std::pair or std::tuple.
A user-extensible hashing mechanism for use with runtime hash tables.
Token for efficient comparison, assignment, and hashing of known strings.
GF_API std::ostream & operator<<(std::ostream &, const GfBBox3d &)
Output a GfBBox3d using the format [(range) matrix zeroArea].
TfToken class for efficient string referencing and hashing, plus conversions to and from stl string c...
std::vector< TfToken > TfTokenVector
Convenience types.