Blob.h

 
#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Types/ArrayPtr.h>
 
template <typename T>
class plBlobPtr
{
public:
  PL_DECLARE_POD_TYPE();
 
  static_assert(!std::is_same_v<T, void>, "plBlobPtr<void> is not allowed (anymore)");
  static_assert(!std::is_same_v<T, const void>, "plBlobPtr<void> is not allowed (anymore)");
 
  using ByteType = typename plArrayPtrDetail::ByteTypeHelper<T>::type;
  using ValueType = T;
  using PointerType = T*;
 
  plBlobPtr() = default;
 
  template <typename U>
  inline plBlobPtr(U* pPtr, plUInt64 uiCount)
    : m_pPtr(pPtr)
    , m_uiCount(uiCount)
  {
    // If any of the arguments is invalid, we invalidate ourself.
    if (m_pPtr == nullptr || m_uiCount == 0)
    {
      m_pPtr = nullptr;
      m_uiCount = 0;
    }
  }
 
  template <size_t N>
  PL_ALWAYS_INLINE plBlobPtr(ValueType (&staticArray)[N])
    : m_pPtr(staticArray)
    , m_uiCount(static_cast<plUInt64>(N))
  {
  }
 
  PL_ALWAYS_INLINE plBlobPtr(const plBlobPtr<T>& other)
    : m_pPtr(other.m_pPtr)
    , m_uiCount(other.m_uiCount)
  {
  }
 
  operator plBlobPtr<const T>() const { return plBlobPtr<const T>(static_cast<const T*>(GetPtr()), GetCount()); }
 
  PL_ALWAYS_INLINE void operator=(const plBlobPtr<T>& other)
  {
    m_pPtr = other.m_pPtr;
    m_uiCount = other.m_uiCount;
  }
 
  PL_ALWAYS_INLINE void Clear()
  {
    m_pPtr = nullptr;
    m_uiCount = 0;
  }
 
  PL_ALWAYS_INLINE void operator=(std::nullptr_t)
  {
    m_pPtr = nullptr;
    m_uiCount = 0;
  }
 
  PL_ALWAYS_INLINE PointerType GetPtr() const { return m_pPtr; }
 
  PL_ALWAYS_INLINE PointerType GetPtr() { return m_pPtr; }
 
  PL_ALWAYS_INLINE PointerType GetEndPtr() { return m_pPtr + m_uiCount; }
 
  PL_ALWAYS_INLINE PointerType GetEndPtr() const { return m_pPtr + m_uiCount; }
 
  PL_ALWAYS_INLINE bool IsEmpty() const { return GetCount() == 0; }
 
  PL_ALWAYS_INLINE plUInt64 GetCount() const { return m_uiCount; }
 
  PL_FORCE_INLINE plBlobPtr<T> GetSubArray(plUInt64 uiStart, plUInt64 uiCount) const // [tested]
  {
    PL_ASSERT_DEV(
      uiStart + uiCount <= GetCount(), "uiStart+uiCount ({0}) has to be smaller or equal than the count ({1}).", uiStart + uiCount, GetCount());
    return plBlobPtr<T>(GetPtr() + uiStart, uiCount);
  }
 
  PL_FORCE_INLINE plBlobPtr<T> GetSubArray(plUInt64 uiStart) const // [tested]
  {
    PL_ASSERT_DEV(uiStart <= GetCount(), "uiStart ({0}) has to be smaller or equal than the count ({1}).", uiStart, GetCount());
    return plBlobPtr<T>(GetPtr() + uiStart, GetCount() - uiStart);
  }
 
  PL_ALWAYS_INLINE plBlobPtr<const ByteType> ToByteBlob() const
  {
    return plBlobPtr<const ByteType>(reinterpret_cast<const ByteType*>(GetPtr()), GetCount() * sizeof(T));
  }
 
  PL_ALWAYS_INLINE plBlobPtr<ByteType> ToByteBlob() { return plBlobPtr<ByteType>(reinterpret_cast<ByteType*>(GetPtr()), GetCount() * sizeof(T)); }
 
