runner.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 "config.h"
#include "system.h"
#include "functional.h"
#include "types.h"
 
#ifdef INK_ENABLE_UNREAL
#   include "Containers/UnrealString.h"
#endif
 
namespace ink::runtime
{
class choice;

class runner_interface
{
public:
    virtual ~runner_interface(){};

#ifdef INK_ENABLE_STL
    using line_type = std::string;
#elif defined(INK_ENABLE_UNREAL)
    using line_type = FString;
#endif
 
#pragma region Interface Methods
    virtual void set_rng_seed(uint32_t seed) = 0;

    virtual void set_whitespace_mode(whitespace_mode mode) = 0;

    virtual bool move_to(hash_t path) = 0;

    bool move_to(const char* path) { return move_to(ink::hash_string(path)); }

    virtual bool can_continue() const = 0;

    virtual snapshot* create_snapshot() const = 0;

    virtual const char* getline_alloc() = 0;
 
#if defined(INK_ENABLE_STL) || defined(INK_ENABLE_UNREAL)
    virtual line_type getline() = 0;

    virtual line_type getall() = 0;
#endif
 
#ifdef INK_ENABLE_STL
    virtual void getline(std::ostream&) = 0;

    virtual void getall(std::ostream&) = 0;
#endif

    virtual const choice* begin() const = 0;

    virtual const choice* end() const = 0;

    virtual void choose(size_t index) = 0;

    virtual bool has_tags() const = 0;

    virtual size_t num_tags() const = 0;

    virtual const char* get_tag(size_t index) const = 0;

    virtual bool has_global_tags() const = 0;

    virtual size_t num_global_tags() const = 0;

    virtual const char* get_global_tag(size_t index) const = 0;

    virtual bool has_knot_tags() const = 0;

    virtual size_t num_knot_tags() const = 0;

    virtual const char* get_knot_tag(size_t index) const = 0;

    virtual hash_t get_current_knot() const = 0;

    virtual config::statistics::runner statistics() const = 0;
 
protected:
    virtual void internal_bind(hash_t name, internal::function_base* function) = 0;
 
public:
    template<typename F>
    inline void bind(hash_t name, F function, bool lookaheadSafe = false)
    {
        internal_bind(name, new internal::function(function, lookaheadSafe));
    }

    template<typename F>
    inline void bind(const char* name, F function, bool lookaheadSafe = false)
    {
        bind(ink::hash_string(name), function, lookaheadSafe);
    }
 
#ifdef INK_ENABLE_UNREAL
    template<typename D>
    void bind_delegate(hash_t name, D functionDelegate, bool lookaheadSafe)
    {
        internal_bind(name, new internal::function_array_delegate(functionDelegate, lookaheadSafe));
    }
#endif
 
#pragma endregion
 
#pragma region Convenience Methods

    inline operator bool() const { return can_continue(); }

    inline bool has_choices() const { return begin() != end(); }

    size_t num_choices() const;

    const choice* get_choice(size_t index) const;

    inline const choice* operator[](size_t index) { return get_choice(index); }
 
#pragma endregion
};
} // namespace ink::runtime