10 #include "helics/helics-config.h"
12 #include "helics_cxx_export.h"
28 HELICS_CXX_EXPORT
bool isTrueString(std::string_view str);
31 using defV = std::variant<double,
36 std::vector<std::complex<double>>,
46 complex_vector_loc = 5U,
50 HELICS_CXX_EXPORT
bool changeDetected(
const defV& prevValue,
const std::string& val,
double deltaV);
51 HELICS_CXX_EXPORT
bool changeDetected(
const defV& prevValue, std::string_view val,
double deltaV);
52 HELICS_CXX_EXPORT
bool
55 const std::vector<std::complex<double>>& val,
57 HELICS_CXX_EXPORT
bool
59 HELICS_CXX_EXPORT
bool
61 HELICS_CXX_EXPORT
bool changeDetected(
const defV& prevValue,
double val,
double deltaV);
62 HELICS_CXX_EXPORT
bool changeDetected(
const defV& prevValue, int64_t val,
double deltaV);
64 HELICS_CXX_EXPORT
bool changeDetected(
const defV& prevValue,
const NamedPoint& val,
double deltaV);
70 return (obj) ? 1LL : 0LL;
76 return static_cast<int64_t
>(val);
80 return static_cast<int64_t
>(val);
84 return static_cast<int64_t
>(val);
88 return static_cast<int64_t
>(val);
92 return static_cast<int64_t
>(val);
96 return static_cast<int64_t
>(val);
100 return static_cast<int64_t
>(val);
104 return val.getBaseTimeCode();
109 return static_cast<double>(val);
112 inline std::complex<double>
make_valid(
const std::complex<float>& val)
114 return {val.real(), val.imag()};
121 return std::forward<X>(obj);
127 HELICS_CXX_EXPORT
void valueExtract(
const defV& data, std::complex<double>& val);
130 HELICS_CXX_EXPORT
void valueExtract(
const defV& data, std::vector<double>& val);
133 HELICS_CXX_EXPORT
void valueExtract(
const defV& data, std::vector<std::complex<double>>& val);
147 HELICS_CXX_EXPORT
defV readJsonValue(
const data_view& data);
149 HELICS_CXX_EXPORT
void valueExtract(
const data_view& data,
DataType baseType, std::string& val);
151 HELICS_CXX_EXPORT
void
154 HELICS_CXX_EXPORT
void
157 HELICS_CXX_EXPORT
void
172 std::enable_if_t<std::is_arithmetic<X>::value && (!std::is_same<X, char>::value)>
175 switch (data.index()) {
177 val =
static_cast<X
>(std::get<double>(data));
180 val =
static_cast<X
>(std::get<int64_t>(data));
184 const auto& v = std::get<std::string>(data);
185 if (v.find_first_of(
".eE[]") == std::string::npos) {
195 auto& cv = std::get<std::complex<double>>(data);
196 val =
static_cast<X
>((cv.imag() != 0.0) ? std::abs(cv) : cv.real());
202 const auto& vec = std::get<std::vector<double>>(data);
203 val =
static_cast<X
>((vec.size() == 1) ? vec[0] :
vectorNorm(vec));
206 case complex_vector_loc:
208 const auto& vec = std::get<std::vector<std::complex<double>>>(data);
210 if (vec.size() == 1) {
211 if (vec[0].imag() == 0.0) {
212 vald = vec[0].real();
214 vald = std::abs(vec[0]);
219 val =
static_cast<X
>(vald);
222 case named_point_loc: {
223 const auto& np = std::get<NamedPoint>(data);
224 if (std::isnan(np.value)) {
225 if (np.name.find_first_of(
".eE[]") == std::string::npos) {
231 val =
static_cast<X
>(np.value);
240 std::enable_if_t<std::is_arithmetic<X>::value && (!std::is_same<X, char>::value)>
244 case DataType::HELICS_ANY: {
250 case DataType::HELICS_STRING:
251 case DataType::HELICS_CHAR:
254 if (v.find_first_of(
".eE[]") == std::string_view::npos) {
262 case DataType::HELICS_BOOL:
265 case DataType::HELICS_NAMED_POINT: {
267 if (std::isnan(npval.value)) {
269 if (npval.name.find_first_of(
".eE[]") == std::string::npos) {
275 catch (
const std::invalid_argument&) {
276 val =
static_cast<X
>(
278 std::conditional_t<std::is_integral<X>::value, int64_t,
double>>());
281 val =
static_cast<X
>(npval.value);
286 case DataType::HELICS_DOUBLE: {
288 val =
static_cast<X
>(V);
291 case DataType::HELICS_INT: {
293 val =
static_cast<X
>(V);
296 case DataType::HELICS_TIME: {
299 val = std::is_integral<X>::value ?
static_cast<X
>(vtime.getBaseTimeCode()) :
300 static_cast<X
>(
static_cast<double>(vtime));
303 case DataType::HELICS_VECTOR: {
306 val =
static_cast<X
>(V[0]);
312 case DataType::HELICS_COMPLEX: {
315 val =
static_cast<X
>((V.imag() != 0) ? std::abs(V) : V.real());
318 case DataType::HELICS_COMPLEX_VECTOR: {
321 if (V[0].imag() == 0) {
322 val =
static_cast<X
>(V[0].real());
324 val =
static_cast<X
>(std::abs(V[0]));
332 case DataType::HELICS_JSON:
335 case DataType::HELICS_CUSTOM:
336 throw(std::invalid_argument(
"unrecognized helics type"));
340 HELICS_CXX_EXPORT
void valueConvert(
defV& val,
DataType newType);
342 HELICS_CXX_EXPORT SmallBuffer typeConvertDefV(
DataType type,
const defV& val);
343 HELICS_CXX_EXPORT SmallBuffer typeConvertDefV(
const defV& val);
Definition: helicsTypes.hpp:110
Definition: ValueConverter.hpp:113
static X interpret(const data_view &block)
Definition: ValueConverter.hpp:147
Definition: data_view.hpp:22
the main namespace for the helics co-simulation library User functions will be in the helics namespac...
Definition: AsyncFedCallInfo.hpp:14
DataType
Definition: helicsTypes.hpp:273
bool isTrueString(const std::string_view str)
Definition: helicsPrimaryTypes.cpp:43
std::int64_t getIntFromString(std::string_view val)
Definition: helicsTypes.cpp:481
void valueExtract(const defV &data, std::string &val)
Definition: helicsPrimaryTypes.cpp:170
TypeLocation
Definition: HelicsPrimaryTypes.hpp:40
double getDoubleFromString(std::string_view val)
Definition: helicsTypes.cpp:492
double vectorNorm(const std::vector< double > &vec)
Definition: helicsTypes.cpp:103
int64_t make_valid(bool obj)
Definition: HelicsPrimaryTypes.hpp:68
X invalidValue()
Definition: helicsTypes.hpp:493
bool changeDetected(const defV &prevValue, const std::string &val, double)
Definition: helicsPrimaryTypes.cpp:16
TimeRepresentation< count_time< 9 > > Time
Definition: helicsTime.hpp:27
std::variant< double, int64_t, std::string, std::complex< double >, std::vector< double >, std::vector< std::complex< double > >, NamedPoint > defV
Definition: HelicsPrimaryTypes.hpp:37