14#include "arccore/base/String.h"
15#include "arccore/base/StringBuilder.h"
16#include "arccore/base/CStringUtils.h"
17#include "arccore/base/APReal.h"
18#include "arccore/base/TraceInfo.h"
19#include "arccore/base/FatalErrorException.h"
20#include "arccore/base/NotSupportedException.h"
21#include "arccore/base/StringView.h"
24#include "arccore/base/internal/StringImpl.h"
31#define A_FASTLOCK(ptr)
47String(
const std::string& str)
48: m_p(new StringImpl(str))
58String(std::string_view str)
59: m_p(new StringImpl(str))
82: m_p(new StringImpl(ustr))
93: m_p(new StringImpl(ustr))
105, m_const_ptr_size(-1)
116: m_p(new StringImpl(std::string_view(str,
len)))
117, m_const_ptr_size(-1)
127: m_p(new StringImpl(str))
128, m_const_ptr_size(-1)
137String(
const char* str,
bool do_alloc)
139, m_const_ptr(nullptr)
140, m_const_ptr_size(-1)
143 m_p =
new StringImpl(str);
149 m_const_ptr_size = std::strlen(str);
159, m_const_ptr(str.m_const_ptr)
160, m_const_ptr_size(str.m_const_ptr_size)
173 str.m_p->addReference();
174 _removeReferenceIfNeeded();
185 _removeReferenceIfNeeded();
233 return m_p->toStdStringView().data();
241_removeImplReference()
243 m_p->removeReference();
249ConstArrayView<UChar> String::
250_internalUtf16BE()
const
260 return ConstArrayView<UChar>();
269 return _internalUtf16BE();
279 return m_p->largeUtf8().smallView();
281 Int64 ts = m_const_ptr_size+1;
319 return m_const_ptr[0]==
'\0';
353 Int64 xlen = std::strlen(m_const_ptr);
354 if (xlen!=m_const_ptr_size)
355 ARCCORE_FATAL(
"Bad length (computed={0} stored={1})",xlen,m_const_ptr_size);
357 return _viewFromConstChar();
360 return m_p->toStdStringView();
361 return std::string_view();
391 if (m_const_ptr || !m_p){
392 std::string_view sview;
394 sview = _viewFromConstChar();
395 m_p =
new StringImpl(sview);
397 m_const_ptr =
nullptr;
398 m_const_ptr_size = -1;
401 if (m_p->nbReference()!=1){
402 StringImpl* old_p = m_p;
405 old_p->removeReference();
416 return String(m_p->clone());
429 if (str.m_const_ptr){
430 m_p = m_p->append(str._viewFromConstChar());
433 m_p = m_p->append(str.m_p);
445 s2.m_p = s2.m_p->replaceWhiteSpace();
459 s2.m_p = s2.m_p->collapseWhiteSpace();
471 s2.m_p = s2.m_p->toUpper();
483 s2.m_p = s2.m_p->toLower();
496 return s2._append(str);
508 return s2._append(str);
518 return s2._append(str);
525fromNumber(
unsigned long v)
531fromNumber(
unsigned int v)
533 return StringFormatterArg(v).value();
539 return StringFormatterArg(v).value();
543fromNumber(
long double v)
545 return StringFormatterArg(v).value();
551 return StringFormatterArg(v).value();
557 return StringFormatterArg(v).value();
561fromNumber(
unsigned long long v)
563 return StringFormatterArg(v).value();
567fromNumber(
long long v)
569 return StringFormatterArg(v).value();
573fromNumber(
const APReal& v)
575 return StringFormatterArg(v).value();
579fromNumber(
double v,
Integer nb_digit_after_point)
582 for(
Integer z=0; z<nb_digit_after_point; ++z )
585 Int64 after_digit = p % mulp;
586 Int64 before_digit = p / mulp;
587 StringBuilder s(String::fromNumber(before_digit) +
".");
590 Int64 mv = mulp / 10;
591 for(
Integer i=0; i<(nb_digit_after_point-1); ++i ){
592 if (after_digit>=mv){
598 for(
Integer i=0; i<nb_zero; ++i )
601 s += String::fromNumber(after_digit);
612 return s2._append(String::fromNumber(v));
619 return s2._append(String::fromNumber(v));
626 return s2._append(String::fromNumber(v));
633 return s2._append(String::fromNumber(v));
640 return s2._append(String::fromNumber(v));
647 return s2._append(String::fromNumber(v));
654 return s2._append(String::fromNumber(v));
661 return s2._append(String::fromNumber(v));
668 return s2._append(String::fromNumber(v));
675isLess(
const String& b)
const
681 if (b.m_p->isEqual(m_const_ptr))
683 return !(b.m_p->isLessThan(m_const_ptr));
691 return m_p->isLessThan(b.m_const_ptr);
698 return m_p->isLessThan(b.m_p);
704 return b.m_p==
nullptr;
722 ostr <<
"StringDump(m_const_ptr=" << (
void*)m_const_ptr <<
",m_p=" << m_p;
725 m_p->internalDump(ostr);
739 for(
Int64 i=0; i<n; ++i ){
740 h = (h << 5) - h + s[i];
748void StringFormatterArg::
749_formatReal(
Real avalue)
751 std::ostringstream ostr;
752 ostr.precision(std::numeric_limits<Real>::digits10);
754 m_str_value = ostr.str();
763 StringFormatter(
const String& format)
764 : m_format(format), m_current_arg(0) {}
766 void addArg(
const String& ostr)
775 std::cerr <<
"Too many args (maximum is 100)";
780 buf[0] = (char)(
'0' + (z / 10));
781 buf[1] = (char)(
'0' + (z % 10));
785 buf[0] = (char)(
'0' + z);
791 std::string str = m_format.
localstr();
792 const char* local_str = str.c_str();
794 const Int64 slen = str.length();
795 for(
Int64 i=0; i<slen; ++i ){
796 if (local_str[i]==
'{'){
800 for(
Integer j=0; j<nb_z; ++j )
801 if (local_str[i+1+j]!=buf[j]){
806 std::string str1(local_str,local_str+i);
807 std::string str2(local_str+i+1+nb_z);
808 m_format =
String(str1) + ostr + str2;
817 const String& value()
const {
return m_format; }
837format(
const String& str,
const StringFormatterArg& arg1)
839 StringFormatter sf(str);
840 sf.addArg(arg1.value());
851 StringFormatter sf(str);
852 sf.addArg(arg1.value());
853 sf.addArg(arg2.value());
865 StringFormatter sf(str);
866 sf.addArg(arg1.value());
867 sf.addArg(arg2.value());
868 sf.addArg(arg3.value());
881 StringFormatter sf(str);
882 sf.addArg(arg1.value());
883 sf.addArg(arg2.value());
884 sf.addArg(arg3.value());
885 sf.addArg(arg4.value());
899 StringFormatter sf(str);
900 sf.addArg(arg1.value());
901 sf.addArg(arg2.value());
902 sf.addArg(arg3.value());
903 sf.addArg(arg4.value());
904 sf.addArg(arg5.value());
919 StringFormatter sf(str);
920 sf.addArg(arg1.value());
921 sf.addArg(arg2.value());
922 sf.addArg(arg3.value());
923 sf.addArg(arg4.value());
924 sf.addArg(arg5.value());
925 sf.addArg(arg6.value());
941 StringFormatter sf(str);
942 sf.addArg(arg1.value());
943 sf.addArg(arg2.value());
944 sf.addArg(arg3.value());
945 sf.addArg(arg4.value());
946 sf.addArg(arg5.value());
947 sf.addArg(arg6.value());
948 sf.addArg(arg7.value());
965 StringFormatter sf(str);
966 sf.addArg(arg1.value());
967 sf.addArg(arg2.value());
968 sf.addArg(arg3.value());
969 sf.addArg(arg4.value());
970 sf.addArg(arg5.value());
971 sf.addArg(arg6.value());
972 sf.addArg(arg7.value());
973 sf.addArg(arg8.value());
991 StringFormatter sf(str);
992 sf.addArg(arg1.value());
993 sf.addArg(arg2.value());
994 sf.addArg(arg3.value());
995 sf.addArg(arg4.value());
996 sf.addArg(arg5.value());
997 sf.addArg(arg6.value());
998 sf.addArg(arg7.value());
999 sf.addArg(arg8.value());
1000 sf.addArg(arg9.value());
1010 return arg1.value();
1017 return arg1.value()+arg2.value();
1025 return arg1.value()+arg2.value()+arg3.value();
1034 return arg1.value()+arg2.value()+arg3.value()+arg4.value();
1051 return (a>0) ? a : (-a);
1059 return String::concat(n,
" ", ((_abs(n) > 1)?str2:str) );
1061 return ((_abs(n) > 1)?str2:str);
1077 return a.find(b) != std::string_view::npos;
1090 if (ref_size>v_size)
1092 const Byte* v_begin = &v[v_size-ref_size];
1093 return std::memcmp(v_begin,ref.
data(),ref_size)==0;
1106 if (ref_size>v_size)
1108 return memcmp(v.
data(),ref.
data(),ref_size)==0;
1130 String s2(StringImpl::substring(m_p,pos,
len));
1160 return b.m_p->isEqual(a.m_const_ptr);
1167 return a.m_p->isEqual(b.m_const_ptr);
1172 return a.m_p->isEqual(b.m_p);
1178 return b.m_p==
nullptr;
1197 bool v = a.isLess(b);
1219bool global_write_utf8 =
false;
1225 if (global_write_utf8)
1241 o.write((
const char*)v.
data(),vlen);
1262 static std::vector<UChar>
1263 toUtf16BE(
const String& str)
1271 return { x.begin(), x.begin()+(n-1) };
1278std::vector<UChar> StringUtils::
1279asUtf16BE(
const String& str)
1281 return StringUtilsImpl::toUtf16BE(str);
1287std::wstring StringUtils::
1288convertToStdWString(
const String& str)
1290#ifdef ARCCORE_OS_WIN32
1292 const wchar_t* wdata =
reinterpret_cast<const wchar_t*
>(utf16.
data());
1293 const size_t wlen = utf16.
size();
1294 std::wstring_view wstr_view(wdata,wlen);
1295 return std::wstring(wstr_view);
1305convertToArcaneString(
const std::wstring_view& wstr)
1307#ifdef ARCCORE_OS_WIN32
1308 const UChar* ux =
reinterpret_cast<const UChar*
>(wstr.data());
Fonctions utilitaires sur les chaînes de caractères.
Emulation de réel en précision arbitraire.
Vue constante d'un tableau de type T.
constexpr const_pointer data() const noexcept
Pointeur sur la mémoire allouée.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
constexpr __host__ __device__ pointer data() const noexcept
Pointeur sur le début de la vue.
Vue d'un tableau d'éléments de type T.
Constructeur de chaîne de caractère unicode.
String toString() const
Retourne la chaîne de caractères construite.
Vue sur une chaîne de caractères UTF-8.
Chaîne de caractères unicode.
bool startsWith(const String &s) const
Indique si la chaîne commence par les caractères de s.
bool null() const
Retourne true si la chaîne est nulle.
static String plural(const Integer n, const String &str, const bool with_number=true)
Forme standard du pluriel par ajout d'un 's'.
String upper() const
Transforme tous les caractères de la chaîne en majuscules.
Int64 length() const
Retourne la longueur de la chaîne.
String clone() const
Clone cette chaîne.
String lower() const
Transforme tous les caractères de la chaîne en minuscules.
void writeBytes(std::ostream &o) const
Écrit la chaîne au format UTF-8 sur le flot o.
void internalDump(std::ostream &ostr) const
Affiche les infos internes de la classe.
const char * localstr() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
ByteConstArrayView utf8() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
String()
Crée une chaîne nulle.
Int32 hashCode() const
Calcule une valeur de hashage pour cette chaîne de caractères.
friend ARCCORE_BASE_EXPORT bool operator==(const String &a, const String &b)
Compare deux chaînes unicode.
static String replaceWhiteSpace(const String &rhs)
Effectue une normalisation des caractères espaces.
Span< const Byte > bytes() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
bool endsWith(const String &s) const
Indique si la chaîne se termine par les caractères de s.
bool empty() const
Vrai si la chaîne est vide (nulle ou "")
friend ARCCORE_BASE_EXPORT String operator+(const char *a, const String &b)
Ajoute deux chaînes.
static String collapseWhiteSpace(const String &rhs)
Effectue une normalisation des caractères espaces.
ConstArrayView< UChar > utf16() const
Retourne la conversion de l'instance dans l'encodage UTF-16.
StringView view() const
Retourne une vue sur la chaîne actuelle.
String & operator=(const String &str)
Copie str dans cette instance.
bool contains(const String &s) const
Indique si la chaîne contient s.
std::string_view toStdStringView() const
Retourne une vue de la STL sur la chaîne actuelle.
Integer len() const
Retourne la longueur de la chaîne en 32 bits.
String substring(Int64 pos) const
Sous-chaîne commençant à la position pos.
bool isLess(const char *s1, const char *s2)
Retourne true si s1 est inférieur (ordre alphabétique) à s2 , false sinon.
bool isEqual(const char *s1, const char *s2)
Retourne true si s1 et s2 sont identiques, false sinon.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
constexpr __host__ __device__ Integer arccoreCheckArraySize(unsigned long long size)
Vérifie que size peut être converti dans un 'Integer' pour servir de taille à un tableau....
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
bool operator<(const Item &item1, const Item &item2)
Compare deux entités.
std::istream & operator>>(std::istream &istr, eItemKind &item_kind)
Opérateur d'entrée depuis un flot.
double Real
Type représentant un réel.
ConstArrayView< UChar > UCharConstArrayView
Equivalent C d'un tableau à une dimension de caractères unicode.
ConstArrayView< Byte > ByteConstArrayView
Equivalent C d'un tableau à une dimension de caractères.
unsigned char Byte
Type d'un octet.
unsigned short UChar
Type d'un caractère unicode.
std::ostream & operator<<(std::ostream &ostr, eItemKind item_kind)
Opérateur de sortie sur un flot.
std::int32_t Int32
Type entier signé sur 32 bits.