containers.hpp

#pragma once
 
// Disable warning C4251: STL class needs to have dll-interface to be used by clients.
// See: https://stackoverflow.com/a/22054743/1254352
#pragma warning(disable: 4251)
 
#include <array>
#include <cassert>
#include <algorithm>
#include <string>
#include <optional>
#include <map>
#include <vector>
#include <queue>
#include <tuple>
#include <memory>
#include <functional>
#include <variant>
#include <ranges>
#include <mutex>
 
#include "traits.hpp"
#include "string.hpp"
#include "exceptions.hpp"
 
#ifndef LITEFX_DEFINE_FLAGS
#  define LITEFX_DEFINE_FLAGS(T) \
    inline T operator| (const T lhs, const T rhs) { using _base_t = std::underlying_type_t<T>; return static_cast<T>(static_cast<_base_t>(lhs) | static_cast<_base_t>(rhs)); } \
    inline T& operator|= (T& lhs, const T& rhs) { lhs = lhs | rhs; return lhs; } \
    inline T operator& (const T lhs, const T rhs) { using _base_t = std::underlying_type_t<T>; return static_cast<T>(static_cast<_base_t>(lhs) & static_cast<_base_t>(rhs)); } \
    inline T& operator&= (T& lhs, const T& rhs) { lhs = lhs & rhs; return lhs; }
#endif
 
#ifndef LITEFX_FLAG_IS_SET
#  define LITEFX_FLAG_IS_SET(val, flag) static_cast<bool>((static_cast<UInt32>(val) & static_cast<UInt32>(flag)) == static_cast<UInt32>(flag))
#endif
 
namespace LiteFX {
 
    using Handle = void*;
 
    template<class TKey, class TVal>
    using Dictionary = std::unordered_map<TKey, TVal>;
 
    template<class T>
    using Array = std::vector<T>;
 
    template<class T>
    using Queue = std::queue<T>;
 
    template<class T>
    using Span = std::span<T>;
 
    template<class T>
    using Optional = std::optional<T>;
 
    template<class T, class TDeleter = std::default_delete<T>>
    using UniquePtr = std::unique_ptr<T, TDeleter>;
 
    template <class T>
    using SharedPtr = std::shared_ptr<T>;
 
    template <class T>
    using WeakPtr = std::weak_ptr<T>;
 
    template <class... T>
    using Tuple = std::tuple<T...>;
 
    template <class... T>
    using Variant = std::variant<T...>;
 
    template <class T>
    UniquePtr<T> makeUnique() {
        return std::make_unique<T>();
    }
 
    template <class T, class... TArgs>
    UniquePtr<T> makeUnique(TArgs&&... _args) {
        return std::make_unique<T>(std::forward<TArgs>(_args)...);
    }
 
    template <class T>
    SharedPtr<T> makeShared() {
        return std::make_shared<T>();
    }
 
    template <class T, class... TArgs>
    SharedPtr<T> makeShared(TArgs&&... _args) {
        return std::make_shared<T>(std::forward<TArgs>(_args)...);
    }
 
    template <class T>
    SharedPtr<T> makeShared(UniquePtr<T>&& ptr) {
        return std::make_shared<T>(ptr.release());
    }
 
    namespace ranges {
 
        template <typename TContainer>
        struct to_container { };
 
        template <typename TContainer, std::ranges::range TRange> requires 
            std::convertible_to<std::ranges::range_value_t<TRange>, typename TContainer::value_type>
        inline TContainer operator|(TRange&& range, to_container<TContainer>) {
            auto it = range | std::views::common;
            return TContainer{ it.begin(), it.end() };
        }
 
        template <std::ranges::range TContainer> requires 
            (!std::ranges::view<TContainer>)
        auto to() {
            return to_container<TContainer>{};
        }
 
    }
 
#if (defined(BUILD_LITEFX_PIMPL) && BUILD_LITEFX_PIMPL) || (!defined(BUILD_LITEFX_PIMPL)) && !defined(LITEFX_IMPLEMENTATION)
    template <class pImpl>
    class PimplPtr {
    private:
        UniquePtr<pImpl> m_ptr;
 
    public:
        PimplPtr() noexcept = default;
 
        PimplPtr(const PimplPtr& src) noexcept : m_ptr(new pImpl(*src.m_ptr)) { }
 
        PimplPtr(PimplPtr&& src) noexcept = default;
 
        PimplPtr& operator= (const PimplPtr& src) noexcept { m_ptr.reset(new pImpl(*src.m_ptr)); return *this; }
 
        PimplPtr& operator= (PimplPtr&& src) noexcept = default;
 
        ~PimplPtr() noexcept = default;
 
    private:
        PimplPtr(pImpl* pimpl) noexcept : m_ptr(pimpl) { }
 
    public:
        void destroy() { m_ptr = nullptr; }
 
