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 
28 PlanAction::PlanAction(const std::string &json)
29 {
30  from_json(json);
31 }
32 
33 PlanAction::PlanAction(const rapidjson::Value &v)
34 {
35  from_json_value(v);
36 }
37 
39 {
40 }
41 
42 std::string
43 PlanAction::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 
61 void
62 PlanAction::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 
142 void
143 PlanAction::from_json(const std::string &json)
144 {
145  rapidjson::Document d;
146  d.Parse(json);
147 
148  from_json_value(d);
149 }
150 
151 void
152 PlanAction::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 
212 void
213 PlanAction::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