MemoryUtils.h

#pragma once
 
#include <Foundation/Basics.h>
#include <cstdint> // for uintptr_t
 
enum plConstructionMode
{
  ConstructAll = 0,     
  SkipTrivialTypes = 1, 
};
 
class plMemoryUtils
{
public:
  using ConstructorFunction = void (*)(void* pDestination);
  using CopyConstructorFunction = void (*)(void* pDestination, const void* pSource);
  using DestructorFunction = void (*)(void* pDestination);
 
  template <plConstructionMode mode, typename T>
  static void Construct(T* pDestination, size_t uiCount = 1); // [tested]
 
  template <plConstructionMode mode, typename T>
  static ConstructorFunction MakeConstructorFunction(); // [tested]
 
  template <typename Destination, typename Source>
  static void CopyConstruct(Destination* pDestination, const Source& copy, size_t uiCount = 1); // [tested]
 
  template <typename T>
  static void CopyConstructArray(T* pDestination, const T* pSource, size_t uiCount); // [tested]
 
  template <typename T>
  static CopyConstructorFunction MakeCopyConstructorFunction(); // [tested]
 
  template <typename T>
  static void MoveConstruct(T* pDestination, T&& source); // [tested]
 
  template <typename T>
  static void MoveConstruct(T* pDestination, T* pSource, size_t uiCount = 1);
 
  template <typename Destination, typename Source>
  static void CopyOrMoveConstruct(Destination* pDestination, Source&& source);
 
  template <typename T>
  static void RelocateConstruct(T* pDestination, T* pSource, size_t uiCount = 1);
 
  template <typename T>
  static void Destruct(T* pDestination, size_t uiCount = 1); // [tested]
 
  template <typename T>
  static DestructorFunction MakeDestructorFunction(); // [tested]
 
  template <typename T>
  static void Copy(T* pDestination, const T* pSource, size_t uiCount = 1); // [tested]
 
  static void RawByteCopy(void* pDestination, const void* pSource, size_t uiNumBytesToCopy);
 
  template <typename T>
  static void CopyOverlapped(T* pDestination, const T* pSource, size_t uiCount = 1);
 
  template <typename T>
  static void Relocate(T* pDestination, T* pSource, size_t uiCount = 1); // [tested]
 
  template <typename T>
  static void RelocateOverlapped(T* pDestination, T* pSource, size_t uiCount = 1); // [tested]
 
  template <typename T>
  static void Prepend(T* pDestination, const T& source, size_t uiCount);
 
  template <typename T>
  static void Prepend(T* pDestination, T&& source, size_t uiCount);
 
  template <typename T>
  static void Prepend(T* pDestination, const T* pSource, size_t uiSourceCount, size_t uiCount);
 
  template <typename T>
  static bool IsEqual(const T* a, const T* b, size_t uiCount = 1); // [tested]
 
  template <typename T>
  static void ZeroFill(T* pDestination, size_t uiCount = 1); // [tested]
 
  template <typename T, size_t N>
  static void ZeroFill(T (&destination)[N]) = delete;
 
  template <typename T, size_t N>
  static void ZeroFillArray(T (&destination)[N]); // [tested]
 
  template <typename T>
  static void PatternFill(T* pDestination, plUInt8 uiBytePattern, size_t uiCount = 1); // [tested]
 
  template <typename T, size_t N>
  static void PatternFill(T (&destination)[N], plUInt8 uiBytePattern) = delete;
 
  template <typename T, size_t N>
  static void PatternFillArray(T (&destination)[N], plUInt8 uiBytePattern); // [tested]
 
  template <typename T>
  static plInt32 Compare(const T* a, const T* b, size_t uiCount = 1); // [tested]
 
  static plInt32 RawByteCompare(const void* a, const void* b, size_t uiNumBytesToCompare);
 
  template <typename T>
  static T* AddByteOffset(T* pPtr, std::ptrdiff_t offset); // [tested]
 
  template <typename T>
  static T* AlignBackwards(T* pPtr, size_t uiAlignment); // [tested]
 
  template <typename T>
  static T* AlignForwards(T* pPtr, size_t uiAlignment); // [tested]
 
  template <typename T>
  static T AlignSize(T uiSize, T uiAlignment); // [tested]
 
  template <typename T>
  static bool IsAligned(const T* pPtr, size_t uiAlignment); // [tested]
 
  template <typename T>
  static bool IsSizeAligned(T uiSize, T uiAlignment); // [tested]
 
  static void ReserveLower4GBAddressSpace();
};
 
#include <Foundation/Memory/Implementation/MemoryUtils_inl.h>