fix(baseN, hex, sha256): const string & -> string_view

include/base/baseN.hpp

@@ -1,19 +1,20 @@
 #pragma once
 
 #include <cstdint>
+#include <span>
 #include <string>
 #include <vector>
 
 namespace baseN
 {
     bool isValid(const char *str, const int8_t *map) noexcept;
-    bool isValid(const std::string &str, const int8_t *map) noexcept;
+    bool isValid(std::string_view str, const int8_t *map) noexcept;
 
     void encode(const uint8_t *data, uint64_t data_size, char *str, uint8_t base, const char *digits, uint64_t enc_size) noexcept;
-    std::string encode(const std::vector<uint8_t> &data, uint8_t base, const char *digits, uint64_t enc_size) noexcept;
+    std::string encode(std::span<const uint8_t> data, uint8_t base, const char *digits, uint64_t enc_size) noexcept;
-    std::string encode(const std::vector<uint8_t> &data, uint8_t base, const char *digits) noexcept;
+    std::string encode(std::span<const uint8_t> data, uint8_t base, const char *digits) noexcept;
 
     void decode(const char *str, uint8_t *data, uint64_t data_size, uint8_t base, const char *digits, const int8_t *map, uint64_t dec_size);
-    std::vector<uint8_t> decode(const std::string &str, uint8_t base, const char *digits, const int8_t *map, uint64_t dec_size);
+    std::vector<uint8_t> decode(std::string_view str, uint8_t base, const char *digits, const int8_t *map, uint64_t dec_size);
-    std::vector<uint8_t> decode(const std::string &str, 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);
 }

include/base/hash/sha256.hpp

@@ -1,11 +1,12 @@
 #pragma once
 
 #include <cstdint>
+#include <span>
 #include <vector>
 
 #define SHA256_DIGEST_LENGTH 32
 
 namespace hash {
 	void sha256(const uint8_t *data, uint64_t data_size, uint8_t *hash) noexcept;
-	std::vector<uint8_t> sha256(const std::vector<uint8_t> &data) noexcept;
+	std::vector<uint8_t> sha256(std::span<const uint8_t> data) noexcept;
 }

include/base/hex.hpp

@@ -1,15 +1,16 @@
 #pragma once
 
 #include <cstdint>
+#include <span>
 #include <string>
 #include <vector>
 
 namespace hex
 {
     bool isValid(const char *str) noexcept;
-    bool isValid(const std::string &str) noexcept;
+    bool isValid(std::string_view str) noexcept;
     void encode(const uint8_t *data, uint64_t data_size, char *str) noexcept;
-    std::string encode(const std::vector<uint8_t> &data) noexcept;
+    std::string encode(std::span<const uint8_t> data) noexcept;
     void decode(const char *str, uint8_t *data, uint64_t data_size);
-    std::vector<uint8_t> decode(const std::string &str);
+    std::vector<uint8_t> decode(std::string_view str);
 }

src/baseN.cpp

@@ -12,7 +12,7 @@ namespace baseN
         return std::all_of(sv.begin(), sv.end(), [map](char ch)
                            { return map[(int8_t)ch] != -1; });
     }
-    bool isValid(const std::string &str, const int8_t *map) noexcept
+    bool isValid(std::string_view str, const int8_t *map) noexcept
     {
         return baseN::isValid(str.data(), map);
     }
@@ -71,7 +71,7 @@ namespace baseN
         }
         std::copy(res_str, res_str + enc_size, str);
     }
-    std::string encode(const std::vector<uint8_t> &data, uint8_t base, const char *digits, uint64_t enc_size) noexcept
+    std::string encode(std::span<const uint8_t> data, uint8_t base, const char *digits, uint64_t enc_size) noexcept
     {
         std::string str(enc_size, ' ');
         baseN::encode(data.data(), data.size(), str.data(), base, digits, enc_size);
@@ -80,7 +80,7 @@ namespace baseN
                                    { return ch != ' '; }));
         return str;
     }
-    std::string encode(const std::vector<uint8_t> &data, uint8_t base, const char *digits) noexcept
+    std::string encode(std::span<const uint8_t> data, uint8_t base, const char *digits) noexcept
     {
         return baseN::encode(data, base, digits, data.size() * std::log(256) / std::log(base) + 1);
     }
@@ -122,7 +122,7 @@ namespace baseN
         }
         std::copy(res_data, res_data + std::min(dec_size, data_size), data);
     }
-    std::vector<uint8_t> decode(const std::string &str, uint8_t base, const char *digits, const int8_t *map, uint64_t dec_size)
+    std::vector<uint8_t> decode(std::string_view str, uint8_t base, const char *digits, const int8_t *map, uint64_t dec_size)
     {
         std::vector<uint8_t> data(dec_size);
         baseN::decode(str.data(), data.data(), data.size(), base, digits, map, dec_size);
@@ -131,7 +131,7 @@ namespace baseN
                                      { return byte != 0; }));
         return data;
     }
-    std::vector<uint8_t> decode(const std::string &str, 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)
     {
         return baseN::decode(str, base, digits, map, str.size() * std::log(base) / std::log(256) + 1);
     }

src/hash/sha256.cpp

@@ -170,7 +170,7 @@ namespace hash
 		sha256_update(&ctx, data, data_size);
 		sha256_final(&ctx, hash);
 	}
-	std::vector<uint8_t> sha256(const std::vector<uint8_t> &data) noexcept
+	std::vector<uint8_t> sha256(std::span<const uint8_t> data) noexcept
 	{
 		std::vector<uint8_t> hash(SHA256_DIGEST_LENGTH);
 		sha256(data.data(), data.size(), hash.data());

src/hex.cpp

@@ -1,4 +1,3 @@
-#include <span>
 #include <stdexcept>
 
 #include <base/baseN.hpp>
@@ -31,7 +30,7 @@ namespace hex
     {
         return baseN::isValid(str, hexmap);
     }
-    bool isValid(const std::string &str) noexcept
+    bool isValid(std::string_view str) noexcept
     {
         return baseN::isValid(str, hexmap);
     }
@@ -46,7 +45,7 @@ namespace hex
             str[i * 2 + 1] = hexdigits[dv[i] & 0x0F];
         }
     }
-    std::string encode(const std::vector<uint8_t> &data) noexcept
+    std::string encode(std::span<const uint8_t> data) noexcept
     {
         std::string str(data.size() * 2, ' ');
         hex::encode(data.data(), data.size(), str.data());
@@ -70,7 +69,7 @@ namespace hex
             data[i] = hexmap[(int8_t)sv[i * 2]] << 4 | hexmap[(int8_t)sv[i * 2 + 1]];
         }
     }
-    std::vector<uint8_t> decode(const std::string &str)
+    std::vector<uint8_t> decode(std::string_view str)
     {
         std::vector<uint8_t> data(str.size() / 2);
         hex::decode(str.data(), data.data(), data.size());