libproto_demo/CommonFunction.hpp

#pragma once
#include <megopp/endian/net.h>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#define NOMINMAX  // max()无法识别问题是由于与 Windows.h 头文件中的宏定义产生了冲突而导致的编译错误。
#include "ghc/filesystem.hpp"
#include <memepp/native.hpp>
#include <nlohmann/json.hpp>
#include <vector>

using json = nlohmann::json;

namespace fs = ghc::filesystem;

#define Debug_Print_Error(x)  cerr << "(Error in" << __FILE__ << ":" << __LINE__ << ",funtion" << __FUNCTION__ << ")-" << x<< endl;

#define Debug_Print_Info(x)  cerr << __FILE__ << ":" << __LINE__ << ",funtion" << __FUNCTION__ << ")-" << x<< endl;

static  std::string HexArrayToString(const uint8_t *hexArray,const size_t arrayLen)
{
    std::ostringstream oss;

    for (int i = 0;i < arrayLen;++i)
    {
        oss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(hexArray[i]) << " ";
    }

    std::string formattedHexString = oss.str();

    return formattedHexString;
}

template<typename _Ty>
inline void WriteDataToBufferWithNetworkByteOrder(_Ty data, uint8_t* buffer)
{
#if MEGO_ENDIAN__LITTLE_BYTE
    data = megopp::endian::byte_swap(data);
#elif MEGO_ENDIAN__BIG_BYTE
    // nothing
#else
#error "unknown endian"
#endif
    memcpy(buffer, &data, sizeof(data));
}

static bool directoryExists(const std::string& path) {
    return fs::exists(path) && fs::is_directory(path);
}

static uint64_t getNow() {
    const auto current_time = std::chrono::system_clock::now().time_since_epoch();
    auto now = std::chrono::duration_cast<std::chrono::milliseconds>(current_time).count();
    return now;
}

static std::string getRunDir() {
    fs::path currentPath = fs::current_path();
    return currentPath.string();
}

static memepp::native_string getAppDir(memepp::native_string& input) {

#if MG_OS__WIN_AVAIL
    size_t end = input.find(L"line_store");
#else
    size_t end = input.find("line_store");
#endif

    if (end != std::string::npos) {
        return input.substr(0, end);
    }
    else {
        return input;
    }
}

static json parseLog(const std::string& log) {
    json logJson;

    // 寻找方括号的位置
    size_t bracket1 = log.find('[');
    size_t bracket2 = log.find(']', bracket1 + 1);
    size_t bracket3 = log.find('[', bracket2 + 1);
    size_t bracket4 = log.find(']', bracket3 + 1);
    size_t bracket5 = log.find('[', bracket4 + 1);
    size_t bracket6 = log.find(']', bracket5 + 1);
    size_t bracket7 = log.find('[', bracket6 + 1);
    size_t bracket8 = log.find(']', bracket7 + 1);

    if (bracket1 != std::string::npos &&
        bracket2 != std::string::npos &&
        bracket3 != std::string::npos &&
        bracket4 != std::string::npos &&
        bracket5 != std::string::npos &&
        bracket6 != std::string::npos &&
        bracket7 != std::string::npos &&
        bracket8 != std::string::npos
        ) {

        // 提取时间、级别、服务名、消息
        std::string timestampStr = log.substr(bracket1 + 1, bracket2 - bracket1 - 1);
        std::string level = log.substr(bracket5 + 1, bracket6 - bracket5 - 1);
        std::string category = log.substr(bracket7 + 1, bracket8 - bracket7 - 1);
        std::string message = log.substr(bracket8 + 1);

        // 转换时间戳字符串为 int64
        std::tm tm = {};
        std::istringstream timestampStream(timestampStr);
        timestampStream >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");

        std::time_t timestamp = std::mktime(&tm);

        // 构建 JSON 结构
        logJson["ts"] = static_cast<int64_t>(timestamp)*1000;
        logJson["level"] = level;
        logJson["mainSrvName"] = "gateway";
        logJson["subSrvName"] = category;
        logJson["msg"] = message;

        return logJson;
    }

    // 如果解析失败，返回空的 JSON 对象
    return {};
}

static uint64_t get_timestamp_from_vec(const uint8_t* szData,const size_t size)
{
    uint64_t timestamp = 0;

    if (size > 30)
    {
        if (szData[0] == 0x00)
        {
            for (int i = 0; i < 8; i++) {
                timestamp = (timestamp << 8) + szData[5 + i];
            }
        }
        else if (szData[0] == 0x01)
        {
            for (int i = 0; i < 8; i++) {
                timestamp = (timestamp << 8) + szData[11 + i];
            }
        }
    }

    return timestamp;
}

// 去掉字符串中的"${}"部分
static std::string removeBraces(const std::string& input) {
    std::string result;
    size_t startPos = 0;
    size_t foundPos = input.find("${", startPos); // 查找"${"的位置

    while (foundPos != std::string::npos) {
        // 将"${"之前的部分拼接到结果中
        result += input.substr(startPos, foundPos - startPos);
        
        // 更新起始位置，跳过"${"
        startPos = foundPos + 2;

        // 查找下一个"${"的位置
        foundPos = input.find("${", startPos);
    }

    // 将最后一个"${"之后的部分拼接到结果中
    result += input.substr(startPos);

    // 移除剩余的"}"
    size_t closePos;
    while ((closePos = result.find("}", startPos)) != std::string::npos) {
        result.erase(closePos, 1);
    }

    return result;
}


//获取%{}中的数值
static std::vector<std::string> extractValueFromExpression(const std::string& expression)
{
    std::vector<std::string> values;

    size_t startPos = expression.find("%{");
    while (startPos != std::string::npos)
    {
        size_t endPos = expression.find("}", startPos + 2);
        if (endPos != std::string::npos) {
            std::string numberStr = expression.substr(startPos + 2, endPos - startPos - 2);
            values.push_back(numberStr);
            startPos = expression.find("%{", endPos);
        }
        else
        {
            break;
        }
    }

    return values;
}


//把字符串中 %{point}替换成 'id'  
//av: = avg(getLastValue(% { 10001 }), getVal(% { 10001 }));
//switch to:av: = avg(getLastValue('id1'), getVal('id1'));
static std::string replacePlaceholder(const std::string& expression, const std::vector<std::string>& replacements)
{
    std::string result = expression;

    size_t startPos = result.find("%{");
    size_t replaceIndex = 0;
    while (startPos != std::string::npos && replaceIndex < replacements.size())
    {
        size_t endPos = result.find("}", startPos + 2);
        if (endPos != std::string::npos) {
            std::string replacement = replacements[replaceIndex];

            // 将替换内容添加 getVal( )
            std::string replacementWithGetVal = "'" + replacement + "'";

            // 替换 %{x} 成 getVal(x)
            result.replace(startPos, endPos - startPos + 1, replacementWithGetVal);

            // 更新 startPos
            startPos = result.find("%{", startPos + replacementWithGetVal.length());

            replaceIndex++;
        }
        else
        {
            break;
        }
    }

    return result;
}