feat(docs): base64.hpp

include/basen/base64.hpp

@@ -13,12 +13,23 @@ namespace base64
     bool isValid(const char *str, uint64_t str_size) noexcept;
     bool isValid(std::string_view str) noexcept;
 
+    /**
+     * @throw std::overflow_error if if there is an overflow
+     */
     uint64_t sizeEncoded(std::span<const uint8_t> data);
     uint64_t sizeDecoded(std::string_view str) noexcept;
 
+    /**
+     * @throw std::length_error if not enough allocated length
+     */
     void encode(const uint8_t *data, uint64_t data_size, char *str, uint64_t str_size);
     std::string encode(std::span<const uint8_t> data) noexcept;
 
+    /**
+     * @throw std::length_error if not enough allocated length
+     * @throw std::logic_error if out of digits map
+     * @throw std::logic_error if incorrect padding
+     */
     void decode(const char *str, uint64_t str_size, uint8_t *data, uint64_t data_size);
     std::vector<uint8_t> decode(std::string_view str) noexcept;
 }

include/basen/baseN.hpp

@@ -32,6 +32,7 @@ namespace baseN
      * @param base from 1 to 255
      * @param digits char[base] array of digits
      * @return estimated size after decoding
+     * @throw std::overflow_error if if there is an overflow
      */
     uint64_t sizeDecoded(std::string_view str, uint8_t base, const char *digits) noexcept;
 

src/base64.cpp

@@ -64,7 +64,7 @@ namespace base64
     {
         if (str_size < base64::sizeEncoded(std::span<const uint8_t>(data, data_size)))
         {
-            throw std::logic_error("base64::encode: not enough allocated length");
+            throw std::length_error("base64::encode: not enough allocated length");
         }
         for (uint64_t i = 0; i < data_size / 3; i++)
         {
@@ -106,7 +106,7 @@ namespace base64
         std::string_view sv(str, str_size);
         if (data_size < base64::sizeDecoded(sv))
         {
-            throw std::logic_error("base64::decode: not enough allocated length");
+            throw std::length_error("base64::decode: not enough allocated length");
         }
         if (!base64::isValid(sv))
         {

src/hex.cpp

@@ -50,7 +50,7 @@ namespace hex
     {
         if (str_size < hex::sizeEncoded(std::span<const uint8_t>(data, data_size)))
         {
-            throw std::logic_error("hex::encode: not enough allocated length");
+            throw std::length_error("hex::encode: not enough allocated length");
         }
         for (uint64_t i = 0; i < data_size; i++)
         {
@@ -72,7 +72,7 @@ namespace hex
         }
         if (data_size < hex::sizeDecoded(std::string_view(str, str_size)))
         {
-            throw std::logic_error("hex::decode: not enough allocated length");
+            throw std::length_error("hex::decode: not enough allocated length");
         }
         if (!hex::isValid(str, str_size))
         {