        pImpl* release() noexcept { m_ptr.release(); }
 
    public:
        pImpl& operator* () const noexcept { return *m_ptr; }
 
        pImpl* operator-> () const noexcept { return m_ptr.get(); }
 
    public:
        template <class T, class... Arg>
        friend PimplPtr<T> makePimpl(Arg&&... arg);
    };
 
    template <class T, class... Arg>
    PimplPtr<T> makePimpl(Arg&&... arg) {
        return PimplPtr<T>(new T(std::forward<Arg>(arg)...));
    }
 
#  define LITEFX_IMPLEMENTATION(impl) private: \
    class impl; \
    PimplPtr<impl> m_impl;
#endif
 
    template <class TInterface>
    class Implement {
    public:
        using interface_type = TInterface;
        using base = Implement<interface_type>;
 
    protected:
        TInterface* m_parent{ nullptr };
 
    public:
        Implement(TInterface* parent) : m_parent(parent) {
            if (parent == nullptr)
                throw std::runtime_error("Initializing an implementation requires the parent to be provided.");
        }
 
        Implement(Implement<TInterface>&&) = delete;
        Implement(const Implement<TInterface>&) = delete;
        virtual ~Implement() = default;
    };
 
    template <class THandle>
    class IResource {
    public:
        virtual ~IResource() noexcept = default;
 
    protected:
        virtual THandle& handle() noexcept = 0;
 
    public:
        virtual const THandle& handle() const noexcept = 0;
    };
 
    template <class THandle>
    class Resource : public virtual IResource<THandle> {
    private:
        THandle m_handle;
 
    protected:
        explicit Resource(const THandle handle) noexcept : m_handle(handle) { }
 
    public:
        Resource(const Resource&) = delete;
        Resource(Resource&&) = delete;
        virtual ~Resource() noexcept = default;
 
    protected:
        THandle& handle() noexcept override { return m_handle; }
 
    public:
        const THandle& handle() const noexcept override { return m_handle; }
    };
 
    template <typename TDerived, typename T, typename TParent = std::nullptr_t, typename TPointer = UniquePtr<T>>
    class Builder;
 
    template <typename TDerived, typename T, typename TPointer>
    class Builder<TDerived, T, std::nullptr_t, typename TPointer> {
    private:
        TPointer m_instance;
 
    public:
        using derived_type = TDerived;
        using instance_type = T;
        using parent_type = std::nullptr_t;
        using pointer_type = TPointer;
        using builder_type = Builder<derived_type, instance_type, parent_type, pointer_type>;
 
    public:
        const T* instance() const noexcept { return m_instance.get(); }
 
    protected:
        T* instance() noexcept { return m_instance.get(); }
 
    public:
        explicit Builder(TPointer&& instance) noexcept : m_instance(std::move(instance)) { }
 
        Builder(builder_type&& _other) noexcept : m_instance(std::move(_other.m_instance)) { }
 
        Builder(const builder_type&) = delete;
        virtual ~Builder() noexcept = default;
 
    protected:
        virtual void build() { };
 
    public:
        // TODO: Provide concept (`is_buildable<TBuilder>`)
        template <typename TInstance>
        void use(pointer_type&&) = delete;
 
        [[nodiscard]]
        operator TPointer&& () {
            this->build();
            return std::move(m_instance);
        }
    };
 
    template <typename TDerived, typename T, typename TParent, typename TPointer>
    class Builder {
    private:
        TPointer m_instance;
        TParent& m_parent;
 
    public:
        using derived_type = TDerived;
        using instance_type = T;
        using parent_type = TParent;
        using pointer_type = TPointer;
        using builder_type = Builder<derived_type, instance_type, parent_type, pointer_type>;
 
    public:
        const T* instance() const noexcept { return m_instance.get(); }
 
        const TParent& parent() const noexcept { return m_parent; }
 
    protected:
        T* instance() noexcept { return m_instance.get(); }
 
    public:
        explicit Builder(TParent& parent, TPointer&& instance) noexcept : m_parent(parent), m_instance(std::move(instance)) { }
        
        Builder(builder_type&& _other) noexcept : m_instance(std::move(_other.m_instance)), m_parent(_other.m_parent) { }
        
        Builder(const builder_type&) = delete;
        virtual ~Builder() noexcept = default;
 
    protected:
        virtual void build() { };
 
    public:
        // TODO: Provide concept (`is_buildable<TBuilder>`)
        template <typename TInstance>
        void use(pointer_type&&) = delete;
 
        [[nodiscard]]
        TParent& add() {
            this->build();
            m_parent.use(std::move(m_instance));
            return m_parent;
        }
    };
 
#if !defined(LITEFX_BUILDER)
#    define LITEFX_BUILDER(BuilderType) public: \
        using builder_type = BuilderType; \
        friend class BuilderType;
#endif // !defined(LITEFX_BUILDER)
 
}