WString Return bool

cores/esp32/WString.cpp

@@ -176,26 +176,25 @@ void String::invalidate(void) {
     init();
 }
 
-unsigned char String::reserve(unsigned int size) {
+bool String::reserve(unsigned int size) {
     if(buffer() && capacity() >= size)
-        return 1;
+        return true;
     if(changeBuffer(size)) {
         if(len() == 0)
             wbuffer()[0] = 0;
-        return 1;
+        return true;
     }
-    return 0;
+    return false;
 }
 
-unsigned char String::changeBuffer(unsigned int maxStrLen) {
+bool String::changeBuffer(unsigned int maxStrLen) {
     // Can we use SSO here to avoid allocation?
     if (maxStrLen < sizeof(sso.buff) - 1) {
         if (isSSO() || !buffer()) {
             // Already using SSO, nothing to do
-	    uint16_t oldLen = len();
+            uint16_t oldLen = len();
             setSSO(true);
             setLen(oldLen);
-            return 1;
         } else { // if bufptr && !isSSO()
             // Using bufptr, need to shrink into sso.buff
             char temp[sizeof(sso.buff)];
@@ -205,8 +204,8 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
             setSSO(true);
             memcpy(wbuffer(), temp, maxStrLen);
             setLen(oldLen);
-            return 1;
         }
+        return true;
     }
     // Fallthrough to normal allocator
     size_t newSize = (maxStrLen + 16) & (~0xf);
@@ -230,9 +229,9 @@ unsigned char String::changeBuffer(unsigned int maxStrLen) {
         setCapacity(newSize - 1);
         setBuffer(newbuffer);
         setLen(oldLen); // Needed in case of SSO where len() never existed
-        return 1;
+        return true;
     }
-    return 0;
+    return false;
 }
 
 // /*********************************************/
@@ -338,114 +337,117 @@ String & String::operator =(const __FlashStringHelper *pstr) {
 // /*  concat                                   */
 // /*********************************************/
 
-unsigned char String::concat(const String &s) {
+bool String::concat(const String &s) {
     // Special case if we're concatting ourself (s += s;) since we may end up
     // realloc'ing the buffer and moving s.buffer in the method called
     if (&s == this) {
         unsigned int newlen = 2 * len();
         if (!s.buffer())
-            return 0;
+            return false;
         if (s.len() == 0)
-            return 1;
+            return true;
         if (!reserve(newlen))
-            return 0;
+            return false;
         memmove(wbuffer() + len(), buffer(), len());
         setLen(newlen);
         wbuffer()[len()] = 0;
-        return 1;
+        return true;
     } else {
         return concat(s.buffer(), s.len());
     }
 }
 
-unsigned char String::concat(const char *cstr, unsigned int length) {
+bool String::concat(const char *cstr, unsigned int length) {
     unsigned int newlen = len() + length;
     if(!cstr)
-        return 0;
+        return false;
     if(length == 0)
-        return 1;
+        return true;
     if(!reserve(newlen))
-        return 0;
+        return false;
     if (cstr >= wbuffer() && cstr < wbuffer() + len())
         // compatible with SSO in ram #6155 (case "x += x.c_str()")
         memmove(wbuffer() + len(), cstr, length + 1);
     else
         // compatible with source in flash #6367
         memcpy_P(wbuffer() + len(), cstr, length + 1);
     setLen(newlen);
-    return 1;
+    return true;
 }
 
-unsigned char String::concat(const char *cstr) {
+bool String::concat(const char *cstr) {
     if(!cstr)
-        return 0;
+        return false;
     return concat(cstr, strlen(cstr));
 }
 
-unsigned char String::concat(char c) {
+bool String::concat(char c) {
     char buf[] = { c, '\0' };
     return concat(buf, 1);
 }
 
-unsigned char String::concat(unsigned char num) {
+bool String::concat(unsigned char num) {
     char buf[1 + 3 * sizeof(unsigned char)];
     return concat(buf, sprintf(buf, "%d", num));
 }
 
-unsigned char String::concat(int num) {
+bool String::concat(int num) {
     char buf[2 + 3 * sizeof(int)];
     return concat(buf, sprintf(buf, "%d", num));
 }
 
-unsigned char String::concat(unsigned int num) {
+bool String::concat(unsigned int num) {
     char buf[1 + 3 * sizeof(unsigned int)];
     utoa(num, buf, 10);
     return concat(buf, strlen(buf));
 }
 
-unsigned char String::concat(long num) {
+bool String::concat(long num) {
     char buf[2 + 3 * sizeof(long)];
     return concat(buf, sprintf(buf, "%ld", num));
 }
 
-unsigned char String::concat(unsigned long num) {
+bool String::concat(unsigned long num) {
     char buf[1 + 3 * sizeof(unsigned long)];
     ultoa(num, buf, 10);
     return concat(buf, strlen(buf));
 }
 
-unsigned char String::concat(float num) {
+bool String::concat(float num) {
     char buf[20];
     char* string = dtostrf(num, 4, 2, buf);
     return concat(string, strlen(string));
 }
 
-unsigned char String::concat(double num) {
+bool String::concat(double num) {
     char buf[20];
     char* string = dtostrf(num, 4, 2, buf);
     return concat(string, strlen(string));
 }
 
-unsigned char String::concat(long long num) {
+bool String::concat(long long num) {
     char buf[2 + 3 * sizeof(long long)];
     return concat(buf, sprintf(buf, "%lld", num));    // NOT SURE - NewLib Nano ... does it support %lld?
 }
 
-unsigned char String::concat(unsigned long long num) {
+bool String::concat(unsigned long long num) {
     char buf[1 + 3 * sizeof(unsigned long long)];
     ulltoa(num, buf, 10);
     return concat(buf, strlen(buf));
 }
 
-unsigned char String::concat(const __FlashStringHelper * str) {
-    if (!str) return 0;
+bool String::concat(const __FlashStringHelper * str) {
+    if (!str)
+        return false;
     int length = strlen_P((PGM_P)str);
-    if (length == 0) return 1;
+    if (length == 0)
+        return true;
     unsigned int newlen = len() + length;
-    if (!reserve(newlen)) return 0;
+    if (!reserve(newlen))
+        return false;
     memcpy_P(wbuffer() + len(), (PGM_P)str, length + 1);
     setLen(newlen);
-    return 1;
+    return true;
 }
 
 /*********************************************/
@@ -559,48 +561,48 @@ int String::compareTo(const String &s) const {
     return strcmp(buffer(), s.buffer());
 }
 
-unsigned char String::equals(const String &s2) const {
+bool String::equals(const String &s2) const {
     return (len() == s2.len() && compareTo(s2) == 0);
 }
 
-unsigned char String::equals(const char *cstr) const {
+bool String::equals(const char *cstr) const {
     if(len() == 0)
         return (cstr == NULL || *cstr == 0);
     if(cstr == NULL)
         return buffer()[0] == 0;
     return strcmp(buffer(), cstr) == 0;
 }
 
-unsigned char String::operator<(const String &rhs) const {
+bool String::operator<(const String &rhs) const {
     return compareTo(rhs) < 0;
 }
 
-unsigned char String::operator>(const String &rhs) const {
+bool String::operator>(const String &rhs) const {
     return compareTo(rhs) > 0;
 }
 
-unsigned char String::operator<=(const String &rhs) const {
+bool String::operator<=(const String &rhs) const {
     return compareTo(rhs) <= 0;
 }
 
-unsigned char String::operator>=(const String &rhs) const {
+bool String::operator>=(const String &rhs) const {
     return compareTo(rhs) >= 0;
 }
 
-unsigned char String::equalsIgnoreCase(const String &s2) const {
+bool String::equalsIgnoreCase(const String &s2) const {
     if(this == &s2)
-        return 1;
+        return true;
     if(len() != s2.len())
-        return 0;
+        return false;
     if(len() == 0)
-        return 1;
+        return true;
     const char *p1 = buffer();
     const char *p2 = s2.buffer();
     while(*p1) {
         if(tolower(*p1++) != tolower(*p2++))
-            return 0;
+            return false;
     }
-    return 1;
+    return true;
 }
 
 unsigned char String::equalsConstantTime(const String &s2) const {
@@ -630,21 +632,21 @@ unsigned char String::equalsConstantTime(const String &s2) const {
     return (equalcond & diffcond); //bitwise AND
 }
 
-unsigned char String::startsWith(const String &s2) const {
+bool String::startsWith(const String &s2) const {
     if(len() < s2.len())
-        return 0;
+        return false;
     return startsWith(s2, 0);
 }
 
-unsigned char String::startsWith(const String &s2, unsigned int offset) const {
+bool String::startsWith(const String &s2, unsigned int offset) const {
     if(offset > (unsigned)(len() - s2.len()) || !buffer() || !s2.buffer())
-        return 0;
+        return false;
     return strncmp(&buffer()[offset], s2.buffer(), s2.len()) == 0;
 }
 
-unsigned char String::endsWith(const String &s2) const {
+bool String::endsWith(const String &s2) const {
     if(len() < s2.len() || !buffer() || !s2.buffer())
-        return 0;
+        return false;
     return strcmp(&buffer()[len() - s2.len()], s2.buffer()) == 0;
 }
 

cores/esp32/WString.h

@@ -81,7 +81,7 @@ class String {
         // return true on success, false on failure (in which case, the string
         // is left unchanged).  reserve(0), if successful, will validate an
         // invalid string (i.e., "if (s)" will be true afterwards)
-        unsigned char reserve(unsigned int size);
+        bool reserve(unsigned int size);
         inline unsigned int length(void) const {
             if(buffer()) {
                 return len();
@@ -112,21 +112,21 @@ class String {
         // returns true on success, false on failure (in which case, the string
         // is left unchanged).  if the argument is null or invalid, the
         // concatenation is considered unsuccessful.
-        unsigned char concat(const String &str);
-        unsigned char concat(const char *cstr);
-        unsigned char concat(const char *cstr, unsigned int length);
-        unsigned char concat(const uint8_t *cstr, unsigned int length) {return concat((const char*)cstr, length);}
-        unsigned char concat(char c);
-        unsigned char concat(unsigned char c);
-        unsigned char concat(int num);
-        unsigned char concat(unsigned int num);
-        unsigned char concat(long num);
-        unsigned char concat(unsigned long num);
-        unsigned char concat(float num);
-        unsigned char concat(double num);
-        unsigned char concat(long long num);
-        unsigned char concat(unsigned long long num);
-        unsigned char concat(const __FlashStringHelper * str);
+        bool concat(const String &str);
+        bool concat(const char *cstr);
+        bool concat(const char *cstr, unsigned int length);
+        bool concat(const uint8_t *cstr, unsigned int length) {return concat((const char*)cstr, length);}
+        bool concat(char c);
+        bool concat(unsigned char c);
+        bool concat(int num);
+        bool concat(unsigned int num);
+        bool concat(long num);
+        bool concat(unsigned long num);
+        bool concat(float num);
+        bool concat(double num);
+        bool concat(long long num);
+        bool concat(unsigned long long num);
+        bool concat(const __FlashStringHelper * str);
 
         // if there's not enough memory for the concatenated value, the string
         // will be left unchanged (but this isn't signalled in any way)
@@ -202,39 +202,39 @@ class String {
             return buffer() ? &String::StringIfHelper : 0;
         }
         int compareTo(const String &s) const;
-        unsigned char equals(const String &s) const;
-        unsigned char equals(const char *cstr) const;
-        unsigned char operator ==(const String &rhs) const {
+        bool equals(const String &s) const;
+        bool equals(const char *cstr) const;
+        bool operator ==(const String &rhs) const {
             return equals(rhs);
         }
-        unsigned char operator ==(const char *cstr) const {
+        bool operator ==(const char *cstr) const {
             return equals(cstr);
         }
-        unsigned char operator !=(const String &rhs) const {
+        bool operator !=(const String &rhs) const {
             return !equals(rhs);
         }
-        unsigned char operator !=(const char *cstr) const {
+        bool operator !=(const char *cstr) const {
             return !equals(cstr);
         }
-        unsigned char operator <(const String &rhs) const;
-        unsigned char operator >(const String &rhs) const;
-        unsigned char operator <=(const String &rhs) const;
-        unsigned char operator >=(const String &rhs) const;
-        unsigned char equalsIgnoreCase(const String &s) const;
+        bool operator <(const String &rhs) const;
+        bool operator >(const String &rhs) const;
+        bool operator <=(const String &rhs) const;
+        bool operator >=(const String &rhs) const;
+        bool equalsIgnoreCase(const String &s) const;
         unsigned char equalsConstantTime(const String &s) const;
-        unsigned char startsWith(const String &prefix) const;
-        unsigned char startsWith(const char *prefix) const {
+        bool startsWith(const String &prefix) const;
+        bool startsWith(const char *prefix) const {
             return this->startsWith(String(prefix));
         }
-        unsigned char startsWith(const __FlashStringHelper *prefix) const {
+        bool startsWith(const __FlashStringHelper *prefix) const {
             return this->startsWith(String(prefix));
         }
-        unsigned char startsWith(const String &prefix, unsigned int offset) const;
-        unsigned char endsWith(const String &suffix) const;
-        unsigned char endsWith(const char *suffix) const {
+        bool startsWith(const String &prefix, unsigned int offset) const;
+        bool endsWith(const String &suffix) const;
+        bool endsWith(const char *suffix) const {
             return this->endsWith(String(suffix));
         }
-        unsigned char endsWith(const __FlashStringHelper * suffix) const {
+        bool endsWith(const __FlashStringHelper * suffix) const {
             return this->endsWith(String(suffix));
         }
 
@@ -345,7 +345,7 @@ class String {
     protected:
         void init(void);
         void invalidate(void);
-        unsigned char changeBuffer(unsigned int maxStrLen);
+        bool changeBuffer(unsigned int maxStrLen);
 
         // copy and move
         String & copy(const char *cstr, unsigned int length);