fix(baseN): encode, decode now return uint8_t zero offset

include/base/baseN.hpp

@@ -13,9 +13,9 @@ namespace baseN
     uint64_t sizeEncoded(std::span<const uint8_t> data, uint8_t base);
     uint64_t sizeDecoded(std::string_view str, uint8_t base, const char* digits) noexcept;
 
-    void encode(const uint8_t *data, uint64_t data_size, char *str, uint64_t str_size, uint8_t base, const char *digits);
+    uint64_t encode(const uint8_t *data, uint64_t data_size, char *str, uint64_t str_size, uint8_t base, const char *digits);
     std::string encode(std::span<const uint8_t> data, uint8_t base, const char *digits) noexcept;
 
-    void decode(const char *str, uint64_t str_size, uint8_t *data, uint64_t data_size, uint8_t base, const char *digits, const int8_t *map);
+    uint64_t decode(const char *str, uint64_t str_size, uint8_t *data, uint64_t data_size, uint8_t base, const char *digits, const int8_t *map);
     std::vector<uint8_t> decode(std::string_view str, uint8_t base, const char *digits, const int8_t *map) noexcept;
 }

src/baseN.cpp

@@ -36,22 +36,20 @@ namespace baseN
                             str.end());
         return sv.size() * std::log(base) / log256 + 1 + (str.size() - sv.size());
     }
-    void encode(const uint8_t *data, uint64_t data_size, char *str, uint64_t str_size, uint8_t base, const char *digits)
+    uint64_t encode(const uint8_t *data, uint64_t data_size, char *str, uint64_t str_size, uint8_t base, const char *digits)
     {
         std::vector<uint8_t> dv(std::find_if(data, data + data_size, [](uint8_t item)
                                              { return item != 0; }),
                                 data + data_size);
-        if (dv.size() == 0)
-        {
-            return;
-        }
         std::span<char> sv(str, str_size);
         auto sv_it = sv.rbegin();
         auto dv_it = dv.begin();
         auto quo_it = dv.begin();
         auto quo_it_last = dv.end();
-        uint16_t div = *dv_it++;
 
+        if (dv.size() != 0)
+        {
+            uint16_t div = *dv_it++;
             while ((dv[0] > base || quo_it_last > dv.begin() + 1) && sv_it < sv.rend() - 1)
             {
                 if (div < base)
@@ -75,29 +73,25 @@ namespace baseN
                 div = *dv_it++;
             }
             *sv_it++ = digits[div];
+        }
         for (uint64_t i = 0; i < data_size - dv.size() && sv_it < sv.rend(); i++)
         {
             *sv_it++ = digits[0];
         }
+        return std::distance(sv_it, sv.rend());
     }
     std::string encode(std::span<const uint8_t> data, uint8_t base, const char *digits) noexcept
     {
         std::string str(baseN::sizeEncoded(data, base), ' ');
-        baseN::encode(data.data(), data.size(), str.data(), str.size(), base, digits);
+        uint64_t offset = baseN::encode(data.data(), data.size(), str.data(), str.size(), base, digits);
-        str.erase(str.begin(), std::find_if(
+        str.erase(str.begin(), str.begin() + offset);
-                                   str.begin(), str.end(), [](char ch)
-                                   { return ch != ' '; }));
         return str;
     }
-    void decode(const char *str, uint64_t str_size, uint8_t *data, uint64_t data_size, uint8_t base, const char *digits, const int8_t *map)
+    uint64_t decode(const char *str, uint64_t str_size, uint8_t *data, uint64_t data_size, uint8_t base, const char *digits, const int8_t *map)
     {
         std::string_view sv(std::find_if(str, str + str_size, [digits](char ch)
                                          { return ch != digits[0]; }),
-                            str_size);
+                            str + str_size);
-        if (sv.size() == 0)
-        {
-            return;
-        }
         if (!baseN::isValid(sv, map))
         {
             throw std::logic_error("baseN::decode: out of digits map");
@@ -108,6 +102,8 @@ namespace baseN
         auto quo_it_last = dv.rbegin() + 1;
         uint16_t div;
 
+        if (sv.size() != 0)
+        {
             *quo_it = map[(int8_t)*sv_it++];
             while (sv_it < sv.end())
             {
@@ -118,17 +114,25 @@ namespace baseN
                     *quo_it++ = div;
                     div >>= 8;
                 }
+                if (div != 0)
+                {
                     *quo_it++ = div;
+                }
                 quo_it_last = quo_it;
                 quo_it = dv.rbegin();
             }
         }
+        for (uint64_t i = 0; i < str_size - sv.size() && quo_it_last < dv.rend(); i++)
+        {
+            *quo_it_last++ = 0;
+        }
+        return std::distance(quo_it_last, dv.rend());
+    }
     std::vector<uint8_t> decode(std::string_view str, uint8_t base, const char *digits, const int8_t *map) noexcept
     {
         std::vector<uint8_t> data(baseN::sizeDecoded(str, base, digits));
-        baseN::decode(str.data(), str.size(), data.data(), data.size(), base, digits, map);
+        uint64_t offset = baseN::decode(str.data(), str.size(), data.data(), data.size(), base, digits, map);
-        data.erase(data.begin(), std::find_if(data.begin(), data.end(), [](uint8_t item)
+        data.erase(data.begin(), data.begin() + offset);
-                                              { return item != 0; }));
         return data;
     }
 }