core/include/core/utils/AlignedData.hpp

#ifndef CORE_ALIGNED_DATA_HPP
#define CORE_ALIGNED_DATA_HPP

#include "core/utils/Types.hpp"

#define CORE_ASSERT_ALIGNED_DATA(var, type)                                    \
    static_assert(sizeof(var) == sizeof(type), "aligned data size missmatch"); \
    static_assert(decltype(var)::getSize() >= decltype(var)::getAlignment(),   \
                  "size >= alignment");                                        \
    static_assert(alignof(decltype(var)) == alignof(type),                     \
                  "aligned data alignment missmatch");

namespace Core {
    template<size_t SIZE, size_t ALIGNMENT>
    class alignas(ALIGNMENT) AlignedData final {
        char buffer[SIZE] = {};

    public:
        template<typename T>
        constexpr T* as() {
            return reinterpret_cast<T*>(this);
        }

        template<typename T>
        constexpr const T* as() const {
            return reinterpret_cast<T*>(this);
        }

        static consteval size_t getSize() {
            return SIZE;
        }

        static consteval size_t getAlignment() {
            return ALIGNMENT;
        }
    };

    template<typename T>
    using AlignedType = AlignedData<sizeof(T), alignof(T)>;
}

#endif