ImmutableMap.hpp

#pragma once
 
#include <Infinity/Types/Core/Data.hpp>
#include <Infinity/Types/Core/Value.hpp>
#include <Infinity/Types/Containers/Array.hpp>
 
#include <unordered_map>
#include <optional>
#include <memory>
 
namespace Infinity::IO::Data
{
    class ImmutableMapSerializer;
}
 
namespace Infinity::Types::Containers
{
    class INFINITY_API_PUBLIC ImmutableMap : public Core::Data
    {
        public:
            ImmutableMap();
 
            ImmutableMap(const ImmutableMap& copy);
 
            ImmutableMap(ImmutableMap&& move);
 
            virtual ~ImmutableMap();
 
            std::unique_ptr<Core::Base> clone() const override;
 
            virtual const Infinity::Types::TypeID& typeId() const override;
 
            ImmutableMap& operator=(const ImmutableMap& copy);
 
            ImmutableMap& operator=(ImmutableMap&& move);
 
            bool hasKey(const std::string& key) const;
 
            bool hasValueAtKey(const std::string& key) const;
 
            void set(const std::string& key, std::shared_ptr<const Core::Data> data);
 
            template<typename T>
            void set(const std::string& key, const T& data)
            {
                if constexpr (std::is_base_of_v<Core::Data, T>)
                {
                    _map[key] = std::make_shared<T>(data);
                } else {
                    _map[key] = std::make_shared<Core::Value<T>>(data);
                }
            }
 
            template<typename T>
            void set(const std::string& key, T&& data)
            {
                if constexpr (std::is_base_of_v<Core::Data, T>)
                {
                    _map[key] = std::make_shared<T>(std::move(data));
                } else {
                    size_t size = sizeof(uint8_t) + sizeof(Infinity::Types::getTypeID<T>().hash) + sizeof(T);
                    _map[key] = std::make_shared<Core::Value<T>>(std::move(data));
                }
            }
 
            const Core::Data* get(const std::string& key) const;
 
            template<typename T>
            const T& get(const std::string& key) const
            {
                if constexpr (std::is_base_of_v<Core::Data, T>)
                {
                    const T& a = *dynamic_cast<const T*>(_map.at(key).get());
                    return a;
                } else {
                    auto val = dynamic_cast<const Core::Value<T>*>(_map.at(key).get());
                    return val->get();
                }
            }
 
            template<typename T>
            const T& getValue(const std::string& key) const
            {
                return get<const Core::Value<T>>(key).get();
            }
 
            void clear();
 
            size_t size() const noexcept;
 
        private:
            std::unordered_map<std::string, std::shared_ptr<const Core::Data>> _map; 
 
            friend class Infinity::IO::Data::ImmutableMapSerializer;
    };
}
 
INFINITY_TYPE(Infinity::Types::Containers::ImmutableMap)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Containers::ImmutableMap>)