Converters.hpp

#pragma once
 
#include <Infinity/api.h>
#include <Infinity/Types/TypeID.hpp>
#include <Infinity/Types/Core/Base.hpp>
#include <Infinity/Util/unordered_dense.h>
 
namespace Infinity::Types
{
    template<typename F, typename T>
    using Converter = T(const F&);
 
    using ConverterFn = std::function<Core::Base*(const Core::Base*)>;
 
    class INFINITY_API_PUBLIC Converters
    {
        public:
            ~Converters();
 
            bool canConvert(const TypeID& fromType, const TypeID& toType)
            {
                return _converters.find(hashIDs(fromType, toType)) != _converters.end();
            }
 
            Core::Base* convert(const TypeID& fromType, const TypeID& toType, const Core::Base* from);
 
            ConverterFn converter(const TypeID& fromType, const TypeID& toType);
 
            template<typename F, typename T>
            T* convert(F* from)
            {
                const TypeID& fid = getTypeID<F>();
                const TypeID& tid = getTypeID<T>();
                return static_cast<T*>(convert(fid, tid, from));
            }
            
            template<typename F, typename T>
            bool canConvert()
            {
                const TypeID& fid = getTypeID<F>();
                const TypeID& tid = getTypeID<T>();
                return canConvert(fid, tid);
            }
 
            template<typename F, typename T>
            void registerConversion(ConverterFn fn)
            {
                const TypeID& fid = getTypeID<F>();
                const TypeID& tid = getTypeID<T>();
 
                _converters[hashIDs(fid, tid)] = fn;
            }
 
            static Converters& instance();
 
        private:
            Converters();
 
            TypeHash hashIDs(const TypeID& id1, const TypeID& id2);
 
            ankerl::unordered_dense::map<TypeHash, ConverterFn> _converters; 
    };
 
}