upd

Author: GyverLibs

library.properties

@@ -1,5 +1,5 @@
 name=StringUtils
-version=1.4.30
+version=1.4.31
 author=AlexGyver <alex@alexgyver.ru>
 maintainer=AlexGyver <alex@alexgyver.ru>
 sentence=Bunch of converting functions for string data

src/utils/Text.h

@@ -2,10 +2,10 @@
 #include <Arduino.h>
 #include <limits.h>
 
-#include "convert/b64.h"
-#include "convert/convert.h"
-#include "convert/unicode.h"
-#include "convert/url.h"
+#include "./convert/b64.h"
+#include "./convert/convert.h"
+#include "./convert/unicode.h"
+#include "./convert/url.h"
 #include "hash.h"
 
 namespace su {

src/utils/Value.h

@@ -1,10 +1,10 @@
 #pragma once
 #include <Arduino.h>
 
+#include "./convert/convert.h"
 #include "Text.h"
-#include "convert/convert.h"
 
-// автоматическое преобразование любых данных к строке Text
+// автоматическое преобразование любых численных данных к строке Text
 
 #ifndef SU_ANYVALUE_BUF_LEN
 #define SU_ANYVALUE_BUF_LEN 21
@@ -18,78 +18,157 @@ class ValueT : public Text {
    public:
     using Text::Text;
 
-    ValueT() : Text() {}
+    ValueT() {
+        _str = buf;
+        _type = Type::value;
+    }
 
     ValueT(const Text& value) : Text(value) {}
 
-    ValueT(const bool value) {
+    ValueT(bool value) : ValueT() {
         buf[0] = value ? '1' : '0';
         buf[1] = 0;
         _len = 1;
-        _init();
     }
 
-    ValueT(const char value) {
+    ValueT(char value) : ValueT() {
         buf[0] = value;
         buf[1] = 0;
         _len = 1;
-        _init();
     }
-    ValueT(const unsigned char value, uint8_t base = DEC) {
+    ValueT(unsigned char value, uint8_t base = DEC) : ValueT() {
         _len = intToStr(value, buf, base);
-        _init();
     }
 
-    ValueT(const short value, uint8_t base = DEC) {
+    ValueT(short value, uint8_t base = DEC) : ValueT() {
         _len = intToStr(value, buf, base);
-        _init();
     }
-    ValueT(const unsigned short value, uint8_t base = DEC) {
+    ValueT(unsigned short value, uint8_t base = DEC) : ValueT() {
         _len = uintToStr(value, buf, base);
-        _init();
     }
 
-    ValueT(const int value, uint8_t base = DEC) {
+    ValueT(int value, uint8_t base = DEC) : ValueT() {
         _len = intToStr(value, buf, base);
-        _init();
     }
-    ValueT(const unsigned int value, uint8_t base = DEC) {
+    ValueT(unsigned int value, uint8_t base = DEC) : ValueT() {
         _len = uintToStr(value, buf, base);
-        _init();
     }
 
-    ValueT(const long value, uint8_t base = DEC) {
+    ValueT(long value, uint8_t base = DEC) : ValueT() {
         _len = intToStr(value, buf, base);
-        _init();
     }
-    ValueT(const unsigned long value, uint8_t base = DEC) {
+    ValueT(unsigned long value, uint8_t base = DEC) : ValueT() {
         _len = uintToStr(value, buf, base);
-        _init();
     }
 
-    ValueT(const long long value, uint8_t base = DEC) {
-        if (value >= 0 && value < UINT32_MAX) _len = uintToStr(value, buf, base);
-        else if (value < 0 && value > -INT32_MAX) _len = intToStr(value, buf, base);
-        else _len = int64ToStr(value, buf, base);
-        _init();
+    ValueT(long long value, uint8_t base = DEC) : ValueT() {
+        switch (value) {
+            case INT32_MIN ...(-1): _len = intToStr(value, buf, base); break;
+            case 0 ... UINT32_MAX: _len = uintToStr(value, buf, base); break;
+            default: _len = int64ToStr(value, buf, base); break;
+        }
     }
-    ValueT(const unsigned long long value, uint8_t base = DEC) {
-        _len = (value <= UINT32_MAX) ? uintToStr(value, buf, base) : uint64ToStr(value, buf, base);
-        _init();
+    ValueT(unsigned long long value, uint8_t base = DEC) : ValueT() {
+        switch (value) {
+            case 0 ... UINT32_MAX: _len = uintToStr(value, buf, base); break;
+            default: _len = uint64ToStr(value, buf, base); break;
+        }
     }
 
-    ValueT(const double value, uint8_t dec = 2) {
+    ValueT(double value, uint8_t dec = 2) : ValueT() {
         _len = floatToStr(value, buf, dec);
-        _init();
+    }
+
+    // assign
+    ValueT& operator=(bool value) {
+        buf[0] = value ? '1' : '0';
+        buf[1] = 0;
+        _len = 1;
+        return *this;
+    }
+
+    ValueT& operator=(char value) {
+        buf[0] = value;
+        buf[1] = 0;
+        _len = 1;
+        return *this;
+    }
+    ValueT& operator=(unsigned char value) {
+        _len = intToStr(value, buf, DEC);
+        return *this;
+    }
+
+    ValueT& operator=(short value) {
+        _len = intToStr(value, buf, DEC);
+        return *this;
+    }
+    ValueT& operator=(unsigned short value) {
+        _len = uintToStr(value, buf, DEC);
+        return *this;
+    }
+
+    ValueT& operator=(int value) {
+        _len = intToStr(value, buf, DEC);
+        return *this;
+    }
+    ValueT& operator=(unsigned int value) {
+        _len = uintToStr(value, buf, DEC);
+        return *this;
+    }
+
+    ValueT& operator=(long value) {
+        _len = intToStr(value, buf, DEC);
+        return *this;
+    }
+    ValueT& operator=(unsigned long value) {
+        _len = uintToStr(value, buf, DEC);
+        return *this;
+    }
+
+    ValueT& operator=(long long value) {
+        switch (value) {
+            case INT32_MIN ...(-1): _len = intToStr(value, buf, DEC); break;
+            case 0 ... UINT32_MAX: _len = uintToStr(value, buf, DEC); break;
+            default: _len = int64ToStr(value, buf, DEC); break;
+        }
+        return *this;
+    }
+    ValueT& operator=(unsigned long long value) {
+        switch (value) {
+            case 0 ... UINT32_MAX: _len = uintToStr(value, buf, DEC); break;
+            default: _len = uint64ToStr(value, buf, DEC); break;
+        }
+        return *this;
+    }
+
+    ValueT& operator=(double value) {
+        _len = floatToStr(value, buf, 2);
+        return *this;
+    }
+
+    // copy
+    ValueT(const ValueT& v) : ValueT() {
+        _copy(v);
+    }
+    ValueT(ValueT&& v) : ValueT() {
+        _copy(v);
+    }
+    ValueT& operator=(const ValueT& v) {
+        _copy(v);
+        return *this;
+    }
+    ValueT& operator=(ValueT&& v) {
+        _copy(v);
+        return *this;
     }
 
    protected:
     char buf[bufsize] = {0};
 
    private:
-    void _init() {
-        _str = buf;
-        _type = Type::value;
+    void _copy(const ValueT& v) {
+        memcpy(buf, v.buf, v._len);
+        _len = v._len;
     }
 };