Horizon
program.hpp
1 #pragma once
2 #include "set.hpp"
3 #include <vector>
4 #include <functional>
5 #include <memory>
6 #include <string>
7 #include <algorithm>
8 #include <optional>
9 
10 namespace horizon {
11 // using json = nlohmann::json;
12 
14  friend class ParameterCommands;
15 
16 public:
17  ParameterProgram(const std::string &s);
18  ParameterProgram(const ParameterProgram &other);
19  ParameterProgram &operator=(const ParameterProgram &other);
20  std::optional<std::string> get_init_error();
21  const std::string &get_code() const;
22  std::optional<std::string> set_code(const std::string &s);
23 
24  std::optional<std::string> run(const ParameterSet &pset = {});
25  using Stack = std::vector<int64_t>;
26  const auto &get_stack() const
27  {
28  return stack;
29  }
30 
31  bool stack_pop(int64_t &va);
32 
33 protected:
34  class Token {
35  public:
36  enum class Type { INT, CMD, STR, UUID };
37  Token(Type ty) : type(ty)
38  {
39  }
40 
41  const Type type;
42 
43  virtual ~Token()
44  {
45  }
46 
47  virtual std::unique_ptr<Token> clone() const = 0;
48  };
49 
50  class TokenInt : public Token {
51  public:
52  TokenInt(int64_t v) : Token(Token::Type::INT), value(v)
53  {
54  }
55 
56  const int64_t value;
57 
58  std::unique_ptr<Token> clone() const override
59  {
60  return std::make_unique<TokenInt>(*this);
61  }
62  };
63 
64  class TokenCommand : public Token {
65  public:
66  TokenCommand(const std::string &cmd) : Token(Token::Type::CMD), command(cmd)
67  {
68  }
69 
70  TokenCommand(const TokenCommand &other) : Token(Token::Type::CMD), command(other.command)
71  {
72  std::transform(other.arguments.begin(), other.arguments.end(), std::back_inserter(arguments),
73  [](auto &x) { return x->clone(); });
74  }
75 
76  const std::string command;
77  std::vector<std::unique_ptr<Token>> arguments;
78 
79  std::unique_ptr<Token> clone() const override
80  {
81  return std::make_unique<TokenCommand>(*this);
82  }
83  };
84 
85  class TokenString : public Token {
86  public:
87  TokenString(const std::string &str) : Token(Token::Type::STR), string(str)
88  {
89  }
90 
91  const std::string string;
92 
93  std::unique_ptr<Token> clone() const override
94  {
95  return std::make_unique<TokenString>(*this);
96  }
97  };
98 
99  class TokenUUID : public Token {
100  public:
101  TokenUUID(const std::string &str) : Token(Token::Type::UUID), string(str)
102  {
103  }
104 
105  const std::string string;
106 
107  std::unique_ptr<Token> clone() const override
108  {
109  return std::make_unique<TokenUUID>(*this);
110  }
111  };
112 
113  using CommandHandler = std::optional<std::string> (ParameterProgram::*)(const TokenCommand &cmd);
114  virtual CommandHandler get_command(const std::string &cmd);
115 
116  std::vector<int64_t> stack;
117 
118 private:
119  std::string code;
120 
121  std::optional<std::string> compile();
122  std::optional<std::string> init_error;
123  std::vector<std::unique_ptr<Token>> tokens;
124 
125  std::optional<std::string> cmd_dump(const TokenCommand &cmd);
126  std::optional<std::string> cmd_math1(const TokenCommand &cmd);
127  std::optional<std::string> cmd_math2(const TokenCommand &cmd);
128  std::optional<std::string> cmd_math3(const TokenCommand &cmd);
129 };
130 } // namespace horizon
Definition: program.hpp:64
Definition: program.hpp:50
Definition: program.hpp:85
Definition: program.hpp:99
Definition: program.hpp:34
Definition: program.hpp:13
This class encapsulates a UUID and allows it to be uses as a value type.
Definition: uuid.hpp:16
zip_int64_t int64_t
zip_int64_t typedef.
Definition: zip.hpp:103