machines.h

#ifndef MACHINES_H_INCLUDED_
#define MACHINES_H_INCLUDED_

#include "interpolate.h"

#include "kblib/kblib.h"
#include <vector>

namespace fsm {

// TODO(killerbee13): Change state machines to do arbitrary string prefix
// matching instead of using char32_t
// see: https://conlang.lianamir.com/2019/11/the-dailies-november-5-2019/

// TODO(killerbee13): Add template-states for state machines.

class state {
 public:
    std::pair<std::string, const state*> step(char32_t c) const;
    const std::string& suf() const { return end; }

 private:
    struct action_t {
        std::string format;
        const state* dest;
    };
    vmap<char32_t, action_t, 16> cmap;
    struct set_action_t {
        small_vector<char32_t, 64> matches;
        action_t action;
    };
    std::vector<set_action_t> set;
    struct map_action_t {
        small_vector<char32_t, 64> in_set;
        small_vector<char32_t, 64> out_set;
        const state* dest;
    };
    std::vector<map_action_t> map;
    struct match_action_t {
        small_vector<char32_t, 64> matches;
        const state* dest;
    };
    std::vector<match_action_t> match;
    std::optional<action_t> def;
    const state* ret;
    std::string end;

 public:
    std::string_view name;

    friend std::optional<state> toState(const YAML::Node&);
    friend bool set_dests(std::map<std::string, state>& states, std::string name,
                          const YAML::Node& data);
};

class state_machine {
 public:
    enum dir_override : unsigned char {
        none = 0,
        r_in = 1,
        r_out = 2,
        r_both = 3,
    };

    // be a valid string_transformer
    word_data_t operator()(Word, channelID) const;

 private:
    // using std::map for reference stability
    std::map<std::string, state> states;
    dir_override dir;

    friend struct YAML::convert<state_machine>;
};

} // namespace fsm

namespace YAML {

template <>
struct convert<fsm::state_machine> {
    static bool decode(const Node& node, fsm::state_machine& sm);
};

template <>
struct convert<fsm::state> {
    static bool decode(const Node& node, fsm::state& s);
};

} // namespace YAML

#endif // MACHINES_H_INCLUDED_