Add base64_decode

src/numberparsing.h

@@ -62,19 +62,19 @@ template<> inline tl::expected<uint32_t, std::string> fromString<uint32_t>(std::
 }
 
 #ifdef ESP_PLATFORM
-template<> inline tl::expected<int, std::string> fromString<int>(std::string_view str)
+template<> inline tl::expected<long, std::string> fromString<long>(std::string_view str)
 {
-    int val;
-    if (std::sscanf(str.data(), "%" SCNi32, &val) != 1)
-        return tl::make_unexpected(fmt::format("invalid int {}", str));
+    long val;
+    if (std::sscanf(str.data(), "%li", &val) != 1)
+        return tl::make_unexpected(fmt::format("invalid long {}", str));
     return val;
 }
 
-template<> inline tl::expected<unsigned int, std::string> fromString<unsigned int>(std::string_view str)
+template<> inline tl::expected<unsigned long, std::string> fromString<unsigned long>(std::string_view str)
 {
-    unsigned int val;
-    if (std::sscanf(str.data(), "%" SCNu32, &val) != 1)
-        return tl::make_unexpected(fmt::format("invalid unsigned int {}", str));
+    unsigned long val;
+    if (std::sscanf(str.data(), "%lu", &val) != 1)
+        return tl::make_unexpected(fmt::format("invalid unsigned long {}", str));
     return val;
 }
 #endif

src/refwhenneeded.h

@@ -13,10 +13,10 @@ template<> struct RefWhenNeeded<int16_t>                      { using T = int16_
 template<> struct RefWhenNeeded<uint16_t>                     { using T = uint16_t;                     RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<int32_t>                      { using T = int32_t;                      RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<uint32_t>                     { using T = uint32_t;                     RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
-template<> struct RefWhenNeeded<int>                          { using T = int;                          RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
-template<> struct RefWhenNeeded<unsigned int>                 { using T = unsigned int;                 RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<int64_t>                      { using T = int64_t;                      RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<uint64_t>                     { using T = uint64_t;                     RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
+template<> struct RefWhenNeeded<long>                         { using T = long;                         RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
+template<> struct RefWhenNeeded<unsigned long>                { using T = unsigned long;                RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<float>                        { using T = float;                        RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<double>                       { using T = double;                       RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<std::optional<bool>>          { using T = std::optional<bool>;          RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
@@ -26,10 +26,10 @@ template<> struct RefWhenNeeded<std::optional<int16_t>>       { using T = std::o
 template<> struct RefWhenNeeded<std::optional<uint16_t>>      { using T = std::optional<uint16_t>;      RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<std::optional<int32_t>>       { using T = std::optional<int32_t>;       RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<std::optional<uint32_t>>      { using T = std::optional<uint32_t>;      RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
-template<> struct RefWhenNeeded<std::optional<int>>           { using T = std::optional<int>;           RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
-template<> struct RefWhenNeeded<std::optional<unsigned int>>  { using T = std::optional<unsigned int>;  RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<std::optional<int64_t>>       { using T = std::optional<int64_t>;       RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<std::optional<uint64_t>>      { using T = std::optional<uint64_t>;      RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
+template<> struct RefWhenNeeded<std::optional<long>>          { using T = std::optional<long>;          RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
+template<> struct RefWhenNeeded<std::optional<unsigned long>> { using T = std::optional<unsigned long>; RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<std::optional<float>>         { using T = std::optional<float>;         RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 template<> struct RefWhenNeeded<std::optional<double>>        { using T = std::optional<double>;        RefWhenNeeded() = delete; ~RefWhenNeeded() = delete; };
 

src/strutils.cpp

@@ -107,6 +107,58 @@ std::string toBase64String(std::basic_string_view<unsigned char> buf)
     return out;
 }
 
+namespace {
+constexpr std::string_view base64_chars =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz"
+        "0123456789+/";
+bool is_base64(char c) {
+  return (isalnum(c) || (c == '+') || (c == '/'));
+}
+}
+
+std::string base64_decode(std::string const& encoded_string)
+{
+  int in_len = encoded_string.size();
+  int i = 0;
+  int j = 0;
+  int in_ = 0;
+  char char_array_4[4], char_array_3[3];
+  std::string ret;
+
+  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
+    char_array_4[i++] = encoded_string[in_]; in_++;
+    if (i ==4) {
+      for (i = 0; i <4; i++)
+        char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+        char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+        for (i = 0; (i < 3); i++)
+            ret.push_back(char_array_3[i]);
+        i = 0;
+      }
+    }
+
+    if (i) {
+      for (j = i; j <4; j++)
+        char_array_4[j] = 0;
+
+      for (j = 0; j <4; j++)
+        char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+      for (j = 0; (j < i - 1); j++) ret.push_back(char_array_3[j]);
+    }
+
+    return ret;
+  }
+
 bool stringEqualsIgnoreCase(std::string_view a, std::string_view b)
 {
     if (a.size() != b.size())
@@ -118,6 +170,19 @@ bool stringEqualsIgnoreCase(std::string_view a, std::string_view b)
                       });
 }
 
+bool stringStartsWith(std::string_view fullString, std::string_view begin)
+{
+    return fullString.rfind(begin, 0) == 0;
+}
+
+bool stringEndsWith(std::string_view fullString, std::string_view ending)
+{
+    if (fullString.length() < ending.length())
+        return false;
+
+    return fullString.compare(fullString.length() - ending.length(), ending.length(), ending) == 0;
+}
+
 //void stringReplaceAll(char search, char replace, std::string &subject)
 //{
 //    size_t start_pos{};

src/strutils.h

@@ -50,7 +50,11 @@ inline std::string toBase64String(std::string_view str)
     return toBase64String(std::basic_string_view<unsigned char>{reinterpret_cast<const unsigned char *>(str.data()), str.size()});
 }
 
+std::string base64_decode(std::string const& encoded_string);
+
 bool stringEqualsIgnoreCase(std::string_view a, std::string_view b);
+bool stringStartsWith(std::string_view fullString, std::string_view begin);
+bool stringEndsWith(std::string_view fullString, std::string_view ending);
 
 //void stringReplaceAll(char search, char replace, std::string &subject);
 void stringReplaceAll(char search, std::string_view replace, std::string &subject);