Fawkes API Fawkes Development Version
PlanAction.cpp
1
2/****************************************************************************
3 * PlanAction
4 * (auto-generated, do not modify directly)
5 *
6 * CLIPS Executive REST API.
7 * Enables access to goals, plans, and all items in the domain model.
8 *
9 * API Contact: Tim Niemueller <niemueller@kbsg.rwth-aachen.de>
10 * API Version: v1beta1
11 * API License: Apache 2.0
12 ****************************************************************************/
13
14#include "PlanAction.h"
15
16#include <rapidjson/document.h>
17#include <rapidjson/prettywriter.h>
18#include <rapidjson/stringbuffer.h>
19#include <rapidjson/writer.h>
20
21#include <numeric>
22#include <sstream>
23
25{
26}
27
28PlanAction::PlanAction(const std::string &json)
29{
30 from_json(json);
31}
32
33PlanAction::PlanAction(const rapidjson::Value &v)
34{
36}
37
39{
40}
41
42std::string
43PlanAction::to_json(bool pretty) const
44{
45 rapidjson::Document d;
46
47 to_json_value(d, d);
48
49 rapidjson::StringBuffer buffer;
50 if (pretty) {
51 rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
52 d.Accept(writer);
53 } else {
54 rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
55 d.Accept(writer);
56 }
57
58 return buffer.GetString();
59}
60
61void
62PlanAction::to_json_value(rapidjson::Document &d, rapidjson::Value &v) const
63{
64 rapidjson::Document::AllocatorType &allocator = d.GetAllocator();
65 v.SetObject();
66 // Avoid unused variable warnings
67 (void)allocator;
68
69 if (kind_) {
70 rapidjson::Value v_kind;
71 v_kind.SetString(*kind_, allocator);
72 v.AddMember("kind", v_kind, allocator);
73 }
74 if (apiVersion_) {
75 rapidjson::Value v_apiVersion;
76 v_apiVersion.SetString(*apiVersion_, allocator);
77 v.AddMember("apiVersion", v_apiVersion, allocator);
78 }
79 if (id_) {
80 rapidjson::Value v_id;
81 v_id.SetInt64(*id_);
82 v.AddMember("id", v_id, allocator);
83 }
84 if (operator_name_) {
85 rapidjson::Value v_operator_name;
86 v_operator_name.SetString(*operator_name_, allocator);
87 v.AddMember("operator-name", v_operator_name, allocator);
88 }
89 rapidjson::Value v_param_values(rapidjson::kArrayType);
90 v_param_values.Reserve(param_values_.size(), allocator);
91 for (const auto &e : param_values_) {
92 rapidjson::Value v;
93 v.SetString(e, allocator);
94 v_param_values.PushBack(v, allocator);
95 }
96 v.AddMember("param-values", v_param_values, allocator);
97 if (duration_) {
98 rapidjson::Value v_duration;
99 v_duration.SetFloat(*duration_);
100 v.AddMember("duration", v_duration, allocator);
101 }
102 if (dispatch_time_) {
103 rapidjson::Value v_dispatch_time;
104 v_dispatch_time.SetFloat(*dispatch_time_);
105 v.AddMember("dispatch-time", v_dispatch_time, allocator);
106 }
107 if (state_) {
108 rapidjson::Value v_state;
109 v_state.SetString(*state_, allocator);
110 v.AddMember("state", v_state, allocator);
111 }
112 if (executable_) {
113 rapidjson::Value v_executable;
114 v_executable.SetBool(*executable_);
115 v.AddMember("executable", v_executable, allocator);
116 }
117 if (_operator_) {
118 rapidjson::Value v__operator(rapidjson::kObjectType);
119 _operator_->to_json_value(d, v__operator);
120 v.AddMember("operator", v__operator, allocator);
121 }
122 if (precondition_) {
123 rapidjson::Value v_precondition(rapidjson::kObjectType);
124 precondition_->to_json_value(d, v_precondition);
125 v.AddMember("precondition", v_precondition, allocator);
126 }
127 rapidjson::Value v_effects(rapidjson::kArrayType);
128 v_effects.Reserve(effects_.size(), allocator);
129 for (const auto &e : effects_) {
130 rapidjson::Value v(rapidjson::kObjectType);
131 e->to_json_value(d, v);
132 v_effects.PushBack(v, allocator);
133 }
134 v.AddMember("effects", v_effects, allocator);
135 if (preconditions_) {
136 rapidjson::Value v_preconditions(rapidjson::kObjectType);
137 preconditions_->to_json_value(d, v_preconditions);
138 v.AddMember("preconditions", v_preconditions, allocator);
139 }
140}
141
142void
143PlanAction::from_json(const std::string &json)
144{
145 rapidjson::Document d;
146 d.Parse(json);
147
149}
150
151void
152PlanAction::from_json_value(const rapidjson::Value &d)
153{
154 if (d.HasMember("kind") && d["kind"].IsString()) {
155 kind_ = d["kind"].GetString();
156 }
157 if (d.HasMember("apiVersion") && d["apiVersion"].IsString()) {
158 apiVersion_ = d["apiVersion"].GetString();
159 }
160 if (d.HasMember("id") && d["id"].IsInt64()) {
161 id_ = d["id"].GetInt64();
162 }
163 if (d.HasMember("operator-name") && d["operator-name"].IsString()) {
164 operator_name_ = d["operator-name"].GetString();
165 }
166 if (d.HasMember("param-values") && d["param-values"].IsArray()) {
167 const rapidjson::Value &a = d["param-values"];
168 param_values_ = std::vector<std::string>{};
169
170 param_values_.reserve(a.Size());
171 for (auto &v : a.GetArray()) {
172 param_values_.push_back(v.GetString());
173 }
174 }
175 if (d.HasMember("duration") && d["duration"].IsFloat()) {
176 duration_ = d["duration"].GetFloat();
177 }
178 if (d.HasMember("dispatch-time") && d["dispatch-time"].IsFloat()) {
179 dispatch_time_ = d["dispatch-time"].GetFloat();
180 }
181 if (d.HasMember("state") && d["state"].IsString()) {
182 state_ = d["state"].GetString();
183 }
184 if (d.HasMember("executable") && d["executable"].IsBool()) {
185 executable_ = d["executable"].GetBool();
186 }
187 if (d.HasMember("operator") && d["operator"].IsObject()) {
188 std::shared_ptr<DomainOperator> nv{new DomainOperator(d["operator"])};
189 _operator_ = std::move(nv);
190 }
191 if (d.HasMember("precondition") && d["precondition"].IsObject()) {
192 std::shared_ptr<PDDLGrounding> nv{new PDDLGrounding(d["precondition"])};
193 precondition_ = std::move(nv);
194 }
195 if (d.HasMember("effects") && d["effects"].IsArray()) {
196 const rapidjson::Value &a = d["effects"];
197 effects_ = std::vector<std::shared_ptr<DomainEffect>>{};
198
199 effects_.reserve(a.Size());
200 for (auto &v : a.GetArray()) {
201 std::shared_ptr<DomainEffect> nv{new DomainEffect()};
202 nv->from_json_value(v);
203 effects_.push_back(std::move(nv));
204 }
205 }
206 if (d.HasMember("preconditions") && d["preconditions"].IsObject()) {
207 std::shared_ptr<GroundedFormula> nv{new GroundedFormula(d["preconditions"])};
208 preconditions_ = std::move(nv);
209 }
210}
211
212void
213PlanAction::validate(bool subcall) const
214{
215 std::vector<std::string> missing;
216 if (!kind_) {
217 missing.push_back("kind");
218 }
219 if (!apiVersion_) {
220 missing.push_back("apiVersion");
221 }
222 if (!id_) {
223 missing.push_back("id");
224 }
225 if (!operator_name_) {
226 missing.push_back("operator-name");
227 }
228 if (!state_) {
229 missing.push_back("state");
230 }
231 if (!executable_) {
232 missing.push_back("executable");
233 }
234 if (!preconditions_) {
235 missing.push_back("preconditions");
236 }
237 for (size_t i = 0; i < effects_.size(); ++i) {
238 if (!effects_[i]) {
239 missing.push_back("effects[" + std::to_string(i) + "]");
240 } else {
241 try {
242 effects_[i]->validate(true);
243 } catch (std::vector<std::string> &subcall_missing) {
244 for (const auto &s : subcall_missing) {
245 missing.push_back("effects[" + std::to_string(i) + "]." + s);
246 }
247 }
248 }
249 }
250
251 if (!missing.empty()) {
252 if (subcall) {
253 throw missing;
254 } else {
255 std::string s =
256 std::accumulate(std::next(missing.begin()),
257 missing.end(),
258 missing.front(),
259 [](std::string &s, const std::string &n) { return s + ", " + n; });
260 throw std::runtime_error("PlanAction is missing " + s);
261 }
262 }
263}
DomainEffect representation for JSON transfer.
Definition: DomainEffect.h:28
virtual void from_json_value(const rapidjson::Value &v)
Retrieve data from JSON string.
DomainOperator representation for JSON transfer.
GroundedFormula representation for JSON transfer.
PDDLGrounding representation for JSON transfer.
Definition: PDDLGrounding.h:28
virtual ~PlanAction()
Destructor.
Definition: PlanAction.cpp:38
PlanAction()
Constructor.
Definition: PlanAction.cpp:24
virtual void from_json(const std::string &json)
Retrieve data from JSON string.
Definition: PlanAction.cpp:143
virtual std::string to_json(bool pretty=false) const
Render object to JSON.
Definition: PlanAction.cpp:43
virtual void validate(bool subcall=false) const
Validate if all required fields have been set.
Definition: PlanAction.cpp:213
virtual void to_json_value(rapidjson::Document &d, rapidjson::Value &v) const
Render object to JSON.
Definition: PlanAction.cpp:62
virtual void from_json_value(const rapidjson::Value &v)
Retrieve data from JSON string.
Definition: PlanAction.cpp:152