ClearScript/ClearScriptV8/WeakRef.h at master · csharpbuilder/ClearScript · GitHub

History

143 lines (107 loc) · 2.88 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

// Licensed under the MIT license.

#pragma once

//-----------------------------------------------------------------------------

// forward declarations

//-----------------------------------------------------------------------------

template <typename T>

class WeakRefTarget;

template <typename T>

class WeakRefImpl;

//-----------------------------------------------------------------------------

// WeakRef

//-----------------------------------------------------------------------------

template <typename T>

class WeakRef final

{

friend class WeakRefTarget<T>;

public:

WeakRef<T>(const WeakRef<T>& that):

m_spImpl(that.m_spImpl)

{

}

WeakRef<T>(WeakRef<T>&& that) noexcept:

m_spImpl(std::move(that.m_spImpl))

{

}

const WeakRef<T>& operator=(const WeakRef<T>& that)

{

m_spImpl = that.m_spImpl;

return *this;

}

const WeakRef<T>& operator=(WeakRef<T>&& that) noexcept

{

m_spImpl = std::move(that.m_spImpl);

return *this;

}

SharedPtr<T> GetTarget() const

{

return m_spImpl->GetTarget();

}

private:

explicit WeakRef(const SharedPtr<WeakRefImpl<T>>& spImpl):

m_spImpl(spImpl)

{

}

SharedPtr<WeakRefImpl<T>> m_spImpl;

};

//-----------------------------------------------------------------------------

// WeakRefTarget

//-----------------------------------------------------------------------------

template <typename T>

class WeakRefTarget: public SharedPtrTarget

{

public:

WeakRefTarget<T>():

m_spWeakRefImpl(new WeakRefImpl<T>(static_cast<T*>(this)))

{

}

WeakRef<T> CreateWeakRef() const

{

return WeakRef<T>(m_spWeakRefImpl);

}

protected:

~WeakRefTarget()

{

m_spWeakRefImpl->OnTargetDeleted();

}

private:

SharedPtr<WeakRefImpl<T>> m_spWeakRefImpl;

};

//-----------------------------------------------------------------------------

// WeakRefImpl

//-----------------------------------------------------------------------------

template <typename T>

class WeakRefImpl final: public SharedPtrTarget

{

friend class WeakRef<T>;

friend class WeakRefTarget<T>;

private:

explicit WeakRefImpl(T* pTarget):

m_pTarget(pTarget)

{

}

SharedPtr<T> GetTarget()

{

SharedPtr<T> spTarget;

BEGIN_MUTEX_SCOPE(m_Mutex)

if (m_pTarget != nullptr)

{

AddRefScope addRefScope(m_pTarget->GetRefCount());

if (addRefScope.GetRefCountValue() > 1)

{

spTarget = m_pTarget;

}

END_MUTEX_SCOPE

return spTarget;

}

void OnTargetDeleted()

{

BEGIN_MUTEX_SCOPE(m_Mutex)

m_pTarget = nullptr;

END_MUTEX_SCOPE

}

SimpleMutex m_Mutex;

T* m_pTarget;

};

ClearScript/ClearScriptV8/WeakRef.h at master · csharpbuilder/ClearScript · GitHub

Expand file tree

Breadcrumbs

WeakRef.h

Latest commit

History

Breadcrumbs

WeakRef.h

File metadata and controls