globals.h

/* Copyright (c) 2024 Julian Benda
 *
 * This file is part of inkCPP which is released under MIT license.
 * See file LICENSE.txt or go to
 * https://github.com/JBenda/inkcpp for full license details.
 */
#pragma once
 
#include "types.h"
#include "functional.h"
 
namespace ink::runtime
{
class snapshot;
 
class globals_interface
{
public:
    template<typename T>
    optional<T> get(const char* name) const
    {
        static_assert(internal::always_false<T>::value, "Requested Type is not supported");
    }
 
    template<typename T>
    bool set(const char* name, const T& val)
    {
        static_assert(internal::always_false<T>::value, "Requested Type is not supported");
        return false;
    }
 
    template<typename F>
    void observe(const char* name, F callback)
    {
        internal_observe(hash_string(name), new internal::callback(callback));
    }
 
    virtual snapshot* create_snapshot() const = 0;
 
    virtual ~globals_interface() = default;
 
protected:
    virtual optional<value> get_var(hash_t name) const                                       = 0;
    virtual bool            set_var(hash_t name, const value& val)                           = 0;
    virtual void            internal_observe(hash_t name, internal::callback_base* callback) = 0;
};
 
 
template<>
inline optional<value> globals_interface::get<value>(const char* name) const
{
    return get_var(hash_string(name));
}
 
template<>
inline bool globals_interface::set<value>(const char* name, const value& val)
{
    return set_var(hash_string(name), val);
}
 
template<>
inline optional<bool> globals_interface::get<bool>(const char* name) const
{
    auto var = get_var(hash_string(name));
    if (var && var->type == value::Type::Bool) {
        return {var->get<value::Type::Bool>()};
    }
    return nullopt;
}
 
template<>
inline bool globals_interface::set<bool>(const char* name, const bool& val)
{
    return set_var(hash_string(name), value(val));
}
 
template<>
inline optional<uint32_t> globals_interface::get<uint32_t>(const char* name) const
{
    auto var = get_var(hash_string(name));
    if (var && var->type == value::Type::Uint32) {
        return {var->get<value::Type::Uint32>()};
    }
    return nullopt;
}
 
template<>
inline bool globals_interface::set<uint32_t>(const char* name, const uint32_t& val)
{
    return set_var(hash_string(name), value(val));
}
 
template<>
inline optional<int32_t> globals_interface::get<int32_t>(const char* name) const
{
    auto var = get_var(hash_string(name));
    if (var && var->type == value::Type::Int32) {
        return {var->get<value::Type::Int32>()};
    }
    return nullopt;
}
 
template<>
inline bool globals_interface::set<int32_t>(const char* name, const int32_t& val)
{
    return set_var(hash_string(name), value(val));
}
 
template<>
inline optional<float> globals_interface::get<float>(const char* name) const
{
    auto var = get_var(hash_string(name));
    if (var && var->type == value::Type::Float) {
        return {var->get<value::Type::Float>()};
    }
    return nullopt;
}
 
template<>
inline bool globals_interface::set<float>(const char* name, const float& val)
{
    return set_var(hash_string(name), value(val));
}
 
template<>
inline optional<const char*> globals_interface::get<const char*>(const char* name) const
{
    auto var = get_var(hash_string(name));
    if (var && var->type == value::Type::String) {
        return {var->get<value::Type::String>()};
    }
    return nullopt;
}
 
template<>
inline bool globals_interface::set<const char*>(const char* name, const char* const& val)
{
    return set_var(hash_string(name), value(val));
}
 
template<>
inline optional<list> globals_interface::get<list>(const char* name) const
{
    auto var = get_var(hash_string(name));
    if (var && var->type == value::Type::List) {
        return {var->get<value::Type::List>()};
    }
    return nullopt;
}
 
template<>
inline bool globals_interface::set<list>(const char* name, const list& val)
{
    return set_var(hash_string(name), value(val));
}
 
} // namespace ink::runtime