Arcane  v4.1.0.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
ValueConvert.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* ValueConvert.cc (C) 2000-2025 */
9/* */
10/* Fonctions pour convertir une chaîne de caractère en un type donné. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/ValueConvert.h"
15
16#include "arcane/utils/OStringStream.h"
17#include "arcane/utils/NotSupportedException.h"
18#include "arcane/utils/internal/ValueConvertInternal.h"
19
20#include "arccore/base/internal/ConvertInternal.h"
21
22#include <charconv>
23
24// TODO: Pour builtInGetValue(), retourner `true` si la chaîne en entrée est vide.
25
26/*---------------------------------------------------------------------------*/
27/*---------------------------------------------------------------------------*/
28
29namespace Arcane
30{
31namespace
32{
33 /*!
34 * \brief Retourne \a s converti en \a 'const char*'.
35 *
36 * \warning Si la valeur retournée est utilisée pour une fonction C,
37 * il faut être sur que \a s a un '\0' terminal.
38 */
39 const char* _stringViewData(StringView s)
40 {
41 return reinterpret_cast<const char*>(s.bytes().data());
42 }
43} // namespace
44
45/*---------------------------------------------------------------------------*/
46/*---------------------------------------------------------------------------*/
47
48impl::StringViewInputStream::
49StringViewInputStream(StringView v)
50: m_view(v)
51, m_stream(this)
52{
53 auto b = v.bytes();
54 char* begin_ptr = const_cast<char*>(reinterpret_cast<const char*>(b.data()));
55 char* end_ptr = begin_ptr + b.size();
56 setg(begin_ptr, begin_ptr, end_ptr);
57}
58
59/*---------------------------------------------------------------------------*/
60/*---------------------------------------------------------------------------*/
61
62/*---------------------------------------------------------------------------*/
63/*---------------------------------------------------------------------------*/
64
65template <> ARCANE_UTILS_EXPORT bool
66builtInGetValue(double& v, StringView s)
67{
68 return Convert::Impl::StringViewToIntegral::getValue(v,s);
69}
70
71/*---------------------------------------------------------------------------*/
72/*---------------------------------------------------------------------------*/
73
74template <> ARCANE_UTILS_EXPORT bool
75builtInGetValue(BFloat16& v, StringView s)
76{
77 float z = 0.0;
78 bool r = builtInGetValue(z, s);
79 v = z;
80 return r;
81}
82
83template <> ARCANE_UTILS_EXPORT bool
84builtInGetValue(Float16& v, StringView s)
85{
86 float z = 0.0;
87 bool r = builtInGetValue(z, s);
88 v = z;
89 return r;
90}
91
92template <> ARCANE_UTILS_EXPORT bool
93builtInGetValue(Float128& v, StringView s)
94{
95 // Pour l'instant (12/2024), il n'y a pas de fonctions natives pour lire un Float128.
96 // On utilise donc un 'long double'.
97 // TODO: à implémenter correctement
98 long double z = 0.0;
99 bool r = builtInGetValue(z, s);
100 v = z;
101 return r;
102}
103
104template <> ARCANE_UTILS_EXPORT bool
105builtInGetValue(float& v, StringView s)
106{
107 double z = 0.;
108 bool r = builtInGetValue(z, s);
109 v = (float)z;
110 return r;
111}
112
113template <> ARCANE_UTILS_EXPORT bool
114builtInGetValue(long& v, StringView s)
115{
116 return Convert::Impl::StringViewToIntegral::getValue(v,s);
117}
118
119template <> ARCANE_UTILS_EXPORT bool
120builtInGetValue(int& v, StringView s)
121{
122 return Convert::Impl::StringViewToIntegral::getValue(v,s);
123}
124
125template <> ARCANE_UTILS_EXPORT bool
126builtInGetValue(short& v, StringView s)
127{
128 long z = 0;
129 bool r = builtInGetValue(z, s);
130 v = (short)z;
131 return r;
132}
133
134template <> ARCANE_UTILS_EXPORT bool
135builtInGetValue(unsigned long& v, StringView s)
136{
137 const char* ptr = _stringViewData(s);
138 char* ptr2 = 0;
139 v = ::strtoul(ptr, &ptr2, 0);
140 return (ptr2 != (ptr + s.length()));
141}
142
143template <> ARCANE_UTILS_EXPORT bool
144builtInGetValue(unsigned int& v, StringView s)
145{
146 unsigned long z = 0;
147 bool r = builtInGetValue(z, s);
148 v = (unsigned int)z;
149 return r;
150}
151
152template <> ARCANE_UTILS_EXPORT bool
153builtInGetValue(unsigned short& v, StringView s)
154{
155 unsigned long z = 0;
156 bool r = builtInGetValue(z, s);
157 v = (unsigned short)z;
158 return r;
159}
160
161template <> ARCANE_UTILS_EXPORT bool
162builtInGetValue(long long& v, StringView s)
163{
164 return Convert::Impl::StringViewToIntegral::getValue(v,s);
165}
166
167template <> ARCANE_UTILS_EXPORT bool
168builtInGetValue(Real2& v, StringView s)
169{
170 if (Convert::Impl::ConvertPolicy::isUseSameConvertForAllReal()) {
171 s = Convert::Impl::_removeLeadingSpaces(s);
172 v = {};
173 const bool is_verbose = Convert::Impl::ConvertPolicy::verbosity() > 0;
174 if (is_verbose)
175 std::cout << "Try Read Real2: '" << s << "'\n";
176 Int64 p = Convert::Impl::StringViewToDoubleConverter::_getDoubleValue(v.x, s);
177 if (p == (-1))
178 return true;
179 s = Convert::Impl::_removeLeadingSpaces(s, p);
180 if (is_verbose)
181 std::cout << "VX=" << v.x << " remaining_s='" << s << "'\n";
182 p = Convert::Impl::StringViewToDoubleConverter::_getDoubleValue(v.y, s);
183 return (p == (-1) || (p != s.size()));
184 }
185 return impl::builtInGetValueGeneric(v, s);
186}
187
188template <> ARCANE_UTILS_EXPORT bool
189builtInGetValue(Real3& v, StringView s)
190{
191 if (Convert::Impl::ConvertPolicy::isUseSameConvertForAllReal()){
192 s = Convert::Impl::_removeLeadingSpaces(s);
193 v = {};
194 const bool is_verbose = Convert::Impl::ConvertPolicy::verbosity() > 0;
195 if (is_verbose)
196 std::cout << "Try Read Real3: '" << s << "'\n";
197 Int64 p = Convert::Impl::StringViewToDoubleConverter::_getDoubleValue(v.x, s);
198 if (p == (-1) || (p == s.size()))
199 return true;
200 s = Convert::Impl::_removeLeadingSpaces(s, p);
201 if (is_verbose)
202 std::cout << "VX=" << v.x << " remaining_s='" << s << "'\n";
203 p = Convert::Impl::StringViewToDoubleConverter::_getDoubleValue(v.y, s);
204 if (p == (-1) || (p == s.size()))
205 return true;
206 s = Convert::Impl::_removeLeadingSpaces(s, p);
207 if (is_verbose)
208 std::cout << "VY=" << v.x << " remaining_s='" << s << "'\n";
209 p = Convert::Impl::StringViewToDoubleConverter::_getDoubleValue(v.z, s);
210 return (p == (-1) || (p != s.size()));
211 }
212 return impl::builtInGetValueGeneric(v, s);
213}
214
215template <> ARCANE_UTILS_EXPORT bool
216builtInGetValue(Real2x2& v, StringView s)
217{
218 return impl::builtInGetValueGeneric(v, s);
219}
220
221template <> ARCANE_UTILS_EXPORT bool
222builtInGetValue(Real3x3& v, StringView s)
223{
224 return impl::builtInGetValueGeneric(v, s);
225}
226
227template <> ARCANE_UTILS_EXPORT bool
228builtInGetValue(Int128& v, StringView s)
229{
230 // Pour l'instant (12/2024), il n'y a pas de fonctions natives pour lire un Int128.
231 // On utilise donc un 'Int64' en attendant.
232 // TODO: il existe des exemples sur internet. A implémenter correctement
233 long long v2 = 0;
234 const char* ptr = _stringViewData(s);
235 char* ptr2 = 0;
236 v2 = ::strtoll(ptr, &ptr2, 0);
237 v = v2;
238 return (ptr2 != (ptr + s.length()));
239}
240
241template <> ARCANE_UTILS_EXPORT bool
242builtInGetValue(unsigned long long& v, StringView s)
243{
244 const char* ptr = _stringViewData(s);
245 char* ptr2 = 0;
246 v = ::strtoull(ptr, &ptr2, 0);
247 return (ptr2 != (ptr + s.length()));
248}
249
250/*---------------------------------------------------------------------------*/
251/*---------------------------------------------------------------------------*/
252
253#ifdef ARCANE_REAL_NOT_BUILTIN
254template <> ARCANE_UTILS_EXPORT bool
255builtInGetValue(Real& v, StringView s)
256{
257#if 0
258 double vz = 0.0;
259 if (builtInGetValue(vz,s))
260 return true;
261 v = vz;
262 cout << "** CONVERT DOUBLE TO REAL s=" << s << " vz=" << vz << " v=" << v << '\n';
263 return false;
264#endif
265 double vz = 0.0;
266 if (builtInGetValue(vz, s))
267 return true;
268 v = Real((char*)s.localstr(), 1000);
269 cout << "** CONVERT DOUBLE TO REAL s=" << s << '\n';
270 return false;
271}
272#endif
273
274/*---------------------------------------------------------------------------*/
275/*---------------------------------------------------------------------------*/
276
277template <> bool
278builtInGetValue(String& v, StringView s)
279{
280 v = s;
281 return false;
282}
283
284/*---------------------------------------------------------------------------*/
285/*---------------------------------------------------------------------------*/
286
287namespace
288{
289 bool _builtInGetBoolArrayValue(BoolArray& v, StringView s)
290 {
291 // Le type 'bool' est un peu spécial car il doit pouvoir lire les
292 // valeurs comme 'true' ou 'false'.
293 // On le lit donc comme un 'StringUniqueArray', puis on converti en bool
294 //cout << "** GET BOOL ARRAY V=" << s << '\n';
295 //return builtInGetArrayValue(v,s);
296
297 StringUniqueArray sa;
298 if (builtInGetValue(sa, s))
299 return true;
300 for (Integer i = 0, is = sa.size(); i < is; ++i) {
301 bool read_val = false;
302 if (builtInGetValue(read_val, sa[i]))
303 return true;
304 v.add(read_val);
305 }
306 return false;
307 }
308
309 bool
310 _builtInGetStringArrayValue(StringArray& v, StringView s)
311 {
312 std::string s2;
313 String read_val = String();
314 impl::StringViewInputStream svis(s);
315 std::istream& sbuf = svis.stream();
316 while (!sbuf.eof()) {
317 sbuf >> s2;
318 //cout << " ** CHECK READ v='" << s2 << "' '" << sv << "'\n";
319 if (sbuf.bad()) // non-recoverable error
320 return true;
321 if (sbuf.fail()) // recoverable error : this means good conversion
322 return false;
323 read_val = StringView(s2.c_str());
324 v.add(read_val);
325 }
326 return false;
327 }
328} // namespace
329
330template <> ARCANE_UTILS_EXPORT bool
331builtInGetValue(RealArray& v, StringView s)
332{
333 return builtInGetArrayValue(v, s);
334}
335
336template <> ARCANE_UTILS_EXPORT bool
337builtInGetValue(Real2Array& v, StringView s)
338{
339 return builtInGetArrayValue(v, s);
340}
341
342template <> ARCANE_UTILS_EXPORT bool
343builtInGetValue(Real3Array& v, StringView s)
344{
345 return builtInGetArrayValue(v, s);
346}
347
348template <> ARCANE_UTILS_EXPORT bool
349builtInGetValue(Real2x2Array& v, StringView s)
350{
351 return builtInGetArrayValue(v, s);
352}
353
354template <> ARCANE_UTILS_EXPORT bool
355builtInGetValue(Real3x3Array& v, StringView s)
356{
357 return builtInGetArrayValue(v, s);
358}
359
360template <> ARCANE_UTILS_EXPORT bool
361builtInGetValue(Int8Array& v, StringView s)
362{
363 return builtInGetArrayValue(v, s);
364}
365
366template <> ARCANE_UTILS_EXPORT bool
367builtInGetValue(Int16Array& v, StringView s)
368{
369 return builtInGetArrayValue(v, s);
370}
371
372template <> ARCANE_UTILS_EXPORT bool
373builtInGetValue(Int32Array& v, StringView s)
374{
375 return builtInGetArrayValue(v, s);
376}
377
378template <> ARCANE_UTILS_EXPORT bool
379builtInGetValue(Int64Array& v, StringView s)
380{
381 return builtInGetArrayValue(v, s);
382}
383
384template <> ARCANE_UTILS_EXPORT bool
385builtInGetValue(BoolArray& v, StringView s)
386{
387 return _builtInGetBoolArrayValue(v, s);
388}
389
390template <> ARCANE_UTILS_EXPORT bool
391builtInGetValue(StringArray& v, StringView s)
392{
393 return _builtInGetStringArrayValue(v, s);
394}
395
396/*---------------------------------------------------------------------------*/
397/*---------------------------------------------------------------------------*/
398
399template <> ARCANE_UTILS_EXPORT bool
400builtInGetValue(RealUniqueArray& v, StringView s)
401{
402 return builtInGetArrayValue(v, s);
403}
404
405template <> ARCANE_UTILS_EXPORT bool
406builtInGetValue(Real2UniqueArray& v, StringView s)
407{
408 return builtInGetArrayValue(v, s);
409}
410
411template <> ARCANE_UTILS_EXPORT bool
412builtInGetValue(Real3UniqueArray& v, StringView s)
413{
414 return builtInGetArrayValue(v, s);
415}
416
417template <> ARCANE_UTILS_EXPORT bool
418builtInGetValue(Real2x2UniqueArray& v, StringView s)
419{
420 return builtInGetArrayValue(v, s);
421}
422
423template <> ARCANE_UTILS_EXPORT bool
424builtInGetValue(Real3x3UniqueArray& v, StringView s)
425{
426 return builtInGetArrayValue(v, s);
427}
428
429template <> ARCANE_UTILS_EXPORT bool
430builtInGetValue(Int8UniqueArray& v, StringView s)
431{
432 return builtInGetArrayValue(v, s);
433}
434
435template <> ARCANE_UTILS_EXPORT bool
436builtInGetValue(Int16UniqueArray& v, StringView s)
437{
438 return builtInGetArrayValue(v, s);
439}
440
441template <> ARCANE_UTILS_EXPORT bool
442builtInGetValue(Int32UniqueArray& v, StringView s)
443{
444 return builtInGetArrayValue(v, s);
445}
446
447template <> ARCANE_UTILS_EXPORT bool
448builtInGetValue(Int64UniqueArray& v, StringView s)
449{
450 return builtInGetArrayValue(v, s);
451}
452
453template <> ARCANE_UTILS_EXPORT bool
454builtInGetValue(BoolUniqueArray& v, StringView s)
455{
456 return _builtInGetBoolArrayValue(v, s);
457}
458
459template <> ARCANE_UTILS_EXPORT bool
460builtInGetValue(StringUniqueArray& v, StringView s)
461{
462 return _builtInGetStringArrayValue(v, s);
463}
464
465/*---------------------------------------------------------------------------*/
466/*---------------------------------------------------------------------------*/
467
468template <> ARCANE_UTILS_EXPORT bool
469builtInGetValue(RealSharedArray& v, StringView s)
470{
471 return builtInGetArrayValue(v, s);
472}
473
474template <> ARCANE_UTILS_EXPORT bool
475builtInGetValue(Real2SharedArray& v, StringView s)
476{
477 return builtInGetArrayValue(v, s);
478}
479
480template <> ARCANE_UTILS_EXPORT bool
481builtInGetValue(Real3SharedArray& v, StringView s)
482{
483 return builtInGetArrayValue(v, s);
484}
485
486template <> ARCANE_UTILS_EXPORT bool
487builtInGetValue(Real2x2SharedArray& v, StringView s)
488{
489 return builtInGetArrayValue(v, s);
490}
491
492template <> ARCANE_UTILS_EXPORT bool
493builtInGetValue(Real3x3SharedArray& v, StringView s)
494{
495 return builtInGetArrayValue(v, s);
496}
497
498template <> ARCANE_UTILS_EXPORT bool
499builtInGetValue(Int8SharedArray& v, StringView s)
500{
501 return builtInGetArrayValue(v, s);
502}
503
504template <> ARCANE_UTILS_EXPORT bool
505builtInGetValue(Int16SharedArray& v, StringView s)
506{
507 return builtInGetArrayValue(v, s);
508}
509
510template <> ARCANE_UTILS_EXPORT bool
511builtInGetValue(Int32SharedArray& v, StringView s)
512{
513 return builtInGetArrayValue(v, s);
514}
515
516template <> ARCANE_UTILS_EXPORT bool
517builtInGetValue(Int64SharedArray& v, StringView s)
518{
519 return builtInGetArrayValue(v, s);
520}
521
522template <> ARCANE_UTILS_EXPORT bool
523builtInGetValue(BoolSharedArray& v, StringView s)
524{
525 return _builtInGetBoolArrayValue(v, s);
526}
527
528template <> ARCANE_UTILS_EXPORT bool
529builtInGetValue(StringSharedArray& v, StringView s)
530{
531 return _builtInGetStringArrayValue(v, s);
532}
533
534/*---------------------------------------------------------------------------*/
535/*---------------------------------------------------------------------------*/
536
537namespace
538{
539 template <class T> inline bool
540 _builtInPutValue(const T& v, String& s)
541 {
542 OStringStream ostr;
543 ostr() << v;
544 if (ostr().fail() || ostr().bad())
545 return true;
546 s = ostr.str();
547 return false;
548 }
549 template <class T> inline bool
550 _builtInPutArrayValue(Span<const T> v, String& s)
551 {
552 OStringStream ostr;
553 for (Int64 i = 0, n = v.size(); i < n; ++i) {
554 if (i != 0)
555 ostr() << ' ';
556 ostr() << v[i];
557 }
558 if (ostr().fail() || ostr().bad())
559 return true;
560 s = ostr.str();
561 return false;
562 }
563} // namespace
564
565/*---------------------------------------------------------------------------*/
566/*---------------------------------------------------------------------------*/
567
568bool builtInPutValue(const String& v, String& s)
569{
570 return _builtInPutValue(v, s);
571}
572bool builtInPutValue(double v, String& s)
573{
574 return _builtInPutValue(v, s);
575}
576bool builtInPutValue(float v, String& s)
577{
578 return _builtInPutValue(v, s);
579}
580bool builtInPutValue(int v, String& s)
581{
582 return _builtInPutValue(v, s);
583}
584bool builtInPutValue(unsigned int v, String& s)
585{
586 return _builtInPutValue(v, s);
587}
588bool builtInPutValue(long v, String& s)
589{
590 return _builtInPutValue(v, s);
591}
592bool builtInPutValue(long long v, String& s)
593{
594 return _builtInPutValue(v, s);
595}
596bool builtInPutValue(short v, String& s)
597{
598 return _builtInPutValue(v, s);
599}
600bool builtInPutValue(unsigned short v, String& s)
601{
602 return _builtInPutValue(v, s);
603}
604bool builtInPutValue(unsigned long v, String& s)
605{
606 return _builtInPutValue(v, s);
607}
608bool builtInPutValue(unsigned long long v, String& s)
609{
610 return _builtInPutValue(v, s);
611}
612#ifdef ARCANE_REAL_NOT_BUILTIN
613bool builtInPutValue(Real v, String& s)
614{
615 return _builtInPutValue(v, s);
616}
617#endif
618bool builtInPutValue(Real2 v, String& s)
619{
620 return _builtInPutValue(v, s);
621}
622bool builtInPutValue(Real3 v, String& s)
623{
624 return _builtInPutValue(v, s);
625}
626bool builtInPutValue(const Real2x2& v, String& s)
627{
628 return _builtInPutValue(v, s);
629}
630bool builtInPutValue(const Real3x3& v, String& s)
631{
632 return _builtInPutValue(v, s);
633}
634
635bool builtInPutValue(Span<const Real> v, String& s)
636{
637 return _builtInPutArrayValue(v, s);
638}
639bool builtInPutValue(Span<const Real2> v, String& s)
640{
641 return _builtInPutArrayValue(v, s);
642}
643bool builtInPutValue(Span<const Real3> v, String& s)
644{
645 return _builtInPutArrayValue(v, s);
646}
647bool builtInPutValue(Span<const Real2x2> v, String& s)
648{
649 return _builtInPutArrayValue(v, s);
650}
651bool builtInPutValue(Span<const Real3x3> v, String& s)
652{
653 return _builtInPutArrayValue(v, s);
654}
655bool builtInPutValue(Span<const Int16> v, String& s)
656{
657 return _builtInPutArrayValue(v, s);
658}
659bool builtInPutValue(Span<const Int32> v, String& s)
660{
661 return _builtInPutArrayValue(v, s);
662}
663bool builtInPutValue(Span<const Int64> v, String& s)
664{
665 return _builtInPutArrayValue(v, s);
666}
667bool builtInPutValue(Span<const bool> v, String& s)
668{
669 return _builtInPutArrayValue(v, s);
670}
671bool builtInPutValue(Span<const String> v, String& s)
672{
673 return _builtInPutArrayValue(v, s);
674}
675//@}
676
677/*---------------------------------------------------------------------------*/
678/*---------------------------------------------------------------------------*/
679
680} // namespace Arcane
681
682/*---------------------------------------------------------------------------*/
683/*---------------------------------------------------------------------------*/
Arcane::StringView
Vue sur une chaîne de caractères UTF-8.
Definition StringView.h:47
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AbstractCaseDocumentVisitor.cc:20
Arcane::builtInPutValue
bool builtInPutValue(const String &v, String &s)
Converti la valeur v dans la chaîne s.
Definition ValueConvert.cc:568
Arcane::Real
double Real
Type représentant un réel.
Definition ArccoreGlobal.h:223
Arcane::StringUniqueArray
UniqueArray< String > StringUniqueArray
Tableau dynamique à une dimension de chaînes de caractères.
Definition UtilsTypes.h:375