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 <forward_list>
#include <queue>
#include <tuple>
#include <memory>
#include <functional>
#include <variant>
#include <ranges>
#include <mutex>
#include <generator>
#include <utility>
#include <iterator>
#include <cstddef>
#include <concepts>
#include <typeindex>
 
#ifdef __cpp_lib_mdspan
#include <mdspan>
#endif
 
#include "traits.hpp"
#include "string.hpp"
#include "exceptions.hpp"
 
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
#ifndef LITEFX_DEFINE_FLAGS
#  define LITEFX_DEFINE_FLAGS(T) \
    constexpr 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)); } \
    constexpr T& operator|= (T& lhs, const T& rhs) { lhs = lhs | rhs; return lhs; } \
    constexpr 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)); } \
    constexpr 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>((std::to_underlying(val) & std::to_underlying(flag)) == std::to_underlying(flag))
#endif
 
// NOLINTEND(cppcoreguidelines-macro-usage)
 
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... TArgs> 
    struct type_switch : TArgs... { 
        using TArgs::operator()...; 
    };
 
    template <class T>
    using Ref = std::reference_wrapper<T>;
 
    template <class T>
    [[nodiscard]] constexpr UniquePtr<T> makeUnique() {
        return std::make_unique<T>();
    }
 
    template <class T, class... TArgs>
    [[nodiscard]] constexpr UniquePtr<T> makeUnique(TArgs&&... _args) {
        return std::make_unique<T>(std::forward<TArgs>(_args)...);
    }
 
    template <class T>
    [[nodiscard]] constexpr SharedPtr<T> makeShared() {
        return std::make_shared<T>();
    }
 
    template <class T, class... TArgs>
    [[nodiscard]] constexpr SharedPtr<T> makeShared(TArgs&&... _args) {
        return std::make_shared<T>(std::forward<TArgs>(_args)...);
    }
 
    template <class T>
    [[nodiscard]] constexpr SharedPtr<T> asShared(UniquePtr<T>&& ptr) {
        SharedPtr<T> shared = std::move(ptr);
        return shared;
    }
 
    template <typename T, typename TVal = void>
    using Generator = std::generator<T, TVal>;
 
    template <typename TValue, typename TCovariant>
    concept is_covariant = std::is_assignable_v<TCovariant, TValue> || std::is_constructible_v<TCovariant, TValue>;
 
    template <typename TIterator, typename TValue>
    concept covariant_forward_iterator = std::forward_iterator<TIterator> && is_covariant<decltype(*std::declval<TIterator>()), TValue>;
 
    template <typename T>
    struct CovariantIterator {
    public:
        using value_type = std::remove_cvref_t<T>;
 
        using iterator_category = std::forward_iterator_tag;
 
        using difference_type = std::ptrdiff_t;
 
        using pointer = std::remove_reference_t<T>*;
 
    private:
        struct iterator_base {
        protected:
            iterator_base() = default;
            iterator_base(iterator_base&&) noexcept = default;
            iterator_base(const iterator_base&) = default;
            iterator_base& operator=(iterator_base&&) noexcept = default;
            iterator_base& operator=(const iterator_base&) = default;
 
        public:
            virtual ~iterator_base() noexcept = default;
 
            virtual T operator*() const = 0;
            virtual iterator_base& operator++() = 0;
            virtual std::unique_ptr<iterator_base> operator++(int) = 0;
            virtual bool operator==(const iterator_base& _other) const noexcept = 0;
            virtual std::unique_ptr<iterator_base> copy() const = 0;
        };
 
        template <covariant_forward_iterator<T> TIterator>
        struct wrapped_iterator final : public iterator_base {
        private:
            TIterator _it;
 
        private:
            wrapped_iterator() = delete;
            wrapped_iterator(wrapped_iterator&&) noexcept = default;
            wrapped_iterator(const wrapped_iterator&) = delete;
            wrapped_iterator& operator=(wrapped_iterator&&) noexcept = default;
            wrapped_iterator& operator=(const wrapped_iterator&) = delete;
 
        public:
            inline wrapped_iterator(TIterator it) :
                _it(std::move(it))
            { }
 
            inline ~wrapped_iterator() noexcept override = default;
 
            inline T operator*() const override {
                return *_it;
            };
 
            inline iterator_base& operator++() override {
                ++_it;
                return *this;
            }
 
            inline std::unique_ptr<iterator_base> operator++(int) override {
                return std::make_unique<wrapped_iterator>(_it++);
            }
 
            inline bool operator==(const iterator_base& _other) const noexcept override {
                // NOTE: This is only safe if the other iterator is of the same type as the current iterator, which is enforced by the `CovariantIterator` class.
                return this->_it == static_cast<const wrapped_iterator&>(_other)._it;
            }
 
            inline std::unique_ptr<iterator_base> copy() const override {
                return std::make_unique<wrapped_iterator>(_it);
            }
        };
 
        std::unique_ptr<iterator_base> _iterator{ nullptr }; // NOTE: Starting with C++26 there may be a way to express this with a value-semantic unique_ptr.
        std::type_index _iterator_type{ typeid(iterator_base) };
 
    private:
        CovariantIterator(std::unique_ptr<iterator_base>&& iterator, std::type_index iterator_type) :
            _iterator(std::move(iterator)), _iterator_type(iterator_type) 
        { }
 
    public:
        explicit CovariantIterator() {
            // Calling this constructor is not supported. It is only publicly available, to make sure the iterator is `std::semiregular`, which is implicitly required by the `std::ranges::range` concept.
            throw RuntimeException("Default-initializing `CovariantIterator` is not supported!");
        }
 
        template <typename TIterator>
        inline CovariantIterator(const TIterator& it) :
            _iterator(std::make_unique<wrapped_iterator<TIterator>>(it)), _iterator_type(typeid(TIterator))
        { }
 
        inline CovariantIterator(const CovariantIterator& _other) :
            _iterator(_other._iterator->copy()), _iterator_type(_other._iterator_type)
        { }
 
        inline CovariantIterator(CovariantIterator&& _other) noexcept = default;
 
        inline CovariantIterator& operator=(const CovariantIterator& _other) {
            _iterator = _other._iterator->copy();
            _iterator_type = _other._iterator_type;
            return *this;
        }
 
        inline CovariantIterator& operator=(CovariantIterator&& _other) = default;
 
        ~CovariantIterator() noexcept = default;
 
        inline T operator*() const {
            return _iterator->operator*();
        }
 
        inline pointer operator->() requires std::is_lvalue_reference_v<T> {
            return &this->operator*();
        }
 
        inline CovariantIterator& operator++() {
            _iterator->operator++();
            return *this;
        }
 
        inline CovariantIterator operator++(int) {
            return { (*_iterator)++, _iterator_type };
        }
 
        inline bool operator==(const CovariantIterator& _other) const {
            if (this->_iterator_type != _other._iterator_type)
                return false;
 
            return _iterator->operator==(*_other._iterator);
        }
    };
 
    template <typename T>
    struct Enumerable {
    public:
        using value_type = std::remove_cvref_t<T>;
 
        using pointer = std::remove_reference_t<T>*;
 
        using reference = std::remove_reference_t<T>&;
 
        using iterator = CovariantIterator<T>;
 
        using const_iterator = CovariantIterator<const std::remove_const_t<T>>;
 
    private:
        struct range_holder_base {
        protected:
            range_holder_base() = default;
            range_holder_base(range_holder_base&&) noexcept = delete;
            range_holder_base(const range_holder_base&) = delete;
            range_holder_base& operator=(range_holder_base&&) noexcept = delete;
            range_holder_base& operator=(const range_holder_base&) = delete;
 
        public:
            virtual ~range_holder_base() noexcept = default;
 
            virtual iterator begin() = 0;
            virtual iterator end() = 0;
            virtual const_iterator cbegin() = 0;
            virtual const_iterator cend() = 0;
        };
 
        template <std::ranges::viewable_range TRange>
        struct range_holder final : public range_holder_base {
        private:
            TRange _stored_range;
 
        private:
            range_holder() = default;
            range_holder(range_holder&&) noexcept = default;
            range_holder(const range_holder&) = delete;
            range_holder& operator=(range_holder&&) noexcept = default;
            range_holder& operator=(const range_holder&) = delete;
 
        public:
            inline range_holder(TRange&& range) :
                _stored_range(std::move(range))
            { }
 
            inline ~range_holder() noexcept override = default;
 
            inline iterator begin() override {
                return { std::ranges::begin(_stored_range) };
            }
 
            inline iterator end() override {
                return { std::ranges::end(_stored_range) };
            }
 
            inline const_iterator cbegin() override {
                return { std::ranges::begin(_stored_range) };
            }
 
            inline const_iterator cend() override {
                return { std::ranges::end(_stored_range) };
            }
        };
 
        std::shared_ptr<range_holder_base> _range{ };
 
    public:
        inline Enumerable() :
            Enumerable(std::array<T, 0> { })
        { }
 
        inline Enumerable(const Enumerable& range) = default;
        inline Enumerable(Enumerable&& range) noexcept = default;
        inline Enumerable& operator=(const Enumerable& range) = default;
        inline Enumerable& operator=(Enumerable&& range) noexcept = default;
        ~Enumerable() noexcept = default;
 
        template <typename TRange, typename enabled = std::enable_if_t<!std::is_same_v<TRange, Enumerable>>>
        inline Enumerable(TRange&& range) {
            // NOTE: Concept evaluation may fail here, if we provide some other enumerable, in which case the evaluated type may be not complete yet, which is why have to
            //       do a static assert here instead of providing the concept in the template.
            static_assert(std::ranges::viewable_range<TRange>, "The source range does not satisfy std::ranges::viewable_range!");
            _range = std::make_shared<range_holder<std::ranges::views::all_t<decltype(range)>>>(std::forward<TRange>(range)); // NOLINT(cppcoreguidelines-prefer-member-initializer)
        }
 
        inline auto begin() const {
            return _range->begin();
        }
 
        inline auto end() const {
            return _range->end();
        }
 
        inline auto cbegin() const {
            return _range->cbegin();
        }
 
        inline auto cend() const {
            return _range->cend();
        }
 
        inline bool empty() const noexcept {
            return this->begin() == this->end();
        }
    };
 
