Method decode

native/cpp/CommonCpp/Tools/Base64.cpp:118–155

}

std::vector<uint8_t> Base64::decode(const std::string_view base64String) {
  if (base64String.size() == 0) {
    return std::vector<uint8_t>{};
  }
  if (!is_valid_base64_str(base64String)) {
    throw std::runtime_error{"Invalid base64 string"};
  }

  const auto unpadded = base64String.substr(0, base64String.find_first_of('='));
  const auto full_quads = unpadded.size() / 4;

  // 4 base64 characters encode 3 bytes
  std::vector<uint8_t> decoded_bytes;
  decoded_bytes.reserve((full_quads + 1) * 3);

  for (size_t i = 0; i < full_quads; i++) {
    const auto quad = unpadded.substr(i * 4, 4);
    const auto bytes = decode_quad(quad[0], quad[1], quad[2], quad[3]);
    std::copy(bytes.begin(), bytes.end(), back_inserter(decoded_bytes));
  }

  const auto last_quad = unpadded.substr(full_quads * 4);
  if (last_quad.size() == 0) {
    return decoded_bytes;
  }

  // handle padding
  if ((last_quad.size() == 2) || (last_quad[2] == '=')) {
    const auto bytes = decode_quad(last_quad[0], last_quad[1], 'A', 'A');
    decoded_bytes.push_back(bytes[0]);
  } else {
    const auto bytes =
        decode_quad(last_quad[0], last_quad[1], last_quad[2], 'A');
    std::copy_n(bytes.begin(), 2, back_inserter(decoded_bytes));
  }

  return decoded_bytes;
}

} // namespace comm