HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
refPtr.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 PXR_BASE_TF_REF_PTR_H
25 #define PXR_BASE_TF_REF_PTR_H
26 
27 /// \file tf/refPtr.h
28 /// \ingroup group_tf_Memory
29 /// Reference counting.
30 ///
31 /// \anchor refPtr_QuickStart
32 /// <B> Quick Start </B>
33 ///
34 /// Here is how to make a class \c Bunny usable through \c TfRefPtr.
35 ///
36 /// \code
37 /// #include "pxr/base/tf/refPtr.h"
38 /// typedef TfRefPtr<Bunny> BunnyRefPtr;
39 ///
40 /// class Bunny : public TfRefBase {
41 /// public:
42 /// static BunnyRefPtr New() {
43 /// // warning: return new Bunny directly will leak memory!
44 /// return TfCreateRefPtr(new Bunny);
45 /// }
46 /// static BunnyRefPtr New(bool isRabid) {
47 /// return TfCreateRefPtr(new Bunny(isRabid));
48 /// }
49 ///
50 /// ~Bunny();
51 ///
52 /// bool IsHungry();
53 /// private:
54 /// Bunny();
55 /// Bunny(bool);
56 /// };
57 ///
58 /// BunnyRefPtr nice = Bunny::New();
59 /// BunnyRefPtr mean = Bunny::New(true); // this one is rabid
60 ///
61 /// BunnyRefPtr mean2 = mean; // two references to mean rabbit
62 /// mean.Reset(); // one reference to mean rabbit
63 ///
64 /// if (mean2->IsHungry())
65 /// nice.Reset(); // nice bunny gone now...
66 ///
67 /// // this function comes from
68 /// // TfRefBase; meaning is that
69 /// if (mean2->IsUnique()) // mean2 is the last pointer to
70 /// mean2.Reset(); // this bunny...
71 /// \endcode
72 ///
73 /// Pretty much any pointer operation that is legal with regular pointers
74 /// is legal with the \c BunnyRefPtr; continue reading for a more detailed
75 /// description.
76 ///
77 /// Note that by virtue of deriving from \c TfRefBase, the reference
78 /// count can be queried: see \c TfRefBase for details.
79 ///
80 /// \anchor refPtr_DetailedDiscussion
81 /// <B> Detailed Discussion: Overview </B>
82 ///
83 /// Objects created by the \c new operator can easily be a source of
84 /// both memory leaks and dangling pointers. One solution is
85 /// \e reference counting; when an object is created by \c new,
86 /// the number of pointers given the object's address is continually
87 /// tracked in a \e reference \e counter. Then, \c delete is called on
88 /// the object \e only when the object's reference count drops to zero,
89 /// meaning there are no more pointers left pointing to the object.
90 /// Reference counting avoids both dangling pointers and memory leaks.
91 ///
92 /// Access by regular pointers does not perform reference counting, but
93 /// the \c TfRefPtr<T> class implements reference-counted pointer access
94 /// to objects of type \c T, with minimal overhead. The reference counting
95 /// is made thread-safe by use of atomic integers.
96 ///
97 ///
98 /// <B> Basic Use </B>
99 ///
100 /// The use of a \c TfRefPtr is simple. Whenever a \c TfRefPtr is
101 /// made to point at an object, either by initialization or assignment,
102 /// the object being pointed at has its reference count incremented.
103 /// When a \c TfRefPtr with a non-NULL address is reassigned, or
104 /// goes out of scope, the object being pointed to has its reference
105 /// count decremented.
106 ///
107 /// A \c TfRefPtr<T> can access \c T's public members by the
108 /// \c -> operator and can be dereferenced by the "\c *" operator.
109 /// Here is a simple example:
110 /// \code
111 /// #include "pxr/base/tf/refPtr.h"
112 ///
113 /// typedef TfRefPtr<Simple> SimpleRefPtr;
114 ///
115 /// class Simple : public TfRefBase {
116 /// public:
117 /// void Method1();
118 /// int Method2();
119 ///
120 /// static SimpleRefPtr New() {
121 /// return TfCreateRefPtr(new Simple);
122 /// }
123 /// private:
124 /// Simple();
125 /// };
126 ///
127 ///
128 /// SimpleRefPtr p1; // p1 points to NULL
129 /// SimpleRefPtr p2 = Simple::New(); // p2 points to new object A
130 /// SimpleRefPtr p3 = Simple::New(); // p3 points to new object B
131 ///
132 /// p1->Method1(); // runtime error -- p1 is NULL
133 /// p3 = p2; // object B is deleted
134 /// p2->Method1(); // Method1 on object A
135 /// int value = p3->Method2(); // Method2 on object A
136 ///
137 /// p2.Reset(); // only p3 still points at A
138 /// p3 = p1; // object A is deleted
139 ///
140 /// if (...) {
141 /// SimpleRefPtr p4 = Simple::New(); // p4 points to object C
142 /// p4->Method1();
143 /// } // object C destroyed
144 /// \endcode
145 ///
146 /// Note that \c Simple's constructor is private; this ensures that one
147 /// can only get at a \c Simple through \c Simple::New(), which is careful
148 /// to return a \c SimpleRefPtr.
149 ///
150 /// Note that it is often useful to have both const and non-const
151 /// versions of \c TfRefPtr for the same data type. Our convention
152 /// is to use a \c typedef for each of these, with the const version
153 /// beginning with "Const", after any prefix. The const version can be
154 /// used as a parameter to a function in which you want to prevent
155 /// changes to the pointed-to object. For example:
156 /// \code
157 /// typedef TfRefPtr<XySimple> XySimpleRefPtr;
158 /// typedef TfRefPtr<const XySimple> XyConstSimpleRefPtr;
159 ///
160 /// void
161 /// Func1(const XySimpleRefPtr &p)
162 /// {
163 /// p->Modify(); // OK even if Modify() is not a const member
164 /// }
165 ///
166 /// void
167 /// Func2(const XyConstSimpleRefPtr &p)
168 /// {
169 /// p->Query(); // OK only if Query() is a const member
170 /// }
171 /// \endcode
172 ///
173 /// It is always possible to assign a non-const pointer to a const
174 /// pointer variable. In extremely rare cases where you want to do the
175 /// opposite, you can use the \c TfConst_cast function, as in:
176 /// \code
177 /// XyConstSimpleRefPtr p1;
178 /// XySimpleRefPtr p2;
179 ///
180 /// p1 = p2; // OK
181 /// p2 = p1; // Illegal!
182 /// p2 = TfConst_cast<XySimpleRefPtr>(p1); // OK, but discouraged
183 /// \endcode
184 ///
185 /// <B> Comparisons and Tests </B>
186 ///
187 /// Reference-counted pointers of like type can be compared; any \c TfRefPtr
188 /// can be tested to see it is NULL or not:
189 ///
190 /// \code
191 /// TfRefPtr<Elf> elf = Elf::New();
192 /// TfRefPtr<Dwarf> sleepy,
193 /// sneezy = Dwarf::New();
194 ///
195 /// if (!sleepy)
196 /// ... // true: sleepy is NULL
197 ///
198 /// if (sneezy)
199 /// ... // true: sneezy is non-nULL
200 ///
201 /// bool b1 = (sleepy != sneezy),
202 /// b2 = (sleepy == sneezy),
203 /// b3 = (elf == sneezy); // compilation error -- type clash
204 ///
205 /// \endcode
206 ///
207 /// <B> Opaqueness </B>
208 ///
209 /// A \c TfRefPtr can be used as an opaque pointer, just as a regular
210 /// pointer can. For example, without having included the header file
211 /// for a class \c XySimple, the following will still compile:
212 /// \code
213 /// #include "pxr/base/tf/refPtr.h"
214 ///
215 /// class XySimple;
216 ///
217 /// class Complicated {
218 /// public:
219 /// void SetSimple(const TfRefPtr<XySimple>& s) {
220 /// _simplePtr = s;
221 /// }
222 ///
223 /// TfRefPtr<XySimple> GetSimple() {
224 /// return _simplePtr;
225 /// }
226 ///
227 /// void Forget() {
228 /// _simplePtr.Reset();
229 /// }
230 ///
231 /// private:
232 /// TfRefPtr<XySimple> _simplePtr;
233 /// };
234 /// \endcode
235 ///
236 /// Note that the call \c Forget() (or \c SetSimple() for that matter)
237 /// may implicitly cause destruction of an \c XySimple object, if the count
238 /// of the object pointed to by \c _simplePtr drops to zero. Even though
239 /// the definition of \c XySimple is unknown, this compiles and works correctly.
240 ///
241 /// The only time that the definition of \c XySimple is required is when
242 /// putting a raw \c XySimple* into a \c TfRefPtr<XySimple>; note however, that
243 /// this should in fact only be done within the class definition of
244 /// \c XySimple itself.
245 ///
246 /// Other cases that require a definition of \c XySimple are parallel to
247 /// regular raw pointers, such as calling a member function, static or
248 /// dynamic casts (but not const casts) and using the \c TfTypeid
249 /// function. Transferring a \c TfWeakPtr to a \c TfRefPtr also
250 /// requires knowing the definition of \c XySimple.
251 ///
252 /// Sometimes a class may have many typedefs associated with it, having
253 /// to do with \c TfRefPtr or \c TfWeakPtr. If it is useful to use
254 /// the class opaquely, we recommend creating a separate file
255 /// as follows:
256 ///
257 /// \code
258 /// // file: proj/xy/simplePtrDefs.h
259 /// #include "pxr/base/tf/refPtr.h"
260 /// #include "pxr/base/tf/weakPtr.h"
261 ///
262 /// typedef TfRefPtr<class XySimple> XySimpleRefPtr;
263 /// typedef TfRefPtr<const class XySimple> XyConstSimpleRefPtr;
264 ///
265 /// // typedefs for TfWeakPtr<XySimple> would follow,
266 /// // if XySimple derives from TfWeakBase
267 /// \endcode
268 ///
269 /// The definition for \c XySimple would then use the typedefs:
270 ///
271 /// \code
272 /// #include "Proj/Xy/SimpleRefPtrDefs.h"
273 ///
274 /// class XySimple : public TfRefBase {
275 /// public:
276 /// static XySimpleRefPtr New();
277 /// ...
278 /// };
279 ///
280 /// \endcode
281 ///
282 /// The above pattern now allows a consumer of class \c XySimple the option
283 /// to include only \c simplePtrDefs.h, if using the type opaquely suffices,
284 /// or to include \c simple.h, if the class definition is required.
285 ///
286 ///
287 /// <B> Cyclic Dependencies </B>
288 ///
289 /// If you build a tree using \c TfRefPtr, and you only have pointers
290 /// from parent to child, everything is fine: if you "lose" the root of the
291 /// tree, the tree will correctly destroy itself.
292 ///
293 /// But what if children point back to parents? Then a simple parent/child
294 /// pair is stable, because the parent and child point at each other, and
295 /// even if nobody else has a pointer to the parent, the reference count
296 /// of the two nodes remains at one.
297 ///
298 /// The solution to this is to make one of the links (typically from child back
299 /// to parent) use a \c TfWeakPtr. If a class \c T is enabled for both
300 /// "guarding" (see \c TfWeakBase) and reference counting, then a \c TfRefPtr
301 /// can be converted to a \c TfWeakPtr (in this context, a "back pointer")
302 /// and vice versa.
303 ///
304 /// <B> Inheritance </B>
305 ///
306 ///
307 /// Reference-counted pointers obey the same rules with respect to inheritance
308 /// as regular pointers. In particular, if class \c Derived is derived
309 /// from class \c Base, then the following are legal:
310 ///
311 /// \code
312 /// TfRefPtr<Base> bPtr = new Base;
313 /// TfRefPtr<Derived> dPtr = new Derived;
314 ///
315 /// TfRefPtr<Base> b2Ptr = dPtr; // initialization
316 /// b2Ptr = dPtr; // assignment
317 /// b2Ptr == dPtr; // comparison
318 ///
319 /// dPtr = bPtr; // Not legal: compilation error
320 /// \endcode
321 ///
322 /// As the last example shows, initialization or assignment to
323 /// a \c TfRefPtr<Derived> from a \c TfRefPtr<Base> is illegal,
324 /// just as it is illegal to assign a \c Base* to a \c Derived*.
325 /// However, if \c Derived and \c Base are polymorphic
326 /// (i.e. have virtual functions) then the analogue of a \c dynamic_cast<>
327 /// is possible:
328 ///
329 /// \code
330 /// dPtr = TfDynamic_cast<TfRefPtr<Derived> >(bPtr);
331 /// \endcode
332 ///
333 /// Just like a regular \c dynamic_cast<> operation, the \c TfRefPtr
334 /// returned by \c TfDynamic_cast<> points to NULL if the conversion fails,
335 /// so that the operator can also be used to check types:
336 ///
337 /// \code
338 /// if (! TfDynamic_cast<TfRefPtr<T2> >(ptr))
339 /// // complain: ptr is not of type T2
340 /// \endcode
341 ///
342 /// Similarly, one can use the \c TfStatic_cast<> operator to statically
343 /// convert \c TfRefPtrs:
344 ///
345 /// \code
346 /// dPtr = TfStatic_cast<TfRefPtr<Derived> >(bPtr);
347 /// \endcode
348 ///
349 /// This is faster, but not as safe as using \c TfDynamic_cast.
350 ///
351 /// Finally, remember that in \c C++, a \c Derived** is
352 /// not a \c Base**, nor is a \c Derived*& a \c Base*&. This implies
353 /// that
354 ///
355 /// \code
356 /// TfRefPtr<Base>* bPtrPtr = &dPtr; // compilation error
357 /// TfRefPtr<Base>& bPtrRef = dPtr; // compilation error
358 /// const TfRefPtr<Base>&bPtrRef = dPtr; // OK
359 /// \endcode
360 ///
361 /// The last initialization is legal because the compiler implicitly
362 /// converts dPtr into a temporary variable of type \c TfRefPtr<Base>.
363 ///
364 ///
365 /// <B> Thread Safety </B>
366 ///
367 /// One more comment about thread-safety: the above examples are thread-safe
368 /// in the sense that if two or more threads create and destroy their \e own
369 /// \c TfRefPtr objects, the reference counts of the underlying objects are
370 /// always correct; said another way, the reference count it a thread-safe
371 /// quantity.
372 ///
373 /// However, it is never safe for two threads to simultaneously try to alter
374 /// the same \c TfRefPtr object, nor can two threads safely call methods on the
375 /// same underlying object unless that object itself guarantees thread safety.
376 ///
377 /// \anchor refPtr_Tracking
378 /// <B> Tracking References </B>
379 ///
380 /// The \c TfRefPtrTracker singleton can track \c TfRefPtr objects that
381 /// point to particular instances. The macros \c TF_DECLARE_REFBASE_TRACK
382 /// and \c TF_DEFINE_REFBASE_TRACK are used to enable tracking. Tracking
383 /// is enabled at compile time but which instances to track is chosen at
384 /// runtime.
385 ///
386 /// <B> Total Encapsulation </B>
387 /// \anchor refPtr_encapsulation
388 ///
389 /// If you're using \c TfRefPtrs on a type \c T, you probably want
390 /// to completely forbid clients from creating their own objects of
391 /// type \c T, and force them to go through \c TfRefPtrs. Such
392 /// encapsulation is strongly encouraged. Here is the recommended
393 /// technique:
394 ///
395 /// \code
396 ///
397 /// typedef TfRefPtr<class Simple> SimpleRefPtr;
398 ///
399 /// class Simple : public TfRefBase {
400 /// private: // use protected if you plan to derive later
401 /// Simple();
402 /// Simple(<arg-list>);
403 /// public:
404 /// static SimpleRefPtr New() {
405 /// return TfCreateRefPtr(new Simple);
406 /// }
407 ///
408 /// static SimpleRefPtr New(<arg-list>) {
409 /// return TfCreateRefPtr(new Simple(<arg-list>));
410 /// }
411 ///
412 /// ~Simple();
413 /// };
414 /// \endcode
415 ///
416 /// Clients can now only create objects of type \c Simple using a
417 /// \c TfRefPtr:
418 ///
419 /// \code
420 /// Simple s; // compilation error
421 /// SimpleRefPtr sPtr1 = new Simple; // compilation error
422 /// SimpleRefPtr sPtr2 = Simple::New(); // OK
423 /// SimpleRefPtr sPtr3 = Simple::New(<arg-list>); // Ok
424 /// \endcode
425 ///
426 
427 #include "pxr/pxr.h"
428 
430 #include "pxr/base/tf/hash.h"
431 #include "pxr/base/tf/nullPtr.h"
432 #include "pxr/base/tf/refBase.h"
435 #include "pxr/base/tf/api.h"
436 
437 #include "pxr/base/arch/hints.h"
438 
439 
440 #include <typeinfo>
441 #include <type_traits>
442 #include <cstddef>
443 
445 
446 // Tf_SupportsUniqueChanged is a metafunction that may be specialized to return
447 // false for classes (and all derived classes) that *cannot* ever invoke unique
448 // changed listeners.
449 template <class T>
451  static const bool Value = true;
452 };
453 
454 // Remnants are never able to support weak changed listeners.
455 class Tf_Remnant;
456 template <>
458  static const bool Value = false;
459 };
460 
461 class TfWeakBase;
462 
463 template <class T> class TfWeakPtr;
464 template <template <class> class X, class Y>
466 
467 // Functions used for tracking. Do not implement these.
468 inline void Tf_RefPtrTracker_FirstRef(const void*, const void*) { }
469 inline void Tf_RefPtrTracker_LastRef(const void*, const void*) { }
470 inline void Tf_RefPtrTracker_New(const void*, const void*) { }
471 inline void Tf_RefPtrTracker_Delete(const void*, const void*) { }
472 inline void Tf_RefPtrTracker_Assign(const void*, const void*, const void*) { }
473 
474 // This code is used to increment and decrement ref counts in the common case.
475 // It may lock and invoke the unique changed listener, if the reference count
476 // becomes unique or non-unique.
478  static inline int
479  AddRef(TfRefBase const *refBase)
480  {
481  if (refBase) {
482  // Check to see if we need to invoke the unique changed listener.
483  if (refBase->_shouldInvokeUniqueChangedListener)
484  return _AddRef(refBase);
485  else
486  return refBase->GetRefCount()._FetchAndAdd(1);
487  }
488  return 0;
489  }
490 
491  static inline bool
492  RemoveRef(TfRefBase const* refBase) {
493  if (refBase) {
494  // Check to see if we need to invoke the unique changed listener.
495  return refBase->_shouldInvokeUniqueChangedListener ?
496  _RemoveRef(refBase) :
497  refBase->GetRefCount()._DecrementAndTestIfZero();
498  }
499  return false;
500  }
501 
502  // Increment ptr's count if it is not zero. Return true if done so
503  // successfully, false if its count is zero.
504  static inline bool
506  if (!ptr)
507  return false;
508  if (ptr->_shouldInvokeUniqueChangedListener) {
509  return _AddRefIfNonzero(ptr);
510  } else {
511  auto &counter = ptr->GetRefCount()._counter;
512  auto val = counter.load();
513  do {
514  if (val == 0)
515  return false;
516  } while (!counter.compare_exchange_weak(val, val + 1));
517  return true;
518  }
519  }
520 
521  TF_API static bool _RemoveRef(TfRefBase const *refBase);
522 
523  TF_API static int _AddRef(TfRefBase const *refBase);
524 
525  TF_API static bool _AddRefIfNonzero(TfRefBase const *refBase);
526 };
527 
528 // This code is used to increment and decrement ref counts in the case where
529 // the object pointed to explicitly does not support unique changed listeners.
531  static inline int
532  AddRef(TfRefBase const *refBase) {
533  if (refBase)
534  return refBase->GetRefCount()._FetchAndAdd(1);
535  return 0;
536  }
537 
538  static inline bool
540  return (ptr && (ptr->GetRefCount()._DecrementAndTestIfZero()));
541  }
542 
543  // Increment ptr's count if it is not zero. Return true if done so
544  // successfully, false if its count is zero.
545  static inline bool
547  if (!ptr)
548  return false;
549  auto &counter = ptr->GetRefCount()._counter;
550  auto val = counter.load();
551  do {
552  if (val == 0)
553  return false;
554  } while (!counter.compare_exchange_weak(val, val + 1));
555  return true;
556  }
557 };
558 
559 // Helper to post a fatal error when a NULL Tf pointer is dereferenced.
560 [[noreturn]]
561 TF_API void
563 
564 /// \class TfRefPtr
565 /// \ingroup group_tf_Memory
566 ///
567 /// Reference-counted smart pointer utility class
568 ///
569 /// The \c TfRefPtr class implements a reference counting on objects
570 /// that inherit from \c TfRefBase.
571 ///
572 /// For more information, see either the \ref refPtr_QuickStart "Quick Start"
573 /// example or read the \ref refPtr_DetailedDiscussion "detailed discussion".
574 ///
575 template <class T>
576 class TfRefPtr {
577  // Select the counter based on whether T supports unique changed listeners.
578  using _Counter = typename std::conditional<
583 
584 public:
585  /// Convenience type accessor to underlying type \c T for template code.
586  typedef T DataType;
587 
588 
589  template <class U> struct Rebind {
590  typedef TfRefPtr<U> Type;
591  };
592 
593  /// Initialize pointer to nullptr.
594  ///
595  /// The default constructor leaves the pointer initialized to point to the
596  /// NULL object. Attempts to use the \c -> operator will cause an abort
597  /// until the pointer is given a value.
598  TfRefPtr() : _refBase(nullptr) {
599  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
600  }
601 
602  /// Moves the pointer managed by \p p to \c *this.
603  ///
604  /// After construction, \c *this will point to the object \p p had
605  /// been pointing at and \p p will be pointing at the NULL object.
606  /// The reference count of the object being pointed at does not
607  /// change.
608  TfRefPtr(TfRefPtr<T>&& p) : _refBase(p._refBase) {
609  p._refBase = nullptr;
610  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
611  Tf_RefPtrTracker_Assign(&p, p._GetObjectForTracking(),
612  _GetObjectForTracking());
613  }
614 
615  /// Initializes \c *this to point at \p p's object.
616  ///
617  /// Increments \p p's object's reference count.
618  TfRefPtr(const TfRefPtr<T>& p) : _refBase(p._refBase) {
619  _AddRef();
620  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
621  }
622 
623  /// Initializes \c *this to point at \p gp's object.
624  ///
625  /// Increments \p gp's object's reference count.
626  template <template <class> class X, class U>
627  inline TfRefPtr(const TfWeakPtrFacade<X, U>& p,
628  typename std::enable_if<
630  >::type * = 0);
631 
632  /// Transfer a raw pointer to a reference-counted pointer.
633  ///
634  /// The \c TfCreateRefPtr() function should only be used from within a
635  /// static \c New() function (or similarly, a \c Clone() function) of a
636  /// reference-counted class. Reference-counted objects have their
637  /// reference count initially set to one to account for the fact that a
638  /// newly created object must always persist at least until its \c New()
639  /// function returns. Therefore, the transfer of the pointer returned by
640  /// \c new into a reference pointer must \e not increase the reference
641  /// count. The transfer of the raw pointer returned by \c new into the
642  /// object returned by \c New() is a "transfer of ownership" and does not
643  /// represent an additional reference to the object.
644  ///
645  /// In summary, this code is wrong, and will return an object that can
646  /// never be destroyed:
647  ///
648  /// \code
649  /// SimpleRefPtr Simple::New() {
650  /// return SimpleRefPtr(new Simple); // legal, but leaks memory: beware!!
651  /// }
652  /// \endcode
653  ///
654  /// The correct form is
655  ///
656  /// \code
657  /// SimpleRefPtr Simple::New() {
658  /// return TfCreateRefPtr(new Simple);
659  /// }
660  /// \endcode
661  ///
662  /// Note also that a function which is essentially like \c New(),
663  /// for example \c Clone(), would also want to use \c TfCreateRefPtr().
664 #if defined(doxygen)
665  friend inline TfRefPtr TfCreateRefPtr(T*);
666 #else
667  template <class U>
668  friend inline TfRefPtr<U> TfCreateRefPtr(U*);
669 #endif
670 
671  /// Initializes to point at \c *ptr.
672  ///
673  /// Increments \c *ptr's reference count. Note that newly constructed
674  /// objects start with a reference count of one. Therefore, you should \e
675  /// NOT use this constructor (either implicitly or explicitly) from within
676  /// a \c New() function. Use \c TfCreateRefPtr() instead.
677  template <class U>
678  explicit TfRefPtr(
679  U* ptr, typename std::enable_if<
681  _refBase(ptr)
682  {
683  _AddRef();
684  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
685  }
686 
687  /// Implicit conversion from \a TfNullPtr to TfRefPtr.
688  TfRefPtr(TfNullPtrType) : _refBase(nullptr)
689  {
690  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
691  }
692 
693  /// Implicit conversion from \a nullptr to TfRefPtr.
694  TfRefPtr(std::nullptr_t) : _refBase(nullptr)
695  {
696  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
697  }
698 
699  /// Assigns pointer to point at \c p's object, and increments reference
700  /// count.
701  ///
702  /// The object (if any) pointed at before the assignment has its
703  /// reference count decremented, while the object newly pointed at
704  /// has its reference count incremented.
705  /// If the object previously pointed to now has nobody left to point at it,
706  /// the object will typically be destroyed at this point.
707  ///
708  /// An assignment
709  /// \code
710  /// ptr = TfNullPtr;
711  /// \endcode
712  ///
713  /// can be used to make \c ptr "forget" where it is pointing; note
714  /// however that this has an important side effect, since it
715  /// decrements the reference count of the object previously pointed
716  /// to by \c ptr, possibly triggering destruction of that object.
718  //
719  // It is quite possible for
720  // ptr = TfNullPtr;
721  // to delete the space that ptr actually lives in (this happens
722  // when you use a circular reference to keep an object alive).
723  // To avoid a crash, we have to ensure that deletion of the object
724  // is the last thing done in the assignment; so we use some
725  // local variables to help us out.
726  //
727 
728  Tf_RefPtrTracker_Assign(this, p._GetObjectForTracking(),
729  _GetObjectForTracking());
730 
731  const TfRefBase* tmp = _refBase;
732  _refBase = p._refBase;
733 
734  p._AddRef(); // first!
735  _RemoveRef(tmp); // second!
736  return *this;
737  }
738 
739  /// Moves the pointer managed by \p p to \c *this and leaves \p p
740  /// pointing at the NULL object.
741  ///
742  /// The object (if any) pointed at before the assignment has its
743  /// reference count decremented, while the reference count of the
744  /// object newly pointed at is not changed.
746  // See comment in assignment operator.
747  Tf_RefPtrTracker_Assign(this, p._GetObjectForTracking(),
748  _GetObjectForTracking());
749  Tf_RefPtrTracker_Assign(&p, nullptr,
750  p._GetObjectForTracking());
751 
752  const TfRefBase* tmp = _refBase;
753  _refBase = p._refBase;
754  p._refBase = nullptr;
755 
756  _RemoveRef(tmp);
757  return *this;
758  }
759 
760  /// Decrements reference count of object being pointed to.
761  ///
762  /// If the reference count of the object (if any) that was just pointed at
763  /// reaches zero, the object will typically be destroyed at this point.
765  Tf_RefPtrTracker_Delete(this, _GetObjectForTracking());
766  _RemoveRef(_refBase);
767  }
768 
769  /// Initializes to point at \c p's object, and increments reference count.
770  ///
771  /// This initialization is legal only if
772  /// \code
773  /// U* uPtr;
774  /// T* tPtr = uPtr;
775  /// \endcode
776  /// is legal.
777 #if !defined(doxygen)
778  template <class U>
779 #endif
780  TfRefPtr(const TfRefPtr<U>& p) : _refBase(p._refBase) {
781  static_assert(std::is_convertible<U*, T*>::value, "");
782  _AddRef();
783  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
784  }
785 
786  /// Moves the pointer managed by \p p to \c *this and leaves \p p
787  /// pointing at the NULL object. The reference count of the object
788  /// being pointed to is not changed.
789  ///
790  /// This initialization is legal only if
791  /// \code
792  /// U* uPtr;
793  /// T* tPtr = uPtr;
794  /// \endcode
795  /// is legal.
796 #if !defined(doxygen)
797  template <class U>
798 #endif
799  TfRefPtr(TfRefPtr<U>&& p) : _refBase(p._refBase) {
800  static_assert(std::is_convertible<U*, T*>::value, "");
801  p._refBase = nullptr;
802  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
803  Tf_RefPtrTracker_Assign(&p, p._GetObjectForTracking(),
804  _GetObjectForTracking());
805  }
806 
807  /// Assigns pointer to point at \c p's object, and increments reference
808  /// count.
809  ///
810  /// This assignment is legal only if
811  /// \code
812  /// U* uPtr;
813  /// T* tPtr;
814  /// tPtr = uPtr;
815  /// \endcode
816  /// is legal.
817 #if !defined(doxygen)
818  template <class U>
819 #endif
821  static_assert(std::is_convertible<U*, T*>::value, "");
822 
824  reinterpret_cast<T*>(p._GetObjectForTracking()),
825  _GetObjectForTracking());
826  const TfRefBase* tmp = _refBase;
827  _refBase = p._GetData();
828  p._AddRef(); // first!
829  _RemoveRef(tmp); // second!
830  return *this;
831  }
832 
833  /// Moves the pointer managed by \p p to \c *this and leaves \p p
834  /// pointing at the NULL object. The reference count of the object
835  /// being pointed to is not changed.
836  ///
837  /// This assignment is legal only if
838  /// \code
839  /// U* uPtr;
840  /// T* tPtr;
841  /// tPtr = uPtr;
842  /// \endcode
843  /// is legal.
844 #if !defined(doxygen)
845  template <class U>
846 #endif
848  static_assert(std::is_convertible<U*, T*>::value, "");
849 
851  reinterpret_cast<T*>(p._GetObjectForTracking()),
852  _GetObjectForTracking());
854  nullptr,
855  reinterpret_cast<T*>(p._GetObjectForTracking()));
856  const TfRefBase* tmp = _refBase;
857  _refBase = p._GetData();
858  p._refBase = nullptr;
859  _RemoveRef(tmp);
860  return *this;
861  }
862 
863  /// Returns true if \c *this and \c p point to the same object (or if they
864  /// both point to NULL).
865  ///
866  /// The comparison is legal only if a \c T* and a \c U* are comparable.
867 #if !defined(doxygen)
868  template <class U>
869 #endif
870  auto operator==(const TfRefPtr<U>& p) const
871  -> decltype(std::declval<T *>() == std::declval<U *>(), bool()) {
872  return _refBase == p._refBase;
873  }
874 
875  /// Returns true if \c *this and \c p do not point to the same object.
876  ///
877  /// The comparison is legal only if a \c T* and a \c U* are comparable.
878 #if !defined(doxygen)
879  template <class U>
880 #endif
881  auto operator!=(const TfRefPtr<U>& p) const
882  -> decltype(std::declval<T *>() != std::declval<U *>(), bool()) {
883  return _refBase != p._refBase;
884  }
885 
886  /// Returns true if the address of the object pointed to by \c *this
887  /// compares less than the address of the object pointed to by \p p.
888  ///
889  /// The comparison is legal only if a \c T* and a \c U* are comparable.
890 #if !defined(doxygen)
891  template <class U>
892 #endif
893  auto operator<(const TfRefPtr<U>& p) const
894  -> decltype(std::declval<T *>() < std::declval<U *>(), bool()) {
895  return _refBase < p._refBase;
896  }
897 
898 #if !defined(doxygen)
899  template <class U>
900 #endif
901  auto operator>(const TfRefPtr<U>& p) const
902  -> decltype(std::declval<T *>() > std::declval<U *>(), bool()) {
903  return _refBase > p._refBase;
904  }
905 
906 #if !defined(doxygen)
907  template <class U>
908 #endif
909  auto operator<=(const TfRefPtr<U>& p) const
910  -> decltype(std::declval<T *>() <= std::declval<U *>(), bool()) {
911  return _refBase <= p._refBase;
912  }
913 
914 #if !defined(doxygen)
915  template <class U>
916 #endif
917  auto operator>=(const TfRefPtr<U>& p) const
918  -> decltype(std::declval<T *>() >= std::declval<U *>(), bool()) {
919  return _refBase >= p._refBase;
920  }
921 
922  /// Accessor to \c T's public members.
923  T* operator->() const {
924  if (_refBase) {
925  return static_cast<T*>(const_cast<TfRefBase*>(_refBase));
926  }
928  TF_CALL_CONTEXT, typeid(TfRefPtr).name());
929  }
930 
931  /// Dereferences the stored pointer.
932  T& operator *() const {
933  return *operator->();
934  }
935 
936 #if !defined(doxygen)
937  using UnspecifiedBoolType = const TfRefBase * (TfRefPtr::*);
938 #endif
939 
940  /// True if the pointer points to an object.
941  operator UnspecifiedBoolType() const {
942  return _refBase ? &TfRefPtr::_refBase : nullptr;
943  }
944 
945  /// True if the pointer points to \c NULL.
946  bool operator !() const {
947  return _refBase == nullptr;
948  }
949 
950  /// Swap this pointer with \a other.
951  /// After this operation, this pointer will point to what \a other
952  /// formerly pointed to, and \a other will point to what this pointer
953  /// formerly pointed to.
954  void swap(TfRefPtr &other) {
955  Tf_RefPtrTracker_Assign(this, other._GetObjectForTracking(),
956  _GetObjectForTracking());
957  Tf_RefPtrTracker_Assign(&other, _GetObjectForTracking(),
958  other._GetObjectForTracking());
959  std::swap(_refBase, other._refBase);
960  }
961 
962  /// Set this pointer to point to no object.
963  /// Equivalent to assignment with TfNullPtr.
964  void Reset() {
965  *this = TfNullPtr;
966  }
967 
968 private:
969  const TfRefBase* _refBase;
970 
971  template <class HashState, class U>
972  friend inline void TfHashAppend(HashState &, const TfRefPtr<U>&);
973  template <class U>
974  friend inline size_t hash_value(const TfRefPtr<U>&);
975 
976  friend T *get_pointer(TfRefPtr const &p) {
977  return static_cast<T *>(const_cast<TfRefBase *>(p._refBase));
978  }
979 
980  // Used to distinguish construction in TfCreateRefPtr.
981  class _CreateRefPtr { };
982 
983  // private constructor, used by TfCreateRefPtr()
984  TfRefPtr(T* ptr, _CreateRefPtr /* unused */)
985  : _refBase(ptr)
986  {
987  /* reference count is NOT bumped */
988  Tf_RefPtrTracker_FirstRef(this, _GetObjectForTracking());
989  Tf_RefPtrTracker_New(this, _GetObjectForTracking());
990  }
991 
992  // Hide confusing internals of actual C++ definition (e.g. DataType)
993  // for doxygen output:
994 
995  /// Allows dynamic casting of a \c TfRefPtr.
996  ///
997  /// If it is legal to dynamically cast a \c T* to a \c D* , then
998  /// the following is also legal:
999  /// \code
1000  /// TfRefPtr<T> tPtr = ... ;
1001  /// TfRefPtr<D> dPtr;
1002  ///
1003  /// if (!(dPtr = TfDynamic_cast< TfRefPtr<D> >(tPtr)))
1004  /// ...; // cast failed
1005  /// \endcode
1006  /// The runtime performance of this function is exactly the same
1007  /// as a \c dynamic_cast (i.e. one virtual function call). If the pointer
1008  /// being cast is NULL or does not point to an object of the requisite
1009  /// type, the result is a \c TfRefPtr pointing to NULL.
1010 #if defined(doxygen)
1011  // Sanitized for documentation:
1012  template <class D>
1013  friend inline TfRefPtr<D> TfDynamic_cast(const TfRefPtr<T>&);
1014 #else
1015  template <class D, class B>
1017  TfDynamic_cast(const TfRefPtr<B>&);
1018 
1019  template <class D, class B>
1022 #endif
1023 
1024  /// Allows static casting of a \c TfRefPtr.
1025  ///
1026  /// If it is legal to statically cast a \c T* to a \c D* , then
1027  /// the following is also legal:
1028  /// \code
1029  /// TfRefPtr<T> tPtr = ... ;
1030  /// TfRefPtr<D> dPtr;
1031  ///
1032  /// dPtr = TfStatic_cast< TfRefPtr<D> >(tPtr);
1033  /// \endcode
1034  /// The runtime performance of this function is exactly the same
1035  /// as a regular \c TfRefPtr initialization, since the cost of
1036  /// the underlying \c static_cast is zero. Of course, a \c TfDynamic_cast
1037  /// is preferred, assuming the underlying types are polymorphic
1038  /// (i.e. have virtual functions).
1039  ///
1040 #if defined(doxygen)
1041  // Sanitized for documentation:
1042  template <class D>
1043  friend inline TfRefPtr<D> TfStatic_cast(const TfRefPtr<T>&);
1044 #else
1045  template <class D, class B>
1047  TfStatic_cast(const TfRefPtr<B>&);
1048 
1049 #endif
1050 
1051  /// Allows const casting of a \c TfRefPtr.
1052  ///
1053  /// The following is always legal:
1054  /// \code
1055  /// TfRefPtr<const T> cPtr = ...;
1056  /// TfRefPtr<T> tPtr;
1057  ///
1058  /// tPtr = TfConst_cast< TfRefPtr<T> >(cPtr);
1059  /// \endcode
1060  /// As with the C++ \c const_cast operator, use of this function is
1061  /// discouraged.
1062 #if defined(doxygen)
1063  // Sanitized for documentation:
1064  template <class D>
1065  friend inline TfRefPtr<D> TfConst_cast(const TfRefPtr<const D>&);
1066 #else
1067  template <class D>
1070 #endif
1071 
1072  T* _GetData() const {
1073  return static_cast<T*>(const_cast<TfRefBase*>(_refBase));
1074  }
1075 
1076  // This method is only used when calling the hook functions for
1077  // tracking. We reinterpret_cast instead of static_cast so that
1078  // we don't need the definition of T. However, if TfRefBase is
1079  // not the first base class of T then the resulting pointer may
1080  // not point to a T. Nevertheless, it should be consistent to
1081  // all calls to the tracking functions.
1082  T* _GetObjectForTracking() const {
1083  return reinterpret_cast<T*>(const_cast<TfRefBase*>(_refBase));
1084  }
1085 
1086  /// Call \c typeid on the object pointed to by a \c TfRefPtr.
1087  ///
1088  /// If \c ptr is a \c TfRefPtr, \c typeid(ptr) will return
1089  /// type information about the \c TfRefPtr. To access type
1090  /// information about the object pointed to by a \c TfRefPtr,
1091  /// one can use \c TfTypeid.
1092 
1093  template <class U>
1094  friend const std::type_info& TfTypeid(const TfRefPtr<U>& ptr);
1095 
1096  void _AddRef() const {
1097  _Counter::AddRef(_refBase);
1098  }
1099 
1100  void _RemoveRef(const TfRefBase* ptr) const {
1101  if (_Counter::RemoveRef(ptr)) {
1103  reinterpret_cast<T*>(const_cast<TfRefBase*>(ptr)));
1104  delete ptr;
1105  }
1106  }
1107 
1108 #if ! defined(doxygen)
1109  // doxygen is very confused by this. It declares all TfRefPtrs
1110  // to be friends.
1111  template <class U> friend class TfRefPtr;
1112  template <class U> friend class TfWeakPtr;
1113  friend class Tf_Remnant;
1114 
1115  template <class U>
1117 #endif
1118  friend class TfWeakBase;
1119 };
1120 
1121 #if !defined(doxygen)
1122 
1123 //
1124 // nullptr comparisons
1125 //
1126 // These are provided to avoid ambiguous overloads due to
1127 // TfWeakPtrFacade::Derived comparisons with TfRefPtr.
1128 //
1129 
1130 template <class T>
1131 inline bool operator== (const TfRefPtr<T> &p, std::nullptr_t)
1132 {
1133  return !p;
1134 }
1135 template <class T>
1136 inline bool operator== (std::nullptr_t, const TfRefPtr<T> &p)
1137 {
1138  return !p;
1139 }
1140 
1141 template <class T>
1142 inline bool operator!= (const TfRefPtr<T> &p, std::nullptr_t)
1143 {
1144  return !(p == nullptr);
1145 }
1146 template <class T>
1147 inline bool operator!= (std::nullptr_t, const TfRefPtr<T> &p)
1148 {
1149  return !(nullptr == p);
1150 }
1151 
1152 template <class T>
1153 inline bool operator< (const TfRefPtr<T> &p, std::nullptr_t)
1154 {
1155  return std::less<const TfRefBase *>()(get_pointer(p), nullptr);
1156 }
1157 template <class T>
1158 inline bool operator< (std::nullptr_t, const TfRefPtr<T> &p)
1159 {
1160  return std::less<const TfRefBase *>()(nullptr, get_pointer(p));
1161 }
1162 
1163 template <class T>
1164 inline bool operator<= (const TfRefPtr<T> &p, std::nullptr_t)
1165 {
1166  return !(nullptr < p);
1167 }
1168 template <class T>
1169 inline bool operator<= (std::nullptr_t, const TfRefPtr<T> &p)
1170 {
1171  return !(p < nullptr);
1172 }
1173 
1174 template <class T>
1175 inline bool operator> (const TfRefPtr<T> &p, std::nullptr_t)
1176 {
1177  return nullptr < p;
1178 }
1179 template <class T>
1180 inline bool operator> (std::nullptr_t, const TfRefPtr<T> &p)
1181 {
1182  return p < nullptr;
1183 }
1184 
1185 template <class T>
1186 inline bool operator>= (const TfRefPtr<T> &p, std::nullptr_t)
1187 {
1188  return !(p < nullptr);
1189 }
1190 template <class T>
1191 inline bool operator>= (std::nullptr_t, const TfRefPtr<T> &p)
1192 {
1193  return !(nullptr < p);
1194 }
1195 
1196 
1197 template <typename T>
1199  return TfRefPtr<T>(ptr, typename TfRefPtr<T>::_CreateRefPtr());
1200 }
1201 
1202 template <class T>
1203 const std::type_info&
1205 {
1206  if (ARCH_UNLIKELY(!ptr._refBase))
1207  TF_FATAL_ERROR("called TfTypeid on NULL TfRefPtr");
1208 
1209  return typeid(*ptr._GetData());
1210 }
1211 
1212 template <class D, class T>
1213 inline
1216 {
1217  typedef TfRefPtr<typename D::DataType> RefPtr;
1218  return RefPtr(dynamic_cast<typename D::DataType*>(ptr._GetData()));
1219 }
1220 
1221 template <class D, class T>
1222 inline
1225 {
1226  typedef TfRefPtr<typename D::DataType> RefPtr;
1227  return RefPtr(TfSafeDynamic_cast<typename D::DataType*>(ptr._GetData()));
1228 }
1229 
1230 template <class D, class T>
1231 inline
1234 {
1235  typedef TfRefPtr<typename D::DataType> RefPtr;
1236  return RefPtr(static_cast<typename D::DataType*>(ptr._GetData()));
1237 }
1238 
1239 template <class T>
1240 inline
1243 {
1244  // this ugly cast allows TfConst_cast to work without requiring
1245  // a definition for T.
1246  typedef TfRefPtr<typename T::DataType> NonConstRefPtr;
1247  return *((NonConstRefPtr*)(&ptr));
1248 }
1249 
1250 // Specialization: prevent construction of a TfRefPtr<TfRefBase>.
1251 
1252 template <>
1254 private:
1256  }
1257 };
1258 
1259 template <>
1261 private:
1263  }
1264 };
1265 
1266 template <class T>
1268  static T* GetRawPtr(const TfRefPtr<T>& t) {
1269  return t.operator-> ();
1270  }
1271 
1273  return TfRefPtr<T>(ptr);
1274  }
1275 
1276  static bool IsNull(const TfRefPtr<T>& t) {
1277  return !t;
1278  }
1279 
1282 };
1283 
1284 template <class T>
1286  static const T* GetRawPtr(const TfRefPtr<const T>& t) {
1287  return t.operator-> ();
1288  }
1289 
1291  return TfRefPtr<const T>(ptr);
1292  }
1293 
1294  static bool IsNull(const TfRefPtr<const T>& t) {
1295  return !t;
1296  }
1297 
1299 };
1300 
1301 #endif
1302 
1303 #if !defined(doxygen)
1304 
1305 template <class T>
1306 inline void
1308 {
1309  lhs.swap(rhs);
1310 }
1311 
1313 
1314 namespace hboost {
1315 
1316 template<typename T>
1317 T *
1318 get_pointer(PXR_NS::TfRefPtr<T> const& p)
1319 {
1320  return get_pointer(p);
1321 }
1322 
1323 } // end namespace hboost
1324 
1326 
1327 // Extend hboost::hash to support TfRefPtr.
1328 template <class T>
1329 inline size_t
1331 {
1332  return TfHash()(ptr);
1333 }
1334 
1335 template <class HashState, class T>
1336 inline void
1337 TfHashAppend(HashState &h, const TfRefPtr<T> &ptr)
1338 {
1339  h.Append(get_pointer(ptr));
1340 }
1341 
1342 #endif // !doxygen
1343 
1344 #define TF_SUPPORTS_REFPTR(T) std::is_base_of<TfRefBase, T>::value
1345 
1347 
1348 #endif // PXR_BASE_TF_REF_PTR_H
void swap(ArAssetInfo &lhs, ArAssetInfo &rhs)
Definition: assetInfo.h:74
static void Class_Object_MUST_Be_Passed_By_Address()
Definition: refPtr.h:1280
auto operator==(const TfRefPtr< U > &p) const -> decltype(std::declval< T * >()==std::declval< U * >(), bool())
Definition: refPtr.h:870
TfRefPtr< T > TfCreateRefPtr(T *ptr)
Definition: refPtr.h:1198
#define TF_CALL_CONTEXT
Definition: callContext.h:47
PXR_NAMESPACE_OPEN_SCOPE size_t hash_value(const TfRefPtr< T > &ptr)
Definition: refPtr.h:1330
TfRefPtr< typename T::DataType > TfConst_cast(const TfRefPtr< const typename T::DataType > &ptr)
Definition: refPtr.h:1242
static TfRefPtr< const T > ConstructFromRawPtr(T *ptr)
Definition: refPtr.h:1290
#define TF_API
Definition: api.h:40
friend size_t hash_value(const TfRefPtr< U > &)
TfRefPtr(TfNullPtrType)
Implicit conversion from TfNullPtr to TfRefPtr.
Definition: refPtr.h:688
const TfRefCount & GetRefCount() const
Definition: refBase.h:93
Y
Definition: ImathEuler.h:184
void swap(UT::ArraySet< Key, MULTI, MAX_LOAD_FACTOR_256, Clearer, Hash, KeyEqual > &a, UT::ArraySet< Key, MULTI, MAX_LOAD_FACTOR_256, Clearer, Hash, KeyEqual > &b)
Definition: UT_ArraySet.h:1631
auto operator>=(const TfRefPtr< U > &p) const -> decltype(std::declval< T * >() >=std::declval< U * >(), bool())
Definition: refPtr.h:917
GLsizei const GLfloat * value
Definition: glcorearb.h:824
static bool RemoveRef(TfRefBase const *ptr)
Definition: refPtr.h:539
const TfRefBase *(TfRefPtr::*) UnspecifiedBoolType
Definition: refPtr.h:937
static bool IsNull(const TfRefPtr< T > &t)
Definition: refPtr.h:1276
TF_API const TfNullPtrType TfNullPtr
auto operator>(const TfRefPtr< U > &p) const -> decltype(std::declval< T * >() > std::declval< U * >(), bool())
Definition: refPtr.h:901
X
Definition: ImathEuler.h:183
static void Class_Object_MUST_Be_Passed_By_Address()
Definition: refPtr.h:1298
void Tf_RefPtrTracker_LastRef(const void *, const void *)
Definition: refPtr.h:469
friend T * get_pointer(TfRefPtr const &p)
Definition: refPtr.h:976
friend TfRefPtr< U > TfCreateRefPtr(U *)
TfRefPtr< T > & operator=(const TfRefPtr< T > &p)
Definition: refPtr.h:717
Y * get_pointer(TfWeakPtrFacade< X, Y > const &p)
Definition: weakPtrFacade.h:83
bool operator!() const
True if the pointer points to NULL.
Definition: refPtr.h:946
friend TfRefPtr< typename D::DataType > TfSafeDynamic_cast(const TfRefPtr< B > &)
void Tf_RefPtrTracker_Delete(const void *, const void *)
Definition: refPtr.h:471
Definition: hash.h:504
TfRefPtr(U *ptr, typename std::enable_if< std::is_convertible< U *, T * >::value >::type *=nullptr)
Definition: refPtr.h:678
T & operator*() const
Dereferences the stored pointer.
Definition: refPtr.h:932
static bool RemoveRef(TfRefBase const *refBase)
Definition: refPtr.h:492
TfRefPtr< typename D::DataType > TfDynamic_cast(const TfRefPtr< T > &ptr)
Definition: refPtr.h:1215
#define ARCH_UNLIKELY(x)
Definition: hints.h:47
TF_API void Tf_PostNullSmartPtrDereferenceFatalError(const TfCallContext &, const char *)
TfRefPtr(const TfRefPtr< T > &p)
Definition: refPtr.h:618
static TF_API bool _AddRefIfNonzero(TfRefBase const *refBase)
T * get_pointer(PXR_NS::TfRefPtr< T > const &p)
Definition: refPtr.h:1318
static const T * GetRawPtr(const TfRefPtr< const T > &t)
Definition: refPtr.h:1286
TfRefPtr(TfRefPtr< U > &&p)
Definition: refPtr.h:799
A generic, discriminated value, whose type may be queried dynamically.
Definition: Value.h:44
auto operator!=(const TfRefPtr< U > &p) const -> decltype(std::declval< T * >()!=std::declval< U * >(), bool())
Definition: refPtr.h:881
TfRefPtr< T > & operator=(TfRefPtr< U > &&p)
Definition: refPtr.h:847
#define TF_FATAL_ERROR
static T * GetRawPtr(const TfRefPtr< T > &t)
Definition: refPtr.h:1268
bool operator!=(const Mat3< T0 > &m0, const Mat3< T1 > &m1)
Inequality operator, does exact floating point comparisons.
Definition: Mat3.h:556
const std::type_info & TfTypeid(const TfRefPtr< T > &ptr)
Definition: refPtr.h:1204
friend const std::type_info & TfTypeid(const TfRefPtr< U > &ptr)
static bool AddRefIfNonzero(TfRefBase const *ptr)
Definition: refPtr.h:546
TfRefPtr< typename D::DataType > TfSafeDynamic_cast(const TfRefPtr< T > &ptr)
Definition: refPtr.h:1224
TfRefPtr< typename D::DataType > TfStatic_cast(const TfRefPtr< T > &ptr)
Definition: refPtr.h:1233
TfRefPtr(TfRefPtr< T > &&p)
Definition: refPtr.h:608
void Tf_RefPtrTracker_New(const void *, const void *)
Definition: refPtr.h:470
static int AddRef(TfRefBase const *refBase)
Definition: refPtr.h:532
static TF_API int _AddRef(TfRefBase const *refBase)
GLdouble t
Definition: glad.h:2397
friend TfRefPtr< typename D::DataType > TfDynamic_cast(const TfRefPtr< B > &)
bool operator>(const TfRefPtr< T > &p, std::nullptr_t)
Definition: refPtr.h:1175
GLfloat GLfloat GLfloat GLfloat h
Definition: glcorearb.h:2002
TfRefPtr(std::nullptr_t)
Implicit conversion from nullptr to TfRefPtr.
Definition: refPtr.h:694
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1441
TfRefPtr< T > & operator=(TfRefPtr< T > &&p)
Definition: refPtr.h:745
static bool AddRefIfNonzero(TfRefBase const *ptr)
Definition: refPtr.h:505
static bool IsNull(const TfRefPtr< const T > &t)
Definition: refPtr.h:1294
static TF_API bool _RemoveRef(TfRefBase const *refBase)
TfRefPtr()
Definition: refPtr.h:598
void Tf_RefPtrTracker_FirstRef(const void *, const void *)
Definition: refPtr.h:468
auto ptr(T p) -> const void *
Definition: format.h:2448
GLuint GLfloat * val
Definition: glcorearb.h:1608
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:91
static TfRefPtr< T > ConstructFromRawPtr(T *ptr)
Definition: refPtr.h:1272
friend void TfHashAppend(HashState &, const TfRefPtr< U > &)
void TfHashAppend(HashState &h, const TfRefPtr< T > &ptr)
Definition: refPtr.h:1337
~TfRefPtr()
Definition: refPtr.h:764
T DataType
Convenience type accessor to underlying type T for template code.
Definition: refPtr.h:586
friend TfRefPtr< typename D::DataType > TfStatic_cast(const TfRefPtr< B > &)
bool operator>=(const TfRefPtr< T > &p, std::nullptr_t)
Definition: refPtr.h:1186
#define const
Definition: zconf.h:214
TfRefPtr(const TfRefPtr< U > &p)
Definition: refPtr.h:780
friend TfRefPtr< U > TfCreateRefPtrFromProtectedWeakPtr(TfWeakPtr< U > const &)
void Tf_RefPtrTracker_Assign(const void *, const void *, const void *)
Definition: refPtr.h:472
type
Definition: core.h:1059
TfRefPtr< T > & operator=(const TfRefPtr< U > &p)
Definition: refPtr.h:820
static void Class_Object_MUST_Not_Be_Const()
Definition: refPtr.h:1281
T * operator->() const
Accessor to T's public members.
Definition: refPtr.h:923
static int AddRef(TfRefBase const *refBase)
Definition: refPtr.h:479
friend TfRefPtr< typename D::DataType > TfConst_cast(const TfRefPtr< const typename D::DataType > &)
bool operator==(const Mat3< T0 > &m0, const Mat3< T1 > &m1)
Equality operator, does exact floating point comparisons.
Definition: Mat3.h:542
void Reset()
Definition: refPtr.h:964
void swap(TfRefPtr &other)
Definition: refPtr.h:954
TfRefPtr< U > Type
Definition: refPtr.h:590