Runtime.hpp

#pragma once
 
#include <filesystem>
 
#include "Lib.hpp"
#include "TypeMap.hpp"
 
#define LUA_HOT_RELOAD
 
namespace SL
{
 
    struct Runtime
    {
        enum class ErrorCode
        {
            None,
            TypeMismatch,
            VariableDoesntExist,
            NotFunction,
            FunctionError
        };
 
        template<typename T>
        using Result = Util::Result<T, Util::Error<ErrorCode>>;
 
        SL_SYMBOL Runtime(const std::string& filename);
        
        SL_SYMBOL Runtime(Runtime&& r);
        Runtime(const Runtime&) = delete;
 
        SL_SYMBOL ~Runtime();
 
        template<typename... Libraries>
        static Runtime create(const std::string& filename);
 
        SL_SYMBOL Result<void>
        registerFunction(
            const std::string& table_name,
            const std::string& func_name,
            SL::Function function);
 
        template<typename T>
        SL_SYMBOL Result<T>
        getGlobal(const std::string& name);
 
        // TODO: Need to load globals in datastructure so that the file can be hot-reloaded
        // when the lua state is reloaded, the globals that have been loaded in need to be 
        // transferred
 
        template<typename T>
        SL_SYMBOL Result<void>
        setGlobal(const std::string& name, const T& value);
 
        template<typename... Return, typename... Args>
        inline Result<std::tuple<Return...>> 
        runFunction(
            const std::string& name,
            Args&&... args);
 
        SL_SYMBOL bool     good() const;
        SL_SYMBOL operator bool() const;
 
 
        const auto& filename() const { return _filename; }
 
    private:
        SL_SYMBOL void _pop(std::size_t n = 1) const;
        SL_SYMBOL int _call_func(uint32_t args, uint32_t ret) const;
 
        State L;
        bool _good;
        std::string _filename;
 
#   ifdef LUA_HOT_RELOAD
        std::filesystem::file_time_type _last_modified;
#   endif
    };
 
    template<typename... Libraries>
    Runtime Runtime::create(const std::string& filename)
    {
        using namespace Util::CompileTime;
 
        Runtime runtime(filename);
 
        static_for<sizeof...(Libraries)>([&](auto n) 
        {
            const std::size_t i = n;
            using Library = NthType<i, Libraries...>;
            static_assert(std::is_base_of_v<SL::Lib::Base, Library>);
            Library().registerFunctions(runtime);
        });
 
        return runtime;
    }
 
    template<typename... Return, typename... Args>
    Runtime::Result<std::tuple<Return...>>
    Runtime::runFunction(
        const std::string& name,
        Args&&... args)
    {
        const auto glob_res = getGlobal<SL::Function>(name);
        if (!glob_res)
        {
            _pop();
            if (glob_res.error().code() == Runtime::ErrorCode::TypeMismatch) return { Runtime::ErrorCode::NotFunction };
            else return { glob_res.error() };
        }
 
        auto args_set = std::tuple(std::forward<Args>(args)...);
        Util::CompileTime::static_for<sizeof...(args)>([&](auto n){
            constexpr std::size_t I = n;
            using Type = std::remove_reference_t<Util::CompileTime::NthType<I, Args...>>;
            CompileTime::TypeMap<Type>::push(L, std::get<I>(args_set));
        });
 
        if (_call_func(sizeof...(Args), sizeof...(Return)) != 0) return { { ErrorCode::FunctionError, CompileTime::TypeMap<SL::String>::construct(L) } };
        
        bool err = false;
        auto left = sizeof...(Return);
        auto return_vals = std::tuple<Return...>();
        Util::CompileTime::static_for<sizeof...(Return)>([&](auto n) {
            constexpr std::size_t I = n;
            using Type = Util::CompileTime::NthType<I, Return...>;
            using Map  = SL::CompileTime::TypeMap<Type>;
 
            if (!err)
            {
                if (Map::check(L))
                {
                    std::get<I>(return_vals) = Map::construct(L);
                    left--;
                }
                else err = true;
            }
        });
 
        SL_ASSERT(!left, "Still arguments left.");
        if (err)
        {
            _pop(left);
            return { ErrorCode::TypeMismatch };
        }
 
        return { std::move(return_vals) };
    }
 
} // SL