ascii_converter.cpp

#include "ascii_converter.h"
#include <iomanip>
#include <bitset>
#include <regex>
#include <QDebug>

namespace perry {

/****************************** 工具函数 ****************************************/
#if 0
/* 判断一个单词是否是指定进制的字符串 */
static bool isBaseStr(const std::string& str, BaseEnum base)
{
    if (str.empty()) return false;

    bool(*judgeFunc)(char) = nullptr;
    switch (base) {
        case BaseEnum::DEC:
            judgeFunc = [](char c) -> bool { return std::isdigit(c); };
            break;
        case BaseEnum::HEX:
            judgeFunc = [](char c) -> bool { return std::isxdigit(c); };
            break;
        default:
            throw std::out_of_range("base must be DEC or HEX");
    }

    for (char c : str) {
        if (!judgeFunc(c)) {
            return false;
        }
    }
    return true;
}
#endif

/* 将一个 uint8_t 数字转换为指定进制的字符串 */
static std::string num2BaseStr(uint8_t num, BaseEnum base)
{
    std::ostringstream oss;
    switch (base) {
        case BaseEnum::DEC:
            oss << std::dec << static_cast<int>(num);
            break;
        case BaseEnum::HEX:
            oss << std::hex << std::setw(2) <<std::setfill('0')
                << static_cast<int>(num);
            break;
        case BaseEnum::BIN:
            oss << std::bitset<8>(num);
            break;
        default:
            throw std::out_of_range("base must be DEC, HEX or BIN");
    }
    return oss.str();
}

/* ASCII字符串 转 数字数组 */
static std::vector<uint8_t> asciiStr2Nums(const std::string& req)
{
    std::vector<uint8_t> res;
    for (char c : req) {
        res.push_back(static_cast<uint8_t>(c));
    }
    return res;
}

/* 数字数组 转 ASCII字符串 */
static std::string nums2AsciiStr(const std::vector<uint8_t>& nums)
{
    std::string res;
    for (const uint8_t& num : nums) {
        unsigned char ch = static_cast<unsigned char>(num);
        res.push_back(ch);
    }
    return res;
}

/* 数字数组 转 指定进制字符串 */
static std::string nums2BaseStr(std::vector<uint8_t>& req, BaseEnum base, bool hasPrefix)
{
    if ((base != BaseEnum::HEX) && (base != BaseEnum::DEC) && (base != BaseEnum::BIN)) {
        throw std::out_of_range("base must be DEC, HEX or BIN");
    }

    std::ostringstream oss;
    for (size_t i = 0; i < req.size(); ++i) {
        if (i != 0) {
            oss << " ";
        }
        if (base == BaseEnum::HEX && hasPrefix) {
            oss << "0x" << num2BaseStr(req[i], base);
        } else if (base == BaseEnum::BIN && hasPrefix) {
            oss << "0b" << num2BaseStr(req[i], base);
        } else {
            oss << num2BaseStr(req[i], base);
        }
    }
    return oss.str();
}

static bool checkHexStrValid(const std::string str)
{
    if (str.empty()) return true;

    // 匹配不带 0x 前缀的十六进制数，每个单词最多 2 个十六进制字符
    std::regex pattern1(R"(^\s*[0-9a-fA-F]{1,2}(\s+[0-9a-fA-F]{1,2})*\s*$)");
    // 匹配带 0x 前缀的十六进制数，每个单词最多 2 个十六进制字符
    std::regex pattern2(R"(^\s*0x[0-9a-fA-F]{1,2}(\s+0x[0-9a-fA-F]{1,2})*\s*$)");
    // 校验格式
    bool formatCorrect = std::regex_match(str, pattern1) || std::regex_match(str, pattern2);

    if (!formatCorrect) {
        return false;
    }

    return true;
}

static bool checkDecStrValid(const std::string str)
{
    if (str.empty()) return true;

    // 匹配以空格分隔的十进制数，每个数最多3位数字
    std::regex pattern(R"(^\s*\d{1,3}(\s+\d{1,3})*\s*$)");
    bool formatCorrect = std::regex_match(str, pattern);

    if (!formatCorrect) {
        return false;
    }

    // 使用字符串流逐个检查数字是否在0到255之间
    std::istringstream stream(str);
    std::string word;

    while (stream >> word) {
        int number = std::stoi(word);
        if (number < 0 || number > 255) {
            return false;
        }
    }

    return true;
}

static bool checkBinStrValid(const std::string str)
{
    if (str.empty()) return true;

    // 匹配不带 0b 前缀的二进制数，每个单词最多 8 个二进制字符
    std::regex pattern1(R"(^\s*[01]{1,8}(\s+[01]{1,8})*\s*$)");
    // 匹配带 0b 前缀的二进制数，每个单词最多 8 个二进制字符
    std::regex pattern2(R"(^\s*0b[01]{1,8}(\s+0b[01]{1,8})*\s*$)");
    // 校验格式
    bool formatCorrect = std::regex_match(str, pattern1) || std::regex_match(str, pattern2);

    if (!formatCorrect) {
        return false;
    }

    return true;
}

/****************************** AsciiConverter类的内容 ****************************************/

// 定义静态成员变量
AsciiConverter AsciiConverter::instance;

bool AsciiConverter::setStrByType(const std::string& str, BaseEnum base) {
    switch (base) {
        case BaseEnum::ASCII:
            asciiStr = str;
            nums = asciiStr2Nums(asciiStr);
            hexStr = nums2BaseStr(nums, BaseEnum::HEX, hasPrefix);
            decStr = nums2BaseStr(nums, BaseEnum::DEC, hasPrefix);
            binStr = nums2BaseStr(nums, BaseEnum::BIN, hasPrefix);
            break;
        case BaseEnum::HEX:
            if (!checkHexStrValid(str)) {
                return false;
            }
            hexStr = str;
            nums = baseStr2Nums(hexStr, BaseEnum::HEX);
            asciiStr = nums2AsciiStr(nums);
            decStr = nums2BaseStr(nums, BaseEnum::DEC, hasPrefix);
            binStr = nums2BaseStr(nums, BaseEnum::BIN, hasPrefix);
            break;
        case BaseEnum::DEC:
            if (!checkDecStrValid(str)) {
                return false;
            }
            decStr = str;
            nums = baseStr2Nums(decStr, BaseEnum::DEC);
            asciiStr = nums2AsciiStr(nums);
            hexStr = nums2BaseStr(nums, BaseEnum::HEX, hasPrefix);
            binStr = nums2BaseStr(nums, BaseEnum::BIN, hasPrefix);
            break;
        case BaseEnum::BIN:
            if (!checkBinStrValid(str)) {
                return false;
            }
            binStr = str;
            nums = baseStr2Nums(binStr, BaseEnum::BIN);
            asciiStr = nums2AsciiStr(nums);
            hexStr = nums2BaseStr(nums, BaseEnum::HEX, hasPrefix);
            decStr = nums2BaseStr(nums, BaseEnum::DEC, hasPrefix);
            break;
    }

    return true;
}

std::string AsciiConverter::getStrByType(BaseEnum base)
{
    switch (base) {
        case BaseEnum::ASCII:
            return asciiStr;
        case BaseEnum::HEX:
            return hexStr;
        case BaseEnum::DEC:
            return decStr;
        case BaseEnum::BIN:
            return binStr;
        case BaseEnum::OCT:
        default:
            return "";
    }
}

}