All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
node.h
1//
2// Copyright 2016 Pixar
3//
4// Licensed under the terms set forth in the LICENSE.txt file available at
5// https://openusd.org/license.
6//
7#ifndef PXR_USD_PCP_NODE_H
8#define PXR_USD_PCP_NODE_H
9
10#include "pxr/pxr.h"
11#include "pxr/usd/pcp/api.h"
12#include "pxr/usd/pcp/types.h"
13#include "pxr/usd/sdf/types.h"
15#include "pxr/base/tf/hashset.h"
16
17PXR_NAMESPACE_OPEN_SCOPE
18
19class PcpArc;
22class PcpNodeRef;
23class PcpNodeRef_ChildrenIterator;
24class PcpNodeRef_ChildrenReverseIterator;
25class PcpErrorBase;
26typedef std::shared_ptr<PcpErrorBase> PcpErrorBasePtr;
27
28TF_DECLARE_REF_PTRS(PcpPrimIndex_Graph);
29
47{
48public:
49 typedef PcpNodeRef_ChildrenIterator child_const_iterator;
50 typedef PcpNodeRef_ChildrenReverseIterator child_const_reverse_iterator;
51 typedef std::pair<child_const_iterator,
52 child_const_iterator> child_const_range;
53 typedef std::pair<child_const_reverse_iterator,
54 child_const_reverse_iterator> child_const_reverse_range;
55
56 PcpNodeRef() : _graph(0), _nodeIdx(PCP_INVALID_INDEX) {}
57
60
63 inline operator UnspecifiedBoolType() const {
64 return (_graph && _nodeIdx != PCP_INVALID_INDEX) ? &PcpNodeRef::_nodeIdx : 0;
65 }
66
68 inline bool operator==(const PcpNodeRef& rhs) const {
69 return _nodeIdx == rhs._nodeIdx && _graph == rhs._graph;
70 }
71
74 inline bool operator!=(const PcpNodeRef& rhs) const {
75 return !(*this == rhs);
76 }
77
81 PCP_API
82 bool operator<(const PcpNodeRef& rhs) const;
83
86 bool operator<=(const PcpNodeRef& rhs) const {
87 return !(rhs < *this);
88 }
89
92 bool operator>(const PcpNodeRef& rhs) const {
93 return rhs < *this;
94 }
95
98 bool operator>=(const PcpNodeRef& rhs) const {
99 return !(*this < rhs);
100 }
101
103 struct Hash {
104 size_t operator()(const PcpNodeRef& rhs) const
105 { return (size_t)rhs.GetUniqueIdentifier(); }
106 };
107
109 PcpPrimIndex_Graph *GetOwningGraph() const {
110 return _graph;
111 }
112
114 PCP_API
115 void* GetUniqueIdentifier() const;
116
118
123
125 PCP_API
127
130 PCP_API
132
135 PCP_API
136 child_const_range GetChildrenRange() const;
137
140 PCP_API
141 child_const_reverse_range GetChildrenReverseRange() const;
142
145 PCP_API
147 PcpErrorBasePtr *error);
148
151 PCP_API
153 const PcpPrimIndex_GraphRefPtr& subgraph, const PcpArc& arc,
154 PcpErrorBasePtr *error);
155
160 PCP_API
162
167 PCP_API
169
171 PCP_API
173
176 PCP_API
178
181 PCP_API
183
186 PCP_API
188
191 PCP_API
192 int GetNamespaceDepth() const;
193
196 PCP_API
198
200 PCP_API
202
208 PCP_API
210
222 PCP_API
224
226
231
233 PCP_API
235
237 PCP_API
238 const SdfPath& GetPath() const;
239
241 PCP_API
242 const PcpLayerStackRefPtr& GetLayerStack() const;
243
245 PCP_API
246 bool IsRootNode() const;
247
250 PCP_API
251 void SetIsDueToAncestor(bool isDueToAncestor);
252 PCP_API
253 bool IsDueToAncestor() const;
254
257 PCP_API
258 void SetHasSymmetry(bool hasSymmetry);
259 PCP_API
260 bool HasSymmetry() const;
261
264 PCP_API
266 PCP_API
267 SdfPermission GetPermission() const;
268
273 PCP_API
274 void SetInert(bool inert);
275 PCP_API
276 bool IsInert() const;
277
281 PCP_API
282 void SetCulled(bool culled);
283 PCP_API
284 bool IsCulled() const;
285
288 PCP_API
289 void SetRestricted(bool restricted);
290 PCP_API
291 bool IsRestricted() const;
292
295 PCP_API
296 bool CanContributeSpecs() const;
297
305 PCP_API
307
313 PCP_API
315
318 PCP_API
319 void SetHasSpecs(bool hasSpecs);
320 PCP_API
321 bool HasSpecs() const;
322
324
325 // Returns a compressed Sd site. For internal use only.
326 Pcp_CompressedSdSite GetCompressedSdSite(size_t layerIndex) const
327 {
328 return Pcp_CompressedSdSite(_nodeIdx, layerIndex);
329 }
330
331 PCP_API
332 friend std::ostream & operator<<(std::ostream &out, const PcpNodeRef &node);
333
334private:
335 friend class PcpPrimIndex_Graph;
336 friend class PcpNodeIterator;
337 friend class PcpNodeRef_ChildrenIterator;
338 friend class PcpNodeRef_ChildrenReverseIterator;
339 friend class PcpNodeRef_PrivateChildrenConstIterator;
340 friend class PcpNodeRef_PrivateChildrenConstReverseIterator;
341 friend class PcpNodeRef_PrivateSubtreeConstIterator;
342 template <class T> friend class Pcp_TraversalCache;
343
344 // Private constructor for internal use.
345 PcpNodeRef(PcpPrimIndex_Graph* graph, size_t idx)
346 : _graph(graph), _nodeIdx(idx)
347 {}
348
349 size_t _GetNodeIndex() const { return _nodeIdx; }
350
351 inline size_t _GetParentIndex() const;
352 inline size_t _GetOriginIndex() const;
353
354 inline void _SetInert(bool inert);
355 inline void _SetRestricted(bool restricted);
356
357 enum class _Restricted { Yes, Unknown };
358 void _RecordRestrictionDepth(_Restricted isRestricted);
359
360private: // Data
361 PcpPrimIndex_Graph* _graph;
362 size_t _nodeIdx;
363};
364
366template <typename HashState>
367inline
368void
369TfHashAppend(HashState& h, const PcpNodeRef& x){
370 h.Append((size_t)(x.GetUniqueIdentifier()));
371}
372inline
373size_t
374hash_value(const PcpNodeRef& x)
375{
376 return TfHash{}(x);
377}
378
379typedef TfHashSet<PcpNodeRef, PcpNodeRef::Hash> PcpNodeRefHashSet;
380typedef std::vector<PcpNodeRef> PcpNodeRefVector;
381
382class PcpNodeRef_PtrProxy {
383public:
384 PcpNodeRef* operator->() { return &_nodeRef; }
385private:
386 friend class PcpNodeRef_ChildrenIterator;
387 friend class PcpNodeRef_ChildrenReverseIterator;
388 explicit PcpNodeRef_PtrProxy(const PcpNodeRef& nodeRef) : _nodeRef(nodeRef) {}
389 PcpNodeRef _nodeRef;
390};
391
397class PcpNodeRef_ChildrenIterator
398{
399public:
400 using iterator_category = std::forward_iterator_tag;
401 using value_type = PcpNodeRef;
402 using reference = PcpNodeRef;
403 using pointer = PcpNodeRef_PtrProxy;
404 using difference_type = std::ptrdiff_t;
405
407 PCP_API
408 PcpNodeRef_ChildrenIterator();
409
412 PCP_API
413 PcpNodeRef_ChildrenIterator(const PcpNodeRef& node, bool end = false);
414
415 reference operator*() const { return dereference(); }
416 pointer operator->() const { return pointer(dereference()); }
417
418 PcpNodeRef_ChildrenIterator& operator++() {
419 increment();
420 return *this;
421 }
422
423 PcpNodeRef_ChildrenIterator operator++(int) {
424 const PcpNodeRef_ChildrenIterator result = *this;
425 increment();
426 return result;
427 }
428
429 bool operator==(const PcpNodeRef_ChildrenIterator& other) const {
430 return equal(other);
431 }
432
433 bool operator!=(const PcpNodeRef_ChildrenIterator& other) const {
434 return !equal(other);
435 }
436
437private:
438 PCP_API
439 void increment();
440 bool equal(const PcpNodeRef_ChildrenIterator& other) const
441 {
442 // Note: The default constructed iterator is *not* equal to any
443 // other iterator.
444 return (_node == other._node && _index == other._index);
445 }
446 reference dereference() const
447 {
448 return reference(_node._graph, _index);
449 }
450
451private:
452 // Current graph node this iterator is pointing at.
453 PcpNodeRef _node;
454
455 // Index of current child.
456 size_t _index;
457
458 friend class PcpNodeRef_ChildrenReverseIterator;
459};
460
466class PcpNodeRef_ChildrenReverseIterator
467{
468public:
469 using iterator_category = std::forward_iterator_tag;
470 using value_type = PcpNodeRef;
471 using reference = PcpNodeRef;
472 using pointer = PcpNodeRef_PtrProxy;
473 using difference_type = std::ptrdiff_t;
474
476 PCP_API
477 PcpNodeRef_ChildrenReverseIterator();
478
480 PCP_API
481 PcpNodeRef_ChildrenReverseIterator(const PcpNodeRef_ChildrenIterator&);
482
485 PCP_API
486 PcpNodeRef_ChildrenReverseIterator(const PcpNodeRef& node,bool end = false);
487
488 reference operator*() const { return dereference(); }
489 pointer operator->() const { return pointer(dereference()); }
490
491 PcpNodeRef_ChildrenReverseIterator& operator++() {
492 increment();
493 return *this;
494 }
495
496 PcpNodeRef_ChildrenReverseIterator operator++(int) {
497 const PcpNodeRef_ChildrenReverseIterator result = *this;
498 increment();
499 return result;
500 }
501
502 bool operator==(const PcpNodeRef_ChildrenReverseIterator& other) const {
503 return equal(other);
504 }
505
506 bool operator!=(const PcpNodeRef_ChildrenReverseIterator& other) const {
507 return !equal(other);
508 }
509
510private:
511 PCP_API
512 void increment();
513 bool equal(const PcpNodeRef_ChildrenReverseIterator& other) const
514 {
515 // Note: The default constructed iterator is *not* equal to any
516 // other iterator.
517 return (_node == other._node && _index == other._index);
518 }
519 reference dereference() const
520 {
521 return reference(_node._graph, _index);
522 }
523
524private:
525 // Current graph node this iterator is pointing at.
526 PcpNodeRef _node;
527
528 // Index of current child.
529 size_t _index;
530};
531
532template <>
533struct Tf_IteratorInterface<PcpNodeRef::child_const_range, false> {
534 typedef PcpNodeRef::child_const_iterator IteratorType;
535 static IteratorType Begin(PcpNodeRef::child_const_range const &c)
536 {
537 return c.first;
538 }
539 static IteratorType End(PcpNodeRef::child_const_range const &c)
540 {
541 return c.second;
542 }
543};
544
545template <>
546struct Tf_IteratorInterface<PcpNodeRef::child_const_range, true> {
547 typedef PcpNodeRef::child_const_reverse_iterator IteratorType;
548 static IteratorType Begin(PcpNodeRef::child_const_range const &c)
549 {
550 return c.second;
551 }
552 static IteratorType End(PcpNodeRef::child_const_range const &c)
553 {
554 return c.first;
555 }
556};
557
558template <>
559struct Tf_ShouldIterateOverCopy<PcpNodeRef::child_const_range> :
560 std::true_type {};
561
563inline
564PcpNodeRef_ChildrenIterator
565begin(const PcpNodeRef::child_const_range& r)
566{
567 return r.first;
568}
569
571inline
572PcpNodeRef_ChildrenIterator
573end(const PcpNodeRef::child_const_range& r)
574{
575 return r.second;
576}
577
579inline
580PcpNodeRef_ChildrenReverseIterator
581begin(const PcpNodeRef::child_const_reverse_range& r)
582{
583 return r.first;
584}
585
587inline
588PcpNodeRef_ChildrenReverseIterator
589end(const PcpNodeRef::child_const_reverse_range& r)
590{
591 return r.second;
592}
593
594// Helper to count the non-variant path components of a path; equivalent
595// to path.StripAllVariantSelections().GetPathElementCount() except
596// this method avoids constructing a new SdfPath value.
597int PcpNode_GetNonVariantPathElementCount(const SdfPath &path);
598
599PXR_NAMESPACE_CLOSE_SCOPE
600
601#endif // PXR_USD_PCP_NODE_H
A simple iterator adapter for STL containers.
Represents an arc connecting two nodes in the prim index.
Definition: arc.h:28
Base class for all error types.
Definition: errors.h:71
A site specifies a path in a layer stack of scene description.
Definition: site.h:79
An expression that yields a PcpMapFunction value.
Definition: mapExpression.h:39
Object used to iterate over nodes in the prim index graph in strong-to-weak order.
Definition: iterator.h:34
PcpNode represents a node in an expression tree for compositing scene description.
Definition: node.h:47
PCP_API void SetRestricted(bool restricted)
Get/set whether this node is restricted.
PCP_API bool CanContributeSpecs() const
Returns true if this node is allowed to contribute opinions for composition, false otherwise.
PCP_API SdfPath GetPathAtIntroduction() const
Returns the path for this node's site when it was introduced.
PCP_API void * GetUniqueIdentifier() const
Returns a value that uniquely identifies this node.
bool operator==(const PcpNodeRef &rhs) const
Returns true if this references the same node as rhs.
Definition: node.h:68
PCP_API PcpNodeRef GetRootNode() const
Walk up to the root node of this expression.
size_t PcpNodeRef::* UnspecifiedBoolType
Returns true if this is a valid node reference, false otherwise.
Definition: node.h:62
PCP_API SdfPath GetIntroPath() const
Get the path that introduced this node.
PCP_API void SetPermission(SdfPermission perm)
Get/set the permission for this node.
PCP_API void SetIsDueToAncestor(bool isDueToAncestor)
Get/set whether this node was introduced by being copied from its namespace ancestor,...
bool operator>(const PcpNodeRef &rhs) const
Greater than operator.
Definition: node.h:92
PCP_API void SetHasSymmetry(bool hasSymmetry)
Get/set whether this node provides any symmetry opinions, either directly or from a namespace ancesto...
PCP_API PcpArcType GetArcType() const
Returns the type of arc connecting this node to its parent node.
PCP_API void SetSpecContributionRestrictedDepth(size_t depth)
Set this node's contribution restriction depth.
PCP_API size_t GetSpecContributionRestrictedDepth() const
Returns the namespace depth (i.e., the path element count) of this node's path when it was restricted...
PCP_API child_const_reverse_range GetChildrenReverseRange() const
Returns an iterator range over the children nodes in weakest to strongest order.
PCP_API PcpNodeRef GetOriginNode() const
Returns the immediate origin node for this node.
PCP_API PcpLayerStackSite GetSite() const
Get the site this node represents.
PCP_API PcpNodeRef InsertChildSubgraph(const PcpPrimIndex_GraphRefPtr &subgraph, const PcpArc &arc, PcpErrorBasePtr *error)
Inserts subgraph as a child of this node, with the root node of subtree connected to this node via ar...
bool operator<=(const PcpNodeRef &rhs) const
Less than or equal operator.
Definition: node.h:86
PCP_API PcpNodeRef GetParentNode() const
Returns this node's immediate parent node.
PCP_API bool IsRootNode() const
Returns true if this node is the root node of the prim index graph.
PCP_API PcpNodeRef GetOriginRootNode() const
Walk up to the root origin node for this node.
PcpPrimIndex_Graph * GetOwningGraph() const
Returns the graph that this node belongs to.
Definition: node.h:109
PCP_API const SdfPath & GetPath() const
Returns the path for the site this node represents.
PCP_API int GetSiblingNumAtOrigin() const
Returns this node's index among siblings with the same arc type at this node's origin.
PCP_API void SetHasSpecs(bool hasSpecs)
Returns true if this node has opinions authored for composition, false otherwise.
PCP_API PcpNodeRef InsertChild(const PcpLayerStackSite &site, const PcpArc &arc, PcpErrorBasePtr *error)
Inserts a new child node for site, connected to this node via arc.
PCP_API int GetNamespaceDepth() const
Returns the absolute namespace depth of the node that introduced this node.
bool operator>=(const PcpNodeRef &rhs) const
Greater than or equal operator.
Definition: node.h:98
PCP_API bool operator<(const PcpNodeRef &rhs) const
Returns true if this node is 'less' than rhs.
PCP_API const PcpMapExpression & GetMapToRoot() const
Returns mapping function used to translate paths and values from this node directly to the root node.
PCP_API const PcpLayerStackRefPtr & GetLayerStack() const
Returns the layer stack for the site this node represents.
PCP_API void SetInert(bool inert)
Get/set whether this node is inert.
PCP_API int GetDepthBelowIntroduction() const
Return the number of levels of namespace this node's site is below the level at which it was introduc...
PCP_API child_const_range GetChildrenRange() const
Returns an iterator range over the children nodes in strongest to weakest order.
PCP_API SdfPath GetPathAtOriginRootIntroduction() const
Returns the node's path at the same level of namespace as its origin root node was when it was added ...
PCP_API void SetCulled(bool culled)
Get/set whether this node is culled.
PCP_API const PcpMapExpression & GetMapToParent() const
Returns mapping function used to translate paths and values from this node to its parent node.
bool operator!=(const PcpNodeRef &rhs) const
Inequality operator.
Definition: node.h:74
A path value used to locate objects in layers or scenegraphs.
Definition: path.h:274
A user-extensible hashing mechanism for use with runtime hash tables.
Definition: hash.h:460
#define TF_DECLARE_REF_PTRS(type)
Define standard ref pointer types.
Definition: declarePtrs.h:58
Hash functor.
Definition: node.h:103
size_t hash_value(const TfToken &x)
Overload hash_value for TfToken.
Definition: token.h:437
constexpr size_t PCP_INVALID_INDEX
A value which indicates an invalid index.
Definition: types.h:198
PcpArcType
Describes the type of arc connecting two nodes in the prim index.
Definition: types.h:27
Basic Sdf data types.
SdfPermission
An enum that defines permission levels.
Definition: types.h:132