Horizon
rules.hpp
1 #pragma once
2 #include "clipper/clipper.hpp"
3 #include "common/common.hpp"
4 #include "nlohmann/json_fwd.hpp"
5 #include "rule.hpp"
6 #include "util/uuid.hpp"
7 #include "util/uuid_vec.hpp"
8 #include <deque>
9 #include <set>
10 #include <functional>
11 
12 namespace horizon {
13 using json = nlohmann::json;
14 
15 enum class RulesCheckErrorLevel { NOT_RUN, PASS, WARN, FAIL, DISABLED };
16 
17 Color rules_check_error_level_to_color(RulesCheckErrorLevel lev);
18 std::string rules_check_error_level_to_string(RulesCheckErrorLevel lev);
19 
21 public:
22  RulesCheckError(RulesCheckErrorLevel lev);
23  RulesCheckError(RulesCheckErrorLevel lev, const std::string &comment);
24 
25  RulesCheckErrorLevel level = RulesCheckErrorLevel::NOT_RUN;
26  UUID sheet;
27  UUIDVec instance_path;
28  Coordi location;
29  std::string comment;
30  bool has_location = false;
31  ClipperLib::Paths error_polygons;
32 
33  json serialize() const;
34 };
35 
37 public:
38  void clear();
39  void update();
40  json serialize() const;
41  bool check_disabled(const Rule &rule);
42 
43  RulesCheckErrorLevel level = RulesCheckErrorLevel::NOT_RUN;
44  std::string comment;
45 
46  std::deque<RulesCheckError> errors;
47 };
48 
49 typedef std::function<void(const std::string &)> check_status_cb_t;
50 
51 class Rules {
52 public:
53  Rules();
54  virtual void load_from_json(const json &j) = 0;
55  virtual void import_rules(const json &j, const class RuleImportMap &import_map)
56  {
57  throw std::logic_error("import_rules not implemented");
58  }
59 
60 
61  virtual json serialize() const = 0;
62  virtual std::vector<RuleID> get_rule_ids() const = 0;
63 
64  virtual const Rule &get_rule(RuleID id) const = 0;
65  Rule &get_rule(RuleID id);
66  Rule &get_rule_nc(RuleID id)
67  {
68  return get_rule(id);
69  }
70 
71  template <typename T> const T &get_rule_t() const
72  {
73  return dynamic_cast<const T &>(get_rule(T::id));
74  }
75 
76  template <typename T> T &get_rule_t()
77  {
78  return dynamic_cast<T &>(get_rule(T::id));
79  }
80 
81  virtual const Rule &get_rule(RuleID id, const UUID &uu) const = 0;
82  Rule &get_rule(RuleID id, const UUID &uu);
83 
84  template <typename T> const T &get_rule_t(const UUID &uu) const
85  {
86  return dynamic_cast<const T &>(get_rule(T::id, uu));
87  }
88  template <typename T> T &get_rule_t(const UUID &uu)
89  {
90  return dynamic_cast<T &>(get_rule(T::id, uu));
91  }
92 
93  virtual std::map<UUID, const Rule *> get_rules(RuleID id) const = 0;
94  std::map<UUID, Rule *> get_rules(RuleID id);
95  std::map<UUID, Rule *> get_rules_nc(RuleID id)
96  {
97  return get_rules(id);
98  }
99 
100  template <typename T = Rule> std::vector<const T *> get_rules_sorted(RuleID id) const
101  {
102  auto rs = get_rules(id);
103  std::vector<const T *> rv;
104  rv.reserve(rs.size());
105  for (auto &it : rs) {
106  rv.push_back(dynamic_cast<const T *>(it.second));
107  }
108  std::sort(rv.begin(), rv.end(), [](auto a, auto b) { return a->order < b->order; });
109  return rv;
110  }
111 
112  template <typename T> std::vector<const T *> get_rules_sorted() const
113  {
114  return get_rules_sorted<T>(T::id);
115  }
116 
117  template <typename T = Rule> std::vector<T *> get_rules_sorted(RuleID id)
118  {
119  std::vector<T *> r;
120  auto rs = static_cast<const Rules *>(this)->get_rules_sorted<T>(id);
121  r.reserve(rs.size());
122  std::transform(rs.begin(), rs.end(), std::back_inserter(r), [](auto x) { return const_cast<T *>(x); });
123  return r;
124  }
125 
126  template <typename T> std::vector<T *> get_rules_sorted()
127  {
128  return get_rules_sorted<T>(T::id);
129  }
130 
131  virtual void remove_rule(RuleID id, const UUID &uu) = 0;
132  template <typename T> T &add_rule_t()
133  {
134  return dynamic_cast<T &>(add_rule(T::id));
135  }
136  virtual Rule &add_rule(RuleID id) = 0;
137  void move_rule(RuleID id, const UUID &uu, int dir);
138 
139  virtual ~Rules();
140 
141  virtual bool can_export() const
142  {
143  return false;
144  }
145 
146 protected:
147  void fix_order(RuleID id);
148 };
149 } // namespace horizon
Definition: common.hpp:267
Definition: rule.hpp:34
Definition: rule.hpp:54
Definition: rules.hpp:20
Definition: rules.hpp:36
Definition: rules.hpp:51
This class encapsulates a UUID and allows it to be uses as a value type.
Definition: uuid.hpp:16
a class to store JSON values
Definition: json.hpp:177
basic_json<> json
default JSON class
Definition: json_fwd.hpp:62