#if (defined(BUILD_LITEFX_PIMPL) && BUILD_LITEFX_PIMPL) || (!defined(BUILD_LITEFX_PIMPL)) && !defined(LITEFX_IMPLEMENTATION)
    template <class pImpl>
    class PimplPtr final {
    private:
        SharedPtr<pImpl> m_ptr;
 
    public:
        constexpr PimplPtr() /*requires std::is_default_constructible_v<pImpl>*/ :
            m_ptr(makeShared<pImpl>()) { }
 
        template <typename... TArgs>
        constexpr PimplPtr(TArgs&&... args) /*requires std::constructible_from<pImpl, TArgs...>*/ :
            m_ptr(makeShared<pImpl>(std::forward<TArgs>(args)...)) { } // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
 
        constexpr PimplPtr(const PimplPtr& src) /*requires std::copy_constructible<pImpl>*/ : 
            m_ptr(makeShared<pImpl>(*src.m_ptr)) { }
 
        constexpr PimplPtr(PimplPtr&& src) noexcept = default;
 
        constexpr PimplPtr& operator=(const PimplPtr& src) /*requires std::copy_constructible<pImpl>*/
        {
            if (&src != this)
                m_ptr = makeShared<pImpl>(*src.m_ptr);
 
            return *this; 
        }
 
        constexpr PimplPtr& operator=(PimplPtr&& src) noexcept = default;
 
        constexpr ~PimplPtr() noexcept = default;
 
    public:
        constexpr pImpl& operator* () const noexcept { 
            return *m_ptr; 
        }
 
        constexpr pImpl* operator-> () const noexcept { 
            return m_ptr.get(); 
        }
    };
 
    // NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
