RNBO: common/RNBO_String.h Source File

 //
 //  RNBO_String.h
 //
 //  Created by Jeremy Bernstein on 5/9/16.
 //
 //
  
 #ifndef _RNBO_String_H_
 #define _RNBO_String_H_
  
 #include "RNBO_PlatformInterface.h"
  
 namespace RNBO {
  
     class String {
  
     public:
  
         String() : _ptr(new char[1]), _len(0), _truelen(1) { _ptr[0] = '\0'; }
  
         String(const char* str) : _ptr(nullptr), _len(0), _truelen(0) { copy(str); }
  
         String(String const& str) : _ptr(nullptr), _len(0), _truelen(0) { copy(str._ptr); }
  
         ~String() { delete[] _ptr; }
  
         size_t len() const { return _len; }
  
         void clear() { if (_ptr) _ptr[0] = '\0'; _len = 0; }
  
         bool empty() const { return _len == 0; }
  
         void append(const char* astr) {
             size_t alen = Platform::get()->strlen(astr);
             size_t newlen = alen + _len;
  
             if (newlen >= _truelen) {
                 char* oldptr = _ptr;
  
                 if (_truelen < 16) _truelen = 16;
                 while (newlen >= _truelen)
                     _truelen *= 2;
                 _ptr = new char[_truelen];
                 Platform::get()->memcpy(_ptr, oldptr, _len);
                 if (oldptr)
                     delete[] oldptr;
             }
             Platform::get()->memcpy(_ptr + _len, astr, alen);
             _ptr[newlen] = '\0';
             _len = newlen;
         }
  
         void append(String& astr) {
             append(astr._ptr);
         }
  
         const char* c_str() const { return const_cast<const char*>(_ptr); }
  
         String& operator = (const String& origin) { copy(origin._ptr); return *this; }
  
         String& operator = (const char* origin) { copy(origin); return *this; }
  
         String& operator += (const String& origin) { append(origin._ptr); return *this; }
  
         String& operator += (const char* origin) { append(origin); return *this; }
  
         friend String operator+ (String& str1, String& str2);
  
         bool operator==(const String& other) const {
             return Platform::get()->strcmp(_ptr, other._ptr) == 0;
         }
  
         bool operator<(const String& other) const {
             return (Platform::get()->strcmp(_ptr, other._ptr)) < 0 ? true : false;
         }
  
         bool operator>(const String& other) const {
             return (Platform::get()->strcmp(_ptr, other._ptr)) > 0 ? true : false;
         }
  
         friend struct StringHasher;
  
     private:
  
         int copy(const char* origin) {
             clear();
             append(origin);
             return 0;
         }
  
         char*  _ptr;
         size_t _len;
         size_t _truelen;
     };
  
     inline String operator+ (String& str1, String& str2) {
         String* newstr = new String(str1);
         newstr->append(str2._ptr);
         return *newstr;
     }
  
     struct StringHasher {
  
         size_t operator()(const String& k) const {
             const char* str = k.c_str();
             return TAG(str);
         }
     };
  
 } // namespace RNBO
  
 #endif // #ifndef _RNBO_String_H_
C++ Guides

RNBO: common/RNBO_String.h Source File
