72 lines
1.8 KiB
C++
72 lines
1.8 KiB
C++
#pragma once
|
|
|
|
// PFC weakRef class
|
|
// Create weak references to objects that automatically become invalidated upon destruction of the object
|
|
// Note that this is NOT thread safe and meant for single thread usage. If you require thread safety, provide your own means, such as mutexlocking of weakRef::get() and the destruction of your objects.
|
|
|
|
#include <memory> // std::shared_ptr
|
|
|
|
namespace pfc {
|
|
typedef std::shared_ptr<const bool> weakRefKillSwitch_t;
|
|
|
|
template<typename target_t>
|
|
class weakRef {
|
|
typedef weakRef<target_t> self_t;
|
|
public:
|
|
static self_t _make(target_t * target, weakRefKillSwitch_t ks) {
|
|
self_t ret;
|
|
ret.m_target = target;
|
|
ret.m_ks = ks;
|
|
return ret;
|
|
}
|
|
|
|
|
|
bool isValid() const {
|
|
return m_ks && !*m_ks;
|
|
}
|
|
|
|
target_t * get() const {
|
|
if (!isValid()) return nullptr;
|
|
return m_target;
|
|
}
|
|
target_t * operator() () const {
|
|
return get();
|
|
}
|
|
private:
|
|
target_t * m_target = nullptr;
|
|
weakRefKillSwitch_t m_ks;
|
|
};
|
|
|
|
template<typename class_t>
|
|
class weakRefTarget {
|
|
public:
|
|
weakRefTarget() {}
|
|
|
|
typedef weakRef<class_t> weakRef_t;
|
|
|
|
weakRef<class_t> weakRef() {
|
|
PFC_ASSERT(!*m_ks);
|
|
class_t * ptr = static_cast<class_t*>(this);
|
|
return weakRef_t::_make(ptr, m_ks);
|
|
}
|
|
|
|
// Optional: explicitly invalidates all weak references to this object. Called implicitly by the destructor, but you can do it yourself earlier.
|
|
void weakRefShutdown() {
|
|
*m_ks = true;
|
|
}
|
|
~weakRefTarget() {
|
|
weakRefShutdown();
|
|
}
|
|
|
|
// Optional: obtain a reference to the killswitch if you wish to use it directly
|
|
weakRefKillSwitch_t weakRefKS() const {
|
|
return m_ks;
|
|
}
|
|
private:
|
|
std::shared_ptr<bool> m_ks = std::make_shared<bool>(false);
|
|
|
|
weakRefTarget(const weakRefTarget &) = delete;
|
|
void operator=(const weakRefTarget &) = delete;
|
|
};
|
|
}
|