PointerWithFlags.h

#pragma once
 
#include <Foundation/Basics.h>
 
template <typename PtrType, plUInt8 NumFlagBits = 2>
class plPointerWithFlags
{
private:
  enum : size_t
  {
    AllOnes = (std::size_t)(-1),
    PtrBits = sizeof(void*) * 8,
    FlagsMask = (AllOnes >> (PtrBits - NumFlagBits)),
    PtrMask = ~FlagsMask,
  };
 
  void* m_pPtr = nullptr;
 
public:
  plPointerWithFlags() = default;
 
  explicit plPointerWithFlags(PtrType* pPtr, plUInt8 uiFlags = 0) { SetPtrAndFlags(pPtr, uiFlags); }
 
  void SetPtrAndFlags(PtrType* pPtr, plUInt8 uiFlags)
  {
    const std::uintptr_t isrc = *reinterpret_cast<std::uintptr_t*>(&pPtr);
    std::uintptr_t& iptr = *reinterpret_cast<std::uintptr_t*>(&m_pPtr);
 
    iptr = (isrc & PtrMask) | (uiFlags & FlagsMask);
  }
 
  const PtrType* GetPtr() const
  {
    const std::uintptr_t& iptr = *reinterpret_cast<const std::uintptr_t*>(&m_pPtr);
    return reinterpret_cast<const PtrType*>(iptr & PtrMask); // mask off lower N bits
  }
 
  PtrType* GetPtr()
  {
    std::uintptr_t& iptr = *reinterpret_cast<std::uintptr_t*>(&m_pPtr);
    return reinterpret_cast<PtrType*>(iptr & PtrMask); // mask off lower N bits
  }
 
  void SetPtr(PtrType* pPtr)
  {
    const std::uintptr_t isrc = *reinterpret_cast<std::uintptr_t*>(&pPtr);
    PL_ASSERT_DEBUG(
      (isrc & FlagsMask) == 0, "The given pointer does not have an {} byte alignment and thus cannot be stored lossless.", 1u << NumFlagBits);
 
    std::uintptr_t& iptr = *reinterpret_cast<std::uintptr_t*>(&m_pPtr);
 
    iptr = (isrc & PtrMask) | (iptr & FlagsMask);
  }
  plUInt8 GetFlags() const
  {
    const std::uintptr_t& iptr = *reinterpret_cast<const std::uintptr_t*>(&m_pPtr);
    return static_cast<plUInt8>(iptr & FlagsMask);
  }
 
  void SetFlags(plUInt8 uiFlags)
  {
    PL_ASSERT_DEBUG(uiFlags <= FlagsMask, "The flag value {} requires more than {} bits", uiFlags, NumFlagBits);
 
    std::uintptr_t& iptr = *reinterpret_cast<std::uintptr_t*>(&m_pPtr);
 
    iptr = (iptr & PtrMask) | (uiFlags & FlagsMask);
  }
 
  operator PtrType*() { return GetPtr(); }
 
  operator const PtrType*() const { return GetPtr(); }
 
  void operator=(PtrType* pPtr) { SetPtr(pPtr); }
 
  template <typename = typename std::enable_if<std::is_const<PtrType>::value == false>>
  bool operator==(const PtrType* pPtr) const
  {
    return GetPtr() == pPtr;
  }
 
#if PL_DISABLED(PL_USE_CPP20_OPERATORS)
  template <typename = typename std::enable_if<std::is_const<PtrType>::value == false>>
  bool operator!=(const PtrType* pPtr) const
  {
    return !(*this == pPtr);
  }
#endif
 
  bool operator==(const plPointerWithFlags<PtrType, NumFlagBits>& rhs) const
  {
    return GetPtr() == rhs.GetPtr();
  }
 
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plPointerWithFlags<PtrType, NumFlagBits>&);
 
  bool operator==(PtrType* pPtr) const { return GetPtr() == pPtr; }
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(PtrType*);
 
  bool operator==(std::nullptr_t) const { return GetPtr() == nullptr; }
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(std::nullptr_t);
 
  explicit operator bool() const { return GetPtr() != nullptr; }
 
  const PtrType* operator->() const { return GetPtr(); }
 
  PtrType* operator->() { return GetPtr(); }
 
  const PtrType& operator*() const { return *GetPtr(); }
 
  PtrType& operator*() { return *GetPtr(); }
};