  template <typename U>
  PL_ALWAYS_INLINE plBlobPtr<U> Cast()
  {
    static_assert(sizeof(T) == sizeof(U), "Can only cast with equivalent element size.");
    return plBlobPtr<U>(reinterpret_cast<U*>(GetPtr()), GetCount());
  }
 
  template <typename U>
  PL_ALWAYS_INLINE plBlobPtr<const U> Cast() const
  {
    static_assert(sizeof(T) == sizeof(U), "Can only cast with equivalent element size.");
    return plBlobPtr<const U>(reinterpret_cast<const U*>(GetPtr()), GetCount());
  }
 
  PL_FORCE_INLINE const ValueType& operator[](plUInt64 uiIndex) const // [tested]
  {
    PL_ASSERT_DEBUG(uiIndex < GetCount(), "Cannot access element {0}, the array only holds {1} elements.", uiIndex, GetCount());
    return *static_cast<const ValueType*>(GetPtr() + uiIndex);
  }
 
  PL_FORCE_INLINE ValueType& operator[](plUInt64 uiIndex) // [tested]
  {
    PL_ASSERT_DEBUG(uiIndex < GetCount(), "Cannot access element {0}, the array only holds {1} elements.", uiIndex, GetCount());
    return *static_cast<ValueType*>(GetPtr() + uiIndex);
  }
 
  inline bool operator==(const plBlobPtr<const T>& other) const // [tested]
  {
    if (GetCount() != other.GetCount())
      return false;
 
    if (GetPtr() == other.GetPtr())
      return true;
 
    return plMemoryUtils::IsEqual(static_cast<const ValueType*>(GetPtr()), static_cast<const ValueType*>(other.GetPtr()), static_cast<size_t>(GetCount()));
  }
 
  PL_ALWAYS_INLINE bool operator!=(const plBlobPtr<const T>& other) const // [tested]
  {
    return !(*this == other);
  }
 
  inline void CopyFrom(const plBlobPtr<const T>& other) // [tested]
  {
    PL_ASSERT_DEV(GetCount() == other.GetCount(), "Count for copy does not match. Target has {0} elements, source {1} elements", GetCount(), other.GetCount());
 
    plMemoryUtils::Copy(static_cast<ValueType*>(GetPtr()), static_cast<const ValueType*>(other.GetPtr()), static_cast<size_t>(GetCount()));
  }
 
  PL_ALWAYS_INLINE void Swap(plBlobPtr<T>& other)
  {
    plMath::Swap(m_pPtr, other.m_pPtr);
    plMath::Swap(m_uiCount, other.m_uiCount);
  }
 
  using const_iterator = const T*;
  using const_reverse_iterator = const_reverse_pointer_iterator<T>;
  using iterator = T*;
  using reverse_iterator = reverse_pointer_iterator<T>;
 
private:
  PointerType m_pPtr = nullptr;
  plUInt64 m_uiCount = 0u;
};
 
 
using plByteBlobPtr = plBlobPtr<plUInt8>;
using plConstByteBlobPtr = plBlobPtr<const plUInt8>;
 
 
template <typename T>
PL_ALWAYS_INLINE plBlobPtr<T> plMakeBlobPtr(T* pPtr, plUInt64 uiCount)
{
  return plBlobPtr<T>(pPtr, uiCount);
}
 
template <typename T, plUInt64 N>
PL_ALWAYS_INLINE plBlobPtr<T> plMakeBlobPtr(T (&staticArray)[N])
{
  return plBlobPtr<T>(staticArray);
}
 
template <typename T>
PL_ALWAYS_INLINE plConstByteBlobPtr plMakeByteBlobPtr(const T* pPtr, plUInt32 uiCount)
{
  return plConstByteBlobPtr(static_cast<const plUInt8*>(pPtr), uiCount * sizeof(T));
}
 
template <typename T>
PL_ALWAYS_INLINE plByteBlobPtr plMakeByteBlobPtr(T* pPtr, plUInt32 uiCount)
{
  return plByteBlobPtr(reinterpret_cast<plUInt8*>(pPtr), uiCount * sizeof(T));
}
 
PL_ALWAYS_INLINE plByteBlobPtr plMakeByteBlobPtr(void* pPtr, plUInt32 uiBytes)
{
  return plByteBlobPtr(reinterpret_cast<plUInt8*>(pPtr), uiBytes);
}
 
