stable-diffusion.cpp-rest/include/utils.h

#ifndef UTILS_H
#define UTILS_H

#include <string>
#include <vector>
#include <algorithm>
#include <cstdint>
#include <sstream>
#include <iomanip>

namespace Utils {

/**
 * @brief Base64 encoding table
 */
static const char base64_chars[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz"
    "0123456789+/";

/**
 * @brief Encode binary data to base64
 *
 * @param data The binary data to encode
 * @return Base64 encoded string
 */
inline std::string base64Encode(const std::vector<uint8_t>& data) {
    std::string ret;
    int i = 0;
    int j = 0;
    uint8_t char_array_3[3];
    uint8_t char_array_4[4];
    size_t in_len = data.size();
    const uint8_t* bytes_to_encode = data.data();

    while (in_len--) {
        char_array_3[i++] = *(bytes_to_encode++);
        if (i == 3) {
            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
            char_array_4[3] = char_array_3[2] & 0x3f;

            for(i = 0; i < 4; i++)
                ret += base64_chars[char_array_4[i]];
            i = 0;
        }
    }

    if (i) {
        for(j = i; j < 3; j++)
            char_array_3[j] = '\0';

        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
        char_array_4[3] = char_array_3[2] & 0x3f;

        for (j = 0; j < i + 1; j++)
            ret += base64_chars[char_array_4[j]];

        while((i++ < 3))
            ret += '=';
    }

    return ret;
}

/**
 * @brief Check if a character is a base64 character
 *
 * @param c The character to check
 * @return true if the character is a base64 character, false otherwise
 */
inline bool isBase64(unsigned char c) {
    return (isalnum(c) || (c == '+') || (c == '/'));
}

/**
 * @brief Decode base64 string to binary data
 *
 * @param encoded_string The base64 encoded string
 * @return Decoded binary data
 */
inline std::vector<uint8_t> base64Decode(const std::string& encoded_string) {
    size_t in_len = encoded_string.size();
    size_t i = 0;
    size_t j = 0;
    int in_ = 0;
    uint8_t char_array_4[4], char_array_3[3];
    std::vector<uint8_t> ret;

    while (in_len-- && (encoded_string[in_] != '=') && isBase64(encoded_string[in_])) {
        char_array_4[i++] = encoded_string[in_]; in_++;
        if (i == 4) {
            for (i = 0; i < 4; i++) {
                size_t pos = std::string(base64_chars).find(char_array_4[i]);
                if (pos == std::string::npos) {
                    return {}; // Return empty vector on invalid character
                }
                char_array_4[i] = static_cast<uint8_t>(pos);
            }

            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

            for (i = 0; i < 3; i++)
                ret.push_back(char_array_3[i]);
            i = 0;
        }
    }

    if (i) {
        for (j = 0; j < i; j++) {
            size_t pos = std::string(base64_chars).find(char_array_4[j]);
            if (pos == std::string::npos) {
                return {}; // Return empty vector on invalid character
            }
            char_array_4[j] = static_cast<uint8_t>(pos);
        }

        char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
        char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);

        for (j = 0; j < i - 1; j++)
            ret.push_back(char_array_3[j]);
    }

    return ret;
}

/**
 * @brief Check if a string ends with a given suffix
 *
 * @param str The string to check
 * @param suffix The suffix to look for
 * @return true if str ends with suffix, false otherwise
 */
inline bool endsWith(const std::string& str, const std::string& suffix) {
    return str.size() >= suffix.size() &&
           str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
}

/**
 * @brief Check if a string starts with a given prefix
 *
 * @param str The string to check
 * @param prefix The prefix to look for
 * @return true if str starts with prefix, false otherwise
 */
inline bool startsWith(const std::string& str, const std::string& prefix) {
    return str.size() >= prefix.size() &&
           str.compare(0, prefix.size(), prefix) == 0;
}

/**
 * @brief Convert string to lowercase
 *
 * @param str The string to convert
 * @return Lowercase version of the string
 */
inline std::string toLower(const std::string& str) {
    std::string result = str;
    std::transform(result.begin(), result.end(), result.begin(), ::tolower);
    return result;
}

/**
 * @brief Convert string to uppercase
 *
 * @param str The string to convert
 * @return Uppercase version of the string
 */
inline std::string toUpper(const std::string& str) {
    std::string result = str;
    std::transform(result.begin(), result.end(), result.begin(), ::toupper);
    return result;
}

/**
 * @brief Trim whitespace from start of string
 *
 * @param str The string to trim
 * @return Trimmed string
 */
inline std::string trimLeft(const std::string& str) {
    size_t start = str.find_first_not_of(" \t\n\r\f\v");
    return (start == std::string::npos) ? "" : str.substr(start);
}

/**
 * @brief Trim whitespace from end of string
 *
 * @param str The string to trim
 * @return Trimmed string
 */
inline std::string trimRight(const std::string& str) {
    size_t end = str.find_last_not_of(" \t\n\r\f\v");
    return (end == std::string::npos) ? "" : str.substr(0, end + 1);
}

/**
 * @brief Trim whitespace from both ends of string
 *
 * @param str The string to trim
 * @return Trimmed string
 */
inline std::string trim(const std::string& str) {
    return trimLeft(trimRight(str));
}

/**
 * @brief Split a string by delimiter
 *
 * @param str The string to split
 * @param delimiter The delimiter character
 * @return Vector of string parts
 */
inline std::vector<std::string> split(const std::string& str, char delimiter) {
    std::vector<std::string> result;
    std::string current;

    for (char c : str) {
        if (c == delimiter) {
            if (!current.empty()) {
                result.push_back(current);
                current.clear();
            }
        } else {
            current += c;
        }
    }

    if (!current.empty()) {
        result.push_back(current);
    }

    return result;
}

/**
 * @brief Join strings with a delimiter
 *
 * @param parts The strings to join
 * @param delimiter The delimiter to use
 * @return Joined string
 */
inline std::string join(const std::vector<std::string>& parts, const std::string& delimiter) {
    if (parts.empty()) return "";

    std::string result = parts[0];
    for (size_t i = 1; i < parts.size(); i++) {
        result += delimiter + parts[i];
    }

    return result;
}

/**
 * @brief URL decode a string
 *
 * @param encoded The URL-encoded string
 * @return Decoded string
 */
inline std::string urlDecode(const std::string& encoded) {
    std::string decoded;
    for (size_t i = 0; i < encoded.length(); ++i) {
        if (encoded[i] == '%' && i + 2 < encoded.length()) {
            // Convert %XX to character
            int hexValue;
            std::istringstream hexStream(encoded.substr(i + 1, 2));
            if (hexStream >> std::hex >> hexValue) {
                decoded += static_cast<char>(hexValue);
                i += 2;
            } else {
                decoded += encoded[i];
            }
        } else if (encoded[i] == '+') {
            // Convert '+' to space
            decoded += ' ';
        } else {
            decoded += encoded[i];
        }
    }
    return decoded;
}

/**
 * @brief Check if file is an image based on extension
 *
 * @param filename The filename to check
 * @return true if file is an image, false otherwise
 */
inline bool isImageFile(const std::string& filename) {
    std::string lowerFilename = toLower(filename);
    return endsWith(lowerFilename, ".png") ||
           endsWith(lowerFilename, ".jpg") ||
           endsWith(lowerFilename, ".jpeg") ||
           endsWith(lowerFilename, ".gif") ||
           endsWith(lowerFilename, ".webp") ||
           endsWith(lowerFilename, ".bmp") ||
           endsWith(lowerFilename, ".tiff") ||
           endsWith(lowerFilename, ".tif");
}

} // namespace Utils

#endif // UTILS_H