388 lines
11 KiB
C++
388 lines
11 KiB
C++
/********************************************************
|
||
* ██████╗ ██████╗████████╗██╗
|
||
* ██╔════╝ ██╔════╝╚══██╔══╝██║
|
||
* ██║ ███╗██║ ██║ ██║
|
||
* ██║ ██║██║ ██║ ██║
|
||
* ╚██████╔╝╚██████╗ ██║ ███████╗
|
||
* ╚═════╝ ╚═════╝ ╚═╝ ╚══════╝
|
||
* Geophysical Computational Tools & Library (GCTL)
|
||
*
|
||
* Copyright (c) 2023 Yi Zhang (yizhang-geo@zju.edu.cn)
|
||
*
|
||
* GCTL is distributed under a dual licensing scheme. You can redistribute
|
||
* it and/or modify it under the terms of the GNU Lesser General Public
|
||
* License as published by the Free Software Foundation, either version 2
|
||
* of the License, or (at your option) any later version. You should have
|
||
* received a copy of the GNU Lesser General Public License along with this
|
||
* program. If not, see <http://www.gnu.org/licenses/>.
|
||
*
|
||
* If the terms and conditions of the LGPL v.2. would prevent you from using
|
||
* the GCTL, please consider the option to obtain a commercial license for a
|
||
* fee. These licenses are offered by the GCTL's original author. As a rule,
|
||
* licenses are provided "as-is", unlimited in time for a one time fee. Please
|
||
* send corresponding requests to: yizhang-geo@zju.edu.cn. Please do not forget
|
||
* to include some description of your company and the realm of its activities.
|
||
* Also add information on how to contact you by electronic and paper mail.
|
||
******************************************************/
|
||
|
||
#ifndef _GCTL_STR_H
|
||
#define _GCTL_STR_H
|
||
|
||
#include "exceptions.h"
|
||
|
||
#include <cmath>
|
||
#include <cstring>
|
||
#include <iostream>
|
||
#include <fstream>
|
||
#include <sstream>
|
||
#include <vector>
|
||
|
||
namespace gctl
|
||
{
|
||
template <typename ObjValType>
|
||
void type2ss(ObjValType in_val, std::stringstream &out_ss)
|
||
{
|
||
out_ss.clear();
|
||
out_ss << in_val;
|
||
return;
|
||
}
|
||
|
||
template <typename OutValType>
|
||
int str2type(std::string in_str, OutValType &out_val, char sep = ' ')
|
||
{
|
||
std::stringstream tmp_ss;
|
||
|
||
if (sep != ' ')
|
||
{
|
||
std::string new_str = in_str;
|
||
std::string old_sep;
|
||
old_sep = sep;
|
||
std::string new_sep = " ";
|
||
for(std::string::size_type pos(0); pos != std::string::npos; pos += new_sep.length())
|
||
{
|
||
if((pos = new_str.find(old_sep, pos)) != std::string::npos)
|
||
{
|
||
new_str.replace(pos,old_sep.length(), new_sep);
|
||
}
|
||
else break;
|
||
}
|
||
|
||
tmp_ss.clear();
|
||
tmp_ss.str(new_str);
|
||
}
|
||
else
|
||
{
|
||
tmp_ss.clear();
|
||
tmp_ss.str(in_str);
|
||
}
|
||
|
||
tmp_ss >> out_val;
|
||
|
||
if (tmp_ss.fail())
|
||
{
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
template <typename OutValType>
|
||
void str2type_vector(const std::vector<std::string> &in_vec,
|
||
std::vector<OutValType> &out_data)
|
||
{
|
||
if (!out_data.empty()) out_data.clear();
|
||
out_data.resize(in_vec.size());
|
||
|
||
for (int i = 0; i < out_data.size(); i++)
|
||
{
|
||
if (str2type(in_vec[i], out_data[i]))
|
||
{
|
||
throw gctl::runtime_error("[gctl::str2type_vector] Failed to parse: " + in_vec[i]);
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
template <typename ValueType>
|
||
void type2str_vector(const std::vector<ValueType> &in_vec,
|
||
std::vector<std::string> &out_vec)
|
||
{
|
||
if (!out_vec.empty()) out_vec.clear();
|
||
out_vec.resize(in_vec.size());
|
||
|
||
for (size_t i = 0; i < in_vec.size(); i++)
|
||
{
|
||
out_vec[i] = std::to_string(in_vec[i]);
|
||
|
||
}
|
||
return;
|
||
}
|
||
|
||
template <typename ValueType>
|
||
void str2type_vector2d(const std::vector<std::vector<std::string> > &vec2d,
|
||
std::string order_str, std::vector<ValueType> &vec)
|
||
{
|
||
int idx;
|
||
std::string tmp_str;
|
||
std::stringstream tmp_ss(order_str);
|
||
std::getline(tmp_ss, tmp_str, ',');
|
||
|
||
tmp_ss.clear();
|
||
tmp_ss.str(tmp_str);
|
||
tmp_ss >> idx;
|
||
|
||
if (idx >= vec2d.size()) throw std::runtime_error("[gctl::str2type_vector2d] Invalid index.");
|
||
|
||
order_str = order_str.substr(order_str.find_first_of(',') + 1);
|
||
str2type_vector(vec2d[idx], vec);
|
||
return;
|
||
}
|
||
|
||
template <typename ValueType, typename... Args>
|
||
void str2type_vector2d(const std::vector<std::vector<std::string>> &vec2d,
|
||
std::string order_str, std::vector<ValueType> &vec, Args&... rest)
|
||
{
|
||
int idx;
|
||
std::string tmp_str;
|
||
std::stringstream tmp_ss(order_str);
|
||
std::getline(tmp_ss, tmp_str, ',');
|
||
|
||
tmp_ss.clear();
|
||
tmp_ss.str(tmp_str);
|
||
tmp_ss >> idx;
|
||
|
||
if (idx >= vec2d.size()) throw std::runtime_error("[gctl::str2type_vector2d] Invalid index.");
|
||
|
||
order_str = order_str.substr(order_str.find_first_of(',') + 1);
|
||
str2type_vector(vec2d[idx], vec);
|
||
|
||
str2type_vector2d(vec2d, order_str, rest...);
|
||
return;
|
||
}
|
||
|
||
template <typename ValueType>
|
||
void type2str_vector2d(std::vector<std::vector<ValueType> > &vec2d,
|
||
const std::vector<std::string> &vec)
|
||
{
|
||
std::vector<std::string> str_vec;
|
||
type2str_vector(vec, str_vec);
|
||
|
||
vec2d.push_back(str_vec);
|
||
return;
|
||
}
|
||
|
||
template <typename ValueType, typename... Args>
|
||
void type2str_vector2d(std::vector<std::vector<ValueType> > &vec2d,
|
||
const std::vector<std::string> &vec, Args&... rest)
|
||
{
|
||
std::vector<std::string> str_vec;
|
||
type2str_vector(vec, str_vec);
|
||
|
||
vec2d.push_back(str_vec);
|
||
|
||
type2str_vector2d(vec2d, rest...);
|
||
return;
|
||
}
|
||
|
||
/**
|
||
* @brief Parse a string argument into separated elements.
|
||
*
|
||
* @param[in] val_str The input value string
|
||
* @param[in] separator The separator
|
||
* @param[in] throw_err Throw out errors
|
||
* @param[in] fst_val The output values returned by quote
|
||
*
|
||
* @tparam ValueType Runtime value type
|
||
*
|
||
* @return Number of parsed strings
|
||
*/
|
||
template <typename ValueType>
|
||
int parse_string_to_value(std::string val_str, char separator, bool throw_err, ValueType &fst_val)
|
||
{
|
||
std::string tmp_str;
|
||
std::stringstream tmp_ss(val_str);
|
||
std::getline(tmp_ss, tmp_str, separator);
|
||
|
||
tmp_ss.clear();
|
||
tmp_ss.str(tmp_str);
|
||
tmp_ss >> fst_val;
|
||
|
||
if (throw_err && tmp_ss.fail())
|
||
{
|
||
throw std::runtime_error("Fail to parse the input string. From gctl::parse_string_to_value(...)");
|
||
}
|
||
else if (tmp_ss.fail())
|
||
{
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
/**
|
||
* @brief Parse a string argument into separated elements.
|
||
*
|
||
* @param[in] val_str The input value string
|
||
* @param[in] separator The separator
|
||
* @param[in] throw_err Throw out errors
|
||
* @param[in] fst_val The output values returned by quote
|
||
*
|
||
* @tparam ValueType Runtime value type
|
||
* @tparam Args Runtime value types of the rest arguments
|
||
*
|
||
* @return Number of parsed strings
|
||
*/
|
||
template <typename ValueType, typename... Args>
|
||
int parse_string_to_value(std::string val_str, char separator, bool throw_err, ValueType &fst_val, Args&... rest)
|
||
{
|
||
std::string tmp_str;
|
||
std::stringstream tmp_ss(val_str);
|
||
std::getline(tmp_ss, tmp_str, separator);
|
||
|
||
tmp_ss.clear();
|
||
tmp_ss.str(tmp_str);
|
||
tmp_ss >> fst_val;
|
||
|
||
if (throw_err && tmp_ss.fail())
|
||
{
|
||
throw std::runtime_error("Fail to parse the input string. From gctl::parse_string_to_value(...)");
|
||
}
|
||
else if (tmp_ss.fail())
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int position = val_str.find_first_of(separator);
|
||
|
||
if (position == std::string::npos) tmp_str = "";
|
||
else tmp_str = val_str.substr(position+1, val_str.length());
|
||
|
||
return parse_string_to_value(tmp_str, separator, throw_err, rest...) + 1;
|
||
}
|
||
|
||
/**
|
||
* @brief 替换字符串中的指定子串
|
||
*
|
||
* @param new_str 替换后的字符串
|
||
* @param old_str 需要操作的字符串
|
||
* @param old_value 需要被替换的字串
|
||
* @param new_value 替换的字串
|
||
*
|
||
* @return 替换的次数
|
||
*/
|
||
int replace_all(std::string& new_str, const std::string& old_str, const std::string& old_value,
|
||
const std::string& new_value);
|
||
|
||
/**
|
||
* @brief 在输入字符串末尾添加一段字符串，如果输入字符串的尾端与待添加的字符串一致则不添加并返回原字符串
|
||
*
|
||
* @param in_str 输入字符串
|
||
* @param patch_str 待匹配的字符串
|
||
* @return 输出字符串
|
||
*/
|
||
std::string patch_string(std::string in_str, std::string patch_str);
|
||
|
||
/**
|
||
* @brief 转换string对象为stringstream对象
|
||
*
|
||
* @param[in] in_str 输入的string字符串
|
||
* @param out_ss 引用返回的stringstreams对象
|
||
* @param[in] delimiter 分割string对象时的分隔符。如果不为空，
|
||
* 函数会将delimiter转换为空格
|
||
*/
|
||
void str2ss(std::string in_str, std::stringstream &out_ss, std::string delimiter = "");
|
||
|
||
/**
|
||
* @brief 转换string字符串为double类型的数值
|
||
*
|
||
* 这个函数的主要作用是检查输入字符串是否为nan或者inf等表示无效值的符号。有的编译器
|
||
* 可以在>>输入符中完成此检测，但为了函数功能的稳定，所以在此处自定了这个函数。这个函数
|
||
* 还可以将fortran输出文件中以D标注的科学数字转换为浮点类型
|
||
*
|
||
* @param[in] instr 输入字符串
|
||
*
|
||
* @return 返回的double类型的数值
|
||
*/
|
||
double str2double(std::string instr);
|
||
|
||
/**
|
||
* @brief 转换double类型数值为string类型字符串 标准库中有to_string函数，以后就不用这个了。
|
||
*
|
||
* @param[in] in_d 输入数值
|
||
*
|
||
* @return 输出字符串
|
||
*/
|
||
std::string double2str(double in_d);
|
||
|
||
/**
|
||
* @brief 返回一定长度的随机字符串
|
||
*
|
||
* @param[in] length 字符串的长度
|
||
* @param out 输出字符串
|
||
*/
|
||
void random_char(unsigned int length, char* out);
|
||
|
||
/**
|
||
* @brief 返回一定长度的随机字符串
|
||
*
|
||
* @param[in] length 字符串的长度
|
||
* @param out_str 输出字符串
|
||
*/
|
||
void random_str(unsigned int lenght, std::string &out_str);
|
||
|
||
/**
|
||
* @brief Parse a string argument into an element array
|
||
*
|
||
* @param[in] val_str The input value string
|
||
* @param out_vec The output array
|
||
* @param[in] separator The separator
|
||
*
|
||
* @tparam ValueType Runtime value type
|
||
*
|
||
* @return 0 for success, -1 for failure
|
||
*/
|
||
template <typename ValueType>
|
||
int parse_string_to_vector(std::string val_str, char separator, std::vector<ValueType> &out_vec)
|
||
{
|
||
val_str.erase(0, val_str.find_first_not_of(" \t"));
|
||
val_str.erase(val_str.find_last_not_of(" \t") + 1);
|
||
|
||
int pos;
|
||
bool bk = false;
|
||
ValueType val;
|
||
std::string l_str;
|
||
while (1)
|
||
{
|
||
pos = val_str.find(separator);
|
||
if (pos == val_str.npos)
|
||
{
|
||
l_str = val_str;
|
||
bk = true;
|
||
}
|
||
else
|
||
{
|
||
l_str = val_str.substr(0, pos);
|
||
val_str = val_str.substr(pos+1, val_str.length());
|
||
val_str.erase(0, val_str.find_first_not_of(" \t"));
|
||
}
|
||
|
||
// 如果输出也是字符串 就直接赋值即可（避免l_str中含有空格会出现bug）
|
||
if constexpr (std::is_same<ValueType, std::string>::value) val = l_str;
|
||
else str2type(l_str, val);
|
||
|
||
out_vec.push_back(val);
|
||
if (bk) break;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* @brief 解析字符串并返回以空格分割的字符串向量
|
||
*
|
||
* @note 双引号括起来的部分将解析为一个字符串
|
||
*
|
||
* @param in_str 输入字符串
|
||
* @param str_vec 输出字符串向量
|
||
*/
|
||
void parse_string_with_quotes(std::string in_str, std::vector<std::string> &str_vec);
|
||
};
|
||
|
||
#endif // _GCTL_STR_H
|