#  define LITEFX_IMPLEMENTATION(impl) private: \
    class impl; \
    PimplPtr<impl> m_impl; \
    friend class PimplPtr<impl>; \
    friend class impl;
 
    // NOLINTEND(cppcoreguidelines-macro-usage)
#endif
 
    template <class THandle>
    class IResource {
    protected:
        IResource() noexcept = default;
        IResource(const IResource&) = delete;
        IResource(IResource&&) noexcept = default;
        IResource& operator=(const IResource&) = delete;
        IResource& operator=(IResource&&) noexcept = default;
 
    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> {
    public:
        using handle_type = THandle;
 
    private:
        THandle m_handle;
 
    protected:
        explicit Resource(THandle handle) noexcept : m_handle(std::move(handle)) { }
        Resource(const Resource&) = delete;
        Resource(Resource&&) noexcept = default;
        Resource& operator=(const Resource&) = delete;
        Resource& operator=(Resource&&) noexcept = default;
 
    public:
        ~Resource() noexcept override = default;
 
    protected:
        THandle& handle() noexcept override { return m_handle; }
 
    public:
        const THandle& handle() const noexcept override { return m_handle; }
    };
 
    template <typename T, typename TParent = std::nullptr_t, typename TPointer = UniquePtr<T>>
    class Builder;
 
    template <typename T, typename TPointer>
    class Builder<T, std::nullptr_t, TPointer> {
    private:
        TPointer m_instance;
 
    public:
        using instance_type = T;
        using parent_type = std::nullptr_t;
        using pointer_type = TPointer;
 
    public:
        constexpr const T* instance() const noexcept { return m_instance.get(); }
 
    protected:
        constexpr T* instance() noexcept { return m_instance.get(); }
 
    public:
        constexpr explicit Builder(TPointer&& instance) noexcept : m_instance(std::move(instance)) { }
 
        constexpr Builder(Builder&& _other) noexcept : m_instance(std::move(_other.m_instance)) { }
 
        Builder(const Builder&) = delete;
        auto operator=(const Builder&) = delete;
        auto operator=(const Builder&&) noexcept = delete;
 
        constexpr virtual ~Builder() noexcept = default;
 
    protected:
        constexpr virtual void build() { };
 
    public:
        // TODO: Provide concept (`is_buildable<TBuilder>`)
        template <typename TInstance>
        void use(pointer_type&&) noexcept = delete;
 
        [[nodiscard]] constexpr operator TPointer&& () {
            this->build();
            return std::move(m_instance);
        }
    };
 
    template <typename T, typename TParent, typename TPointer>
    class Builder {
    private:
        TPointer m_instance;
        TParent* m_parent;
 
    public:
        using instance_type = T;
        using parent_type = TParent;
        using pointer_type = TPointer;
 
    public:
        constexpr const T* instance() const noexcept { return m_instance.get(); }
 
        constexpr const TParent& parent() const noexcept { return *m_parent; }
 
    protected:
        constexpr T* instance() noexcept { return m_instance.get(); }
 
    public:
        constexpr explicit Builder(TParent& parent, TPointer&& instance) noexcept : m_instance(std::move(instance)), m_parent(&parent) { }
        
        constexpr Builder(Builder&& _other) noexcept : m_instance(std::move(_other.m_instance)), m_parent(_other.m_parent) { }
 
        constexpr Builder(const Builder&) = delete;
        auto operator=(const Builder&) = delete;
        auto operator=(Builder&&) noexcept = delete;
        constexpr virtual ~Builder() noexcept = default;
 
    protected:
        constexpr virtual void build() { };
 
    public:
        // TODO: Provide concept (`is_buildable<TBuilder>`)
        template <typename TInstance>
        void use(pointer_type&&) noexcept = delete;
 
        [[nodiscard]] constexpr TParent& add() {
            this->build();
            m_parent->use(std::move(m_instance));
            return *m_parent;
        }
    };
 
    // NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
#if !defined(LITEFX_BUILDER)
#    define LITEFX_BUILDER(BuilderType) public: \
        using builder_type = BuilderType; \
        friend class BuilderType;
#endif // !defined(LITEFX_BUILDER)
 
    // NOLINTEND(cppcoreguidelines-macro-usage)
 
    class SharedObject : public std::enable_shared_from_this<SharedObject> {
    protected:
        SharedObject() noexcept = default;
        SharedObject(SharedObject&&) noexcept = default;
        SharedObject(const SharedObject&) = default;
        SharedObject& operator=(SharedObject&&) noexcept = default;
        SharedObject& operator=(const SharedObject&) = default;
 
    public:
        virtual ~SharedObject() noexcept = default;
 
    protected:
        template <typename T>
        struct Allocator : public std::allocator<T> {
            template<typename TParent, typename... TArgs>
            void construct(TParent* parent, TArgs&&... args) {
                ::new(static_cast<void*>(parent)) TParent(std::forward<TArgs>(args)...);
            }
        };
 
        template <typename T, typename... TArgs>
        static inline auto create(TArgs&&... args) -> SharedPtr<T> {
            return std::allocate_shared<T>(Allocator<T>{}, std::forward<TArgs>(args)...);
        }
 
    public:
        template <typename TSelf>
        auto inline shared_from_this(this TSelf&& self) noexcept
        {
            return std::static_pointer_cast<std::remove_reference_t<TSelf>>(
                std::forward<TSelf>(self).std::template enable_shared_from_this<SharedObject>::shared_from_this());
        }
        
        template <typename TSelf>
        auto inline weak_from_this(this TSelf&& self) noexcept -> WeakPtr<std::remove_reference_t<TSelf>>
        {
            return std::static_pointer_cast<std::remove_reference_t<TSelf>>(
                std::forward<TSelf>(self).std::template enable_shared_from_this<SharedObject>::weak_from_this().lock());
        }
    };
}