PL_ALWAYS_INLINE plConstByteBlobPtr plMakeByteBlobPtr(const void* pPtr, plUInt32 uiBytes)
{
  return plConstByteBlobPtr(static_cast<const plUInt8*>(pPtr), uiBytes);
}
 
 
template <typename T>
typename plBlobPtr<T>::iterator begin(plBlobPtr<T>& in_container)
{
  return in_container.GetPtr();
}
 
template <typename T>
typename plBlobPtr<T>::const_iterator begin(const plBlobPtr<T>& container)
{
  return container.GetPtr();
}
 
template <typename T>
typename plBlobPtr<T>::const_iterator cbegin(const plBlobPtr<T>& container)
{
  return container.GetPtr();
}
 
template <typename T>
typename plBlobPtr<T>::reverse_iterator rbegin(plBlobPtr<T>& in_container)
{
  return typename plBlobPtr<T>::reverse_iterator(in_container.GetPtr() + in_container.GetCount() - 1);
}
 
template <typename T>
typename plBlobPtr<T>::const_reverse_iterator rbegin(const plBlobPtr<T>& container)
{
  return typename plBlobPtr<T>::const_reverse_iterator(container.GetPtr() + container.GetCount() - 1);
}
 
template <typename T>
typename plBlobPtr<T>::const_reverse_iterator crbegin(const plBlobPtr<T>& container)
{
  return typename plBlobPtr<T>::const_reverse_iterator(container.GetPtr() + container.GetCount() - 1);
}
 
template <typename T>
typename plBlobPtr<T>::iterator end(plBlobPtr<T>& in_container)
{
  return in_container.GetPtr() + in_container.GetCount();
}
 
template <typename T>
typename plBlobPtr<T>::const_iterator end(const plBlobPtr<T>& container)
{
  return container.GetPtr() + container.GetCount();
}
 
template <typename T>
typename plBlobPtr<T>::const_iterator cend(const plBlobPtr<T>& container)
{
  return container.GetPtr() + container.GetCount();
}
 
template <typename T>
typename plBlobPtr<T>::reverse_iterator rend(plBlobPtr<T>& in_container)
{
  return typename plBlobPtr<T>::reverse_iterator(in_container.GetPtr() - 1);
}
 
template <typename T>
typename plBlobPtr<T>::const_reverse_iterator rend(const plBlobPtr<T>& container)
{
  return typename plBlobPtr<T>::const_reverse_iterator(container.GetPtr() - 1);
}
 
template <typename T>
typename plBlobPtr<T>::const_reverse_iterator crend(const plBlobPtr<T>& container)
{
  return typename plBlobPtr<T>::const_reverse_iterator(container.GetPtr() - 1);
}
 
class PL_FOUNDATION_DLL plBlob
{
public:
  PL_DECLARE_MEM_RELOCATABLE_TYPE();
 
  plBlob();
 
  plBlob(plBlob&& other);
 
  void operator=(plBlob&& rhs);
 
  ~plBlob();
 
  void SetFrom(const void* pSource, plUInt64 uiSize);
 
  void Clear();
 
  bool IsEmpty() const;
 
  void SetCountUninitialized(plUInt64 uiCount);
 
  void ZeroFill();
 
  template <typename T>
  plBlobPtr<T> GetBlobPtr()
  {
    return plBlobPtr<T>(static_cast<T*>(m_pStorage), m_uiSize);
  }
 
  template <typename T>
  plBlobPtr<const T> GetBlobPtr() const
  {
    return plBlobPtr<const T>(static_cast<T*>(m_pStorage), m_uiSize);
  }
 
  plByteBlobPtr GetByteBlobPtr() { return plByteBlobPtr(reinterpret_cast<plUInt8*>(m_pStorage), m_uiSize); }
 
  plConstByteBlobPtr GetByteBlobPtr() const { return plConstByteBlobPtr(reinterpret_cast<const plUInt8*>(m_pStorage), m_uiSize); }
 
private:
  void* m_pStorage = nullptr;
  plUInt64 m_uiSize = 0;
};