AimRT/install_x64/include/aimrt/util/string_util.h

// Copyright (c) 2023, AgiBot Inc.
// All rights reserved.

#pragma once

#include <algorithm>
#include <charconv>
#include <cstdint>
#include <cstring>
#include <iomanip>
#include <map>
#include <regex>
#include <set>
#include <sstream>
#include <string>
#include <vector>

namespace aimrt::common::util {

/**
 * @brief 修剪字符串
 *
 * @param[inout] s 待处理字符串
 * @return std::string& 处理后的字符串s的引用
 */
inline std::string& Trim(std::string& s) {
  if (s.empty()) return s;
  s.erase(s.find_last_not_of(' ') + 1);
  s.erase(0, s.find_first_not_of(' '));
  return s;
}

inline std::string_view& Trim(std::string_view& s) {
  if (s.empty()) return s;
  auto p = s.find_last_not_of(' ');
  s = s.substr(0, (p != std::string_view::npos) ? (p + 1) : 0);
  p = s.find_first_not_of(' ');
  s = s.substr((p != std::string_view::npos) ? p : s.size());
  return s;
}

/**
 * @brief 将类似于a=1&b=2&c=3这样的字符串解析到map中
 * @note
 * 分割原则：在两个vsep之间的子字符串，如果包含msep，则以msep为界分为key、val
 * @param[in] source 待分割字符串
 * @param[in] vsep 多个kv之间的分隔符，不可为空
 * @param[in] msep 单个kv内部的分隔符，不可为空
 * @param[in] trim 是否去除k和v里的空格
 * @param[in] clear 是否去除key为空的情况
 * @return std::map<std::string, std::string> 解析后的map
 */
template <class StringType = std::string_view>
  requires(std::is_same_v<StringType, std::string_view> ||
           std::is_same_v<StringType, std::string>)
inline std::map<StringType, StringType> SplitToMap(std::string_view source,
                                                   std::string_view vsep = "&",
                                                   std::string_view msep = "=",
                                                   bool trim = true,
                                                   bool clear = true) {
  std::map<StringType, StringType> result;

  if (source.empty() || vsep.empty() || msep.empty() || vsep == msep)
    return result;
  size_t v_pos_end = 0, v_pos_start = 0;
  do {
    v_pos_end = source.find(vsep, v_pos_start);
    if (v_pos_end == std::string_view::npos) v_pos_end = source.length();
    if (v_pos_end > v_pos_start) {
      auto kv_str = source.substr(v_pos_start, v_pos_end - v_pos_start);
      size_t msep_pos = kv_str.find(msep);
      if (msep_pos != std::string_view::npos) {
        auto first = kv_str.substr(0, msep_pos);
        auto second = kv_str.substr(msep_pos + msep.size());
        if (trim) {
          Trim(first);
          if (!(clear && first.empty())) {
            result[StringType(first)] = StringType(Trim(second));
          }
        } else {
          if (!(clear && first.empty())) {
            result[StringType(first)] = StringType(second);
          }
        }
      }
    }
    v_pos_start = v_pos_end + vsep.size();
  } while (v_pos_end < source.length());

  return result;
}

/**
 * @brief 拼接map为a=1&b=2&c=3形式的string
 *
 * @param[in] kvmap std::map<std::string,std::string>结构体
 * @param[in] vsep 多个kv之间的分隔符
 * @param[in] msep 单个kv内部的分隔符
 * @return std::string 拼接后的字符串
 */
template <class StringType = std::string_view>
  requires(std::is_same_v<StringType, std::string_view> ||
           std::is_same_v<StringType, std::string>)
inline std::string JoinMap(const std::map<StringType, StringType>& kvmap,
                           std::string_view vsep = "&",
                           std::string_view msep = "=") {
  std::stringstream result;
  for (auto itr = kvmap.begin(); itr != kvmap.end(); ++itr) {
    if (itr != kvmap.begin()) result << vsep;
    result << itr->first << msep << itr->second;
  }
  return result.str();
}

/**
 * @brief 带默认值的获取map<std::string,std::string>中val数据
 *
 * @param[in] m std::map<std::string,std::string>结构体
 * @param[in] key 要获取数据的key
 * @param[in] defval 默认字符串，当m中没有对应的key时，返回defval
 * @return std::string 结果
 */
template <class StringType = std::string_view>
  requires(std::is_same_v<StringType, std::string_view> ||
           std::is_same_v<StringType, std::string>)
inline const StringType& GetMapItemWithDef(const std::map<StringType, StringType>& m,
                                           const StringType& key,
                                           const StringType& defval = "") {
  auto finditr = m.find(key);
  return (finditr != m.end()) ? (finditr->second) : defval;
}

/**
 * @brief 向s中添加kv字段
 *
 * @param[inout] s 待处理字符串
 * @param[in] key key
 * @param[in] val val
 * @param[in] vsep 多个kv之间的分隔符
 * @param[in] msep 单个kv内部的分隔符
 * @return std::string& 拼接后的字符串s的引用
 */
inline std::string& AddKV(std::string& s,
                          std::string_view key,
                          std::string_view val,
                          std::string_view vsep = "&",
                          std::string_view msep = "=") {
  if (!s.empty()) s += vsep;
  s += key;
  s += msep;
  s += val;
  return s;
}

/**
 * @brief 从类似于a=1&b=2&c=3这样的字符串中得到key对应的val
 * @note
 * 比直接分割成map再find要快一些，但如果有多次调用，还是建议先分割成map再find
 * @param[in] str 待处理字符串
 * @param[in] key key，不可为空，不能包含vsep或msep，否则返回空结果
 * @param[in] vsep 多个kv之间的分隔符，不可为空
 * @param[in] msep 单个kv内部的分隔符，不可为空
 * @param[in] trim 是否不计空格
 * @return std::string key对应的val
 */
inline std::string_view GetValueFromStrKV(std::string_view str,
                                          std::string_view key,
                                          std::string_view vsep = "&",
                                          std::string_view msep = "=",
                                          bool trim = true) {
  if (key.empty() || vsep.empty() || msep.empty() || vsep == msep) return "";
  if (key.find(vsep) != std::string_view::npos || key.find(msep) != std::string_view::npos)
    return "";

  size_t key_pos = str.find(key);
  while (key_pos != std::string_view::npos) {
    size_t msep_pos = str.find(msep, key_pos + key.size());
    if (msep_pos == std::string_view::npos) return "";

    size_t key_start_pos = str.rfind(vsep, key_pos);
    if (key_start_pos == std::string_view::npos)
      key_start_pos = 0;
    else
      key_start_pos += vsep.length();

    bool right_key_flag = false;
    if (trim) {
      auto real_key = str.substr(key_start_pos, msep_pos - key_start_pos);
      Trim(real_key);
      if (real_key == key) right_key_flag = true;
    } else {
      if ((key_start_pos == key_pos) && (msep_pos == (key_pos + key.size())))
        right_key_flag = true;
    }

    if (right_key_flag) {
      size_t val_start_pos = msep_pos + msep.size();
      size_t val_end_pos = str.find(vsep, val_start_pos);
      if (val_end_pos == std::string_view::npos) val_end_pos = str.length();

      if (trim) {
        auto re = str.substr(val_start_pos, val_end_pos - val_start_pos);
        return Trim(re);
      }
      return str.substr(val_start_pos, val_end_pos - val_start_pos);
    }

    key_pos = str.find(key, msep_pos + msep.length());
  }
  return "";
}

/**
 * @brief 分割字符串到vector
 *
 * @param[in] source 待处理字符串
 * @param[in] sep 分隔符
 * @param[in] trim 是否对每项结果去除空格
 * @param[in] clear 是否去除空项
 * @return std::vector<std::string> 分割结果
 */
template <class StringType = std::string_view>
  requires(std::is_same_v<StringType, std::string_view> ||
           std::is_same_v<StringType, std::string>)
inline std::vector<StringType> SplitToVec(std::string_view source,
                                          std::string_view sep,
                                          bool trim = true,
                                          bool clear = true) {
  std::vector<StringType> result;
  if (source.empty() || sep.empty()) return result;

  size_t pos_end = 0, pos_start = 0;
  do {
    pos_end = source.find(sep, pos_start);
    if (pos_end == std::string_view::npos) pos_end = source.length();

    auto sub_str = source.substr(pos_start, pos_end - pos_start);

    if (trim) Trim(sub_str);

    if (!(clear && sub_str.empty())) result.emplace_back(sub_str);

    pos_start = pos_end + sep.size();
  } while (pos_end < source.length());

  return result;
}

/**
 * @brief 拼接vector到string
 *
 * @param[in] vec 待处理vector
 * @param[in] sep 分隔符
 * @return std::string 拼接后的字符串
 */
template <class StringType = std::string_view>
  requires(std::is_same_v<StringType, std::string_view> ||
           std::is_same_v<StringType, std::string>)
inline std::string JoinVec(const std::vector<StringType>& vec, std::string_view sep) {
  std::string result;
  for (auto itr = vec.begin(); itr != vec.end(); ++itr) {
    if (itr != vec.begin()) result += sep;
    result += *itr;
  }
  return result;
}

/**
 * @brief 分割字符串到set，自动去重
 *
 * @param[in] source 待处理字符串
 * @param[in] sep 分隔符
 * @param[in] trim 是否对每项结果去除空格
 * @param[in] clear 是否去除空项
 * @return std::set<std::string> 分割结果
 */
template <class StringType = std::string_view>
  requires(std::is_same_v<StringType, std::string_view> ||
           std::is_same_v<StringType, std::string>)
inline std::set<StringType> SplitToSet(std::string_view source,
                                       std::string_view sep,
                                       bool trim = true,
                                       bool clear = true) {
  std::set<StringType> result;
  if (source.empty() || sep.empty()) return result;

  size_t pos_end = 0, pos_start = 0;
  do {
    pos_end = source.find(sep, pos_start);
    if (pos_end == std::string_view::npos) pos_end = source.length();

    auto sub_str = source.substr(pos_start, pos_end - pos_start);

    if (trim) Trim(sub_str);

    if (!(clear && sub_str.empty())) result.emplace(sub_str);

    pos_start = pos_end + sep.size();
  } while (pos_end < source.length());

  return result;
}

/**
 * @brief 拼接set到string
 *
 * @param[in] st 待处理set
 * @param[in] sep 分隔符
 * @return std::string 拼接后的字符串
 */
template <class StringType = std::string_view>
  requires(std::is_same_v<StringType, std::string_view> ||
           std::is_same_v<StringType, std::string>)
inline std::string JoinSet(const std::set<StringType>& st, std::string_view sep) {
  std::string result;
  for (auto itr = st.begin(); itr != st.end(); ++itr) {
    if (itr != st.begin()) result += sep;
    result += *itr;
  }
  return result;
}

/**
 * @brief 判断key字符串是否在list字符串中，如"123"是否在"123,456,789"中
 * @note
 * 比直接分割成vector再find要快一些，但如果有多次调用，还是建议先分割成vector再find
 * @param[in] str list字符串
 * @param[in] key key字符串，不可为空，不能包含sep
 * @param[in] sep list的分隔符，不可为空
 * @param[in] trim 是否不计空格
 * @return true key在list中
 * @return false key不在list中
 */
inline bool CheckIfInList(std::string_view str,
                          std::string_view key,
                          std::string_view sep = ",",
                          bool trim = true) {
  if (key.empty() || sep.empty()) return false;
  if (key.find(sep) != std::string_view::npos) return false;

  size_t key_pos = str.find(key);
  while (key_pos != std::string_view::npos) {
    size_t key_start_pos = str.rfind(sep, key_pos);
    if (key_start_pos == std::string_view::npos)
      key_start_pos = 0;
    else
      key_start_pos += sep.length();

    size_t key_end_pos = str.find(sep, key_pos + key.length());
    if (key_end_pos == std::string_view::npos) key_end_pos = str.length();

    if (trim) {
      auto real_key = str.substr(key_start_pos, key_end_pos - key_start_pos);
      Trim(real_key);
      if (real_key == key) return true;
    } else {
      if ((key_start_pos == key_pos) && (key_end_pos == (key_pos + key.size())))
        return true;
    }

    key_pos = str.find(key, key_end_pos + sep.length());
  }

  return false;
}

/**
 * @brief 比较版本，如6.1.1 6.2.8
 *
 * @param[in] ver1 版本1
 * @param[in] ver2 版本2
 * @return int 返回1是大于，返回0是相等，返回-1是小于
 */
inline int CmpVersion(std::string_view ver1, std::string_view ver2) {
  const auto& version1_detail =
      SplitToVec<std::string_view>(ver1, ".", true, true);
  const auto& version2_detail =
      SplitToVec<std::string_view>(ver2, ".", true, true);

  size_t idx = 0;
  for (idx = 0; idx < version1_detail.size() && idx < version2_detail.size(); ++idx) {
    int ver1_num = 0, ver2_num = 0;
    auto [ptr1, ec1] = std::from_chars(version1_detail[idx].data(),
                                       version1_detail[idx].data() + version1_detail[idx].size(),
                                       ver1_num);
    auto [ptr2, ec2] = std::from_chars(version2_detail[idx].data(),
                                       version2_detail[idx].data() + version2_detail[idx].size(),
                                       ver2_num);
    if (ec1 != std::errc() || ec2 != std::errc() ||
        ptr1 != version1_detail[idx].data() + version1_detail[idx].size() ||
        ptr2 != version2_detail[idx].data() + version2_detail[idx].size()) {
      throw std::runtime_error("Invalid version format");
    }
    if (ver1_num < ver2_num)
      return -1;
    if (ver1_num > ver2_num)
      return 1;
  }
  if (idx == version1_detail.size() && idx == version2_detail.size()) {
    return 0;
  }
  return version1_detail.size() > version2_detail.size() ? 1 : -1;
}

/**
 * @brief 检查版本是否处于设定版本之间
 * @note 需要保证start_ver<end_ver。若end_ver空，则设为999.9.9.9
 * @param[in] ver 待检查版本
 * @param[in] start_ver 开始版本
 * @param[in] end_ver 结束版本
 * @return true 在传入的版本之间
 * @return false 不在传入的版本之间
 */
inline bool CheckVersionInside(std::string_view ver,
                               std::string_view start_ver,
                               std::string_view end_ver) {
  return (CmpVersion(ver, start_ver.empty() ? "0.0.0.0" : start_ver) >= 0 &&
          CmpVersion(ver, end_ver.empty() ? "999.9.9.9" : end_ver) <= 0);
}

/**
 * @brief 将一个字符串中指定字符串ov换为字符串nv
 *
 * @param[inout] str 待替换字符串
 * @param[in] ov 要被替换的子字符串
 * @param[in] nv 要替换成的子字符串
 * @return std::string& 替换后的字符串str的引用
 */
inline std::string& ReplaceString(std::string& str,
                                  std::string_view ov,
                                  std::string_view nv) {
  if (str.empty() || ov.empty()) return str;
  std::vector<size_t> vec_pos;
  size_t pos = 0, old_len = ov.size(), new_len = nv.size();
  while ((pos = str.find(ov, pos)) != std::string::npos) {
    vec_pos.emplace_back(pos);
    pos += old_len;
  }
  size_t& vec_len = pos = vec_pos.size();
  if (vec_len) {
    if (old_len == new_len) {
      for (size_t ii = 0; ii < vec_len; ++ii)
        memcpy(const_cast<char*>(str.c_str() + vec_pos[ii]), nv.data(),
               new_len);
    } else if (old_len > new_len) {
      char* p = const_cast<char*>(str.c_str()) + vec_pos[0];
      vec_pos.emplace_back(str.size());
      for (size_t ii = 0; ii < vec_len; ++ii) {
        memcpy(p, nv.data(), new_len);
        p += new_len;
        size_t cplen = vec_pos[ii + 1] - vec_pos[ii] - old_len;
        memmove(p, str.c_str() + vec_pos[ii] + old_len, cplen);
        p += cplen;
      }
      str.resize(p - str.c_str());
    } else {
      size_t diff = new_len - old_len;
      vec_pos.emplace_back(str.size());
      str.resize(str.size() + diff * vec_len);
      char* p = const_cast<char*>(str.c_str()) + str.size();
      for (size_t ii = vec_len - 1; ii < vec_len; --ii) {
        size_t cplen = vec_pos[ii + 1] - vec_pos[ii] - old_len;
        p -= cplen;
        memmove(p, str.c_str() + vec_pos[ii] + old_len, cplen);
        p -= new_len;
        memcpy(p, nv.data(), new_len);
      }
    }
  }
  return str;
}

/**
 * @brief 判断字符串是否为数字和字母组成
 *
 * @param[in] str 待判断字符串
 * @return true 全部为数字和字母组成
 * @return false 不全为数字和字母组成
 */
inline bool IsAlnumStr(std::string_view str) {
  if (str.length() == 0) return false;
  for (const auto& c : str) {
    if (!isalnum(c)) return false;
  }
  return true;
}

/**
 * @brief 判断字符串是否为数字组成
 *
 * @param[in] str 待判断字符串
 * @return true 全部为数字组成
 * @return false 不全为数字组成
 */
inline bool IsDigitStr(std::string_view str) {
  if (str.length() == 0) return false;
  for (const auto& c : str) {
    if (c > '9' || c < '0') return false;
  }
  return true;
}

/**
 * @brief 获取map中的key的集合
 *
 * @tparam KeyType map中key的类型
 * @tparam ValType map中val的类型
 * @param m 输入map
 * @return std::set<KeyType> key的集合
 */
template <typename KeyType, typename ValType>
inline std::set<KeyType> GetMapKeys(const std::map<KeyType, ValType>& m) {
  std::set<KeyType> re;
  for (const auto& it : m) re.emplace(it.first);
  return re;
}

/**
 * @brief 画一个表格
 *
 * @param table 表格数据
 * @param with_header 是否要画表头
 * @return std::string 结果字符串，可以直接打印
 */
template <class StringType = std::string_view>
  requires(std::is_same_v<StringType, std::string_view> ||
           std::is_same_v<StringType, std::string>)
inline std::string DrawTable(
    const std::vector<std::vector<StringType>>& table, bool with_header = true) {
  size_t row = table.size();
  if (row == 0) return "<empty table>";

  std::vector<size_t> column_width;

  for (auto& row_item : table) {
    if (column_width.size() < row_item.size())
      column_width.resize(row_item.size());

    for (size_t ii = 0; ii < row_item.size(); ++ii)
      column_width[ii] = std::max(column_width[ii], row_item[ii].size());
  }

  for (auto& item : column_width)
    item += 2;

  size_t column = column_width.size();

  std::stringstream result;

  // first line
  for (size_t jj = 0; jj < column; ++jj) {
    result << "+" << std::setfill('-') << std::setw(column_width[jj]) << "-";
  }
  result << "+\n";

  for (size_t ii = 0; ii < row; ++ii) {
    for (size_t jj = 0; jj < column; ++jj) {
      std::string cur_data = " ";

      if (table[ii].size() > jj)
        cur_data += table[ii][jj];

      result << "|" << std::left << std::setfill(' ') << std::setw(column_width[jj]) << cur_data;
    }
    result << "|\n";

    // table header
    if (with_header && ii == 0) {
      for (size_t jj = 0; jj < column; ++jj) {
        result << "+" << std::setfill('-') << std::setw(column_width[jj]) << "-";
      }
      result << "+\n";
    }
  }

  // last line
  for (size_t jj = 0; jj < column; ++jj) {
    result << "+" << std::setfill('-') << std::setw(column_width[jj]) << "-";
  }
  result << "+\n";

  return result.str();
}

/**
 * @brief 将字符串中形如 ${XXX_ENV} 的部分替换为对应环境变量的值
 *
 * @param input
 * @return std::string
 */
inline std::string ReplaceEnvVars(std::string_view input) {
  std::regex pattern(R"(\$\{([^}]+)\})");
  std::smatch match;
  std::string result(input);
  size_t cur_pos = 0;

  while (std::regex_search(result.cbegin() + cur_pos, result.cend(), match, pattern)) {
    std::string env_name = match[1].str();
    const char* env_val = std::getenv(env_name.c_str());
    if (env_val == nullptr) env_val = "";

    result.replace(cur_pos + match.position(0), match.length(0), env_val);

    cur_pos += (match.position(0) + strlen(env_val));
  }

  return result;
}

/**
 * @brief 字符转小写
 *
 * @param c 字符
 * @return char 小写字符
 */
inline char CharToLower(char c) { return static_cast<char>(tolower(c)); }

/**
 * @brief 字符转大写
 *
 * @param c 字符
 * @return char 大写字符
 */
inline char CharToUpper(char c) { return static_cast<char>(toupper(c)); }

/**
 * @brief 字符串转小写
 *
 * @param str 字符串
 * @return std::string& 小写字符串
 */
inline std::string& StrToLower(std::string& str) {
  std::transform(str.begin(), str.end(), str.begin(), CharToLower);
  return str;
}

/**
 * @brief 字符串转小写
 *
 * @param str 字符串
 * @return std::string 小写字符串
 */
inline std::string StrToLower(std::string_view str) {
  std::string result;
  result.resize(str.size());

  std::transform(str.begin(), str.end(), result.begin(), CharToLower);
  return result;
}

/**
 * @brief 字符串转大写
 *
 * @param str 字符串
 * @return std::string& 大写字符串
 */
inline std::string& StrToUpper(std::string& str) {
  std::transform(str.begin(), str.end(), str.begin(), CharToUpper);
  return str;
}

/**
 * @brief 字符串转大写
 *
 * @param str 字符串
 * @return std::string 大写字符串
 */
inline std::string StrToUpper(std::string_view str) {
  std::string result;
  result.resize(str.size());

  std::transform(str.begin(), str.end(), result.begin(), CharToUpper);
  return result;
}

/**
 * @brief 比较两个字符串忽略大小写后是否相等
 *
 * @param str1
 * @param str2
 * @return true
 * @return false
 */
inline bool CheckIEqual(std::string_view str1, std::string_view str2) {
  if (str1.size() != str2.size()) return false;

  return std::equal(str1.begin(), str1.end(), str2.begin(),
                    [](char a, char b) { return std::tolower(a) == std::tolower(b); });
}

/**
 * @brief 字符串转为标题形式，单词首字符大写
 *
 * @param str 字符串
 * @return std::string& 标题形式字符串
 */
inline std::string& StrToTitleCase(std::string& str) {
  std::string::iterator it = str.begin();
  *it = CharToUpper(*it);
  for (; it != str.end() - 1; ++it) {
    if (*it == ' ') {
      *(it + 1) = CharToUpper(*(it + 1));
    }
  }
  return str;
}

/**
 * @brief standardise a path string
 *
 * @param path
 * @return std::string&
 */
inline std::string& StandardisePath(std::string& path) {
  if (path.empty()) return (path = "/");
  std::replace(path.begin(), path.end(), '\\', '/');
  if (path[path.length() - 1] != '/') path += '/';
  return path;
}

/**
 * @brief judge if str start with pattern
 *
 * @param str
 * @param pattern
 * @param ignore_case if ignore the case
 * @return true
 * @return false
 */
inline bool StartsWith(std::string_view str,
                       std::string_view pattern,
                       bool ignore_case = false) {
  const size_t str_len = str.length();
  const size_t pattern_len = pattern.length();
  if (str_len < pattern_len || pattern_len == 0) return false;

  if (ignore_case) {
    for (size_t i = 0; i < pattern_len; ++i) {
      if (tolower(pattern[i]) != tolower(str[i])) return false;
    }
    return true;
  }
  for (size_t i = 0; i < pattern_len; ++i) {
    if (pattern[i] != str[i]) return false;
  }
  return true;
}

/**
 * @brief judge if str end with pattern
 *
 * @param str
 * @param pattern
 * @param ignore_case if ignore the case
 * @return true
 * @return false
 */
inline bool EndsWith(std::string_view str,
                     std::string_view pattern,
                     bool ignore_case = false) {
  const size_t str_len = str.length();
  const size_t pattern_len = pattern.length();
  if (str_len < pattern_len || pattern_len == 0) return false;

  const size_t& begin_pos = str_len - pattern_len;
  if (ignore_case) {
    for (size_t i = 0; i < pattern_len; ++i) {
      if (tolower(pattern[i]) != tolower(str[begin_pos + i])) return false;
    }
    return true;
  }
  for (size_t i = 0; i < pattern_len; i++) {
    if (pattern[i] != str[begin_pos + i]) return false;
  }
  return true;
}

/**
 * @brief fnv1a hash算法，64位
 *
 * @param data
 * @param len
 * @return uint64_t hash值
 */
inline uint64_t Hash64Fnv1a(const char* data, size_t len) {
  constexpr uint64_t kPrime = 0x100000001b3;
  uint64_t hash = 0xcbf29ce484222325;
  for (size_t i = 0; i < len; ++i) {
    hash = (hash ^ static_cast<uint8_t>(data[i])) * kPrime;
  }
  return hash;
}

/**
 * @brief fnv1a hash算法，32位
 *
 * @param data
 * @param len
 * @return uint32_t hash值
 */
inline uint32_t Hash32Fnv1a(const char* data, size_t len) {
  constexpr uint32_t kPrime = 0x1000193;
  uint32_t hash = 0x811c9dc5;
  for (size_t i = 0; i < len; ++i) {
    hash = (hash ^ static_cast<uint8_t>(data[i])) * kPrime;
  }
  return hash;
}

template <typename T>
inline std::string SSToString(const T& obj) {
  std::stringstream ss;
  ss << obj;
  return ss.str();
}

struct StringHash {
  using hash_type = std::hash<std::string_view>;
  using is_transparent = void;

  std::size_t operator()(const char* str) const { return hash_type{}(str); }
  std::size_t operator()(std::string_view str) const { return hash_type{}(str); }
  std::size_t operator()(std::string const& str) const { return hash_type{}(str); }
};

}  // namespace aimrt::common::util