23 #include "openPMD/Datatype.hpp" 24 #include "openPMD/auxiliary/Variant.hpp" 33 #include <type_traits> 69 std::complex<long double>,
75 std::vector<long long>,
76 std::vector<unsigned char>,
77 std::vector<unsigned short>,
78 std::vector<unsigned int>,
79 std::vector<unsigned long>,
80 std::vector<unsigned long long>,
83 std::vector<long double>,
84 std::vector<std::complex<float> >,
85 std::vector<std::complex<double> >,
86 std::vector<std::complex<long double> >,
87 std::vector<std::string>,
88 std::array<double, 7>,
104 template <
typename U>
111 bool isConvertible = std::is_convertible<T, U>::value>
114 template <
typename T,
typename U>
119 throw std::runtime_error(
"getCast: no cast possible.");
123 template <
typename T,
typename U>
128 return static_cast<U
>(*pv);
132 template <
typename T,
typename U>
135 static constexpr
bool convertible = std::is_convertible<T, U>::value;
137 template <
typename UU = U>
138 auto operator()(std::vector<T>
const *pv) ->
139 typename std::enable_if<convertible, std::vector<UU> >::type
142 u.reserve(pv->size());
143 std::copy(pv->begin(), pv->end(), std::back_inserter(u));
147 template <
typename UU = U>
148 auto operator()(std::vector<T>
const *) ->
149 typename std::enable_if<!convertible, std::vector<UU> >::type
151 throw std::runtime_error(
"getCast: no vector cast possible.");
156 template <
typename T,
typename U>
159 static constexpr
bool convertible = std::is_convertible<T, U>::value;
161 template <
typename UU = U>
162 auto operator()(
T const *pv) ->
163 typename std::enable_if<convertible, std::vector<UU> >::type
167 u.push_back(static_cast<U>(*pv));
171 template <
typename UU = U>
172 auto operator()(
T const *) ->
173 typename std::enable_if<!convertible, std::vector<UU> >::type
175 throw std::runtime_error(
176 "getCast: no scalar to vector conversion possible.");
183 template <
typename T,
typename U,
size_t n>
186 static constexpr
bool convertible = std::is_convertible<T, U>::value;
188 template <
typename UU = U>
189 auto operator()(std::array<T, n>
const *pv) ->
190 typename std::enable_if<convertible, std::vector<UU> >::type
194 std::copy(pv->begin(), pv->end(), std::back_inserter(u));
198 template <
typename UU = U>
199 auto operator()(std::array<T, n>
const *) ->
200 typename std::enable_if<!convertible, std::vector<UU> >::type
202 throw std::runtime_error(
203 "getCast: no array to vector conversion possible.");
210 template <
typename T,
typename U,
size_t n>
213 static constexpr
bool convertible = std::is_convertible<T, U>::value;
215 template <
typename UU = U>
216 auto operator()(std::vector<T>
const *pv) ->
217 typename std::enable_if<convertible, std::array<UU, n> >::type
222 throw std::runtime_error(
223 "getCast: no vector to array conversion possible " 224 "(wrong requested array size).");
226 for (
size_t i = 0; i < n; ++i)
228 u[i] =
static_cast<U
>((*pv)[i]);
233 template <
typename UU = U>
234 auto operator()(std::vector<T>
const *) ->
235 typename std::enable_if<!convertible, std::array<UU, n> >::type
237 throw std::runtime_error(
238 "getCast: no vector to array conversion possible.");
248 template <
typename U>
258 #if defined(__ICC) || defined(__INTEL_COMPILER) 259 if (
auto pvalue_c = variantSrc::get_if<char>(&v))
261 else if (
auto pvalue_uc = variantSrc::get_if<unsigned char>(&v))
263 else if (
auto pvalue_s = variantSrc::get_if<short>(&v))
265 else if (
auto pvalue_i = variantSrc::get_if<int>(&v))
267 else if (
auto pvalue_l = variantSrc::get_if<long>(&v))
269 else if (
auto pvalue_ll = variantSrc::get_if<long long>(&v))
271 else if (
auto pvalue_us = variantSrc::get_if<unsigned short>(&v))
273 else if (
auto pvalue_ui = variantSrc::get_if<unsigned int>(&v))
275 else if (
auto pvalue_ul = variantSrc::get_if<unsigned long>(&v))
277 else if (
auto pvalue_ull = variantSrc::get_if<unsigned long long>(&v))
279 else if (
auto pvalue_f = variantSrc::get_if<float>(&v))
281 else if (
auto pvalue_d = variantSrc::get_if<double>(&v))
283 else if (
auto pvalue_ld = variantSrc::get_if<long double>(&v))
285 else if (
auto pvalue_cf = variantSrc::get_if<std::complex<float> >(&v))
286 return DoConvert<std::complex<float>, U>{}(pvalue_cf);
287 else if (
auto pvalue_cd = variantSrc::get_if<std::complex<double> >(&v))
288 return DoConvert<std::complex<double>, U>{}(pvalue_cd);
290 auto pvalue_cld = variantSrc::get_if<std::complex<long double> >(&v))
291 return DoConvert<std::complex<long double>, U>{}(pvalue_cld);
292 else if (
auto pvalue_str = variantSrc::get_if<std::string>(&v))
295 else if (
auto pvalue_vc = variantSrc::get_if<std::vector<char> >(&v))
296 return DoConvert<std::vector<char>, U>{}(pvalue_vc);
298 auto pvalue_vuc = variantSrc::get_if<std::vector<unsigned char> >(&v))
299 return DoConvert<std::vector<unsigned char>, U>{}(pvalue_vuc);
300 else if (
auto pvalue_vs = variantSrc::get_if<std::vector<short> >(&v))
301 return DoConvert<std::vector<short>, U>{}(pvalue_vs);
302 else if (
auto pvalue_vi = variantSrc::get_if<std::vector<int> >(&v))
303 return DoConvert<std::vector<int>, U>{}(pvalue_vi);
304 else if (
auto pvalue_vl = variantSrc::get_if<std::vector<long> >(&v))
305 return DoConvert<std::vector<long>, U>{}(pvalue_vl);
306 else if (
auto pvalue_vll = variantSrc::get_if<std::vector<long long> >(&v))
307 return DoConvert<std::vector<long long>, U>{}(pvalue_vll);
309 auto pvalue_vus = variantSrc::get_if<std::vector<unsigned short> >(&v))
310 return DoConvert<std::vector<unsigned short>, U>{}(pvalue_vus);
312 auto pvalue_vui = variantSrc::get_if<std::vector<unsigned int> >(&v))
313 return DoConvert<std::vector<unsigned int>, U>{}(pvalue_vui);
315 auto pvalue_vul = variantSrc::get_if<std::vector<unsigned long> >(&v))
316 return DoConvert<std::vector<unsigned long>, U>{}(pvalue_vul);
319 variantSrc::get_if<std::vector<unsigned long long> >(&v))
320 return DoConvert<std::vector<unsigned long long>, U>{}(pvalue_vull);
321 else if (
auto pvalue_vf = variantSrc::get_if<std::vector<float> >(&v))
322 return DoConvert<std::vector<float>, U>{}(pvalue_vf);
323 else if (
auto pvalue_vd = variantSrc::get_if<std::vector<double> >(&v))
324 return DoConvert<std::vector<double>, U>{}(pvalue_vd);
326 auto pvalue_vld = variantSrc::get_if<std::vector<long double> >(&v))
327 return DoConvert<std::vector<long double>, U>{}(pvalue_vld);
330 variantSrc::get_if<std::vector<std::complex<float> > >(&v))
331 return DoConvert<std::vector<std::complex<float> >, U>{}(pvalue_vcf);
334 variantSrc::get_if<std::vector<std::complex<double> > >(&v))
335 return DoConvert<std::vector<std::complex<double> >, U>{}(pvalue_vcd);
338 variantSrc::get_if<std::vector<std::complex<long double> > >(&v))
339 return DoConvert<std::vector<std::complex<long double> >, U>{}(
342 auto pvalue_vstr = variantSrc::get_if<std::vector<std::string> >(&v))
343 return DoConvert<std::vector<std::string>, U>{}(pvalue_vstr);
345 else if (
auto pvalue_vad = variantSrc::get_if<std::array<double, 7> >(&v))
346 return DoConvert<std::array<double, 7>, U>{}(pvalue_vad);
347 else if (
auto pvalue_b = variantSrc::get_if<bool>(&v))
350 throw std::runtime_error(
"getCast: unknown Datatype.");
353 return variantSrc::visit(
354 [](
auto &&containedValue) -> U {
355 using containedType = std::decay_t<decltype(containedValue)>;
362 template <
typename U>
365 return getCast<U>(Variant::getResource());
openPMD::auxiliary::Variant< Datatype, char, unsigned char, short, int, long, long long, unsigned short, unsigned int, unsigned long, unsigned long long, float, double, long double, std::complex< float >, std::complex< double >, std::complex< long double >, std::string, std::vector< char >, std::vector< short >, std::vector< int >, std::vector< long >, std::vector< long long >, std::vector< unsigned char >, std::vector< unsigned short >, std::vector< unsigned int >, std::vector< unsigned long >, std::vector< unsigned long long >, std::vector< float >, std::vector< double >, std::vector< long double >, std::vector< std::complex< float > >, std::vector< std::complex< double > >, std::vector< std::complex< long double > >, std::vector< std::string >, std::array< double, 7 >, bool >::Variant Variant(resource r)
Construct a lightweight wrapper around a generic object that indicates the concrete datatype of the s...
Definition: Variant.hpp:55
U get() const
Retrieve a stored specific Attribute and cast if convertible.
Definition: Attribute.hpp:363
Definition: Attribute.hpp:112
Generic object to store a set of datatypes in without losing type safety.
Definition: Variant.hpp:40
U getCast(Attribute const &a)
Retrieve a stored specific Attribute and cast if convertible.
Definition: Attribute.hpp:249
Varidic datatype supporting at least all formats for attributes specified in the openPMD standard...
Definition: Attribute.hpp:51
Public definitions of openPMD-api.
Definition: Date.cpp:28
resource getResource() const
Retrieve the stored generic object.
Definition: Variant.hpp:75