24#ifndef PXR_USD_USD_PRIM_FLAGS_H
25#define PXR_USD_USD_PRIM_FLAGS_H
76#include "pxr/usd/usd/api.h"
83PXR_NAMESPACE_OPEN_SCOPE
94 Usd_PrimComponentFlag,
97 Usd_PrimHasDefiningSpecifierFlag,
101 Usd_PrimHasPayloadFlag,
104 Usd_PrimPrototypeFlag,
105 Usd_PrimInstanceProxyFlag,
106 Usd_PrimPseudoRootFlag,
111typedef 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); }
120 bool operator==(Usd_Term other)
const {
121 return flag == other.flag && negated == other.negated;
123 bool operator!=(Usd_Term other)
const {
124 return !(*
this == other);
131operator!(Usd_PrimFlags flag) {
132 return Usd_Term(flag,
true);
136class 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));
263 operator==(
const Usd_PrimFlagsPredicate &lhs,
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) {
279 p._mask.to_ulong(), p._values.to_ulong(), p._negate
299class Usd_PrimFlagsConjunction :
public Usd_PrimFlagsPredicate {
302 Usd_PrimFlagsConjunction() {};
305 explicit Usd_PrimFlagsConjunction(Usd_Term term) {
310 Usd_PrimFlagsConjunction &operator&=(Usd_Term term) {
312 if (ARCH_UNLIKELY(_IsContradiction()))
316 if (!_mask[term.flag]) {
317 _mask[term.flag] = 1;
318 _values[term.flag] = !term.negated;
319 }
else if (_values[term.flag] != !term.negated) {
323 _MakeContradiction();
346 class Usd_PrimFlagsDisjunction operator!() const;
351 friend class Usd_PrimFlagsDisjunction;
352 Usd_PrimFlagsConjunction(
const Usd_PrimFlagsPredicate &base) :
353 Usd_PrimFlagsPredicate(base) {}
356 friend Usd_PrimFlagsConjunction
357 operator&&(Usd_Term lhs, Usd_Term rhs);
360 friend Usd_PrimFlagsConjunction
361 operator&&(
const Usd_PrimFlagsConjunction &conjunction, Usd_Term rhs);
364 friend Usd_PrimFlagsConjunction
365 operator&&(Usd_Term lhs,
const Usd_PrimFlagsConjunction &conjunction);
368inline Usd_PrimFlagsConjunction
369operator&&(Usd_Term lhs, Usd_Term rhs) {
372 Usd_PrimFlagsConjunction tmp;
373 return (tmp && lhs) && rhs;
376inline Usd_PrimFlagsConjunction
377operator&&(
const Usd_PrimFlagsConjunction &conjunction, Usd_Term rhs) {
378 return Usd_PrimFlagsConjunction(conjunction) &= rhs;
381inline Usd_PrimFlagsConjunction
382operator&&(Usd_Term lhs,
const Usd_PrimFlagsConjunction &conjunction) {
383 return Usd_PrimFlagsConjunction(conjunction) &= lhs;
386inline Usd_PrimFlagsConjunction
387operator&&(Usd_PrimFlags lhs, Usd_PrimFlags rhs) {
388 return Usd_Term(lhs) && Usd_Term(rhs);
402class Usd_PrimFlagsDisjunction :
public Usd_PrimFlagsPredicate {
405 Usd_PrimFlagsDisjunction() { _Negate(); };
408 explicit Usd_PrimFlagsDisjunction(Usd_Term term) {
414 Usd_PrimFlagsDisjunction &operator|=(Usd_Term term) {
416 if (ARCH_UNLIKELY(_IsTautology()))
420 if (!_mask[term.flag]) {
421 _mask[term.flag] = 1;
422 _values[term.flag] = term.negated;
423 }
else if (_values[term.flag] != term.negated) {
450 class Usd_PrimFlagsConjunction operator!() const;
455 friend class Usd_PrimFlagsConjunction;
456 Usd_PrimFlagsDisjunction(
const Usd_PrimFlagsPredicate &base) :
457 Usd_PrimFlagsPredicate(base) {}
460 friend Usd_PrimFlagsDisjunction operator||(Usd_Term lhs, Usd_Term rhs);
463 friend Usd_PrimFlagsDisjunction
464 operator||(
const Usd_PrimFlagsDisjunction &disjunction, Usd_Term rhs);
467 friend Usd_PrimFlagsDisjunction
468 operator||(Usd_Term lhs,
const Usd_PrimFlagsDisjunction &disjunction);
471inline Usd_PrimFlagsDisjunction
472operator||(Usd_Term lhs, Usd_Term rhs) {
473 return (Usd_PrimFlagsDisjunction() || lhs) || rhs;
476inline Usd_PrimFlagsDisjunction
477operator||(
const Usd_PrimFlagsDisjunction &disjunction, Usd_Term rhs) {
478 return Usd_PrimFlagsDisjunction(disjunction) |= rhs;
481inline Usd_PrimFlagsDisjunction
482operator||(Usd_Term lhs,
const Usd_PrimFlagsDisjunction &disjunction) {
483 return Usd_PrimFlagsDisjunction(disjunction) |= lhs;
486inline Usd_PrimFlagsDisjunction
487operator||(Usd_PrimFlags lhs, Usd_PrimFlags rhs) {
488 return Usd_Term(lhs) || Usd_Term(rhs);
539 = Usd_PrimHasDefiningSpecifierFlag;
576inline Usd_PrimFlagsPredicate
579 return predicate.TraverseInstanceProxies(
true);
586inline Usd_PrimFlagsPredicate
592PXR_NAMESPACE_CLOSE_SCOPE
A path value used to locate objects in layers or scenegraphs.
static size_t Combine(Args &&... args)
Produce a hash code by combining the hash codes of several objects.
UsdPrim is the sole persistent scenegraph object on a UsdStage, and is the embodiment of a "Prim" as ...
size_t hash_value(const half h)
Overload hash_value for half.
unspecified UsdPrimIsGroup
Tests UsdPrim::IsGroup()
unspecified UsdPrimIsActive
Tests UsdPrim::IsActive()
unspecified UsdPrimIsDefined
Tests UsdPrim::IsDefined()
unspecified UsdPrimIsInstance
Tests UsdPrim::IsInstance()
unspecified UsdPrimIsLoaded
Tests UsdPrim::IsLoaded()
unspecified UsdPrimDefaultPredicate
The default predicate used for prim traversals in methods like UsdPrim::GetChildren,...
unspecified UsdPrimIsAbstract
Tests UsdPrim::IsAbstract()
unspecified UsdPrimIsModel
Tests UsdPrim::IsModel()
unspecified UsdPrimHasDefiningSpecifier
Tests UsdPrim::HasDefiningSpecifier()
Usd_PrimFlagsPredicate UsdTraverseInstanceProxies()
This is an overloaded member function, provided for convenience. It differs from the above function o...
unspecified UsdPrimAllPrimsPredicate
Predicate that includes all prims.