Jolt Physics
A multi core friendly Game Physics Engine
Loading...
Searching...
No Matches
Reference.h
Go to the documentation of this file.
1// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
2// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
3// SPDX-License-Identifier: MIT
4
5#pragma once
6
7#include <Jolt/Core/Atomics.h>
8
10
11// Forward declares
12template <class T> class Ref;
13template <class T> class RefConst;
14
33template <class T>
35{
36public:
38 inline RefTarget() = default;
39 inline RefTarget(const RefTarget &) { /* Do not copy refcount */ }
40 inline ~RefTarget() { JPH_IF_ENABLE_ASSERTS(uint32 value = mRefCount.load(memory_order_relaxed);) JPH_ASSERT(value == 0 || value == cEmbedded); }
41
45 inline void SetEmbedded() const { JPH_IF_ENABLE_ASSERTS(uint32 old = ) mRefCount.fetch_add(cEmbedded, memory_order_relaxed); JPH_ASSERT(old < cEmbedded); }
46
48 inline RefTarget & operator = (const RefTarget &) { /* Don't copy refcount */ return *this; }
49
51 uint32 GetRefCount() const { return mRefCount.load(memory_order_relaxed); }
52
54 inline void AddRef() const
55 {
56 // Adding a reference can use relaxed memory ordering
57 mRefCount.fetch_add(1, memory_order_relaxed);
58 }
59
60 inline void Release() const
61 {
62 // Releasing a reference must use release semantics...
63 if (mRefCount.fetch_sub(1, memory_order_release) == 1)
64 {
65 // ... so that we can use acquire to ensure that we see any updates from other threads that released a ref before deleting the object
66 atomic_thread_fence(memory_order_acquire);
67 delete static_cast<const T *>(this);
68 }
69 }
70
72 static int sInternalGetRefCountOffset() { return offsetof(T, mRefCount); }
73
74protected:
75 static constexpr uint32 cEmbedded = 0x0ebedded;
76
77 mutable atomic<uint32> mRefCount = 0;
78};
79
82{
83public:
85 virtual ~RefTargetVirtual() = default;
86
88 virtual void AddRef() = 0;
89
91 virtual void Release() = 0;
92};
93
99template <class T>
100class Ref
101{
102public:
104 inline Ref() : mPtr(nullptr) { }
105 inline Ref(T *inRHS) : mPtr(inRHS) { AddRef(); }
106 inline Ref(const Ref<T> &inRHS) : mPtr(inRHS.mPtr) { AddRef(); }
107 inline Ref(Ref<T> &&inRHS) noexcept : mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
108 inline ~Ref() { Release(); }
109
111 inline Ref<T> & operator = (T *inRHS) { if (mPtr != inRHS) { Release(); mPtr = inRHS; AddRef(); } return *this; }
112 inline Ref<T> & operator = (const Ref<T> &inRHS) { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
113 inline Ref<T> & operator = (Ref<T> &&inRHS) noexcept { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
114
116 inline operator T *() const { return mPtr; }
117
119 inline T * operator -> () const { return mPtr; }
120 inline T & operator * () const { return *mPtr; }
121
123 inline bool operator == (const T * inRHS) const { return mPtr == inRHS; }
124 inline bool operator == (const Ref<T> &inRHS) const { return mPtr == inRHS.mPtr; }
125 inline bool operator != (const T * inRHS) const { return mPtr != inRHS; }
126 inline bool operator != (const Ref<T> &inRHS) const { return mPtr != inRHS.mPtr; }
127
129 inline T * GetPtr() const { return mPtr; }
130
132 void ** InternalGetPointer() { return reinterpret_cast<void **>(&mPtr); }
133
134private:
135 template <class T2> friend class RefConst;
136
138 inline void AddRef() { if (mPtr != nullptr) mPtr->AddRef(); }
139 inline void Release() { if (mPtr != nullptr) mPtr->Release(); }
140
141 T * mPtr;
142};
143
149template <class T>
151{
152public:
154 inline RefConst() : mPtr(nullptr) { }
155 inline RefConst(const T * inRHS) : mPtr(inRHS) { AddRef(); }
156 inline RefConst(const RefConst<T> &inRHS) : mPtr(inRHS.mPtr) { AddRef(); }
157 inline RefConst(RefConst<T> &&inRHS) noexcept : mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
158 inline RefConst(const Ref<T> &inRHS) : mPtr(inRHS.mPtr) { AddRef(); }
159 inline RefConst(Ref<T> &&inRHS) noexcept : mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
160 inline ~RefConst() { Release(); }
161
163 inline RefConst<T> & operator = (const T * inRHS) { if (mPtr != inRHS) { Release(); mPtr = inRHS; AddRef(); } return *this; }
164 inline RefConst<T> & operator = (const RefConst<T> &inRHS) { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
165 inline RefConst<T> & operator = (RefConst<T> &&inRHS) noexcept { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
166 inline RefConst<T> & operator = (const Ref<T> &inRHS) { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
167 inline RefConst<T> & operator = (Ref<T> &&inRHS) noexcept { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
168
170 inline operator const T * () const { return mPtr; }
171
173 inline const T * operator -> () const { return mPtr; }
174 inline const T & operator * () const { return *mPtr; }
175
177 inline bool operator == (const T * inRHS) const { return mPtr == inRHS; }
178 inline bool operator == (const RefConst<T> &inRHS) const { return mPtr == inRHS.mPtr; }
179 inline bool operator == (const Ref<T> &inRHS) const { return mPtr == inRHS.mPtr; }
180 inline bool operator != (const T * inRHS) const { return mPtr != inRHS; }
181 inline bool operator != (const RefConst<T> &inRHS) const { return mPtr != inRHS.mPtr; }
182 inline bool operator != (const Ref<T> &inRHS) const { return mPtr != inRHS.mPtr; }
183
185 inline const T * GetPtr() const { return mPtr; }
186
188 void ** InternalGetPointer() { return const_cast<void **>(reinterpret_cast<const void **>(&mPtr)); }
189
190private:
192 inline void AddRef() { if (mPtr != nullptr) mPtr->AddRef(); }
193 inline void Release() { if (mPtr != nullptr) mPtr->Release(); }
194
195 const T * mPtr;
196};
197
199
200JPH_SUPPRESS_WARNING_PUSH
201JPH_CLANG_SUPPRESS_WARNING("-Wc++98-compat")
202
203namespace std
204{
206 template <class T>
207 struct hash<JPH::Ref<T>>
208 {
209 size_t operator () (const JPH::Ref<T> &inRHS) const
210 {
211 return hash<T *> { }(inRHS.GetPtr());
212 }
213 };
214
216 template <class T>
217 struct hash<JPH::RefConst<T>>
218 {
219 size_t operator () (const JPH::RefConst<T> &inRHS) const
220 {
221 return hash<const T *> { }(inRHS.GetPtr());
222 }
223 };
224}
225
226JPH_SUPPRESS_WARNING_POP
#define JPH_EXPORT
Definition: Core.h:227
#define JPH_NAMESPACE_END
Definition: Core.h:367
#define JPH_CLANG_SUPPRESS_WARNING(w)
Definition: Core.h:254
std::uint32_t uint32
Definition: Core.h:442
#define JPH_NAMESPACE_BEGIN
Definition: Core.h:361
#define JPH_IF_ENABLE_ASSERTS(...)
Definition: IssueReporting.h:35
#define JPH_ASSERT(...)
Definition: IssueReporting.h:33
Definition: Reference.h:151
const T * GetPtr() const
Get pointer.
Definition: Reference.h:185
bool operator!=(const T *inRHS) const
Definition: Reference.h:180
RefConst()
Constructor.
Definition: Reference.h:154
~RefConst()
Definition: Reference.h:160
RefConst(const T *inRHS)
Definition: Reference.h:155
const T & operator*() const
Definition: Reference.h:174
RefConst< T > & operator=(const T *inRHS)
Assignment operators.
Definition: Reference.h:163
RefConst(const Ref< T > &inRHS)
Definition: Reference.h:158
void ** InternalGetPointer()
INTERNAL HELPER FUNCTION USED BY SERIALIZATION.
Definition: Reference.h:188
const T * operator->() const
Access like a normal pointer.
Definition: Reference.h:173
RefConst(RefConst< T > &&inRHS) noexcept
Definition: Reference.h:157
RefConst(const RefConst< T > &inRHS)
Definition: Reference.h:156
bool operator==(const T *inRHS) const
Comparison.
Definition: Reference.h:177
RefConst(Ref< T > &&inRHS) noexcept
Definition: Reference.h:159
Definition: Reference.h:101
Ref(const Ref< T > &inRHS)
Definition: Reference.h:106
T * GetPtr() const
Get pointer.
Definition: Reference.h:129
bool operator!=(const T *inRHS) const
Definition: Reference.h:125
Ref()
Constructor.
Definition: Reference.h:104
~Ref()
Definition: Reference.h:108
T * operator->() const
Access like a normal pointer.
Definition: Reference.h:119
void ** InternalGetPointer()
INTERNAL HELPER FUNCTION USED BY SERIALIZATION.
Definition: Reference.h:132
Ref< T > & operator=(T *inRHS)
Assignment operators.
Definition: Reference.h:111
Ref(Ref< T > &&inRHS) noexcept
Definition: Reference.h:107
Ref(T *inRHS)
Definition: Reference.h:105
bool operator==(const T *inRHS) const
Comparison.
Definition: Reference.h:123
T & operator*() const
Definition: Reference.h:120
Definition: Reference.h:35
void Release() const
Definition: Reference.h:60
atomic< uint32 > mRefCount
Current reference count.
Definition: Reference.h:77
RefTarget & operator=(const RefTarget &)
Assignment operator.
Definition: Reference.h:48
void SetEmbedded() const
Definition: Reference.h:45
RefTarget()=default
Constructor.
RefTarget(const RefTarget &)
Definition: Reference.h:39
static int sInternalGetRefCountOffset()
INTERNAL HELPER FUNCTION USED BY SERIALIZATION.
Definition: Reference.h:72
~RefTarget()
assert no one is referencing us
Definition: Reference.h:40
uint32 GetRefCount() const
Get current refcount of this object.
Definition: Reference.h:51
void AddRef() const
Add or release a reference to this object.
Definition: Reference.h:54
static constexpr uint32 cEmbedded
A large value that gets added to the refcount to mark the object as embedded.
Definition: Reference.h:75
Pure virtual version of RefTarget.
Definition: Reference.h:82
virtual ~RefTargetVirtual()=default
Virtual destructor.
virtual void Release()=0
Virtual release reference.
virtual void AddRef()=0
Virtual add reference.
Definition: Reference.h:204