base.hpp

浏览该文件的文档.

// Distributed under the MIT License that can be found in the LICENSE file.
// https://github.com/kotucode/base
//
// Author: Keunlas <keunlaz at gmail dot com>
 
#ifndef KEUNLAS_KOTUCODE_BASE_H_
#define KEUNLAS_KOTUCODE_BASE_H_
 
#include <algorithm>
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
namespace kotucode {
namespace base {
 
namespace alphabet {

struct base62 {
  static const std::array<char, 62>& data() noexcept {
    static constexpr std::array<char, 62> data{
        {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
         'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
         'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c',
         'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
         'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'}};
    return data;
  }
  static const std::array<int8_t, 256>& rdata() noexcept {
    static constexpr std::array<int8_t, 256> rdata{
        {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,
         6,  7,  8,  9,  -1, -1, -1, -1, -1, -1, -1, 10, 11, 12, 13, 14, 15, 16,
         17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
         35, -1, -1, -1, -1, -1, -1, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
         47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1}};
    return rdata;
  }
};

struct base64 {
  static const std::array<char, 64>& data() {
    static constexpr std::array<char, 64> data{
        {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
         'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
         'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'}};
    return data;
  }
  static const std::array<int8_t, 256>& rdata() {
    static constexpr std::array<int8_t, 256> rdata{
        {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57,
         58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,
         7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
         25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
         37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1}};
    return rdata;
  }
  static const std::string& fill() {
    static const std::string fill{"="};
    return fill;
  }
};

struct base64url {
  static const std::array<char, 64>& data() {
    static constexpr std::array<char, 64> data{
        {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
         'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
         'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'}};
    return data;
  }
  static const std::array<int8_t, 256>& rdata() {
    static constexpr std::array<int8_t, 256> rdata{
        {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 52, 53, 54, 55, 56, 57,
         58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0,  1,  2,  3,  4,  5,  6,
         7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
         25, -1, -1, -1, -1, 63, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
         37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1}};
    return rdata;
  }
  static const std::string& fill() {
    static const std::string fill{"%3d"};
    return fill;
  }
};
 
}  // namespace alphabet
 
namespace base62 {
 
namespace details {
 
inline std::string encode(const std::string& binary_data,
                          const std::array<char, 62>& alphabet) {
  if (binary_data.empty()) return "";
 
  // 统计输入中的前导零字节（0x00）个数
  std::size_t zeros = 0;
  while (zeros < binary_data.size() && binary_data[zeros] == 0) {
    zeros += 1;
  }
 
  // 全零输入直接返回对应数量的 alphabet[0] 字符
  if (zeros == binary_data.size()) {
    return std::string(zeros, alphabet[0]);
  }
 
  // 将剩余字节复制到大整数向量（big-endian 表示，索引 0 为最高字节）
  std::vector<uint8_t> bignum;
  bignum.reserve(binary_data.size() - zeros);
  for (auto i = zeros; i < binary_data.size(); ++i) {
    bignum.push_back(static_cast<uint8_t>(binary_data[i]));
  }
 
  // 临时存放逆序的编码字符（低位在前）
  std::string tmp;
  tmp.reserve(binary_data.size() * 2);
 
  // 反复执行“大整数 / 62”操作，直到商为 0
  while (!bignum.empty()) {
    int carry = 0;
    // 从高位到低位处理每个字节
    for (std::size_t i = 0; i < bignum.size(); ++i) {
      int value = (carry << 8) + bignum[i];
      bignum[i] = static_cast<uint8_t>(value / 62);
      carry = value % 62;
    }
    // 移除商的前导零，保持规范化
    std::size_t first_nonzero = 0;
    while (first_nonzero < bignum.size() && bignum[first_nonzero] == 0) {
      ++first_nonzero;
    }
    if (first_nonzero == bignum.size()) {
      bignum.clear();
    } else if (first_nonzero > 0) {
      bignum.erase(bignum.begin(), bignum.begin() + first_nonzero);
    }
    // carry 即为本次除法的余数，对应一个 base 字符
    tmp.push_back(alphabet[carry]);
  }
 
  // 组合最终结果：前导“0”字符 + 反转后的 tmp
  std::string result;
  result.reserve(zeros + tmp.size());
  result.append(zeros, alphabet[0]);
  result.append(tmp.rbegin(), tmp.rend());
 
  return result;
}
 
inline std::string decode(const std::string& base_string,
                          const std::array<int8_t, 256>& rdata) {
  if (base_string.empty()) return "";
 
  // 找到 alphabet[0] 对应的字符（用于前导零处理）
  char zero_char = 0;
  bool found_zero = false;
  for (int i = 0; i < 256; ++i) {
    if (rdata[i] == 0) {
      zero_char = static_cast<char>(i);
      found_zero = true;
      break;
    }
  }
  if (!found_zero) {
    zero_char = '0';  // 安全回退（Base62 中 '0' 即为 0 值字符）
  }
 
  // 统计输入字符串前导“零字符”的个数
  std::size_t zeros = 0;
  while (zeros < base_string.size() && base_string[zeros] == zero_char) {
    ++zeros;
  }
 
  // 初始化大整数（little-endian）
  std::vector<uint8_t> bignum(1, 0);
 
  // 遍历剩余字符，进行 bignum = bignum * base + digit
  for (std::size_t i = zeros; i < base_string.size(); ++i) {
    auto c = static_cast<uint8_t>(base_string[i]);
    auto digit = static_cast<int>(rdata[c]);
    if (digit < 0) {
      return "";  // 包含非法字符，直接返回空表示失败
    }
 
    // --- 乘法：bignum *= base ---
    int carry = 0;
    // 从低位（末尾）向高位（开头）处理
    for (auto&& term : bignum) {
      int product = static_cast<int>(term) * 62 + carry;
      term = static_cast<uint8_t>(product % 256);
      carry = product / 256;
    }
    // 处理乘法产生的额外进位
    while (carry > 0) {
      bignum.push_back(static_cast<uint8_t>(carry % 256));
      carry >>= 8;
    }
 
    // --- 加法：bignum += digit ---
    if (digit > 0) {
      int add_carry = digit;
      for (auto&& term : bignum) {
        int sum = static_cast<int>(term) + add_carry;
        term = static_cast<uint8_t>(sum % 256);
        add_carry = sum >> 8;
      }
      while (add_carry > 0) {
        bignum.push_back(static_cast<uint8_t>(add_carry % 256));
        add_carry >>= 8;
      }
    }
  }
 
  // 移除大整数前导零
  while (!bignum.empty() && bignum.back() == 0) {
    bignum.pop_back();
  }
 
  // 构造最终二进制结果：zeros 个 0x00 + bignum 字节序列
  std::string result;
  result.reserve(zeros + bignum.size());
  result.append(zeros, '\0');
  for (auto it = bignum.rbegin(); it != bignum.rend(); ++it) {
    result.push_back(static_cast<char>(*it));
  }
 
  return result;
}
 
}  // namespace details

template <typename Alphabets = alphabet::base62>
std::string encode(const std::string& binary_data) {
  return details::encode(binary_data, Alphabets::data());
}

template <typename Alphabets = alphabet::base62>
std::string decode(const std::string& base_string) {
  return details::decode(base_string, Alphabets::rdata());
}
 
}  // namespace base62
 
namespace base64 {
 
namespace details {
 
inline std::string encode(const std::string& binary_data,
                          const std::array<char, 64>& alphabet,
                          const std::string& fill) {
  if (binary_data.empty()) return "";
 
  std::string result;
  result.reserve(((binary_data.size() + 2) / 3) * 4);
 
  auto iter = binary_data.begin();
  for (; binary_data.end() - iter >= 3; iter += 3) {
    auto index1 = ((*iter) & 0xfc) >> 2;
    auto index2 = (((*iter) & 0x03) << 4) + (((*(iter + 1)) & 0xf0) >> 4);
    auto index3 = (((*(iter + 1)) & 0x0f) << 2) + (((*(iter + 2)) & 0xc0) >> 6);
    auto index4 = ((*(iter + 2)) & 0x3f);
    result.push_back(alphabet.at(index1));
    result.push_back(alphabet.at(index2));
    result.push_back(alphabet.at(index3));
    result.push_back(alphabet.at(index4));
  }
 
  if (auto remains = binary_data.end() - iter; remains == 1) {
    auto index1 = ((*iter) & 0xfc) >> 2;
    auto index2 = (((*iter) & 0x03) << 4);
    result.push_back(alphabet.at(index1));
    result.push_back(alphabet.at(index2));
    result.append(fill);
    result.append(fill);
  } else if (remains == 2) {
    auto index1 = ((*iter) & 0xfc) >> 2;
    auto index2 = (((*iter) & 0x03) << 4) + (((*(iter + 1)) & 0xf0) >> 4);
    auto index3 = (((*(iter + 1)) & 0x0f) << 2);
    result.push_back(alphabet.at(index1));
    result.push_back(alphabet.at(index2));
    result.push_back(alphabet.at(index3));
    result.append(fill);
  }
 
  return result;
}
 
inline std::string decode(const std::string& base_string,
                          const std::array<int8_t, 256>& rdata,
                          const std::string& fill) {
  if (base_string.empty()) return "";
 
  std::string result;
  result.reserve(((base_string.size() + 3) / 4) * 3);
 
  auto iter = base_string.begin();
  for (; base_string.end() - iter > 4; iter += 4) {
    auto index1 = rdata.at(*iter);
    auto index2 = rdata.at(*(iter + 1));
    auto index3 = rdata.at(*(iter + 2));
    auto index4 = rdata.at(*(iter + 3));
 
    if (index1 < 0 || index2 < 0 || index3 < 0 || index4 < 0) {
      return "";
    }
 
    auto char1 = ((index1 & 0x3f) << 2) | ((index2 & 0x30) >> 4);
    auto char2 = ((index2 & 0x0f) << 4) | ((index3 & 0x3c) >> 2);
    auto char3 = ((index3 & 0x03) << 6) | (index4 & 0x3f);
 
    result.push_back(static_cast<char>(char1));
    result.push_back(static_cast<char>(char2));
    result.push_back(static_cast<char>(char3));
  }
 
  if (iter == base_string.end()) {
    return result;
  }
 
  size_t paddings = 0;
  auto pad_pos = base_string.find(fill);
  if (pad_pos != std::string_view::npos) {
    paddings = base_string.size() - pad_pos;
  }
 
  size_t remains = 0;
  if (paddings == 0) {
    remains = base_string.end() - iter;
  } else {
    remains = 4 - paddings;
  }
 
  if (remains > 1) {
    auto char1 =
        ((rdata.at(*iter) & 0x3f) << 2) | ((rdata.at(*(iter + 1)) & 0x30) >> 4);
    result.push_back(static_cast<char>(char1));
  }
 
  if (remains > 2) {
    auto char2 = ((rdata.at(*(iter + 1)) & 0x0f) << 4) |
                 ((rdata.at(*(iter + 2)) & 0x3c) >> 2);
    result.push_back(static_cast<char>(char2));
  }
 
  if (remains > 3) {
    auto char3 =
        ((rdata.at(*(iter + 2)) & 0x03) << 6) | (rdata.at(*(iter + 3)) & 0x3f);
    result.push_back(static_cast<char>(char3));
  }
 
  return result;
}
 
inline std::string pad(const std::string& base_string,
                       const std::string& fill) {
  std::string padding;
  for (std::size_t i = 0; i < base_string.size() % 4; ++i) {
    padding += fill;
  }
  return base_string + padding;
}
 
inline std::string trim(const std::string& base_string,
                        const std::string& fill) {
  auto pos = base_string.find(fill);
  return base_string.substr(0, pos);
}
 
}  // namespace details

template <typename Alphabets = alphabet::base64>
std::string encode(const std::string& binary_data) {
  return details::encode(binary_data, Alphabets::data(), Alphabets::fill());
}

template <typename Alphabets = alphabet::base64>
std::string decode(const std::string& base_string) {
  return details::decode(base_string, Alphabets::rdata(), Alphabets::fill());
}

template <typename Alphabets = alphabet::base64>
std::string pad(const std::string& base_string) {
  return details::pad(base_string, Alphabets::fill());
}

template <typename Alphabets = alphabet::base64>
std::string trim(const std::string& base_string) {
  return details::trim(base_string, Alphabets::fill());
}
 
}  // namespace base64
 
}  // namespace base
}  // namespace kotucode
 
#endif  // !KEUNLAS_KOTUCODE_BASE_H_