HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
primFlags.h
Go to the documentation of this file.
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the Apache License, Version 2.0 (the "Apache License")
5 // with the following modification; you may not use this file except in
6 // compliance with the Apache License and the following modification to it:
7 // Section 6. Trademarks. is deleted and replaced with:
8 //
9 // 6. Trademarks. This License does not grant permission to use the trade
10 // names, trademarks, service marks, or product names of the Licensor
11 // and its affiliates, except as required to comply with Section 4(c) of
12 // the License and to reproduce the content of the NOTICE file.
13 //
14 // You may obtain a copy of the Apache License at
15 //
16 // http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the Apache License with the above modification is
20 // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21 // KIND, either express or implied. See the Apache License for the specific
22 // language governing permissions and limitations under the Apache License.
23 //
24 #ifndef USD_PRIMFLAGS_H
25 #define USD_PRIMFLAGS_H
26 
27 /// \file usd/primFlags.h
28 ///
29 /// \anchor Usd_PrimFlags
30 ///
31 /// Provides terms for UsdPrim flags that can be combined to form either a
32 /// conjunction (via &&) or a disjunction (via ||). The result is a
33 /// predicate functor object that tests those flags on the passed prim.
34 /// Currently UsdPrim::GetFilteredChildren(), UsdPrim::GetNextFilteredSibling(),
35 /// UsdPrim::GetFilteredDescendants(), and UsdPrimRange() accept these
36 /// predicates to filter out unwanted prims.
37 ///
38 /// For example:
39 /// \code
40 /// // Get only loaded model children.
41 /// prim.GetFilteredChildren(UsdPrimIsModel && UsdPrimIsLoaded)
42 /// \endcode
43 ///
44 /// For performance, these predicates are implemented by a bitwise test, so
45 /// arbitrary boolean expressions cannot be represented. The set of boolean
46 /// expressions that can be represented are conjunctions with possibly negated
47 /// terms (or disjunctions, by De Morgan's law). Here are some examples of
48 /// valid expressions:
49 /// \code
50 /// // simple conjunction.
51 /// (UsdPrimIsLoaded && UsdPrimIsGroup)
52 /// // conjunction with negated term.
53 /// (UsdPrimIsDefined && !UsdPrimIsAbstract)
54 /// // disjunction with negated term.
55 /// (!UsdPrimIsDefined || !UsdPrimIsActive)
56 /// // negated conjunction gives a disjunction.
57 /// !(UsdPrimIsLoaded && UsdPrimIsModel)
58 /// // negated conjunction gives a disjunction, which is further extended.
59 /// (!(UsdPrimIsLoaded && UsdPrimIsModel) || UsdPrimIsAbstract)
60 /// // equivalent to above.
61 /// (!UsdPrimIsLoaded || !UsdPrimIsModel || UsdPrimIsAbstract)
62 /// \endcode
63 /// Here are some examples of invalid expressions:
64 /// \code
65 /// // error: cannot || a term with a conjunction.
66 /// (UsdPrimIsLoaded && UsdPrimIsModel) || UsdPrimIsAbstract
67 /// // error: cannot && disjunctions.
68 /// (!UsdPrimIsDefined || UsdPrimIsAbstract) && (UsdPrimIsModel || !UsdPrimIsActive)
69 /// \endcode
70 ///
71 ///
72 /// The following variables provide the clauses that can be combined and
73 /// negated to produce predicates:
74 
75 #include "pxr/pxr.h"
76 #include "pxr/usd/usd/api.h"
77 #include "pxr/base/arch/hints.h"
78 #include "pxr/base/tf/bitUtils.h"
79 
80 #include <hboost/functional/hash.hpp>
81 
82 #include <bitset>
83 
85 
86 class SdfPath;
87 
88 // Enum for cached flags on prims.
90  // Flags for use with predicates.
99 
100  // Flags for internal use.
106 
108 };
109 
110 typedef std::bitset<Usd_PrimNumFlags> Usd_PrimFlagBits;
111 
112 // Term class. This class exists merely to allow building up conjunctions or
113 // disjunctions of terms. See Usd_PrimFlagsPredicate, Usd_PrimFlagsConjunction,
114 // Usd_PrimFlagsDisjunction which provide the logcial operators.
115 struct Usd_Term {
116  Usd_Term(Usd_PrimFlags flag) : flag(flag), negated(false) {}
117  Usd_Term(Usd_PrimFlags flag, bool negated) : flag(flag), negated(negated) {}
118  Usd_Term operator!() const { return Usd_Term(flag, !negated); }
119  bool operator==(Usd_Term other) const {
120  return flag == other.flag && negated == other.negated;
121  }
122  bool operator!=(Usd_Term other) const {
123  return !(*this == other);
124  }
126  bool negated;
127 };
128 
129 inline Usd_Term
131  return Usd_Term(flag, /*negated=*/true);
132 }
133 
134 // Predicate functor class that tests a prim's flags against desired values.
136 {
137 public:
138  // Functor result type.
139  typedef bool result_type;
140 
141  // Default ctor produces a tautology.
142  Usd_PrimFlagsPredicate() : _negate(false) {}
143 
145  : _negate(false) {
146  _mask[flag] = 1;
147  _values[flag] = true;
148  }
149 
150  // Implicit conversion from a single term.
152  : _negate(false) {
153  _mask[term.flag] = 1;
154  _values[term.flag] = !term.negated;
155  }
156 
157  // Convenience to produce a tautological predicate. Returns a
158  // default-constructed predicate.
160  return Usd_PrimFlagsPredicate();
161  }
162 
163  // Convenience to produce a contradictory predicate. Returns a negated
164  // default-constructed predicate.
166  return Usd_PrimFlagsPredicate()._Negate();
167  }
168 
169  // Set flag to indicate whether prim traversal functions using this
170  // predicate should traverse beneath instances and return descendants
171  // that pass this predicate as instance proxy prims.
173  if (traverse) {
176  }
177  else {
180  }
181  return *this;
182  }
183 
184  // Returns true if this predicate was explicitly set to include
185  // instance proxies, false otherwise.
187  return !_mask[Usd_PrimInstanceProxyFlag] &&
189  }
190 
191  // Invoke boolean predicate on UsdPrim \p prim.
192  USD_API
193  bool operator()(const class UsdPrim &prim) const;
194 
195 protected:
196 
197  // Return true if this predicate is a tautology, false otherwise.
198  bool _IsTautology() const { return *this == Tautology(); }
199 
200  // Set this predicate to be a tautology.
201  void _MakeTautology() { *this = Tautology(); }
202 
203  // Return true if this predicate is a contradiction, false otherwise.
204  bool _IsContradiction() const { return *this == Contradiction(); }
205 
206  // Set this predicate to be a contradiction.
207  void _MakeContradiction() { *this = Contradiction(); }
208 
209  // Negate this predicate.
211  _negate = !_negate;
212  return *this;
213  }
214 
215  // Return a negated copy of this predicate.
217  return Usd_PrimFlagsPredicate(*this)._Negate();
218  }
219 
220  // Mask indicating which flags are of interest.
222 
223  // Desired values for prim flags.
225 
226 private:
227  // Evaluate this predicate with prim data \p prim. \p isInstanceProxy
228  // should be true if this is being evaluated for an instance proxy prim.
229  template <class PrimPtr>
230  bool _Eval(const PrimPtr &prim, bool isInstanceProxy) const {
231  // Manually set the instance proxy bit, since instance proxy
232  // state is never stored in Usd_PrimData's flags.
233  const Usd_PrimFlagBits primFlags = Usd_PrimFlagBits(prim->_GetFlags())
234  .set(Usd_PrimInstanceProxyFlag, isInstanceProxy);
235 
236  // Mask the prim's flags, compare to desired values, then optionally
237  // negate the result.
238  return ((primFlags & _mask) == (_values & _mask)) ^ _negate;
239  }
240 
241  // Evaluate the predicate \p pred with prim data \p prim. \p isInstanceProxy
242  // should be true if this is being evaluated for an instance proxy prim.
243  template <class PrimPtr>
244  friend bool
245  Usd_EvalPredicate(const Usd_PrimFlagsPredicate &pred, const PrimPtr &prim,
246  bool isInstanceProxy) {
247  return pred._Eval(prim, isInstanceProxy);
248  }
249 
250  // Convenience method for evaluating \p pred using \p prim and
251  // \p proxyPrimPath to determine whether this is for an instance proxy
252  // prim.
253  template <class PrimPtr>
254  friend bool
255  Usd_EvalPredicate(const Usd_PrimFlagsPredicate &pred, const PrimPtr &prim,
256  const SdfPath &proxyPrimPath) {
257  return pred._Eval(prim, Usd_IsInstanceProxy(prim, proxyPrimPath));
258  }
259 
260  // Equality comparison.
261  friend bool
263  const Usd_PrimFlagsPredicate &rhs) {
264  return lhs._mask == rhs._mask &&
265  lhs._values == rhs._values &&
266  lhs._negate == rhs._negate;
267  }
268  // Inequality comparison.
269  friend bool
271  const Usd_PrimFlagsPredicate &rhs) {
272  return !(lhs == rhs);
273  }
274 
275  // hash overload.
276  friend size_t hash_value(const Usd_PrimFlagsPredicate &p) {
277  size_t hash = p._mask.to_ulong();
278  hboost::hash_combine(hash, p._values.to_ulong());
279  hboost::hash_combine(hash, p._negate);
280  return hash;
281  }
282 
283  // Whether or not to negate the predicate's result.
284  bool _negate;
285 
286 };
287 
288 
289 /// Conjunction of prim flag predicate terms.
290 ///
291 /// Usually clients will implicitly create conjunctions by &&-ing together flag
292 /// predicate terms. For example:
293 /// \code
294 /// // Get all loaded model children.
295 /// prim.GetFilteredChildren(UsdPrimIsModel && UsdPrimIsLoaded)
296 /// \endcode
297 ///
298 /// See primFlags.h for more details.
300 public:
301  /// Default constructed conjunction is a tautology.
303 
304  /// Construct with a term.
306  *this &= term;
307  }
308 
309  /// Add an additional term to this conjunction.
311  // If this conjunction is a contradiction, do nothing.
313  return *this;
314 
315  // If we don't have the bit, set it in _mask and _values (if needed).
316  if (!_mask[term.flag]) {
317  _mask[term.flag] = 1;
318  _values[term.flag] = !term.negated;
319  } else if (_values[term.flag] != !term.negated) {
320  // If we do have the bit and the values disagree, then this entire
321  // conjunction becomes a contradiction. If the values agree, it's
322  // redundant and we do nothing.
324  }
325  return *this;
326  }
327 
328  /// Negate this conjunction, producing a disjunction by De Morgan's law.
329  /// For instance:
330  ///
331  /// \code
332  /// !(UsdPrimIsLoaded && UsdPrimIsModel)
333  /// \endcode
334  ///
335  /// Will negate the conjunction in parens to produce a disjunction
336  /// equivalent to:
337  ///
338  /// \code
339  /// (!UsdPrimIsLoaded || !UsdPrimIsModel)
340  /// \endcode
341  ///
342  /// Every expression may be formulated as either a disjunction or a
343  /// conjuction, but allowing both affords increased expressiveness.
344  ///
345  USD_API
346  class Usd_PrimFlagsDisjunction operator!() const;
347 
348 private:
349 
350  // Let Usd_PrimFlagsDisjunction produce conjunctions when negated
353  Usd_PrimFlagsPredicate(base) {}
354 
355  /// Combine two terms to make a conjunction.
357  operator&&(Usd_Term lhs, Usd_Term rhs);
358 
359  /// Create a new conjunction with the term \p rhs added.
361  operator&&(const Usd_PrimFlagsConjunction &conjunction, Usd_Term rhs);
362 
363  /// Create a new conjunction with the term \p lhs added.
365  operator&&(Usd_Term lhs, const Usd_PrimFlagsConjunction &conjunction);
366 };
367 
370  // Apparently gcc 4.8.x doesn't like this as:
371  // return (Usd_PrimFlagsConjunction() && lhs) && rhs;
373  return (tmp && lhs) && rhs;
374 }
375 
377 operator&&(const Usd_PrimFlagsConjunction &conjunction, Usd_Term rhs) {
378  return Usd_PrimFlagsConjunction(conjunction) &= rhs;
379 }
380 
382 operator&&(Usd_Term lhs, const Usd_PrimFlagsConjunction &conjunction) {
383  return Usd_PrimFlagsConjunction(conjunction) &= lhs;
384 }
385 
388  return Usd_Term(lhs) && Usd_Term(rhs);
389 }
390 
391 
392 /// Disjunction of prim flag predicate terms.
393 ///
394 /// Usually clients will implicitly create disjunctions by ||-ing together flag
395 /// predicate terms. For example:
396 /// \code
397 /// // Get all deactivated or undefined children.
398 /// prim.GetFilteredChildren(!UsdPrimIsActive || !UsdPrimIsDefined)
399 /// \endcode
400 ///
401 /// See primFlags.h for more details.
403 public:
404  // Default constructed disjunction is a contradiction.
406 
407  // Construct with a term.
409  _Negate();
410  *this |= term;
411  }
412 
413  /// Add an additional term to this disjunction.
415  // If this disjunction is a tautology, do nothing.
417  return *this;
418 
419  // If we don't have the bit, set it in _mask and _values (if needed).
420  if (!_mask[term.flag]) {
421  _mask[term.flag] = 1;
422  _values[term.flag] = term.negated;
423  } else if (_values[term.flag] != term.negated) {
424  // If we do have the bit and the values disagree, then this entire
425  // disjunction becomes a tautology. If the values agree, it's
426  // redundant and we do nothing.
427  _MakeTautology();
428  }
429  return *this;
430  }
431 
432  /// Negate this disjunction, producing a disjunction by De Morgan's law.
433  /// For instance:
434  ///
435  /// \code
436  /// !(UsdPrimIsLoaded || UsdPrimIsModel)
437  /// \endcode
438  ///
439  /// Will negate the disjunction in parens to produce a conjunction
440  /// equivalent to:
441  ///
442  /// \code
443  /// (!UsdPrimIsLoaded && !UsdPrimIsModel)
444  /// \endcode
445  ///
446  /// Every expression may be formulated as either a disjunction or a
447  /// conjuction, but allowing both affords increased expressiveness.
448  ///
449  USD_API
450  class Usd_PrimFlagsConjunction operator!() const;
451 
452 private:
453 
454  // Let Usd_PrimFlagsDisjunction produce conjunctions when negated.
457  Usd_PrimFlagsPredicate(base) {}
458 
459  /// Combine two terms to make a disjunction.
461 
462  /// Create a new disjunction with the term \p rhs added.
464  operator||(const Usd_PrimFlagsDisjunction &disjunction, Usd_Term rhs);
465 
466  /// Create a new disjunction with the term \p lhs added.
468  operator||(Usd_Term lhs, const Usd_PrimFlagsDisjunction &disjunction);
469 };
470 
473  return (Usd_PrimFlagsDisjunction() || lhs) || rhs;
474 }
475 
477 operator||(const Usd_PrimFlagsDisjunction &disjunction, Usd_Term rhs) {
478  return Usd_PrimFlagsDisjunction(disjunction) |= rhs;
479 }
480 
482 operator||(Usd_Term lhs, const Usd_PrimFlagsDisjunction &disjunction) {
483  return Usd_PrimFlagsDisjunction(disjunction) |= lhs;
484 }
485 
488  return Usd_Term(lhs) || Usd_Term(rhs);
489 }
490 
491 #ifdef doxygen
492 
493 /// Tests UsdPrim::IsActive()
494 extern unspecified UsdPrimIsActive;
495 /// Tests UsdPrim::IsLoaded()
496 extern unspecified UsdPrimIsLoaded;
497 /// Tests UsdPrim::IsModel()
498 extern unspecified UsdPrimIsModel;
499 /// Tests UsdPrim::IsGroup()
500 extern unspecified UsdPrimIsGroup;
501 /// Tests UsdPrim::IsAbstract()
502 extern unspecified UsdPrimIsAbstract;
503 /// Tests UsdPrim::IsDefined()
504 extern unspecified UsdPrimIsDefined;
505 /// Tests UsdPrim::IsInstance()
506 extern unspecified UsdPrimIsInstance;
507 /// Tests UsdPrim::HasDefiningSpecifier()
508 extern unspecified UsdPrimHasDefiningSpecifier;
509 
510 /// The default predicate used for prim traversals in methods like
511 /// UsdPrim::GetChildren, UsdStage::Traverse, and by UsdPrimRange.
512 /// This is a conjunction that includes all active, loaded, defined,
513 /// non-abstract prims, equivalent to:
514 /// \code
515 /// UsdPrimIsActive && UsdPrimIsDefined && UsdPrimIsLoaded && !UsdPrimIsAbstract
516 /// \endcode
517 ///
518 /// This represents the prims on a stage that a processor would typically
519 /// consider present, meaningful, and needful of consideration.
520 ///
521 /// See \ref Usd_PrimFlags "Prim predicate flags" for more information.
522 extern unspecified UsdPrimDefaultPredicate;
523 
524 /// Predicate that includes all prims.
525 ///
526 /// See \ref Usd_PrimFlags "Prim predicate flags" for more information.
527 extern unspecified UsdPrimAllPrimsPredicate;
528 
529 #else
530 
531 static const Usd_PrimFlags UsdPrimIsActive = Usd_PrimActiveFlag;
532 static const Usd_PrimFlags UsdPrimIsLoaded = Usd_PrimLoadedFlag;
533 static const Usd_PrimFlags UsdPrimIsModel = Usd_PrimModelFlag;
534 static const Usd_PrimFlags UsdPrimIsGroup = Usd_PrimGroupFlag;
535 static const Usd_PrimFlags UsdPrimIsAbstract = Usd_PrimAbstractFlag;
536 static const Usd_PrimFlags UsdPrimIsDefined = Usd_PrimDefinedFlag;
537 static const Usd_PrimFlags UsdPrimIsInstance = Usd_PrimInstanceFlag;
538 static const Usd_PrimFlags UsdPrimHasDefiningSpecifier
540 
543 
544 #endif // doxygen
545 
546 /// This function is used to allow the prim traversal functions listed under
547 /// \ref Usd_PrimFlags "Prim predicate flags" to traverse beneath instance
548 /// prims and return descendants that pass the specified \p predicate
549 /// as instance proxy prims. For example:
550 ///
551 /// \code
552 /// // Return all children of the specified prim.
553 /// // If prim is an instance, return all children as instance proxy prims.
554 /// prim.GetFilteredChildren(
555 /// UsdTraverseInstanceProxies(UsdPrimAllPrimsPredicate))
556 ///
557 /// // Return children of the specified prim that pass the default predicate.
558 /// // If prim is an instance, return the children that pass this predicate
559 /// // as instance proxy prims.
560 /// prim.GetFilteredChildren(UsdTraverseInstanceProxies());
561 ///
562 /// // Return all model or group children of the specified prim.
563 /// // If prim is an instance, return the children that pass this predicate
564 /// // as instance proxy prims.
565 /// prim.GetFilteredChildren(UsdTraverseInstanceProxies(UsdPrimIsModel || UsdPrimIsGroup));
566 /// \endcode
567 ///
568 /// Users may also call Usd_PrimFlagsPredicate::TraverseInstanceProxies to
569 /// enable traversal beneath instance prims. This function is equivalent to:
570 /// \code
571 /// predicate.TraverseInstanceProxies(true);
572 /// \endcode
573 ///
574 /// However, this function may be more convenient, especially when calling
575 /// a prim traversal function with a default-constructed tautology predicate.
578 {
579  return predicate.TraverseInstanceProxies(true);
580 }
581 
582 /// \overload
583 /// Convenience method equivalent to calling UsdTraverseInstanceProxies
584 /// with the UsdPrimDefaultPredicate that is used by default for prim
585 /// traversals.
588 {
590 }
591 
593 
594 #endif // USD_PRIMFLAGS_H
bool operator!=(Usd_Term other) const
Definition: primFlags.h:122
Usd_Term(Usd_PrimFlags flag, bool negated)
Definition: primFlags.h:117
Usd_PrimFlagsDisjunction & operator|=(Usd_Term term)
Add an additional term to this disjunction.
Definition: primFlags.h:414
bool _IsContradiction() const
Definition: primFlags.h:204
friend Usd_PrimFlagsConjunction operator&&(Usd_Term lhs, Usd_Term rhs)
Combine two terms to make a conjunction.
Definition: primFlags.h:369
#define USD_API
Definition: api.h:40
bool _IsTautology() const
Definition: primFlags.h:198
Usd_PrimFlagsConjunction operator&&(Usd_Term lhs, Usd_Term rhs)
Definition: primFlags.h:369
Usd_PrimFlagsConjunction(Usd_Term term)
Construct with a term.
Definition: primFlags.h:305
friend size_t hash_value(const Usd_PrimFlagsPredicate &p)
Definition: primFlags.h:276
Usd_PrimFlagsPredicate & _Negate()
Definition: primFlags.h:210
Usd_PrimFlagsConjunction()
Default constructed conjunction is a tautology.
Definition: primFlags.h:302
Usd_PrimFlags
Definition: primFlags.h:89
Usd_PrimFlagBits _mask
Definition: primFlags.h:221
Usd_PrimFlagsPredicate _GetNegated() const
Definition: primFlags.h:216
Usd_PrimFlags flag
Definition: primFlags.h:125
Usd_PrimFlagsPredicate & TraverseInstanceProxies(bool traverse)
Definition: primFlags.h:172
friend class Usd_PrimFlagsDisjunction
Definition: primFlags.h:351
Usd_PrimFlagsPredicate(Usd_PrimFlags flag)
Definition: primFlags.h:144
#define ARCH_UNLIKELY(x)
Definition: hints.h:47
Usd_PrimFlagBits _values
Definition: primFlags.h:224
static Usd_PrimFlagsPredicate Tautology()
Definition: primFlags.h:159
bool Usd_IsInstanceProxy(const PrimDataPtr &p, const SdfPath &proxyPrimPath)
Definition: primData.h:473
bool IncludeInstanceProxiesInTraversal() const
Definition: primFlags.h:186
friend bool Usd_EvalPredicate(const Usd_PrimFlagsPredicate &pred, const PrimPtr &prim, const SdfPath &proxyPrimPath)
Definition: primFlags.h:255
Definition: prim.h:131
Usd_PrimFlagsPredicate UsdTraverseInstanceProxies(Usd_PrimFlagsPredicate predicate)
Definition: primFlags.h:577
friend bool Usd_EvalPredicate(const Usd_PrimFlagsPredicate &pred, const PrimPtr &prim, bool isInstanceProxy)
Definition: primFlags.h:245
friend Usd_PrimFlagsDisjunction operator||(Usd_Term lhs, Usd_Term rhs)
Combine two terms to make a disjunction.
Definition: primFlags.h:472
Definition: path.h:287
GLfloat GLfloat p
Definition: glew.h:16321
Usd_Term operator!(Usd_PrimFlags flag)
Definition: primFlags.h:130
static Usd_PrimFlagsPredicate Contradiction()
Definition: primFlags.h:165
USD_API const Usd_PrimFlagsConjunction UsdPrimDefaultPredicate
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1245
Usd_Term(Usd_PrimFlags flag)
Definition: primFlags.h:116
USD_API const Usd_PrimFlagsPredicate UsdPrimAllPrimsPredicate
Usd_PrimFlagsDisjunction(Usd_Term term)
Definition: primFlags.h:408
friend bool operator==(const Usd_PrimFlagsPredicate &lhs, const Usd_PrimFlagsPredicate &rhs)
Definition: primFlags.h:262
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:83
friend bool operator!=(const Usd_PrimFlagsPredicate &lhs, const Usd_PrimFlagsPredicate &rhs)
Definition: primFlags.h:270
Usd_Term operator!() const
Definition: primFlags.h:118
Usd_PrimFlagsConjunction & operator&=(Usd_Term term)
Add an additional term to this conjunction.
Definition: primFlags.h:310
bool operator==(Usd_Term other) const
Definition: primFlags.h:119
USD_API bool operator()(const class UsdPrim &prim) const
#define const
Definition: zconf.h:214
std::bitset< Usd_PrimNumFlags > Usd_PrimFlagBits
Definition: primFlags.h:110
Usd_PrimFlagsDisjunction operator||(Usd_Term lhs, Usd_Term rhs)
Definition: primFlags.h:472
bool negated
Definition: primFlags.h:126
Usd_PrimFlagsPredicate(Usd_Term term)
Definition: primFlags.h:151
friend class Usd_PrimFlagsConjunction
Definition: primFlags.h:455