Új hozzászólás Aktív témák

• #21768 weiss addikt Wolfram #21767

  Új Válasz 2024-01-12 18:33:32 #21768

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  weiss

  addikt

  válasz Wolfram #21767 üzenetére

  chatgpt mire van? Mondjuk nem teszteltem.

  #ifndef BASE_64_HPP
#define BASE_64_HPP

#include <algorithm>
#include <cstdint>
#include <stdexcept>
#include <string>

namespace base64 {

const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";

template <class OutputBuffer, class InputIterator>
inline OutputBuffer encode_into(InputIterator begin, InputIterator end) {
static_assert(std::is_same<typename std::decay<decltype(*begin)>::type, char>::value
|| std::is_same<typename std::decay<decltype(*begin)>::type, unsigned char>::value
|| std::is_same<typename std::decay<decltype(*begin)>::type, uint8_t>::value);

size_t counter = 0;
uint32_t bit_stream = 0;
size_t offset = 0;
OutputBuffer encoded;
encoded.reserve(static_cast<size_t>(1.5 * static_cast<double>(std::distance(begin, end))));
while (begin != end) {
auto const num_val = static_cast<uint8_t>(*begin);
offset = 16 - counter % 3 * 8;
bit_stream += num_val << offset;
if (offset == 16) {
encoded.push_back(base64_chars[bit_stream >> 18 & 0x3f]);
}
if (offset == 8) {
encoded.push_back(base64_chars[bit_stream >> 12 & 0x3f]);
}
if (offset == 0 && counter != 3) {
encoded.push_back(base64_chars[bit_stream >> 6 & 0x3f]);
encoded.push_back(base64_chars[bit_stream & 0x3f]);
bit_stream = 0;
}
++counter;
++begin;
}
if (offset == 16) {
encoded.push_back(base64_chars[bit_stream >> 12 & 0x3f]);
encoded.push_back('=');
encoded.push_back('=');
}
if (offset == 8) {
encoded.push_back(base64_chars[bit_stream >> 6 & 0x3f]);
encoded.push_back('=');
}
return encoded;
}

inline std::string to_base64(const std::string& data) {
return encode_into<std::string>(data.begin(), data.end());
}

template <class OutputBuffer>
inline OutputBuffer decode_into(const std::string& data) {
using value_type = typename OutputBuffer::value_type;
static_assert(std::is_same<value_type, char>::value
|| std::is_same<value_type, unsigned char>::value
|| std::is_same<value_type, uint8_t>::value);

size_t counter = 0;
uint32_t bit_stream = 0;
OutputBuffer decoded;
decoded.reserve(data.size());
for (unsigned char c : data) {
auto const num_val = base64_chars.find(c);
if (num_val != std::string::npos) {
auto const offset = 18 - counter % 4 * 6;
bit_stream += static_cast<uint32_t>(num_val) << offset;
if (offset == 12) {
decoded.push_back(static_cast<value_type>(bit_stream >> 16 & 0xff));
}
if (offset == 6) {
decoded.push_back(static_cast<value_type>(bit_stream >> 8 & 0xff));
}
if (offset == 0 && counter != 4) {
decoded.push_back(static_cast<value_type>(bit_stream & 0xff));
bit_stream = 0;
}
} else if (c != '=') {
throw std::runtime_error("Invalid base64 encoded data");
}
counter++;
}
return decoded;
}

inline std::string from_base64(const std::string& data) {
return decode_into<std::string>(data);
}

} // namespace base64



#endif // BASE_64_HPP

Új hozzászólás Aktív témák