58 #define strtoull _strtoui64
62 namespace std { using ::list; }
68 const
UInt_t kHashShift = 5;
107 char *data =
Init(n, n);
119 char *data =
Init(n, n);
120 memcpy(data, s.c_str(),
n);
128 char *data =
Init(n, n);
137 char *data =
Init(1, 1);
154 char *data =
Init(n, n);
155 while (n--) data[
n] =
c;
167 char *data =
Init(n, n);
188 char *data =
Init(len, len);
189 memcpy(data, substr.
Data(), len);
200 char *data =
Init(tot, tot);
201 memcpy(data, a1, n1);
202 memcpy(data+n1, a2, n2);
220 Error(
"TString::Init",
"capacity too large (%d, max = %d)", capacity,
MaxSize());
222 if (nchar > capacity)
227 if (capacity < kMinCap) {
232 data =
new char[cap+1];
305 char *data =
Init(n, n);
331 if (!rep)
return *
this;
337 Error(
"TString::Append",
"rep too large (%d, max = %d)", rep,
MaxSize()-len);
345 if (capac - tot >= 0) {
350 data =
new char[cap+1];
351 memcpy(data, p, len);
389 const char *cs1 =
Data();
393 for (; cs2[i]; ++i) {
394 if (i == len)
return -1;
395 if (cs1[i] != cs2[i])
return ((cs1[i] > cs2[i]) ? 1 : -1);
398 for (; cs2[i]; ++i) {
399 if (i == len)
return -1;
400 char c1 = tolower((
unsigned char)cs1[i]);
401 char c2 = tolower((
unsigned char)cs2[i]);
402 if (c1 != c2)
return ((c1 > c2) ? 1 : -1);
405 return (i < len) ? 1 : 0;
417 const char *s1 =
Data();
418 const char *s2 = str.
Data();
422 if (len < slen) slen = len;
424 int result = memcmp(s1, s2, slen);
425 if (result != 0)
return result;
428 for (; i < slen; ++i) {
429 char c1 = tolower((
unsigned char)s1[i]);
430 char c2 = tolower((
unsigned char)s2[i]);
431 if (c1 != c2)
return ((c1 > c2) ? 1 : -1);
436 if (len == slen)
return 0;
437 return (len > slen) ? 1 : -1;
447 const char *data =
Data();
448 for (
Int_t n = 0; n < len; n++)
449 if (data[n] == c) count++;
468 const char *
f = strchr(
Data(), c);
477 const char *
f = strpbrk(
Data(), cs);
486 return (((x & 0x000000ffU) << 24) | ((x & 0x0000ff00U) << 8) |
487 ((x & 0x00ff0000U) >> 8) | ((x & 0xff000000U) >> 24));
497 ((hash << kHashShift) |
506 UInt_t len = str ? strlen(str) : 0;
524 if ((i = len*
sizeof(
char)%
sizeof(
UInt_t)) != 0) {
526 const char*
c = (
const char*)p;
534 const unsigned char *p = (
const unsigned char*)str;
537 memcpy(&h, p,
sizeof(
UInt_t));
547 if ((i = len*
sizeof(
char)%
sizeof(
UInt_t)) != 0) {
549 const char*
c = (
const char*)p;
579 const char*
c = (
const char*)p;
594 const unsigned char *p = (
const unsigned char*)
Data();
596 Mash(hv, toupper(*p));
630 #if defined(_MSC_VER) && (_MSC_VER < 1800)
632 typedef unsigned char uint8_t;
633 typedef unsigned long uint32_t;
634 typedef unsigned __int64 uint64_t;
635 #else // defined(_MSC_VER)
638 #endif // !defined(_MSC_VER)
641 #if defined(_MSC_VER)
643 #define FORCE_INLINE __forceinline
645 #define ROTL64(x,y) _rotl64(x,y)
646 #define BIG_CONSTANT(x) (x)
647 #else // defined(_MSC_VER)
651 return (x << r) | (x >> (64 -
r));
654 #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) <= 40101
656 #define FORCE_INLINE inline
660 #define FORCE_INLINE __attribute__((always_inline)) inline
662 #define ROTL64(x,y) rotl64(x,y)
663 #define BIG_CONSTANT(x) (x##LLU)
664 #endif // !defined(_MSC_VER)
672 FORCE_INLINE uint64_t getblock(
const uint64_t* p,
int i)
697 static void MurmurHash3_x64_128(
const void * key,
const int len,
698 const uint32_t seed, uint64_t
out[2] )
700 const uint8_t * data = (
const uint8_t*)key;
701 const int nblocks = len / 16;
712 const uint64_t * blocks = (
const uint64_t *)(data);
714 for(
int i = 0; i < nblocks; i++)
716 uint64_t k1 = getblock(blocks,i*2+0);
717 uint64_t k2 = getblock(blocks,i*2+1);
719 k1 *=
c1; k1 =
ROTL64(k1,31); k1 *=
c2; h1 ^= k1;
721 h1 =
ROTL64(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
723 k2 *=
c2; k2 =
ROTL64(k2,33); k2 *=
c1; h2 ^= k2;
725 h2 =
ROTL64(h2,31); h2 +=
h1; h2 = h2*5+0x38495ab5;
731 const uint8_t * tail = (
const uint8_t*)(data + nblocks*16);
737 case 15: k2 ^= uint64_t(tail[14]) << 48;
738 case 14: k2 ^= uint64_t(tail[13]) << 40;
739 case 13: k2 ^= uint64_t(tail[12]) << 32;
740 case 12: k2 ^= uint64_t(tail[11]) << 24;
741 case 11: k2 ^= uint64_t(tail[10]) << 16;
742 case 10: k2 ^= uint64_t(tail[ 9]) << 8;
743 case 9: k2 ^= uint64_t(tail[ 8]) << 0;
744 k2 *=
c2; k2 =
ROTL64(k2,33); k2 *=
c1; h2 ^= k2;
746 case 8: k1 ^= uint64_t(tail[ 7]) << 56;
747 case 7: k1 ^= uint64_t(tail[ 6]) << 48;
748 case 6: k1 ^= uint64_t(tail[ 5]) << 40;
749 case 5: k1 ^= uint64_t(tail[ 4]) << 32;
750 case 4: k1 ^= uint64_t(tail[ 3]) << 24;
751 case 3: k1 ^= uint64_t(tail[ 2]) << 16;
752 case 2: k1 ^= uint64_t(tail[ 1]) << 8;
753 case 1: k1 ^= uint64_t(tail[ 0]) << 0;
754 k1 *=
c1; k1 =
ROTL64(k1,31); k1 *=
c2; h1 ^= k1;
760 h1 ^= len; h2 ^= len;
771 ((uint64_t*)out)[0] =
h1;
772 ((uint64_t*)out)[1] = h2;
789 if (ntxt !=
sizeof(
void*)) {
790 uint64_t buf[2] = {0};
791 MurmurHash3_x64_128(txt, ntxt, 0x6384BA69, buf);
797 if (((
size_t)txt) %
sizeof(
void*)) {
800 if (
sizeof(
void*) >
sizeof(
UInt_t)) {
804 const unsigned char* ctxt = (
const unsigned char*) txt;
805 for (
unsigned int i = 0; i < 4; ++i) {
806 ret ^= ctxt[i] << (i * 8);
808 if (
sizeof(
void*) >
sizeof(
UInt_t)) {
810 for (
unsigned int i = 0; i < 4; ++i) {
811 ret ^= ctxt[i] << (i * 8);
826 if (tolower((
unsigned char)*p) != tolower((
unsigned char)*q))
842 if (slen < startIndex + plen)
return kNPOS;
843 if (plen == 0)
return startIndex;
844 slen -= startIndex + plen;
845 const char *sp =
Data() + startIndex;
848 for (
Ssiz_t i = 0; i <= slen; ++i)
849 if (sp[i] == first && memcmp(sp+i+1, pattern+1, plen-1) == 0)
850 return i + startIndex;
852 int first = tolower((
unsigned char) *pattern);
853 for (
Ssiz_t i = 0; i <= slen; ++i)
854 if (tolower((
unsigned char) sp[i]) == first &&
856 return i + startIndex;
866 const char *
f = strrchr(
Data(), (
unsigned char) c);
887 const char *specials =
"^$.[]*+?";
899 const char *specials =
"[]*?";
911 if (!rep)
return *
this;
917 Error(
"TString::Prepend",
"rep too large (%d, max = %d)", rep,
MaxSize()-len);
925 if (capac - tot >= 0) {
926 memmove(p + rep, p, len);
931 data =
new char[cap+1];
932 memcpy(data+rep, p, len);
953 if (pos <= kNPOS || pos > len) {
954 Error(
"TString::Replace",
955 "first argument out of bounds: pos = %d, Length = %d", pos, len);
962 Ssiz_t tot = len - n1 + n2;
963 Ssiz_t rem = len - n1 - pos;
968 if (capac - len + n1 >= n2) {
972 if (n2) memmove(p + pos, cs, n2);
973 memmove(p + pos + n2, p + pos + n1, rem);
976 if (p + pos < cs && cs < p + len) {
977 if (p + pos + n1 <= cs)
980 memmove(p + pos, cs, n1);
987 memmove(p + pos + n2, p + pos + n1, rem);
990 if (n2) memmove(p + pos, cs, n2);
996 char *data =
new char[cap+1];
997 if (pos) memcpy(data, p, pos);
998 if (n2 ) memcpy(data + pos, cs, n2);
999 if (rem) memcpy(data + pos + n2, p + pos + n1, rem);
1016 if (s1 && ls1 > 0) {
1034 const char *direct =
Data();
1038 while (start < end && direct[start] == c)
1041 while (start < end && direct[end-1] == c)
1051 Remove(send - start - (send - end), send - end);
1073 const char *direct =
Data();
1076 while (start < end && direct[start] == c)
1079 while (start < end && direct[end-1] == c)
1081 if (end == start) start = end =
kNPOS;
1093 *p = tolower((
unsigned char)*p);
1106 *p = toupper((
unsigned char)*p);
1117 Error(
"TString::AssertElement",
1118 "out of bounds: i = %d, Length = %d", i,
Length());
1127 if (newCap > ms - 1) {
1128 Error(
"TString::AdjustCapacity",
"capacity too large (%d, max = %d)",
1150 Error(
"TString::Clobber",
"capacity too large (%d, max = %d)", nc,
MaxSize());
1161 data =
new char[cap+1];
1178 if (len >= tot)
return;
1181 Error(
"TString::Clone",
"tot too large (%d, max = %d)", tot,
MaxSize());
1188 if (capac - tot < 0) {
1190 data =
new char[cap+1];
1191 memcpy(data, p, len);
1214 tobuf(buffer, nchars);
1220 for (
int i = 0; i < nchars; i++) buffer[i] = data[i];
1242 Error(
"TString::ReadBuffer",
"found case with nwh=%d and nchars=%d", nwh, nchars);
1246 char *data =
Init(nchars, nchars);
1248 for (
int i = 0; i < nchars; i++)
frombuf(buffer, &data[i]);
1280 ::Error(
"TString::ReadObject",
"could not create object of class %s",
1308 void TString::Streamer(
TBuffer &b)
1354 #if defined(R__TEMPLATE_OVERLOAD_BUG)
1382 const char *data = s1.
Data();
1385 for (i = 0; s2[i]; ++i)
1386 if (data[i] != s2[i] || i == len)
return kFALSE;
1397 const char *uc = str.
Data();
1398 char *lc = (
char*)temp.
Data();
1400 while (n--) { *lc++ = tolower((
unsigned char)*uc); uc++; }
1411 const char* uc = str.
Data();
1412 char* lc = (
char*)temp.
Data();
1414 while (n--) { *lc++ = toupper((
unsigned char)*uc); uc++; }
1456 snprintf(si,
sizeof(si),
"%ld", i);
1466 snprintf(si,
sizeof(si),
"%lu", i);
1476 snprintf(si,
sizeof(si),
"%lld", i);
1486 snprintf(si,
sizeof(si),
"%llu", i);
1504 snprintf(si,
sizeof(si),
"%ld", i);
1514 snprintf(si,
sizeof(si),
"%lu", i);
1524 snprintf(si,
sizeof(si),
"%lld", i);
1534 snprintf(si,
sizeof(si),
"%llu", i);
1546 ::Obsolete(
"TString::GetInitialCapacity",
"v5-30-00",
"v5-32-00");
1554 ::Obsolete(
"TString::GetResizeIncrement",
"v5-30-00",
"v5-32-00");
1562 ::Obsolete(
"TString::GetMaxWaste",
"v5-30-00",
"v5-32-00");
1571 ::Obsolete(
"TString::InitialCapacity",
"v5-30-00",
"v5-32-00");
1580 ::Obsolete(
"TString::ResizeIncrement",
"v5-30-00",
"v5-32-00");
1590 ::Obsolete(
"TString::MaxWaste",
"v5-30-00",
"v5-32-00");
1608 : fStr((
TString&)str), fBegin(start), fExtent(nextent)
1617 if (start <
Length() && len > 0) {
1618 if (start+len >
Length())
1636 Ssiz_t len = pattern ? strlen(pattern) : 0;
1685 if (ss.
IsNull())
return *cs ==
'\0';
1689 for (i = 0; cs[i]; ++i)
1723 while (n--) { *p = tolower((
unsigned char)*p); p++;}
1735 while (n--) { *p = toupper((
unsigned char)*p); p++;}
1744 Error(
"TSubString::SubStringError",
1745 "out of bounds: start = %d, n = %d, sr = %d", start, n, sr);
1754 Error(
"TSubString::AssertElement",
1755 "out of bounds: i = %d, Length = %d", i,
Length());
1763 const char *cp =
Data();
1776 const char *cp =
Data();
1778 if (len == 0)
return kFALSE;
1779 for (
Ssiz_t i = 0; i < len; ++i)
1780 if (!isalpha(cp[i]))
1791 const char *cp =
Data();
1793 if (len == 0)
return kFALSE;
1794 for (
Ssiz_t i = 0; i < len; ++i)
1795 if (!isalnum(cp[i]))
1808 const char *cp =
Data();
1810 if (len == 0)
return kFALSE;
1812 for (
Ssiz_t i = 0; i < len; ++i) {
1813 if (cp[i] !=
' ' && !isdigit(cp[i]))
return kFALSE;
1814 if (cp[i] ==
' ') b++;
1815 if (isdigit(cp[i])) d++;
1846 pos = tmp.
First(
',');
1848 pos = tmp.
Index(
"e-");
1849 if (pos >= 1) tmp.
Replace(pos, 2,
" ", 1);
1850 pos = tmp.
Index(
"e+");
1851 if (pos >= 1) tmp.
Replace(pos, 2,
" ", 1);
1852 pos = tmp.
Index(
"e");
1853 if (pos >= 1) tmp.
Replace(pos, 1,
" ", 1);
1854 pos = tmp.
First(
'-');
1855 if (pos == 0) tmp.
Replace(pos, 1,
" ", 1);
1856 pos = tmp.
First(
'+');
1857 if (pos == 0) tmp.
Replace(pos, 1,
" ", 1);
1870 const char *cp =
Data();
1872 if (len == 0)
return kFALSE;
1873 for (
Ssiz_t i = 0; i < len; ++i)
1874 if (!isxdigit(cp[i]))
1886 const char *cp =
Data();
1888 if (len == 0)
return kFALSE;
1889 for (
Ssiz_t i = 0; i < len; ++i)
1890 if (cp[i] !=
'0' && cp[i] !=
'1')
1902 const char *cp =
Data();
1904 if (len == 0)
return kFALSE;
1905 for (
Ssiz_t i = 0; i < len; ++i)
1906 if (!isdigit(cp[i]) || cp[i]==
'8' || cp[i]==
'9')
1918 const char *cp =
Data();
1920 if (len == 0)
return kFALSE;
1921 for (
Ssiz_t i = 0; i < len; ++i)
1922 if (!isdigit(cp[i]))
1935 if (base < 2 || base > 36) {
1936 Error(
"TString::IsInBaseN",
"base %d is not supported. Supported bases are {2,3,...,36}.", base);
1940 Error(
"TString::IsInBaseN",
"input string is empty.") ;
1945 TString str_ref0 =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
1969 if (end == -1)
return atoi(
Data());
1975 tmp += (*this)(start, end-start);
1976 start = end+1; end =
Index(
" ", start);
1980 tmp += (*this)(start, end-start);
1981 return atoi(tmp.
Data());
1996 if (end == -1)
return atoll(
Data());
1998 if (end == -1)
return _atoi64(
Data());
2005 tmp += (*this)(start, end-start);
2006 start = end+1; end =
Index(
" ", start);
2010 tmp += (*this)(start, end-start);
2012 return atoll(tmp.
Data());
2014 return _atoi64(tmp.
Data());
2036 if (comma == -1 && end == -1)
return atof(
Data());
2043 if (end == -1)
return atof(tmp.
Data());
2048 tmp2 += tmp(start, end-start);
2049 start = end+1; end = tmp.
Index(
" ", start);
2052 tmp2 += tmp(start, end-start);
2053 return atof(tmp2.
Data());
2072 if (base < 2 || base > 36) {
2073 Error(
"TString::Itoa",
"base %d is not supported. Supported bases are {2,3,...,36}.",base) ;
2080 buf +=
"0123456789abcdefghijklmnopqrstuvwxyz"[
TMath::Abs(quotient % base) ];
2084 if (value < 0) buf +=
'-';
2085 std::reverse(buf.begin(), buf.end());
2099 if (base < 2 || base > 36) {
2100 Error(
"TString::UItoa",
"base %d is not supported. Supported bases are {2,3,...,36}.",base);
2107 buf +=
"0123456789abcdefghijklmnopqrstuvwxyz"[ quotient % base ];
2110 std::reverse(buf.begin(), buf.end());
2124 if (base < 2 || base > 36) {
2125 Error(
"TString::LLtoa",
"base %d is not supported. Supported bases are {2,3,...,36}.",base);
2132 buf +=
"0123456789abcdefghijklmnopqrstuvwxyz"[
TMath::Abs(quotient % base) ];
2136 if (value < 0) buf +=
'-';
2137 std::reverse(buf.begin(), buf.end());
2151 if (base < 2 || base > 36) {
2152 Error(
"TString::ULLtoa",
"base %d is not supported. Supported bases are {2,3,...,36}.",base);
2159 buf +=
"0123456789abcdefghijklmnopqrstuvwxyz"[ quotient % base ];
2162 std::reverse(buf.begin(), buf.end());
2174 if (base_in < 2 || base_in > 36 || base_out < 2 || base_out > 36) {
2175 Error(
"TString::BaseConvert",
"only bases 2-36 are supported (base_in=%d, base_out=%d).", base_in, base_out);
2181 if (s_in_[0] ==
'-') {
2185 if (!isSigned && s_in_[0] ==
'+') s_in_.
Remove(0, 1);
2188 if (!s_in_.
Length()) s_in_ +=
'0';
2191 Error(
"TString::BaseConvert",
"s_in=\"%s\" is not in base %d", s_in.
Data(), base_in);
2198 Error(
"TString::BaseConvert",
"s_in=\"%s\" > %s = 2^64-1 in base %d.", s_in.
Data(), s_max.
Data(), base_in);
2203 if (s_in_ > s_max) {
2205 Error(
"TString::BaseConvert",
"s_in=\"%s\" > %s = 2^64-1 in base %d.", s_in.
Data(), s_max.
Data(), base_in);
2213 if (isSigned) s_out.
Prepend(
"-");
2222 if (!s)
return kTRUE;
2229 return strcmp(s, s2) == 0;
2230 return strcasecmp(s, s2) == 0;
2242 std::list<Int_t> splitIndex;
2244 Int_t i, start, nrDiff = 0;
2245 for (i = 0; i < delim.
Length(); i++) {
2247 while (start <
Length()) {
2249 if (pos ==
kNPOS)
break;
2250 splitIndex.push_back(pos);
2253 if (start > 0) nrDiff++;
2255 splitIndex.push_back(
Length());
2264 std::list<Int_t>::const_iterator it;
2266 for (it = splitIndex.begin(); it != splitIndex.end(); it++) {
2268 for (it = splitIndex.begin(); it != (std::list<Int_t>::const_iterator) splitIndex.end(); it++) {
2271 if (stop - 1 >= start + 1) {
2272 TString tok = (*this)(start+1, stop-start-1);
2288 Ssiz_t buflen = 20 + 20 * strlen(fmt);
2296 n = vsnprintf(
GetPointer(), buflen, fmt, ap);
2299 if (n == -1 || n >= buflen) {
2324 va_start(ap,
va_(fmt));
2337 va_start(ap,
va_(fmt));
2352 static const int fld_size = 2048;
2353 TTHREAD_TLS(
char*) slowBuffer(0);
2354 TTHREAD_TLS(
int) slowBufferSize(0);
2356 if (hint == -1) hint = fld_size;
2357 if (hint > slowBufferSize) {
2358 delete [] slowBuffer;
2359 slowBufferSize = 2 * hint;
2360 if (hint < 0 || slowBufferSize < 0) {
2365 slowBuffer =
new char[slowBufferSize];
2371 int n = vsnprintf(slowBuffer, slowBufferSize, format, ap);
2374 if (n == -1 || n >= slowBufferSize) {
2375 if (n == -1) n = 2 * slowBufferSize;
2376 if (n == slowBufferSize) n++;
2400 static const int cb_size = 4096;
2401 static const int fld_size = 2048;
2404 TTHREAD_TLS_ARRAY(
char,cb_size,gFormbuf);
2405 TTHREAD_TLS(
char*) gBfree(0);
2406 TTHREAD_TLS(
char*) gEndbuf(0);
2410 gEndbuf = &gFormbuf[cb_size-1];
2414 if (buf+fld_size > gEndbuf)
2420 int n = vsnprintf(buf, fld_size, format, ap);
2423 if (n == -1 || n >= fld_size) {
2448 va_start(ap,
va_(fmt));
2462 va_start(ap,
va_(fmt));
2482 char *buf =
new char[l+1];
2495 const char *t2 = s + l - 1;
2496 while (*t2 == c && t2 > s)
2503 strncpy(buf, t1, (
Ssiz_t) (t2-t1+1));
2504 *(buf+(t2-t1+1)) =
'\0';
2517 char *s =
new char[strlen(str)+1];
2518 if (s) strcpy(s, str);
2531 const char *p = str;
2532 char *s, *s1 =
new char[strlen(str)+1];
2548 int EscChar(
const char *src,
char *dst,
int dstlen,
char *specchars,
2552 char *
q, *end = dst+dstlen-1;
2554 for (p = src, q = dst; *p && q < end; ) {
2555 if (strchr(specchars, *p)) {
2572 int UnEscChar(
const char *src,
char *dst,
int dstlen,
char *specchars,
char)
2575 char *
q, *end = dst+dstlen-1;
2577 for (p = src, q = dst; *p && q < end; ) {
2578 if (strchr(specchars, *p))
2590 #ifdef NEED_STRCASECMP
2594 int strcasecmp(
const char *str1,
const char *str2)
2596 return strncasecmp(str1, str2, str2 ? strlen(str2)+1 : 0);
2602 int strncasecmp(
const char *str1,
const char *str2,
Ssiz_t n)
2645 std::string str(val);
A zero length substring is legal.
static Ssiz_t GetMaxWaste()
TString MD5() const
Return the MD5 digest for this string, in a string representation.
void SetBufferOffset(Int_t offset=0)
Ssiz_t Last(char c) const
Find last occurrence of a character c.
void frombuf(char *&buf, Bool_t *x)
void ToLower()
Convert sub-string to lower-case.
virtual void FillBuffer(char *&buffer) const
Copy string into I/O buffer.
TSubString & operator=(const char *s)
Assign char* to sub-string.
static TString Itoa(Int_t value, Int_t base)
Converts an Int_t to a TString with respect to the base specified (2-36).
TString operator+(const TString &s, const char *cs)
Use the special concatenation constructor.
static Ssiz_t MaxWaste(Ssiz_t mw=15)
Set maximum space that may be wasted in a string before doing a resize.
char * Compress(const char *str)
Remove all blanks from the string str.
void Final()
MD5 finalization, ends an MD5 message-digest operation, writing the the message digest and zeroizing ...
Bool_t MaybeRegexp() const
Returns true if string contains one of the regexp characters "^$.[]*+?".
void ToUpper()
Convert sub-string to upper-case.
Collectable string class.
Bool_t IsOct() const
Returns true if all characters in string are octal digits (0-7).
TString & ReplaceAll(const TString &s1, const TString &s2)
void SubStringError(Ssiz_t, Ssiz_t, Ssiz_t) const
Output error message.
char * StrDup(const char *str)
Duplicate the string str.
Bool_t IsInBaseN(Int_t base) const
Returns true if all characters in string are expressed in the base specified (range=2-36), i.e.
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Double_t Atof() const
Return floating-point value contained in string.
Bool_t IsAlnum() const
Returns true if all characters in string are alphanumeric.
void Clone(Ssiz_t nc)
Make self a distinct copy with capacity of at least tot, where tot cannot be smaller than the current...
static TString UItoa(UInt_t value, Int_t base)
Converts a UInt_t (twice the range of an Int_t) to a TString with respect to the base specified (2-36...
void ToUpper()
Change string to upper case.
Buffer base class used for serializing objects.
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
Bool_t operator==(const TString &s1, const char *s2)
Compare TString with a char *.
TString ToUpper(const TString &str)
Return an upper-case version of str.
Short_t Min(Short_t a, Short_t b)
void ToLower()
Change string to lower-case.
TString & operator=(char s)
Assign character c to TString.
virtual void WriteClass(const TClass *cl)=0
static Ssiz_t ResizeIncrement(Ssiz_t ri=16)
Set default resize increment for all TStrings. Default is 16.
virtual void WriteTString(const TString &s)=0
TString ToLower(const TString &str)
Return a lower-case version of str.
TString & Prepend(const char *cs)
static std::string format(double x, double y, int digits, int width)
TBuffer & operator<<(TBuffer &buf, const TString *s)
Write TString or derived to TBuffer.
static void WriteString(TBuffer &b, const TString *a)
Write TString object to buffer.
TString Copy() const
Copy a string.
void Obsolete(const char *function, const char *asOfVers, const char *removedFromVers)
Use this function to declare a function obsolete.
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
char * Init(Ssiz_t capacity, Ssiz_t nchar)
Private member function returning an empty string representation of size capacity and containing ncha...
static int MemIsEqual(const char *p, const char *q, Ssiz_t n)
Returns false if strings are not equal.
TString & Replace(Ssiz_t pos, Ssiz_t n, const char *s)
const char * Data() const
Bool_t IsBin() const
Returns true if all characters in string are binary digits (0,1).
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString...
virtual void ReadBuffer(char *&buffer)
Read string from I/O buffer.
const char * AsString() const
Return message digest as string.
This code implements the MD5 message-digest algorithm.
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
static TString * ReadString(TBuffer &b, const TClass *clReq)
Read TString object from buffer.
void Clear()
Clear string without changing its capacity.
TString & Append(const char *cs)
static Ssiz_t Recommend(Ssiz_t s)
static Ssiz_t GetInitialCapacity()
Int_t Atoi() const
Return integer value of string.
void tobuf(char *&buf, Bool_t x)
void Error(const char *location, const char *msgfmt,...)
void AssertElement(Ssiz_t nc) const
Check to make sure a string index is in range.
char & operator()(Ssiz_t i)
static UInt_t SwapInt(UInt_t x)
std::string printValue(const TDatime &val)
Print a TDatime at the prompt.
void AssertElement(Ssiz_t i) const
Check to make sure a sub-string index is in range.
char & operator[](Ssiz_t i)
Return character at pos i from sub-string. Check validity of i.
R__EXTERN Bool_t gPrintViaErrorHandler
Bool_t IsDec() const
Returns true if all characters in string are decimal digits (0-9).
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
#define R__VA_COPY(to, from)
void Update(const UChar_t *buf, UInt_t len)
Update TMD5 object to reflect the concatenation of another buffer full of bytes.
Ssiz_t GetLongSize() const
TSubString SubString(const char *pat, Ssiz_t start=0, ECaseCompare cmp=kExact) const
Returns a substring matching "pattern", or the null substring if there is no such match...
char & operator()(Ssiz_t i)
Return character at pos i from sub-string. No check on i.
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
TBuffer & operator>>(TBuffer &buf, TString *&s)
Read string from TBuffer. Function declared in ClassDef.
void SetLongCap(Ssiz_t s)
virtual const char * GetName() const
Returns name of object.
TSubString Strip(EStripType s=kTrailing, char c= ' ') const
Return a substring of self stripped at beginning and/or end.
The ROOT global object gROOT contains a list of all defined classes.
virtual void SetByteCount(UInt_t cntpos, Bool_t packInVersion=kFALSE)=0
UInt_t HashFoldCase() const
Return a case-insensitive hash value (endian independent).
void SetLongPointer(char *p)
Int_t CountChar(Int_t c) const
Return number of times character c occurs in the string.
static Ssiz_t GetResizeIncrement()
int UnEscChar(const char *src, char *dst, int dstlen, char *specchars, char)
Un-escape specchars in src from escchar and copy to dst.
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
static Ssiz_t InitialCapacity(Ssiz_t ic=15)
Set default initial capacity for all TStrings. Default is 15.
void FormImp(const char *fmt, va_list ap)
Formats a string using a printf style format descriptor.
static const Ssiz_t kNPOS
void Clobber(Ssiz_t nc)
Clear string and make sure it has a capacity of nc.
TString & Remove(Ssiz_t pos)
int EscChar(const char *src, char *dst, int dstlen, char *specchars, char escchar)
Escape specchars in src with escchar and copy to dst.
void SetLongSize(Ssiz_t s)
static char * SlowFormat(const char *format, va_list ap, int hint)
Format a string in a formatting buffer (using a printf style format descriptor).
Long64_t Atoll() const
Return long long value of string.
unsigned long long ULong64_t
ClassImp(TMCParticle) void TMCParticle printf(": p=(%7.3f,%7.3f,%9.3f) ;", fPx, fPy, fPz)
static TString BaseConvert(const TString &s_in, Int_t base_in, Int_t base_out)
Converts string from base base_in to base base_out.
Bool_t IsFloat() const
Returns kTRUE if string contains a floating point or integer number.
Bool_t MaybeWildcard() const
Returns true if string contains one of the wildcard characters "[]*?".
static TString ULLtoa(ULong64_t value, Int_t base)
Converts a ULong64_t (twice the range of an Long64_t) to a TString with respect to the base specified...
UInt_t HashCase() const
Return a case-sensitive hash value (endian independent).
void SetShortSize(Ssiz_t s)
virtual void ReadTString(TString &s)=0
Bool_t IsDigit() const
Returns true if all characters in string are digits (0-9) or white spaces, i.e.
void ErrorHandler(int level, const char *location, const char *fmt, va_list va)
General error handler function. It calls the user set error handler.
TSubString(const TString &s, Ssiz_t start, Ssiz_t len)
Private constructor.
const size_t kBitsPerByte
Short_t Max(Short_t a, Short_t b)
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
uint64_t rotl64(uint64_t x, int8_t r)
virtual Int_t Sizeof() const
Returns size string will occupy on I/O buffer.
virtual TClass * ReadClass(const TClass *cl=0, UInt_t *objTag=0)=0
ClassImp(TSlaveInfo) Int_t TSlaveInfo const TSlaveInfo * si
Used to sort slaveinfos by ordinal.
static TString LLtoa(Long64_t value, Int_t base)
Converts a Long64_t to a TString with respect to the base specified (2-36).
TString()
TString default ctor.
const char * Data() const
static void Mash(UInt_t &hash, UInt_t chars)
Utility used by Hash().
UInt_t Hash(const char *str)
Return a case-sensitive hash value (endian independent).
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
Bool_t IsAlpha() const
Returns true if all characters in string are alphabetic.
Bool_t IsHex() const
Returns true if all characters in string are hexadecimal digits (0-9,a-f,A-F).
void Printf(const char *va_(fmt),...)
Formats a string in a circular formatting buffer and prints the string.
static Ssiz_t AdjustCapacity(Ssiz_t oldCap, Ssiz_t newCap)
Calculate a nice capacity greater than or equal to newCap.
Ssiz_t First(char c) const
Find first occurrence of a character c.
int CompareTo(const char *cs, ECaseCompare cmp=kExact) const
Compare a string to char *cs2.
Bool_t IsAscii() const
Returns true if all characters in string are ascii.
void InitChar(char c)
Initialize a string with a single character.
ClassImp(TString) const UInt_t kHashShift
void Resize(Ssiz_t n)
Resize the string. Truncate or add blanks as necessary.
virtual ~TString()
Delete a TString.
UInt_t Hash(ECaseCompare cmp=kExact) const
Return hash value.