24 #ifndef PXR_USD_USD_PRIM_FLAGS_H
25 #define PXR_USD_USD_PRIM_FLAGS_H
76 #include "pxr/usd/usd/api.h"
80 #include <boost/functional/hash.hpp>
84 PXR_NAMESPACE_OPEN_SCOPE
97 Usd_PrimHasDefiningSpecifierFlag,
101 Usd_PrimHasPayloadFlag,
104 Usd_PrimPrototypeFlag,
105 Usd_PrimInstanceProxyFlag,
106 Usd_PrimPseudoRootFlag,
111 typedef std::bitset<Usd_PrimNumFlags> Usd_PrimFlagBits;
117 Usd_Term(Usd_PrimFlags flag) : flag(flag), negated(false) {}
118 Usd_Term(Usd_PrimFlags flag,
bool negated) : flag(flag), negated(negated) {}
119 Usd_Term operator!()
const {
return Usd_Term(flag, !negated); }
121 return flag == other.flag && negated == other.negated;
123 bool operator!=(Usd_Term other)
const {
124 return !(*
this == other);
131 operator!(Usd_PrimFlags flag) {
132 return Usd_Term(flag,
true);
136 class Usd_PrimFlagsPredicate
140 typedef bool result_type;
143 Usd_PrimFlagsPredicate() : _negate(false) {}
145 Usd_PrimFlagsPredicate(Usd_PrimFlags flag)
148 _values[flag] =
true;
152 Usd_PrimFlagsPredicate(Usd_Term term)
154 _mask[term.flag] = 1;
155 _values[term.flag] = !term.negated;
160 static Usd_PrimFlagsPredicate Tautology() {
161 return Usd_PrimFlagsPredicate();
166 static Usd_PrimFlagsPredicate Contradiction() {
167 return Usd_PrimFlagsPredicate()._Negate();
173 Usd_PrimFlagsPredicate &TraverseInstanceProxies(
bool traverse) {
175 _mask[Usd_PrimInstanceProxyFlag] = 0;
176 _values[Usd_PrimInstanceProxyFlag] = 1;
179 _mask[Usd_PrimInstanceProxyFlag] = 1;
180 _values[Usd_PrimInstanceProxyFlag] = 0;
187 bool IncludeInstanceProxiesInTraversal()
const {
188 return !_mask[Usd_PrimInstanceProxyFlag] &&
189 _values[Usd_PrimInstanceProxyFlag];
194 bool operator()(
const class UsdPrim &prim)
const;
199 bool _IsTautology()
const {
return *
this == Tautology(); }
202 void _MakeTautology() { *
this = Tautology(); }
205 bool _IsContradiction()
const {
return *
this == Contradiction(); }
208 void _MakeContradiction() { *
this = Contradiction(); }
211 Usd_PrimFlagsPredicate &_Negate() {
217 Usd_PrimFlagsPredicate _GetNegated()
const {
218 return Usd_PrimFlagsPredicate(*this)._Negate();
222 Usd_PrimFlagBits _mask;
225 Usd_PrimFlagBits _values;
230 template <
class PrimPtr>
231 bool _Eval(
const PrimPtr &prim,
bool isInstanceProxy)
const {
234 const Usd_PrimFlagBits primFlags = Usd_PrimFlagBits(prim->_GetFlags())
235 .set(Usd_PrimInstanceProxyFlag, isInstanceProxy);
239 return ((primFlags & _mask) == (_values & _mask)) ^ _negate;
244 template <
class PrimPtr>
246 Usd_EvalPredicate(
const Usd_PrimFlagsPredicate &pred,
const PrimPtr &prim,
247 bool isInstanceProxy) {
248 return pred._Eval(prim, isInstanceProxy);
254 template <
class PrimPtr>
256 Usd_EvalPredicate(
const Usd_PrimFlagsPredicate &pred,
const PrimPtr &prim,
257 const SdfPath &proxyPrimPath) {
258 return pred._Eval(prim, Usd_IsInstanceProxy(prim, proxyPrimPath));
264 const Usd_PrimFlagsPredicate &rhs) {
265 return lhs._mask == rhs._mask &&
266 lhs._values == rhs._values &&
267 lhs._negate == rhs._negate;
271 operator!=(
const Usd_PrimFlagsPredicate &lhs,
272 const Usd_PrimFlagsPredicate &rhs) {
273 return !(lhs == rhs);
277 friend size_t hash_value(
const Usd_PrimFlagsPredicate &p) {
278 size_t hash = p._mask.to_ulong();
279 boost::hash_combine(hash, p._values.to_ulong());
280 boost::hash_combine(hash, p._negate);
300 class Usd_PrimFlagsConjunction :
public Usd_PrimFlagsPredicate {
303 Usd_PrimFlagsConjunction() {};
306 explicit Usd_PrimFlagsConjunction(Usd_Term term) {
311 Usd_PrimFlagsConjunction &operator&=(Usd_Term term) {
313 if (ARCH_UNLIKELY(_IsContradiction()))
317 if (!_mask[term.flag]) {
318 _mask[term.flag] = 1;
319 _values[term.flag] = !term.negated;
320 }
else if (_values[term.flag] != !term.negated) {
324 _MakeContradiction();
347 class Usd_PrimFlagsDisjunction operator!() const;
352 friend class Usd_PrimFlagsDisjunction;
353 Usd_PrimFlagsConjunction(
const Usd_PrimFlagsPredicate &base) :
354 Usd_PrimFlagsPredicate(base) {}
357 friend Usd_PrimFlagsConjunction
358 operator&&(Usd_Term lhs, Usd_Term rhs);
361 friend Usd_PrimFlagsConjunction
362 operator&&(
const Usd_PrimFlagsConjunction &conjunction, Usd_Term rhs);
365 friend Usd_PrimFlagsConjunction
366 operator&&(Usd_Term lhs,
const Usd_PrimFlagsConjunction &conjunction);
369 inline Usd_PrimFlagsConjunction
370 operator&&(Usd_Term lhs, Usd_Term rhs) {
373 Usd_PrimFlagsConjunction tmp;
374 return (tmp && lhs) && rhs;
377 inline Usd_PrimFlagsConjunction
378 operator&&(
const Usd_PrimFlagsConjunction &conjunction, Usd_Term rhs) {
379 return Usd_PrimFlagsConjunction(conjunction) &= rhs;
382 inline Usd_PrimFlagsConjunction
383 operator&&(Usd_Term lhs,
const Usd_PrimFlagsConjunction &conjunction) {
384 return Usd_PrimFlagsConjunction(conjunction) &= lhs;
387 inline Usd_PrimFlagsConjunction
388 operator&&(Usd_PrimFlags lhs, Usd_PrimFlags rhs) {
389 return Usd_Term(lhs) && Usd_Term(rhs);
403 class Usd_PrimFlagsDisjunction :
public Usd_PrimFlagsPredicate {
406 Usd_PrimFlagsDisjunction() { _Negate(); };
409 explicit Usd_PrimFlagsDisjunction(Usd_Term term) {
415 Usd_PrimFlagsDisjunction &operator|=(Usd_Term term) {
417 if (ARCH_UNLIKELY(_IsTautology()))
421 if (!_mask[term.flag]) {
422 _mask[term.flag] = 1;
423 _values[term.flag] = term.negated;
424 }
else if (_values[term.flag] != term.negated) {
451 class Usd_PrimFlagsConjunction operator!() const;
456 friend class Usd_PrimFlagsConjunction;
457 Usd_PrimFlagsDisjunction(
const Usd_PrimFlagsPredicate &base) :
458 Usd_PrimFlagsPredicate(base) {}
461 friend Usd_PrimFlagsDisjunction operator||(Usd_Term lhs, Usd_Term rhs);
464 friend Usd_PrimFlagsDisjunction
465 operator||(
const Usd_PrimFlagsDisjunction &disjunction, Usd_Term rhs);
468 friend Usd_PrimFlagsDisjunction
469 operator||(Usd_Term lhs,
const Usd_PrimFlagsDisjunction &disjunction);
472 inline Usd_PrimFlagsDisjunction
473 operator||(Usd_Term lhs, Usd_Term rhs) {
474 return (Usd_PrimFlagsDisjunction() || lhs) || rhs;
477 inline Usd_PrimFlagsDisjunction
478 operator||(
const Usd_PrimFlagsDisjunction &disjunction, Usd_Term rhs) {
479 return Usd_PrimFlagsDisjunction(disjunction) |= rhs;
482 inline Usd_PrimFlagsDisjunction
483 operator||(Usd_Term lhs,
const Usd_PrimFlagsDisjunction &disjunction) {
484 return Usd_PrimFlagsDisjunction(disjunction) |= lhs;
487 inline Usd_PrimFlagsDisjunction
488 operator||(Usd_PrimFlags lhs, Usd_PrimFlags rhs) {
489 return Usd_Term(lhs) || Usd_Term(rhs);
532 static const Usd_PrimFlags UsdPrimIsActive = Usd_PrimActiveFlag;
533 static const Usd_PrimFlags UsdPrimIsLoaded = Usd_PrimLoadedFlag;
534 static const Usd_PrimFlags UsdPrimIsModel = Usd_PrimModelFlag;
535 static const Usd_PrimFlags UsdPrimIsGroup = Usd_PrimGroupFlag;
536 static const Usd_PrimFlags UsdPrimIsAbstract = Usd_PrimAbstractFlag;
537 static const Usd_PrimFlags UsdPrimIsDefined = Usd_PrimDefinedFlag;
538 static const Usd_PrimFlags UsdPrimIsInstance = Usd_PrimInstanceFlag;
539 static const Usd_PrimFlags UsdPrimHasDefiningSpecifier
540 = Usd_PrimHasDefiningSpecifierFlag;
577 inline Usd_PrimFlagsPredicate
580 return predicate.TraverseInstanceProxies(
true);
587 inline Usd_PrimFlagsPredicate
593 PXR_NAMESPACE_CLOSE_SCOPE
595 #endif // PXR_USD_USD_PRIM_FLAGS_H
unspecified UsdPrimDefaultPredicate
The default predicate used for prim traversals in methods like UsdPrim::GetChildren, UsdStage::Traverse, and by UsdPrimRange.
unspecified UsdPrimIsAbstract
Tests UsdPrim::IsAbstract()
unspecified UsdPrimHasDefiningSpecifier
Tests UsdPrim::HasDefiningSpecifier()
unspecified UsdPrimIsModel
Tests UsdPrim::IsModel()
unspecified UsdPrimIsActive
Tests UsdPrim::IsActive()
unspecified UsdPrimIsLoaded
Tests UsdPrim::IsLoaded()
unspecified UsdPrimIsDefined
Tests UsdPrim::IsDefined()
UsdPrim is the sole persistent scenegraph object on a UsdStage, and is the embodiment of a "Prim" as ...
Usd_PrimFlagsPredicate UsdTraverseInstanceProxies(Usd_PrimFlagsPredicate predicate)
This function is used to allow the prim traversal functions listed under Prim predicate flags to trav...
A path value used to locate objects in layers or scenegraphs.
unspecified UsdPrimAllPrimsPredicate
Predicate that includes all prims.
unspecified UsdPrimIsInstance
Tests UsdPrim::IsInstance()
VT_API bool operator==(VtDictionary const &, VtDictionary const &)
Equality comparison.
unspecified UsdPrimIsGroup
Tests UsdPrim::IsGroup()