OpaqueObject.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "AlignedStorage.h"
namespace SC
{
 
 
template <typename Definition>
struct OpaqueObject
{
    using Object = typename Definition::Object;
 
    OpaqueObject() { construct(buffer); }
    ~OpaqueObject() { destruct(get()); }
    OpaqueObject(OpaqueObject&& other) { moveConstruct(buffer, forward<Object>(other.get())); }
    OpaqueObject& operator=(OpaqueObject&& other)
    {
        moveAssign(get(), forward<Object>(other.get()));
        return *this;
    }
 
    // Disallow copy construction and copy assignment
    OpaqueObject(const OpaqueObject&)            = delete;
    OpaqueObject& operator=(const OpaqueObject&) = delete;
 
    Object&       get() { return reinterpret_cast<Object&>(buffer); }
    const Object& get() const { return reinterpret_cast<const Object&>(buffer); }
 
  private:
#if SC_PLATFORM_WINDOWS
    static constexpr int Size = Definition::Windows;
#elif SC_PLATFORM_APPLE
    static constexpr int Size = Definition::Apple;
#elif SC_PLATFORM_LINUX
    static constexpr int Size = Definition::Linux;
#else
    static constexpr int Size = Definition::Default;
#endif
    static constexpr int Alignment = Definition::Alignment;
 
    AlignedStorage<Size, Alignment> buffer;
 
    using Handle = AlignedStorage<Size, Alignment>;
    static void construct(Handle& buffer);
    static void destruct(Object& obj);
    static void moveConstruct(Handle& buffer, Object&& obj);
    static void moveAssign(Object& selfPointer, Object&& obj);
};
 
} // namespace SC