Horizon
Loading...
Searching...
No Matches
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
12namespace horizon {
13using json = nlohmann::json;
14
15enum class RulesCheckErrorLevel { NOT_RUN, PASS, WARN, FAIL, DISABLED, CANCELLED };
16
17Color rules_check_error_level_to_color(RulesCheckErrorLevel lev);
18std::string rules_check_error_level_to_string(RulesCheckErrorLevel lev);
19
21public:
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 std::set<int> layers;
33 void add_layer_range(const class LayerProvider &prv, const class LayerRange &range);
34
35 json serialize() const;
36};
37
39public:
40 void clear();
41 void update();
42 json serialize() const;
43 bool check_disabled(const Rule &rule);
44 bool check_cancelled(bool cancel);
45
46
47 RulesCheckErrorLevel level = RulesCheckErrorLevel::NOT_RUN;
48
49 std::deque<RulesCheckError> errors;
50};
51
52typedef std::function<void(const std::string &)> check_status_cb_t;
53
54class Rules {
55public:
56 Rules();
57 virtual void load_from_json(const json &j) = 0;
58 virtual void import_rules(const json &j, const class RuleImportMap &import_map)
59 {
60 throw std::logic_error("import_rules not implemented");
61 }
62
63
64 virtual json serialize() const = 0;
65 virtual std::vector<RuleID> get_rule_ids() const = 0;
66
67 virtual const Rule &get_rule(RuleID id) const = 0;
68 Rule &get_rule(RuleID id);
69 Rule &get_rule_nc(RuleID id)
70 {
71 return get_rule(id);
72 }
73
74 template <typename T> const T &get_rule_t() const
75 {
76 return dynamic_cast<const T &>(get_rule(T::id));
77 }
78
79 template <typename T> T &get_rule_t()
80 {
81 return dynamic_cast<T &>(get_rule(T::id));
82 }
83
84 virtual const Rule &get_rule(RuleID id, const UUID &uu) const = 0;
85 Rule &get_rule(RuleID id, const UUID &uu);
86
87 template <typename T> const T &get_rule_t(const UUID &uu) const
88 {
89 return dynamic_cast<const T &>(get_rule(T::id, uu));
90 }
91 template <typename T> T &get_rule_t(const UUID &uu)
92 {
93 return dynamic_cast<T &>(get_rule(T::id, uu));
94 }
95
96 virtual std::map<UUID, const Rule *> get_rules(RuleID id) const = 0;
97 std::map<UUID, Rule *> get_rules(RuleID id);
98 std::map<UUID, Rule *> get_rules_nc(RuleID id)
99 {
100 return get_rules(id);
101 }
102
103 template <typename T = Rule> std::vector<const T *> get_rules_sorted(RuleID id) const
104 {
105 auto rs = get_rules(id);
106 std::vector<const T *> rv;
107 rv.reserve(rs.size());
108 for (auto &it : rs) {
109 rv.push_back(dynamic_cast<const T *>(it.second));
110 }
111 std::sort(rv.begin(), rv.end(), [](auto a, auto b) { return a->order < b->order; });
112 return rv;
113 }
114
115 template <typename T> std::vector<const T *> get_rules_sorted() const
116 {
117 return get_rules_sorted<T>(T::id);
118 }
119
120 template <typename T = Rule> std::vector<T *> get_rules_sorted(RuleID id)
121 {
122 std::vector<T *> r;
123 auto rs = static_cast<const Rules *>(this)->get_rules_sorted<T>(id);
124 r.reserve(rs.size());
125 std::transform(rs.begin(), rs.end(), std::back_inserter(r), [](auto x) { return const_cast<T *>(x); });
126 return r;
127 }
128
129 template <typename T> std::vector<T *> get_rules_sorted()
130 {
131 return get_rules_sorted<T>(T::id);
132 }
133
134 virtual void remove_rule(RuleID id, const UUID &uu) = 0;
135 template <typename T> T &add_rule_t()
136 {
137 return dynamic_cast<T &>(add_rule(T::id));
138 }
139 virtual Rule &add_rule(RuleID id) = 0;
140 void move_rule(RuleID id, const UUID &uu, int dir);
141
142 virtual ~Rules();
143
144 virtual bool can_export() const
145 {
146 return false;
147 }
148
149protected:
150 void fix_order(RuleID id);
151};
152} // namespace horizon
Definition common.hpp:278
Definition layer_provider.hpp:8
Definition layer_range.hpp:11
Definition rule.hpp:38
Definition rule.hpp:58
Definition rules.hpp:20
Definition rules.hpp:38
Definition rules.hpp:54
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