#pragma once
#include <wtf/DumbPtrTraits.h>
#include <wtf/Gigacage.h>
namespace WTF {
template<Gigacage::Kind passedKind, typename T, typename PtrTraits = DumbPtrTraits<T>>
class CagedPtr {
public:
static constexpr Gigacage::Kind kind = passedKind;
CagedPtr() : CagedPtr(nullptr) { }
CagedPtr(std::nullptr_t) : m_ptr(nullptr) { }
explicit CagedPtr(T* ptr)
: m_ptr(ptr)
{
}
T* get() const
{
ASSERT(m_ptr);
return Gigacage::caged(kind, PtrTraits::unwrap(m_ptr));
}
T* getMayBeNull() const
{
if (!m_ptr)
return nullptr;
return get();
}
CagedPtr& operator=(T* ptr)
{
m_ptr = ptr;
return *this;
}
CagedPtr& operator=(T*&& ptr)
{
m_ptr = WTFMove(ptr);
return *this;
}
bool operator==(const CagedPtr& other) const
{
return getMayBeNull() == other.getMayBeNull();
}
bool operator!=(const CagedPtr& other) const
{
return !(*this == other);
}
explicit operator bool() const
{
return *this != CagedPtr();
}
T& operator*() const { return *get(); }
T* operator->() const { return get(); }
template<typename IndexType>
T& operator[](IndexType index) const { return get()[index]; }
protected:
typename PtrTraits::StorageType m_ptr;
};
template<Gigacage::Kind passedKind, typename PtrTraits>
class CagedPtr<passedKind, void, PtrTraits> {
public:
static constexpr Gigacage::Kind kind = passedKind;
CagedPtr() : CagedPtr(nullptr) { }
CagedPtr(std::nullptr_t) : m_ptr(nullptr) { }
explicit CagedPtr(void* ptr)
: m_ptr(ptr)
{
}
void* get() const
{
ASSERT(m_ptr);
return Gigacage::caged(kind, PtrTraits::unwrap(m_ptr));
}
void* getMayBeNull() const
{
if (!m_ptr)
return nullptr;
return get();
}
CagedPtr& operator=(void* ptr)
{
m_ptr = ptr;
return *this;
}
bool operator==(const CagedPtr& other) const
{
return getMayBeNull() == other.getMayBeNull();
}
bool operator!=(const CagedPtr& other) const
{
return !(*this == other);
}
explicit operator bool() const
{
return *this != CagedPtr();
}
protected:
typename PtrTraits::StorageType m_ptr;
};
}
using WTF::CagedPtr;