get.h

Go to the documentation of this file.

 
#ifndef NNGN_LUA_GET_H
#define NNGN_LUA_GET_H
 
#include <string_view>
#include <tuple>
#include <utility>
#include <vector>
 
#include "utils/concepts/fundamental.h"
 
#include "lua.h"
#include "user.h"
 
namespace nngn::lua {
 
template<typename T>
struct stack_get<std::optional<T>> {
    static std::optional<T> get(lua_State *L, int i) {
        switch(lua_type(L, i)) {
        case LUA_TNONE:
        case LUA_TNIL:
            return {};
        default:
            return {stack_get<T>::get(L, i)};
        }
    }
};
 
template<>
struct stack_get<bool> {
    static bool get(lua_State *L, int i) {
        return lua_toboolean(L, i);
    }
};
 
template<std::convertible_to<const void> T>
struct stack_get<T*> {
    static T* get(lua_State *L, int i) {
        return lua_touserdata(L, i);
    }
};
 
template<detail::integer T>
struct stack_get<T> {
    static T get(lua_State *L, int i) {
        return static_cast<T>(lua_tointeger(L, i));
    }
};
 
template<detail::number T>
struct stack_get<T> {
    static T get(lua_State *L, int i) {
        return static_cast<T>(lua_tonumber(L, i));
    }
};
 
template<scoped_enum T>
requires(detail::can_get<std::underlying_type_t<T>>)
struct stack_get<T> {
    static T get(lua_State *L, int i) {
        return static_cast<T>(stack_get<std::underlying_type_t<T>>::get(L, i));
    }
};
 
template<>
struct stack_get<const char*> {
    static const char *get(lua_State *L, int i) {
        return lua_tostring(L, i);
    }
};
 
template<>
struct stack_get<std::string_view> {
    static std::string_view get(lua_State *L, int i) {
        std::size_t n = 0;
        const char *const s = lua_tolstring(L, i, &n);
        return {s, n};
    }
};
 
template<>
struct stack_get<std::string> {
    static std::string get(lua_State *L, int i) {
        return std::string{stack_get<std::string_view>::get(L, i)};
    }
};
 
template<>
struct stack_get<lua_CFunction> {
    static lua_CFunction get(lua_State *L, int i) {
        return lua_tocfunction(L, i);
    }
};
 
template<detail::stack_type T>
struct stack_get<T> {
    static T get(lua_State *L, int i) {
        return {L, i};
    }
};
 
template<user_type T>
struct stack_get<T*> {
    static T *get(lua_State *L, int i) {
        return user_data<T*>::get(L, i);
    }
};
 
template<user_type T>
struct stack_get<T&> {
    static T &get(lua_State *L, int i) {
        return *stack_get<T*>::get(L, i);
    }
};
 
template<typename ...Ts>
requires(... && detail::can_get<Ts>)
struct stack_get<std::tuple<Ts...>> {
    static std::tuple<Ts...> get(lua_State *L, int i) {
        constexpr auto n = static_cast<int>(sizeof...(Ts));
        return [L, i]<int ...Is>(std::integer_sequence<int, Is...>) {
            return std::tuple<Ts...>{stack_get<Ts>::get(L, i + Is)...};
        }(std::make_integer_sequence<int, n>{});
    }
};
 
}
 
#endif