Poly.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include <memory>
#include <type_traits>
 
#ifndef NDEBUG
#include <cstring>
#endif
 
namespace CeresEngine {
 
#define CE_POLY_TMPL(T) typename T, size_t T##SmallSize, bool T##Copyable, typename T##BaseType
#define CE_POLY_TYPE(T) Poly<T, T##SmallSize, T##Copyable, T##BaseType>
 
    namespace impl {
        template<typename T> struct PolyImplementation {
            T* (*get)(void* raw);
 
            void (*copy)(void* lhs, const void* rhs);
 
            void (*move)(void* lhs, void* rhs);
 
            void (*destroy)(void* raw);
        };
    }
 
    template<typename T, size_t SmallSize = sizeof(int*) * 4, bool Copyable = true, typename BaseType = T> class Poly {
        template<typename, size_t, bool, typename> friend class Poly;
 
    private:
        using Implementation = impl::PolyImplementation<BaseType>;
        static_assert(SmallSize >= sizeof(void*), "SmallSize must be at least the size of a single pointer.");
 
        mutable Byte mRaw[SmallSize];
 
        const Implementation* mImplementation = nullptr;
 
    public:
        template<typename U> static constexpr inline bool isSmall = sizeof(U) <= SmallSize&& std::is_move_constructible_v<U>;
 
    private:
        template<typename TT> static const Implementation* create() {
            if constexpr(isSmall<TT>) {
                // For small objects, we can store the actual object
                // directly in the raw memory.
                static const Implementation implementation{
                    .get = [](void* const ptr) -> BaseType* { return reinterpret_cast<TT*>(ptr); },
                    .copy = []() -> decltype(Implementation::copy) {
                        if constexpr(std::is_copy_constructible_v<TT>) {
                            return [](void* const destination, const void* source) {
                                new(destination) TT(*reinterpret_cast<const TT*>(source));
                            };
                        }
                        return nullptr;
                    }(),
                    .move = []() -> decltype(Implementation::move) {
                        if constexpr(std::is_move_constructible_v<TT>) {
                            return [](void* const destination, void* const source) {
                                new(destination) TT(std::move(*reinterpret_cast<TT*>(source)));
                            };
                        }
                        return nullptr;
                    }(),
                    .destroy = [](void* const ptr) { reinterpret_cast<TT*>(ptr)->~TT(); },
                };
                return &implementation;
            } else {
                // However, for large objects we need to heap allocate and
                // only store a pointer in to the raw memory.
                static const Implementation implementation{
                    .get = [](void* const ptr) -> BaseType* { return *reinterpret_cast<TT**>(ptr); },
                    .copy = []() -> decltype(Implementation::copy) {
                        if constexpr(std::is_copy_constructible_v<TT>) {
                            return [](void* const destination, const void* const source) {
                                *reinterpret_cast<TT**>(destination) = new TT(**reinterpret_cast<const TT* const*>(source));
                            };
                        }
                        return nullptr;
                    }(),
                    .move =
                        [](void* const destination, void* const source) { //
                            *reinterpret_cast<TT**>(destination) = std::exchange(*reinterpret_cast<TT**>(source), nullptr);
                        },
                    .destroy = [](void* const ptr) { delete *reinterpret_cast<TT**>(ptr); },
                };
                return &implementation;
            }
        }
 
        static const Implementation* getReference() {
            static const Implementation implementation{
                .get = [](void* const ptr) -> BaseType* { return *reinterpret_cast<T**>(ptr); },
                .copy = [](void* const dst, const void* const src) { *reinterpret_cast<T**>(dst) = *reinterpret_cast<T* const*>(src); },
                .move = [](void* const dst, void* const src) { *reinterpret_cast<T**>(dst) = *reinterpret_cast<T**>(src); },
                .destroy = [](void* const ptr) { *reinterpret_cast<T**>(ptr) = nullptr; },
            };
            return &implementation;
        }
 
    public:
        [[nodiscard]] bool isCopyable() const noexcept requires(Copyable) { return mImplementation == nullptr || mImplementation->copy != nullptr; }
 
        Poly(const Poly& other) requires(Copyable) : mImplementation(other.mImplementation) {
            CE_ASSERT(other.isCopyable());
 
            if(mImplementation == nullptr) {
                return;
            }
 
            CE_ASSERT(mImplementation->copy != nullptr);
            mImplementation->copy(mRaw, other.mRaw);
        }
 
        Poly& operator=(const Poly& other) requires(Copyable) { // NOLINT(bugprone-unhandled-self-assignment,cert-oop54-cpp)
            CE_ASSERT(other.isCopyable());
 
            reset();
            CE_ASSERT(mImplementation == nullptr);
 
            mImplementation = other.mImplementation;
            if(mImplementation != nullptr) {
                CE_ASSERT(mImplementation->copy != nullptr);
                mImplementation->copy(mRaw, other.mRaw);
            }
 
            return *this;
        }
 
        [[nodiscard]] bool isMovable() const noexcept { return mImplementation == nullptr || mImplementation->move != nullptr; }
 
        Poly(Poly&& other) noexcept : mImplementation(other.mImplementation) {
            CE_ASSERT(other.isMovable());
 
            if(mImplementation == nullptr) {
                return;
            }
 
            CE_ASSERT(mImplementation->move != nullptr);
            mImplementation->move(mRaw, other.mRaw);
        }
 
        Poly& operator=(Poly&& other) { // NOLINT
            CE_ASSERT(other.isMovable());
 
            reset();
            CE_ASSERT(mImplementation == nullptr);
 
            mImplementation = other.mImplementation;
            if(mImplementation != nullptr) {
                CE_ASSERT(mImplementation->move != nullptr);
                mImplementation->move(mRaw, other.mRaw);
            }
 
            return *this;
        }
 
        Poly(std::nullptr_t) noexcept : mImplementation(nullptr) {} // NOLINT
 
        Poly& operator=(std::nullptr_t) noexcept {
            reset();
            return *this;
        }
 
        ~Poly() noexcept { reset(); }
 
    private:
        template<typename TT> struct ConstructTag {};
 
        template<typename TT, typename... Args>
        explicit Poly(ConstructTag<TT>, Args&&... args) requires(std::is_convertible_v<TT*, T*>&& std::is_constructible_v<TT, Args&&...>) {
            emplace<TT>(std::forward<Args>(args)...);
        }
 
    public:
        template<typename TT = T> Poly() noexcept requires(std::is_default_constructible_v<TT>) : Poly(ConstructTag<TT>{}) {}
        template<typename TT, typename... Args>
        explicit Poly(std::in_place_type_t<TT>, Args&&... args) requires(std::is_convertible_v<TT*, T*>&& std::is_constructible_v<TT, Args&&...>) {
            emplace<TT>(std::forward<Args>(args)...);
        }
 
        template<typename... Args>
        explicit Poly(Args&&... args) requires(std::is_constructible_v<T, Args...>) : Poly(ConstructTag<T>{}, std::forward<Args>(args)...) {}
 
        template<typename TT>
        Poly(TT object) requires(std::is_convertible_v<TT*, T*> && Copyable) // NOLINT
                : Poly(ConstructTag<TT>{}, std::forward<TT>(object)) {}
 
        template<typename TT>
        Poly(TT&& object) requires(std::is_convertible_v<TT*, T*> && !Copyable) { // NOLINT
            emplace<TT>(std::move(object));
        }
 
        CE_EXPLICIT(false) Poly(T* const instance) {
            mImplementation = getReference();
            CE_ASSERT(mImplementation != nullptr);
 
            *reinterpret_cast<T**>(mRaw) = instance;
        }
 
        template<typename TT, typename... Args> TT& emplace(Args&&... args) requires std::is_constructible_v<TT, Args...> {
            reset();
            CE_ASSERT(mImplementation == nullptr);
 
            mImplementation = create<TT>();
            CE_ASSERT(mImplementation != nullptr);
 
            using SmallType = TT;
            using LargeType = TT*;
 
            if constexpr(isSmall<TT>) {
                new(mRaw) SmallType(std::forward<Args>(args)...);
            } else {
                TT* const pointer = new TT(std::forward<Args>(args)...);
                new(mRaw) LargeType(pointer);
            }
 
            return static_cast<TT&>(*get());
        }
 
        template<typename TT> TT& emplace(TT&& instance) {
            reset();
            CE_ASSERT(mImplementation == nullptr);
 
            mImplementation = create<TT>();
            CE_ASSERT(mImplementation != nullptr);
 
            using SmallType = TT;
            using LargeType = TT*;
 
            if constexpr(isSmall<TT>) {
                new(mRaw) SmallType(std::move(instance));
            } else {
                TT* const pointer = new TT(std::move(instance));
                new(mRaw) LargeType(pointer);
            }
 
            return static_cast<TT&>(*get());
        }
 
        template<typename U> requires(Copyable)
        CE_EXPLICIT(false) Poly(const Poly<U, SmallSize, Copyable, BaseType>& other) : mImplementation(other.mImplementation) {
            CE_ASSERT(other.isCopyable());
            if(mImplementation == nullptr) {
                return;
            }
 
            CE_ASSERT(mImplementation->copy != nullptr);
            mImplementation->copy(mRaw, other.mRaw);
        }
 
        template<typename U>
        CE_EXPLICIT(false) Poly(Poly<U, SmallSize, Copyable, BaseType>&& other) : mImplementation(other.mImplementation) {
            CE_ASSERT(other.isMovable());
            if(mImplementation == nullptr) {
                return;
            }
 
            CE_ASSERT(mImplementation->move != nullptr);
            mImplementation->move(mRaw, other.mRaw);
        }
 
    public: // Public interface
        [[nodiscard]] bool valid() const { return get() != nullptr; }
 
        [[nodiscard]] bool empty() const { return valid(); }
 
        [[nodiscard]] explicit operator bool() const { return valid(); }
 
        [[nodiscard]] T* get() { return mImplementation == nullptr ? nullptr : dynamic_cast<T*>(mImplementation->get(mRaw)); }
 
        [[nodiscard]] const T* get() const { return mImplementation == nullptr ? nullptr : dynamic_cast<const T*>(mImplementation->get(mRaw)); }
 
        [[nodiscard]] T* operator->() { return get(); }
 
        [[nodiscard]] const T* operator->() const { return get(); }
 
        [[nodiscard]] const T& operator*() const& {
            CE_ASSERT(valid());
            return *get();
        }
 
        [[nodiscard]] T& operator*() & {
            CE_ASSERT(valid());
            return *get();
        }
 
        [[nodiscard]] T&& operator*() && {
            CE_ASSERT(valid());
            return std::move(*get());
        }
 
    public: // Type casting
        [[nodiscard]] const std::type_info& getTypeID() const {
            CE_ASSERT(valid());
            return typeid(*get());
        }
 
        template<typename TT> [[nodiscard]] bool is() const requires std::is_convertible_v<TT*, T*> { return dynamic_cast<const TT*>(get()) != nullptr; }
 
        template<typename TT> TT* being() requires std::is_convertible_v<TT*, T*> { return dynamic_cast<TT*>(get()); }
 
        template<typename TT> const TT* being() const requires std::is_convertible_v<TT*, T*> { return dynamic_cast<const TT*>(get()); }
 
        template<typename TT> TT& as() & requires std::is_convertible_v<TT*, T*> {
            CE_ASSERT(valid());
            CE_ASSERT_DEBUG(is<TT>());
            return static_cast<TT&>(*get());
        }
 
        template<typename TT> TT&& as() && requires std::is_convertible_v<TT*, T*> {
            CE_ASSERT(valid());
            CE_ASSERT_DEBUG(is<TT>());
            return static_cast<TT&&>(*get());
        }
 
        template<typename TT> const TT& as() const& requires std::is_convertible_v<TT*, T*> {
            CE_ASSERT(valid());
            CE_ASSERT_DEBUG(is<TT>());
            return static_cast<const TT&>(*get());
        }
 
    private:
        void reset() {
            if(mImplementation == nullptr) {
                return;
            }
 
            CE_ASSERT(mImplementation->destroy != nullptr);
            mImplementation->destroy(mRaw);
            mImplementation = nullptr;
#ifndef NDEBUG
            std::memset(mRaw, 0x00, sizeof(mRaw));
#endif
        }
    };
 
