helics  3.0.1
fileConnections.hpp
1 /*
2 Copyright (c) 2017-2021,
3 Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
4 Energy, LLC. See the top-level NOTICE for additional details. All rights reserved.
5 SPDX-License-Identifier: BSD-3-Clause
6 */
7 #pragma once
8 
9 #include "../common/JsonProcessingFunctions.hpp"
10 #include "../common/TomlProcessingFunctions.hpp"
11 #include "../common/addTargets.hpp"
12 #include "Broker.hpp"
13 #include "Core.hpp"
14 #include "core-exceptions.hpp"
15 
16 #include <string>
17 #include <type_traits>
18 
19 namespace helics {
20 
21 namespace fileops {
22  template<class brkX>
23  void makeConnectionsToml(brkX* brk, const std::string& file)
24  {
25  toml::value uVal;
26  static_assert(std::is_base_of<Broker, brkX>::value || std::is_base_of<Core, brkX>::value,
27  "broker must be Core or broker");
28  toml::value doc;
29  try {
30  doc = loadToml(file);
31  }
32  catch (const std::invalid_argument& ia) {
33  throw(helics::InvalidParameter(ia.what()));
34  }
35 
36  auto conns = toml::find_or(doc, "connections", uVal);
37  if (!conns.is_uninitialized()) {
38  auto& connArray = conns.as_array();
39  for (const auto& conn : connArray) {
40  if (conn.is_array()) {
41  auto& connAct = conn.as_array();
42  brk->dataLink(connAct[0].as_string(), connAct[1].as_string());
43  } else {
44  std::string pub = getOrDefault(conn, "publication", std::string());
45  if (!pub.empty()) {
46  addTargets(conn, "targets", [brk, &pub](const std::string& target) {
47  brk->dataLink(pub, target);
48  });
49  } else {
50  std::string ipt = getOrDefault(conn, "input", std::string());
51  if (!ipt.empty()) {
52  addTargets(conn, "targets", [brk, &ipt](const std::string& target) {
53  brk->dataLink(target, ipt);
54  });
55  addTargets(conn, "sources", [brk, &ipt](const std::string& source) {
56  brk->dataLink(source, ipt);
57  });
58  } else {
59  std::string ept = getOrDefault(conn, "endpoint", std::string());
60  if (!ept.empty()) {
61  addTargets(conn, "targets", [brk, &ept](const std::string& target) {
62  brk->linkEndpoints(ept, target);
63  });
64  addTargets(conn, "sources", [brk, &ept](const std::string& source) {
65  brk->linkEndpoints(source, ept);
66  });
67  }
68  }
69  }
70  }
71  }
72  }
73  auto lnks = toml::find_or(doc, "links", uVal);
74  if (!lnks.is_uninitialized()) {
75  auto& connArray = lnks.as_array();
76  for (const auto& conn : connArray) {
77  if (conn.is_array()) {
78  auto& connAct = conn.as_array();
79  brk->linkEndpoints(connAct[0].as_string(), connAct[1].as_string());
80  } else {
81  std::string pub = getOrDefault(conn, "publication", std::string());
82  if (!pub.empty()) {
83  addTargets(conn, "targets", [brk, &pub](const std::string& target) {
84  brk->dataLink(pub, target);
85  });
86  } else {
87  std::string ipt = getOrDefault(conn, "input", std::string());
88  if (!ipt.empty()) {
89  addTargets(conn, "targets", [brk, &ipt](const std::string& target) {
90  brk->dataLink(target, ipt);
91  });
92  addTargets(conn, "sources", [brk, &ipt](const std::string& source) {
93  brk->dataLink(source, ipt);
94  });
95  } else {
96  std::string ept = getOrDefault(conn, "endpoint", std::string());
97  if (!ept.empty()) {
98  addTargets(conn, "targets", [brk, &ept](const std::string& target) {
99  brk->linkEndpoints(ept, target);
100  });
101  addTargets(conn, "sources", [brk, &ept](const std::string& source) {
102  brk->linkEndpoints(source, ept);
103  });
104  }
105  }
106  }
107  }
108  }
109  }
110  auto filts = toml::find_or(doc, "filters", uVal);
111  if (!filts.is_uninitialized()) {
112  auto& filtArray = filts.as_array();
113  for (const auto& filt : filtArray) {
114  if (filt.is_array()) {
115  auto& filtAct = filt.as_array();
116  brk->addSourceFilterToEndpoint(filtAct[0].as_string(), filtAct[1].as_string());
117  } else {
118  std::string fname = getOrDefault(filt, "filter", std::string());
119  if (!fname.empty()) {
120  auto asrc = [brk, &fname](const std::string& ept) {
121  brk->addSourceFilterToEndpoint(fname, ept);
122  };
123  addTargets(filt, "endpoints", asrc);
124  addTargets(filt, "source_endpoints", asrc);
125  addTargets(filt, "sourceEndpoints", asrc);
126  auto adst = [brk, &fname](const std::string& ept) {
127  brk->addDestinationFilterToEndpoint(fname, ept);
128  };
129  addTargets(filt, "dest_endpoints", adst);
130  addTargets(filt, "destEndpoints", adst);
131  }
132  }
133  }
134  }
135  auto globals = toml::find_or(doc, "globals", uVal);
136  if (!globals.is_uninitialized()) {
137  if (globals.is_array()) {
138  for (auto& val : globals.as_array()) {
139  brk->setGlobal(val.as_array()[0].as_string(), val.as_array()[1].as_string());
140  }
141  } else {
142  for (const auto& val : globals.as_table()) {
143  brk->setGlobal(val.first, val.second.as_string());
144  }
145  }
146  }
147  }
148 
149  template<class brkX>
150  void makeConnectionsJson(brkX* brk, const std::string& file)
151  {
152  static_assert(std::is_base_of<Broker, brkX>::value || std::is_base_of<Core, brkX>::value,
153  "input must be Core or Broker");
154  Json::Value doc;
155  try {
156  doc = loadJson(file);
157  }
158  catch (const std::invalid_argument& ia) {
159  throw(helics::InvalidParameter(ia.what()));
160  }
161 
162  if (doc.isMember("connections")) {
163  for (const auto& conn : doc["connections"]) {
164  if (conn.isArray() && conn.size() >= 2) {
165  brk->dataLink(conn[0].asString(), conn[1].asString());
166  } else {
167  std::string pub = fileops::getOrDefault(conn, "publication", std::string());
168  if (!pub.empty()) {
169  addTargets(conn, "targets", [brk, &pub](const std::string& target) {
170  brk->dataLink(pub, target);
171  });
172  } else {
173  std::string ipt = fileops::getOrDefault(conn, "input", std::string());
174  if (!ipt.empty()) {
175  addTargets(conn, "targets", [brk, &ipt](const std::string& target) {
176  brk->dataLink(target, ipt);
177  });
178  addTargets(conn, "sources", [brk, &ipt](const std::string& source) {
179  brk->dataLink(source, ipt);
180  });
181  } else {
182  std::string ept =
183  fileops::getOrDefault(conn, "endpoint", std::string());
184  if (!ept.empty()) {
185  addTargets(conn, "targets", [brk, &ept](const std::string& target) {
186  brk->linkEndpoints(ept, target);
187  });
188  addTargets(conn, "sources", [brk, &ept](const std::string& source) {
189  brk->linkEndpoints(source, ept);
190  });
191  }
192  }
193  }
194  }
195  }
196  }
197  if (doc.isMember("links")) {
198  for (const auto& conn : doc["links"]) {
199  if (conn.isArray() && conn.size() >= 2) {
200  brk->linkEndpoints(conn[0].asString(), conn[1].asString());
201  } else {
202  std::string pub = fileops::getOrDefault(conn, "publication", std::string());
203  if (!pub.empty()) {
204  addTargets(conn, "targets", [brk, &pub](const std::string& target) {
205  brk->dataLink(pub, target);
206  });
207  } else {
208  std::string ipt = fileops::getOrDefault(conn, "input", std::string());
209  if (!ipt.empty()) {
210  addTargets(conn, "targets", [brk, &ipt](const std::string& target) {
211  brk->dataLink(target, ipt);
212  });
213  addTargets(conn, "sources", [brk, &ipt](const std::string& source) {
214  brk->dataLink(source, ipt);
215  });
216  } else {
217  std::string ept =
218  fileops::getOrDefault(conn, "endpoint", std::string());
219  if (!ept.empty()) {
220  addTargets(conn, "targets", [brk, &ept](const std::string& target) {
221  brk->linkEndpoints(ept, target);
222  });
223  addTargets(conn, "sources", [brk, &ept](const std::string& source) {
224  brk->linkEndpoints(source, ept);
225  });
226  }
227  }
228  }
229  }
230  }
231  }
232  if (doc.isMember("filters")) {
233  for (const auto& filt : doc["filters"]) {
234  if (filt.isArray()) {
235  brk->addSourceFilterToEndpoint(filt[0].asString(), filt[1].asString());
236  } else {
237  std::string fname = fileops::getOrDefault(filt, "filter", std::string());
238  if (!fname.empty()) {
239  auto asrc = [brk, &fname](const std::string& ept) {
240  brk->addSourceFilterToEndpoint(fname, ept);
241  };
242  addTargets(filt, "endpoints", asrc);
243  addTargets(filt, "source_endpoints", asrc);
244  addTargets(filt, "sourceEndpoints", asrc);
245  auto adst = [brk, &fname](const std::string& ept) {
246  brk->addDestinationFilterToEndpoint(fname, ept);
247  };
248  addTargets(filt, "dest_endpoints", adst);
249  addTargets(filt, "destEndpoints", adst);
250  }
251  }
252  }
253  }
254  if (doc.isMember("globals")) {
255  if (doc["globals"].isArray()) {
256  for (auto& val : doc["globals"]) {
257  brk->setGlobal(val[0].asString(), val[1].asString());
258  }
259  } else {
260  auto members = doc["globals"].getMemberNames();
261  for (auto& val : members) {
262  brk->setGlobal(val, doc["globals"][val].asString());
263  }
264  }
265  }
266  if constexpr (std::is_base_of<Core, brkX>::value) {
267  loadTags(doc, [brk](const std::string& tagname, const std::string& tagvalue) {
268  brk->setFederateTag(gLocalCoreId, tagname, tagvalue);
269  });
270  }
271  }
272 } // namespace fileops
273 } // namespace helics
helics::InvalidParameter
Definition: core-exceptions.hpp:47
helics
the main namespace for the helics co-simulation library User functions will be in the helics namespac...
Definition: AsyncFedCallInfo.hpp:14
core-exceptions.hpp
helics::gLocalCoreId
constexpr LocalFederateId gLocalCoreId(-259)