7 #ifndef PXR_BASE_TF_REF_PTR_H
8 #define PXR_BASE_TF_REF_PTR_H
424 #include <type_traits>
447 template <
template <
class>
class X,
class Y>
472 const auto relaxed = std::memory_order_relaxed;
475 int prevCount = counter.load(relaxed);
482 if (prevCount != -1 && counter.
483 compare_exchange_weak(prevCount, prevCount-1, relaxed)) {
490 counter.fetch_add(1, relaxed);
499 const auto relaxed = std::memory_order_relaxed;
500 const auto release = std::memory_order_release;
503 int prevCount = counter.load(relaxed);
510 if (prevCount != -2 && counter.
511 compare_exchange_weak(prevCount, prevCount+1, release)) {
512 return prevCount == -1;
518 return counter.fetch_sub(1, release) == 1;
543 refBase->_GetRefCount().fetch_add(1, std::memory_order_relaxed);
551 return refBase->_GetRefCount()
552 .fetch_sub(1, std::memory_order_release) == 1;
562 auto &counter = refBase->_GetRefCount();
563 int prevCount = counter.load(std::memory_order_relaxed);
565 if (counter.compare_exchange_weak(prevCount, prevCount+1)) {
592 using _Counter =
typename std::conditional<
598 static constexpr
T *_NullT =
nullptr;
625 p._refBase =
nullptr;
641 template <
template <
class>
class X,
class U>
643 typename std::enable_if<
694 U*
ptr,
typename std::enable_if<
746 _refBase = p._refBase;
765 _refBase = p._refBase;
766 p._refBase =
nullptr;
778 _RemoveRef(_refBase);
789 #if !defined(doxygen)
808 #if !defined(doxygen)
813 p._refBase =
nullptr;
828 #if !defined(doxygen)
836 _refBase = p._GetData();
853 #if !defined(doxygen)
862 _refBase = p._GetData();
863 p._refBase =
nullptr;
872 #if !defined(doxygen)
876 -> decltype(std::declval<T *>() == std::declval<U *>(),
bool()) {
877 return _refBase == p._refBase;
883 #if !defined(doxygen)
887 -> decltype(std::declval<T *>() != std::declval<U *>(),
bool()) {
888 return _refBase != p._refBase;
895 #if !defined(doxygen)
898 auto operator<(const TfRefPtr<U>& p)
const
899 -> decltype(std::declval<T *>() < std::declval<U *>(),
bool()) {
900 return _refBase < p._refBase;
903 #if !defined(doxygen)
907 -> decltype(std::declval<T *>() > std::declval<U *>(),
bool()) {
908 return _refBase > p._refBase;
911 #if !defined(doxygen)
914 auto operator<=(const TfRefPtr<U>& p)
const
915 -> decltype(std::declval<T *>() <= std::declval<U *>(),
bool()) {
916 return _refBase <= p._refBase;
919 #if !defined(doxygen)
923 -> decltype(std::declval<T *>() >= std::declval<U *>(),
bool()) {
924 return _refBase >= p._refBase;
930 return static_cast<T*
>(
const_cast<TfRefBase*
>(_refBase));
941 #if !defined(doxygen)
947 return _refBase ? &TfRefPtr::_refBase :
nullptr;
952 return _refBase ==
nullptr;
974 template <
class HashState,
class U>
980 return static_cast<T *
>(
const_cast<TfRefBase *
>(p._refBase));
984 class _CreateRefPtr { };
1013 #if defined(doxygen)
1018 template <
class D,
class B>
1022 template <
class D,
class B>
1043 #if defined(doxygen)
1048 template <
class D,
class B>
1065 #if defined(doxygen)
1075 T* _GetData()
const {
1076 return static_cast<T*
>(
const_cast<TfRefBase*
>(_refBase));
1089 void _AddRef()
const {
1090 _Counter::AddRef(_refBase);
1094 if (_Counter::RemoveRef(ptr)) {
1100 #if ! defined(doxygen)
1113 #if !defined(doxygen)
1136 return !(p ==
nullptr);
1141 return !(
nullptr == p);
1145 inline bool operator< (const TfRefPtr<T> &p, std::nullptr_t)
1147 return std::less<const TfRefBase *>()(
get_pointer(p),
nullptr);
1150 inline bool operator< (std::nullptr_t, const TfRefPtr<T> &p)
1152 return std::less<const TfRefBase *>()(
nullptr,
get_pointer(p));
1156 inline bool operator<= (const TfRefPtr<T> &p, std::nullptr_t)
1158 return !(
nullptr < p);
1161 inline bool operator<= (std::nullptr_t, const TfRefPtr<T> &p)
1163 return !(p <
nullptr);
1180 return !(p <
nullptr);
1185 return !(
nullptr < p);
1189 template <
typename T>
1195 const std::type_info&
1201 return typeid(*ptr._GetData());
1204 template <
class D,
class T>
1210 return RefPtr(dynamic_cast<typename D::DataType*>(ptr._GetData()));
1213 template <
class D,
class T>
1219 return RefPtr(TfSafeDynamic_cast<typename D::DataType*>(ptr._GetData()));
1222 template <
class D,
class T>
1228 return RefPtr(static_cast<typename D::DataType*>(ptr._GetData()));
1239 return *((NonConstRefPtr*)(&ptr));
1259 return t.operator-> ();
1277 return t.operator-> ();
1293 #if !defined(doxygen)
1309 template <
class HashState,
class T>
1318 #define TF_SUPPORTS_REFPTR(T) std::is_base_of_v<TfRefBase, T>
1322 #endif // PXR_BASE_TF_REF_PTR_H
void swap(ArAssetInfo &lhs, ArAssetInfo &rhs)
static void Class_Object_MUST_Be_Passed_By_Address()
auto operator==(const TfRefPtr< U > &p) const -> decltype(std::declval< T * >()==std::declval< U * >(), bool())
static TF_API bool _RemoveRefMaybeLocked(TfRefBase const *refBase, int prevCount)
TfRefPtr< T > TfCreateRefPtr(T *ptr)
TfRefPtr< typename T::DataType > TfConst_cast(const TfRefPtr< const typename T::DataType > &ptr)
static TfRefPtr< const T > ConstructFromRawPtr(T *ptr)
friend size_t hash_value(const TfRefPtr< U > &)
TfRefPtr(TfNullPtrType)
Implicit conversion from TfNullPtr to TfRefPtr.
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)
auto operator>=(const TfRefPtr< U > &p) const -> decltype(std::declval< T * >() >=std::declval< U * >(), bool())
GLsizei const GLfloat * value
const TfRefBase *(TfRefPtr::*) UnspecifiedBoolType
static bool IsNull(const TfRefPtr< T > &t)
TF_API const TfNullPtrType TfNullPtr
auto operator>(const TfRefPtr< U > &p) const -> decltype(std::declval< T * >() > std::declval< U * >(), bool())
static void Class_Object_MUST_Be_Passed_By_Address()
friend T * get_pointer(TfRefPtr const &p)
friend TfRefPtr< U > TfCreateRefPtr(U *)
static void AddRef(TfRefBase const *refBase)
TfRefPtr< T > & operator=(const TfRefPtr< T > &p)
Y * get_pointer(TfWeakPtrFacade< X, Y > const &p)
bool operator!() const
True if the pointer points to NULL.
friend TfRefPtr< typename D::DataType > TfSafeDynamic_cast(const TfRefPtr< B > &)
TfRefPtr(U *ptr, typename std::enable_if< std::is_convertible< U *, T * >::value >::type *=nullptr)
T & operator*() const
Dereferences the stored pointer.
static bool RemoveRef(TfRefBase const *refBase)
TfRefPtr< typename D::DataType > TfDynamic_cast(const TfRefPtr< T > &ptr)
GLint GLint GLsizei GLint GLenum GLenum type
TF_API void Tf_PostNullSmartPtrDereferenceFatalError(const TfCallContext &, const char *)
static void AddRef(TfRefBase const *refBase)
TfRefPtr(const TfRefPtr< T > &p)
void Tf_RefPtrTracker_Delete(const void *, const TfRefBase *, const void *)
static const T * GetRawPtr(const TfRefPtr< const T > &t)
TfRefPtr(TfRefPtr< U > &&p)
A generic, discriminated value, whose type may be queried dynamically.
static bool RemoveRef(TfRefBase const *refBase)
auto operator!=(const TfRefPtr< U > &p) const -> decltype(std::declval< T * >()!=std::declval< U * >(), bool())
TfRefPtr< T > & operator=(TfRefPtr< U > &&p)
static TF_API void _AddRefMaybeLocked(TfRefBase const *refBase, int prevCount)
static T * GetRawPtr(const TfRefPtr< T > &t)
bool operator!=(const Mat3< T0 > &m0, const Mat3< T1 > &m1)
Inequality operator, does exact floating point comparisons.
const std::type_info & TfTypeid(const TfRefPtr< T > &ptr)
friend const std::type_info & TfTypeid(const TfRefPtr< U > &ptr)
void Tf_RefPtrTracker_LastRef(const void *, const TfRefBase *, const void *)
static bool AddRefIfNonzero(TfRefBase const *refBase)
TfRefPtr< typename D::DataType > TfSafeDynamic_cast(const TfRefPtr< T > &ptr)
GLuint const GLchar * name
TfRefPtr< typename D::DataType > TfStatic_cast(const TfRefPtr< T > &ptr)
TfRefPtr(TfRefPtr< T > &&p)
friend TfRefPtr< typename D::DataType > TfDynamic_cast(const TfRefPtr< B > &)
size_t hash_value(const TfRefPtr< T > &ptr)
bool operator>(const TfRefPtr< T > &p, std::nullptr_t)
GLfloat GLfloat GLfloat GLfloat h
static TF_API bool AddRefIfNonzero(TfRefBase const *refBase)
TfRefPtr(std::nullptr_t)
Implicit conversion from nullptr to TfRefPtr.
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
void Tf_RefPtrTracker_Assign(const void *, const TfRefBase *, const TfRefBase *, const void *)
TfRefPtr< T > & operator=(TfRefPtr< T > &&p)
static bool IsNull(const TfRefPtr< const T > &t)
void Tf_RefPtrTracker_New(const void *, const TfRefBase *, const void *)
#define PXR_NAMESPACE_CLOSE_SCOPE
void Tf_RefPtrTracker_FirstRef(const void *, const TfRefBase *, const void *)
static TfRefPtr< T > ConstructFromRawPtr(T *ptr)
friend void TfHashAppend(HashState &, const TfRefPtr< U > &)
void TfHashAppend(HashState &h, const TfRefPtr< T > &ptr)
T DataType
Convenience type accessor to underlying type T for template code.
friend TfRefPtr< typename D::DataType > TfStatic_cast(const TfRefPtr< B > &)
bool operator>=(const TfRefPtr< T > &p, std::nullptr_t)
TfRefPtr(const TfRefPtr< U > &p)
friend TfRefPtr< U > TfCreateRefPtrFromProtectedWeakPtr(TfWeakPtr< U > const &)
TfRefPtr< T > & operator=(const TfRefPtr< U > &p)
static void Class_Object_MUST_Not_Be_Const()
T * operator->() const
Accessor to T's public members.
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.
void swap(TfRefPtr &other)