    template<CE_POLY_TMPL(T), CE_POLY_TMPL(U)> bool operator==(const CE_POLY_TYPE(T) & lhs, const CE_POLY_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) == *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), typename U> bool operator==(const CE_POLY_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) == rhs;
    }
 
    template<typename U, CE_POLY_TMPL(T)> bool operator==(const U& lhs, const CE_POLY_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs == *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), CE_POLY_TMPL(U)> bool operator!=(const CE_POLY_TYPE(T) & lhs, const CE_POLY_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return true;
        }
        if(rhs.get() == nullptr) {
            return true;
        }
        return *(lhs.get()) != *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), typename U> bool operator!=(const CE_POLY_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return true;
        }
        return *(lhs.get()) != rhs;
    }
 
    template<typename U, CE_POLY_TMPL(T)> bool operator!=(const U& lhs, const CE_POLY_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return true;
        }
        return lhs != *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), CE_POLY_TMPL(U)> bool operator>(const CE_POLY_TYPE(T) & lhs, const CE_POLY_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) > *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), typename U> bool operator>(const CE_POLY_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) > rhs;
    }
 
    template<typename U, CE_POLY_TMPL(T)> bool operator>(const U& lhs, const CE_POLY_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs > *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), CE_POLY_TMPL(U)> bool operator>=(const CE_POLY_TYPE(T) & lhs, const CE_POLY_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) >= *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), typename U> bool operator>=(const CE_POLY_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) >= rhs;
    }
 
    template<typename U, CE_POLY_TMPL(T)> bool operator>=(const U& lhs, const CE_POLY_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs >= *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), CE_POLY_TMPL(U)> bool operator<(const CE_POLY_TYPE(T) & lhs, const CE_POLY_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) < *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), typename U> bool operator<(const CE_POLY_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) < rhs;
    }
 
    template<typename U, CE_POLY_TMPL(T)> bool operator<(const U& lhs, const CE_POLY_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs < *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), CE_POLY_TMPL(U)> bool operator<=(const CE_POLY_TYPE(T) & lhs, const CE_POLY_TYPE(U) & rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        if(rhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) <= *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T), typename U> bool operator<=(const CE_POLY_TYPE(T) & lhs, const U& rhs) noexcept {
        if(lhs.get() == nullptr) {
            return false;
        }
        return *(lhs.get()) <= rhs;
    }
 
    template<typename U, CE_POLY_TMPL(T)> bool operator<=(const U& lhs, const CE_POLY_TYPE(T) & rhs) noexcept {
        if(rhs.get() == nullptr) {
            return false;
        }
        return lhs <= *(rhs.get());
    }
 
    template<CE_POLY_TMPL(T)> bool operator==(const CE_POLY_TYPE(T) & lhs, std::nullptr_t) noexcept { return lhs.get() == nullptr; }
 
    template<CE_POLY_TMPL(T)> bool operator!=(const CE_POLY_TYPE(T) & lhs, std::nullptr_t) noexcept { return lhs.get() != nullptr; }
 
#undef CE_POLY_TMPL
#undef CE_POLY_TYPE
 
} // namespace CeresEngine