Map.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 MapSerializer;
}
 
namespace Infinity::Types::Containers
{
    class INFINITY_API_PUBLIC Map : public Core::Data
    {
        public:
            Map();
 
            Map(const Map& copy);
 
            Map(Map&& move);
 
            virtual ~Map();
 
            std::unique_ptr<Core::Base> clone() const override;
 
            virtual const Infinity::Types::TypeID& typeId() const override;
 
            Map& operator=(const Map& copy);
 
            Map& operator=(Map&& move);
 
            bool hasKey(const std::string& key) const;
 
            bool hasValueAtKey(const std::string& key) const;
 
            void set(const std::string& key, std::shared_ptr<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>(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>
            T& get(const std::string& key)
            {
                if constexpr (std::is_base_of_v<Core::Data, T>)
                {
                    T& a = *dynamic_cast<T*>(_map.at(key).get());
                    return a;
                } else {
                    auto val = dynamic_cast<Core::Value<T>*>(_map.at(key).get());
                    return val->get();
                }
            }
 
            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>
            T& getValue(const std::string& key)
            {
                return get<Core::Value<T>>(key).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<Core::Data>> _map; 
 
            friend class Infinity::IO::Data::MapSerializer;
    };
}
 
INFINITY_TYPE(Infinity::Types::Containers::Map)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Containers::Map>)