source/utils/CarlaString.hpp

   1 // SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
   2 // SPDX-License-Identifier: GPL-2.0-or-later
   3
   4 #ifndef CARLA_STRING_HPP_INCLUDED
   5 #define CARLA_STRING_HPP_INCLUDED
   6
   7 #include "CarlaMathUtils.hpp"
   8 #include "CarlaScopeUtils.hpp"
   9
  10 #include <algorithm>
  11
  12 // -----------------------------------------------------------------------
  13 // CarlaString class
  14
  15 class CARLA_API CarlaString
  16 {
  17 public:
  18     // -------------------------------------------------------------------
  19     // constructors (no explicit conversions allowed)
  20
  21     /*
  22      * Empty string.
  23      */
  24     explicit CarlaString() noexcept
  25         : fBuffer(_null()),
  26           fBufferLen(0),
  27           fBufferAlloc(false) {}
  28
  29     /*
  30      * Simple character.
  31      */
  32     explicit CarlaString(const char c) noexcept
  33         : fBuffer(_null()),
  34           fBufferLen(0),
  35           fBufferAlloc(false)
  36     {
  37         char ch[2];
  38         ch[0] = c;
  39         ch[1] = '\0';
  40
  41         _dup(ch);
  42     }
  43
  44     /*
  45      * Simple char string.
  46      */
  47     explicit CarlaString(char* const strBuf, const bool reallocData = true) noexcept
  48         : fBuffer(_null()),
  49           fBufferLen(0),
  50           fBufferAlloc(false)
  51     {
  52         if (reallocData || strBuf == nullptr)
  53         {
  54             _dup(strBuf);
  55         }
  56         else
  57         {
  58             fBuffer      = strBuf;
  59             fBufferLen   = std::strlen(strBuf);
  60             fBufferAlloc = true;
  61         }
  62     }
  63
  64     /*
  65      * Simple const char string.
  66      */
  67     explicit CarlaString(const char* const strBuf) noexcept
  68         : fBuffer(_null()),
  69           fBufferLen(0),
  70           fBufferAlloc(false)
  71     {
  72         _dup(strBuf);
  73     }
  74
  75     /*
  76      * Integer.
  77      */
  78     explicit CarlaString(const int value) noexcept
  79         : fBuffer(_null()),
  80           fBufferLen(0),
  81           fBufferAlloc(false)
  82     {
  83         char strBuf[0xff+1];
  84         std::snprintf(strBuf, 0xff, "%d", value);
  85         strBuf[0xff] = '\0';
  86
  87         _dup(strBuf);
  88     }
  89
  90     /*
  91      * Unsigned integer, possibly in hexadecimal.
  92      */
  93     explicit CarlaString(const unsigned int value, const bool hexadecimal = false) noexcept
  94         : fBuffer(_null()),
  95           fBufferLen(0),
  96           fBufferAlloc(false)
  97     {
  98         char strBuf[0xff+1];
  99         std::snprintf(strBuf, 0xff, hexadecimal ? "0x%x" : "%u", value);
 100         strBuf[0xff] = '\0';
 101
 102         _dup(strBuf);
 103     }
 104
 105     /*
 106      * Long integer.
 107      */
 108     explicit CarlaString(const long value) noexcept
 109         : fBuffer(_null()),
 110           fBufferLen(0),
 111           fBufferAlloc(false)
 112     {
 113         char strBuf[0xff+1];
 114         std::snprintf(strBuf, 0xff, "%ld", value);
 115         strBuf[0xff] = '\0';
 116
 117         _dup(strBuf);
 118     }
 119
 120     /*
 121      * Long unsigned integer, possibly hexadecimal.
 122      */
 123     explicit CarlaString(const unsigned long value, const bool hexadecimal = false) noexcept
 124         : fBuffer(_null()),
 125           fBufferLen(0),
 126           fBufferAlloc(false)
 127     {
 128         char strBuf[0xff+1];
 129         std::snprintf(strBuf, 0xff, hexadecimal ? "0x%lx" : "%lu", value);
 130         strBuf[0xff] = '\0';
 131
 132         _dup(strBuf);
 133     }
 134
 135     /*
 136      * Long long integer.
 137      */
 138     explicit CarlaString(const long long value) noexcept
 139         : fBuffer(_null()),
 140           fBufferLen(0),
 141           fBufferAlloc(false)
 142     {
 143         char strBuf[0xff+1];
 144         std::snprintf(strBuf, 0xff, "%lld", value);
 145         strBuf[0xff] = '\0';
 146
 147         _dup(strBuf);
 148     }
 149
 150     /*
 151      * Long long unsigned integer, possibly hexadecimal.
 152      */
 153     explicit CarlaString(const unsigned long long value, const bool hexadecimal = false) noexcept
 154         : fBuffer(_null()),
 155           fBufferLen(0),
 156           fBufferAlloc(false)
 157     {
 158         char strBuf[0xff+1];
 159         std::snprintf(strBuf, 0xff, hexadecimal ? "0x%llx" : "%llu", value);
 160         strBuf[0xff] = '\0';
 161
 162         _dup(strBuf);
 163     }
 164
 165     /*
 166      * Single-precision floating point number.
 167      */
 168     explicit CarlaString(const float value) noexcept
 169         : fBuffer(_null()),
 170           fBufferLen(0),
 171           fBufferAlloc(false)
 172     {
 173         char strBuf[0xff+1];
 174
 175         {
 176             const CarlaScopedLocale csl;
 177             std::snprintf(strBuf, 0xff, "%.12g", static_cast<double>(value));
 178         }
 179
 180         strBuf[0xff] = '\0';
 181
 182         _dup(strBuf);
 183     }
 184
 185     /*
 186      * Double-precision floating point number.
 187      */
 188     explicit CarlaString(const double value) noexcept
 189         : fBuffer(_null()),
 190           fBufferLen(0),
 191           fBufferAlloc(false)
 192     {
 193         char strBuf[0xff+1];
 194
 195         {
 196             const CarlaScopedLocale csl;
 197             std::snprintf(strBuf, 0xff, "%.24g", value);
 198         }
 199
 200         strBuf[0xff] = '\0';
 201
 202         _dup(strBuf);
 203     }
 204
 205     // -------------------------------------------------------------------
 206     // non-explicit constructor
 207
 208     /*
 209      * Create string from another string.
 210      */
 211     CarlaString(const CarlaString& str) noexcept
 212         : fBuffer(_null()),
 213           fBufferLen(0),
 214           fBufferAlloc(false)
 215     {
 216         _dup(str.fBuffer);
 217     }
 218
 219     // -------------------------------------------------------------------
 220     // destructor
 221
 222     /*
 223      * Destructor.
 224      */
 225     ~CarlaString() noexcept
 226     {
 227         CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);
 228
 229         if (fBufferAlloc)
 230             std::free(fBuffer);
 231
 232         fBuffer      = nullptr;
 233         fBufferLen   = 0;
 234         fBufferAlloc = false;
 235     }
 236
 237     // -------------------------------------------------------------------
 238     // public methods
 239
 240     /*
 241      * Get length of the string.
 242      */
 243     std::size_t length() const noexcept
 244     {
 245         return fBufferLen;
 246     }
 247
 248     /*
 249      * Check if the string is empty.
 250      */
 251     bool isEmpty() const noexcept
 252     {
 253         return (fBufferLen == 0);
 254     }
 255
 256     /*
 257      * Check if the string is not empty.
 258      */
 259     bool isNotEmpty() const noexcept
 260     {
 261         return (fBufferLen != 0);
 262     }
 263
 264     /*
 265      * Check if the string contains a specific character, case-sensitive.
 266      */
 267     bool contains(const char c) const noexcept
 268     {
 269         for (std::size_t i=0; i<fBufferLen; ++i)
 270         {
 271             if (fBuffer[i] == c)
 272                 return true;
 273         }
 274
 275         return false;
 276     }
 277
 278     /*
 279      * Check if the string contains another string, optionally ignoring case.
 280      */
 281     bool contains(const char* const strBuf, const bool ignoreCase = false) const noexcept
 282     {
 283         CARLA_SAFE_ASSERT_RETURN(strBuf != nullptr, false);
 284
 285         if (ignoreCase)
 286             return carla_strcasestr(fBuffer, strBuf) != nullptr;
 287
 288         return std::strstr(fBuffer, strBuf) != nullptr;
 289     }
 290
 291     /*
 292      * Check if character at 'pos' is a digit.
 293      */
 294     bool isDigit(const std::size_t pos) const noexcept
 295     {
 296         CARLA_SAFE_ASSERT_RETURN(pos < fBufferLen, false);
 297
 298         return (fBuffer[pos] >= '0' && fBuffer[pos] <= '9');
 299     }
 300
 301     /*
 302      * Check if the string starts with the character 'c'.
 303      */
 304     bool startsWith(const char c) const noexcept
 305     {
 306         CARLA_SAFE_ASSERT_RETURN(c != '\0', false);
 307
 308         return (fBufferLen > 0 && fBuffer[0] == c);
 309     }
 310
 311     /*
 312      * Check if the string starts with the string 'prefix'.
 313      */
 314     bool startsWith(const char* const prefix) const noexcept
 315     {
 316         CARLA_SAFE_ASSERT_RETURN(prefix != nullptr, false);
 317
 318         const std::size_t prefixLen(std::strlen(prefix));
 319
 320         if (fBufferLen < prefixLen)
 321             return false;
 322
 323         return (std::strncmp(fBuffer, prefix, prefixLen) == 0);
 324     }
 325
 326     /*
 327      * Check if the string ends with the character 'c'.
 328      */
 329     bool endsWith(const char c) const noexcept
 330     {
 331         CARLA_SAFE_ASSERT_RETURN(c != '\0', false);
 332
 333         return (fBufferLen > 0 && fBuffer[fBufferLen-1] == c);
 334     }
 335
 336     /*
 337      * Check if the string ends with the string 'suffix'.
 338      */
 339     bool endsWith(const char* const suffix) const noexcept
 340     {
 341         CARLA_SAFE_ASSERT_RETURN(suffix != nullptr, false);
 342
 343         const std::size_t suffixLen(std::strlen(suffix));
 344
 345         if (fBufferLen < suffixLen)
 346             return false;
 347
 348         return (std::strncmp(fBuffer + (fBufferLen-suffixLen), suffix, suffixLen) == 0);
 349     }
 350
 351     /*
 352      * Find the first occurrence of character 'c' in the string.
 353      * Returns "length()" if the character is not found.
 354      */
 355     std::size_t find(const char c, bool* const found = nullptr) const noexcept
 356     {
 357         if (fBufferLen == 0 || c == '\0')
 358         {
 359             if (found != nullptr)
 360                 *found = false;
 361             return fBufferLen;
 362         }
 363
 364         for (std::size_t i=0; i < fBufferLen; ++i)
 365         {
 366             if (fBuffer[i] == c)
 367             {
 368                 if (found != nullptr)
 369                     *found = true;
 370                 return i;
 371             }
 372         }
 373
 374         if (found != nullptr)
 375             *found = false;
 376         return fBufferLen;
 377     }
 378
 379     /*
 380      * Find the first occurrence of string 'strBuf' in the string.
 381      * Returns "length()" if the string is not found.
 382      */
 383     std::size_t find(const char* const strBuf, bool* const found = nullptr) const noexcept
 384     {
 385         if (fBufferLen == 0 || strBuf == nullptr || strBuf[0] == '\0')
 386         {
 387             if (found != nullptr)
 388                 *found = false;
 389             return fBufferLen;
 390         }
 391
 392         if (char* const subStrBuf = std::strstr(fBuffer, strBuf))
 393         {
 394             const ssize_t ret = subStrBuf - fBuffer;
 395
 396             if (ret < 0)
 397             {
 398                 // should never happen!
 399                 carla_safe_assert_int("ret >= 0", __FILE__, __LINE__, int(ret));
 400
 401                 if (found != nullptr)
 402                     *found = false;
 403                 return fBufferLen;
 404             }
 405
 406             if (found != nullptr)
 407                 *found = true;
 408             return static_cast<std::size_t>(ret);
 409         }
 410
 411         if (found != nullptr)
 412             *found = false;
 413         return fBufferLen;
 414     }
 415
 416     /*
 417      * Find the last occurrence of character 'c' in the string.
 418      * Returns "length()" if the character is not found.
 419      */
 420     std::size_t rfind(const char c, bool* const found = nullptr) const noexcept
 421     {
 422         if (fBufferLen == 0 || c == '\0')
 423         {
 424             if (found != nullptr)
 425                 *found = false;
 426             return fBufferLen;
 427         }
 428
 429         for (std::size_t i=fBufferLen; i > 0; --i)
 430         {
 431             if (fBuffer[i-1] == c)
 432             {
 433                 if (found != nullptr)
 434                     *found = true;
 435                 return i-1;
 436             }
 437         }
 438
 439         if (found != nullptr)
 440             *found = false;
 441         return fBufferLen;
 442     }
 443
 444     /*
 445      * Find the last occurrence of string 'strBuf' in the string.
 446      * Returns "length()" if the string is not found.
 447      */
 448     std::size_t rfind(const char* const strBuf, bool* const found = nullptr) const noexcept
 449     {
 450         if (found != nullptr)
 451             *found = false;
 452
 453         if (fBufferLen == 0 || strBuf == nullptr || strBuf[0] == '\0')
 454             return fBufferLen;
 455
 456         const std::size_t strBufLen(std::strlen(strBuf));
 457
 458         std::size_t ret = fBufferLen;
 459         const char* tmpBuf = fBuffer;
 460
 461         for (std::size_t i=0; i < fBufferLen; ++i)
 462         {
 463             if (std::strstr(tmpBuf+1, strBuf) == nullptr && std::strncmp(tmpBuf, strBuf, strBufLen) == 0)
 464             {
 465                 if (found != nullptr)
 466                     *found = true;
 467                 break;
 468             }
 469
 470             --ret;
 471             ++tmpBuf;
 472         }
 473
 474         return fBufferLen-ret;
 475     }
 476
 477     /*
 478      * Clear the string.
 479      */
 480     void clear() noexcept
 481     {
 482         truncate(0);
 483     }
 484
 485     /*
 486      * Replace all occurrences of character 'before' with character 'after'.
 487      */
 488     CarlaString& replace(const char before, const char after) noexcept
 489     {
 490         CARLA_SAFE_ASSERT_RETURN(before != '\0' && after != '\0', *this);
 491
 492         for (std::size_t i=0; i < fBufferLen; ++i)
 493         {
 494             if (fBuffer[i] == before)
 495                 fBuffer[i] = after;
 496         }
 497
 498         return *this;
 499     }
 500
 501     /*
 502      * Truncate the string to size 'n'.
 503      */
 504     CarlaString& truncate(const std::size_t n) noexcept
 505     {
 506         if (n >= fBufferLen)
 507             return *this;
 508
 509         fBuffer[n] = '\0';
 510         fBufferLen = n;
 511
 512         return *this;
 513     }
 514
 515     /*
 516      * Convert all non-basic characters to '_'.
 517      */
 518     CarlaString& toBasic() noexcept
 519     {
 520         for (std::size_t i=0; i < fBufferLen; ++i)
 521         {
 522             if (fBuffer[i] >= '0' && fBuffer[i] <= '9')
 523                 continue;
 524             if (fBuffer[i] >= 'A' && fBuffer[i] <= 'Z')
 525                 continue;
 526             if (fBuffer[i] >= 'a' && fBuffer[i] <= 'z')
 527                 continue;
 528             if (fBuffer[i] == '_')
 529                 continue;
 530
 531             fBuffer[i] = '_';
 532         }
 533
 534         return *this;
 535     }
 536
 537     /*
 538      * Convert all ascii characters to lowercase.
 539      */
 540     CarlaString& toLower() noexcept
 541     {
 542         static const char kCharDiff('a' - 'A');
 543
 544         for (std::size_t i=0; i < fBufferLen; ++i)
 545         {
 546             if (fBuffer[i] >= 'A' && fBuffer[i] <= 'Z')
 547                 fBuffer[i] = static_cast<char>(fBuffer[i] + kCharDiff);
 548         }
 549
 550         return *this;
 551     }
 552
 553     /*
 554      * Convert all ascii characters to uppercase.
 555      */
 556     CarlaString& toUpper() noexcept
 557     {
 558         static const char kCharDiff('a' - 'A');
 559
 560         for (std::size_t i=0; i < fBufferLen; ++i)
 561         {
 562             if (fBuffer[i] >= 'a' && fBuffer[i] <= 'z')
 563                 fBuffer[i] = static_cast<char>(fBuffer[i] - kCharDiff);
 564         }
 565
 566         return *this;
 567     }
 568
 569     /*
 570      * Direct access to the string buffer (read-only).
 571      */
 572     const char* buffer() const noexcept
 573     {
 574         return fBuffer;
 575     }
 576
 577     /*
 578      * Return a duplicate string buffer.
 579      * May throw.
 580      */
 581     const char* dup() const
 582     {
 583         return carla_strdup(fBuffer);
 584     }
 585
 586     /*
 587      * Return a duplicate string buffer or null.
 588      */
 589     const char* dupSafe() const noexcept
 590     {
 591         return carla_strdup_safe(fBuffer);
 592     }
 593
 594     /*
 595      * Release the buffer pointer while clearing this string.
 596      * This allows to keep a pointer to the buffer after this object is deleted.
 597      */
 598     char* releaseBufferPointer() noexcept
 599     {
 600         char* ret = fBufferLen > 0 ? fBuffer : nullptr;
 601         fBuffer = _null();
 602         fBufferLen = 0;
 603         fBufferAlloc = false;
 604         return ret;
 605     }
 606
 607     // -------------------------------------------------------------------
 608     // base64 stuff, based on http://www.adp-gmbh.ch/cpp/common/base64.html
 609     // Copyright (C) 2004-2008 René Nyffenegger
 610
 611     static CarlaString asBase64(const void* const data, const std::size_t dataSize)
 612     {
 613         static const char* const kBase64Chars =
 614             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 615             "abcdefghijklmnopqrstuvwxyz"
 616             "0123456789+/";
 617
 618         static constexpr const std::size_t kTmpBufSize = 65536U;
 619
 620         const uchar* bytesToEncode((const uchar*)data);
 621
 622         uint i=0, j=0;
 623         uint charArray3[3], charArray4[4];
 624
 625         char strBuf[kTmpBufSize+1];
 626         strBuf[kTmpBufSize] = '\0';
 627         std::size_t strBufIndex = 0;
 628
 629         CarlaString ret;
 630
 631         for (std::size_t s=0; s<dataSize; ++s)
 632         {
 633             charArray3[i++] = *(bytesToEncode++);
 634
 635             if (i == 3)
 636             {
 637                 charArray4[0] =  (charArray3[0] & 0xfc) >> 2;
 638                 charArray4[1] = ((charArray3[0] & 0x03) << 4) + ((charArray3[1] & 0xf0) >> 4);
 639                 charArray4[2] = ((charArray3[1] & 0x0f) << 2) + ((charArray3[2] & 0xc0) >> 6);
 640                 charArray4[3] =   charArray3[2] & 0x3f;
 641
 642                 for (i=0; i<4; ++i)
 643                     strBuf[strBufIndex++] = kBase64Chars[charArray4[i]];
 644
 645                 if (strBufIndex >= kTmpBufSize-7)
 646                 {
 647                     strBuf[strBufIndex] = '\0';
 648                     strBufIndex = 0;
 649                     ret += strBuf;
 650                 }
 651
 652                 i = 0;
 653             }
 654         }
 655
 656         if (i != 0)
 657         {
 658             for (j=i; j<3; ++j)
 659               charArray3[j] = '\0';
 660
 661             charArray4[0] =  (charArray3[0] & 0xfc) >> 2;
 662             charArray4[1] = ((charArray3[0] & 0x03) << 4) + ((charArray3[1] & 0xf0) >> 4);
 663             charArray4[2] = ((charArray3[1] & 0x0f) << 2) + ((charArray3[2] & 0xc0) >> 6);
 664             charArray4[3] =   charArray3[2] & 0x3f;
 665
 666             for (j=0; j<4 && i<3 && j<i+1; ++j)
 667                 strBuf[strBufIndex++] = kBase64Chars[charArray4[j]];
 668
 669             for (; i++ < 3;)
 670                 strBuf[strBufIndex++] = '=';
 671         }
 672
 673         if (strBufIndex != 0)
 674         {
 675             strBuf[strBufIndex] = '\0';
 676             ret += strBuf;
 677         }
 678
 679         return ret;
 680     }
 681
 682     // -------------------------------------------------------------------
 683     // public operators
 684
 685     operator const char*() const noexcept
 686     {
 687         return fBuffer;
 688     }
 689
 690     char operator[](const std::size_t pos) const noexcept
 691     {
 692         if (pos < fBufferLen)
 693             return fBuffer[pos];
 694
 695         carla_safe_assert("pos < fBufferLen", __FILE__, __LINE__);
 696
 697         static char fallback = '\0';
 698         return fallback;
 699     }
 700
 701     char& operator[](const std::size_t pos) noexcept
 702     {
 703         if (pos < fBufferLen)
 704             return fBuffer[pos];
 705
 706         carla_safe_assert("pos < fBufferLen", __FILE__, __LINE__);
 707
 708         static char fallback = '\0';
 709         return fallback;
 710     }
 711
 712     bool operator==(const char* const strBuf) const noexcept
 713     {
 714         return (strBuf != nullptr && std::strcmp(fBuffer, strBuf) == 0);
 715     }
 716
 717     bool operator==(const CarlaString& str) const noexcept
 718     {
 719         return operator==(str.fBuffer);
 720     }
 721
 722     bool operator!=(const char* const strBuf) const noexcept
 723     {
 724         return !operator==(strBuf);
 725     }
 726
 727     bool operator!=(const CarlaString& str) const noexcept
 728     {
 729         return !operator==(str.fBuffer);
 730     }
 731
 732     CarlaString& operator=(const char* const strBuf) noexcept
 733     {
 734         _dup(strBuf);
 735
 736         return *this;
 737     }
 738
 739     CarlaString& operator=(const CarlaString& str) noexcept
 740     {
 741         _dup(str.fBuffer);
 742
 743         return *this;
 744     }
 745
 746     CarlaString& operator+=(const char* const strBuf) noexcept
 747     {
 748         if (strBuf == nullptr || strBuf[0] == '\0')
 749             return *this;
 750
 751         const std::size_t strBufLen = std::strlen(strBuf);
 752
 753         // for empty strings, we can just take the appended string as our entire data
 754         if (isEmpty())
 755         {
 756             _dup(strBuf, strBufLen);
 757             return *this;
 758         }
 759
 760         // we have some data ourselves, reallocate to add the new stuff
 761         char* const newBuf = (char*)realloc(fBuffer, fBufferLen + strBufLen + 1);
 762         CARLA_SAFE_ASSERT_RETURN(newBuf != nullptr, *this);
 763
 764         std::memcpy(newBuf + fBufferLen, strBuf, strBufLen + 1);
 765
 766         fBuffer = newBuf;
 767         fBufferLen += strBufLen;
 768
 769         return *this;
 770     }
 771
 772     CarlaString& operator+=(const CarlaString& str) noexcept
 773     {
 774         return operator+=(str.fBuffer);
 775     }
 776
 777     CarlaString operator+(const char* const strBuf) noexcept
 778     {
 779         if (strBuf == nullptr || strBuf[0] == '\0')
 780             return *this;
 781         if (isEmpty())
 782             return CarlaString(strBuf);
 783
 784         const std::size_t strBufLen = std::strlen(strBuf);
 785         const std::size_t newBufSize = fBufferLen + strBufLen;
 786         char* const newBuf = (char*)std::malloc(newBufSize + 1);
 787         CARLA_SAFE_ASSERT_RETURN(newBuf != nullptr, CarlaString());
 788
 789         std::memcpy(newBuf, fBuffer, fBufferLen);
 790         std::memcpy(newBuf + fBufferLen, strBuf, strBufLen + 1);
 791
 792         return CarlaString(newBuf, false);
 793     }
 794
 795     CarlaString operator+(const CarlaString& str) noexcept
 796     {
 797         return operator+(str.fBuffer);
 798     }
 799
 800     // needed for std::map compatibility
 801     bool operator<(const CarlaString& str) const noexcept
 802     {
 803         return std::strcmp(fBuffer, str.fBuffer) < 0;
 804     }
 805
 806     // -------------------------------------------------------------------
 807
 808 private:
 809     char*       fBuffer;      // the actual string buffer
 810     std::size_t fBufferLen;   // string length
 811     bool        fBufferAlloc; // wherever the buffer is allocated, not using _null()
 812
 813     /*
 814      * Static null string.
 815      * Prevents allocation for new and/or empty strings.
 816      */
 817     static char* _null() noexcept
 818     {
 819         static char sNull = '\0';
 820         return &sNull;
 821     }
 822
 823     /*
 824      * Helper function.
 825      * Called whenever the string needs to be allocated.
 826      *
 827      * Notes:
 828      * - Allocates string only if 'strBuf' is not null and new string contents are different
 829      * - If 'strBuf' is null, 'size' must be 0
 830      */
 831     void _dup(const char* const strBuf, const std::size_t size = 0) noexcept
 832     {
 833         if (strBuf != nullptr)
 834         {
 835             // don't recreate string if contents match
 836             if (std::strcmp(fBuffer, strBuf) == 0)
 837                 return;
 838
 839             if (fBufferAlloc)
 840                 std::free(fBuffer);
 841
 842             fBufferLen = (size > 0) ? size : std::strlen(strBuf);
 843             fBuffer    = (char*)std::malloc(fBufferLen+1);
 844
 845             if (fBuffer == nullptr)
 846             {
 847                 fBuffer      = _null();
 848                 fBufferLen   = 0;
 849                 fBufferAlloc = false;
 850                 return;
 851             }
 852
 853             fBufferAlloc = true;
 854
 855             std::strcpy(fBuffer, strBuf);
 856             fBuffer[fBufferLen] = '\0';
 857         }
 858         else
 859         {
 860             CARLA_SAFE_ASSERT_UINT(size == 0, static_cast<uint>(size));
 861
 862             // don't recreate null string
 863             if (! fBufferAlloc)
 864                 return;
 865
 866             CARLA_SAFE_ASSERT(fBuffer != nullptr);
 867             std::free(fBuffer);
 868
 869             fBuffer      = _null();
 870             fBufferLen   = 0;
 871             fBufferAlloc = false;
 872         }
 873     }
 874
 875     CARLA_PREVENT_HEAP_ALLOCATION
 876 };
 877
 878 // -----------------------------------------------------------------------
 879
 880 static inline
 881 CarlaString operator+(const CarlaString& strBefore, const char* const strBufAfter) noexcept
 882 {
 883     if (strBufAfter == nullptr || strBufAfter[0] == '\0')
 884         return strBefore;
 885     if (strBefore.isEmpty())
 886         return CarlaString(strBufAfter);
 887
 888     const std::size_t strBeforeLen = strBefore.length();
 889     const std::size_t strBufAfterLen = std::strlen(strBufAfter);
 890     const std::size_t newBufSize = strBeforeLen + strBufAfterLen;
 891     char* const newBuf = (char*)std::malloc(newBufSize + 1);
 892     CARLA_SAFE_ASSERT_RETURN(newBuf != nullptr, CarlaString());
 893
 894     std::memcpy(newBuf, strBefore.buffer(), strBeforeLen);
 895     std::memcpy(newBuf + strBeforeLen, strBufAfter, strBufAfterLen + 1);
 896
 897     return CarlaString(newBuf, false);
 898 }
 899
 900 static inline
 901 CarlaString operator+(const char* const strBufBefore, const CarlaString& strAfter) noexcept
 902 {
 903     if (strAfter.isEmpty())
 904         return CarlaString(strBufBefore);
 905     if (strBufBefore == nullptr || strBufBefore[0] == '\0')
 906         return strAfter;
 907
 908     const std::size_t strBufBeforeLen = std::strlen(strBufBefore);
 909     const std::size_t strAfterLen = strAfter.length();
 910     const std::size_t newBufSize = strBufBeforeLen + strAfterLen;
 911     char* const newBuf = (char*)std::malloc(newBufSize + 1);
 912     CARLA_SAFE_ASSERT_RETURN(newBuf != nullptr, CarlaString());
 913
 914     std::memcpy(newBuf, strBufBefore, strBufBeforeLen);
 915     std::memcpy(newBuf + strBufBeforeLen, strAfter.buffer(), strAfterLen + 1);
 916
 917     return CarlaString(newBuf, false);
 918 }
 919
 920 // -----------------------------------------------------------------------
 921
 922 #endif // CARLA_STRING_HPP_INCLUDED