322 lines
9.6 KiB
C++
322 lines
9.6 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_STREAM_TEMPLATE_H
|
||
#define _GCTL_STREAM_TEMPLATE_H
|
||
|
||
#include "string"
|
||
#include "sstream"
|
||
|
||
#include "../core/exceptions.h"
|
||
#include "../core/vector_t.h"
|
||
|
||
/**
|
||
* terminal control symbols
|
||
*/
|
||
#define GCTL_BOLD "\033[1m" ///< 设置终端字体与颜色为粗体
|
||
#define GCTL_BOLDRED "\033[1m\033[31m" ///< 设置终端字体与颜色为粗体红色
|
||
#define GCTL_BOLDGREEN "\033[1m\033[32m" ///< 设置终端字体与颜色为粗体绿色
|
||
#define GCTL_BOLDBLUE "\033[1m\033[34m" ///< 设置终端字体与颜色为粗体蓝色
|
||
#define GCTL_BOLDYELLOW "\033[1m\033[33m" ///< 设置后续字符字体为黄色加粗
|
||
#define GCTL_UNDERLINE "\033[1m\033[4m" ///< 设置终端字体为下划线
|
||
#define GCTL_RESET "\033[0m" ///< 重置字体与颜色设定
|
||
#define GCTL_CLEARLINE "\033[K" ///< 清空终端当前行
|
||
#define GCTL_CLEARALL "\033[2J" ///< 清空终端窗口
|
||
#define GCTL_MOVEUP(os, x) do {os << "\033[" << x << "A";} while (0); ///< 终端光标上移x行
|
||
#define GCTL_MOVEDOWN(os, x) do {os << "\033[" << x << "B";} while (0); ///< 终端光标下移x行
|
||
#define GCTL_MOVERIGHT(os, x) do {os << "\033[" << x << "C";} while (0); ///< 终端光标右移x列
|
||
#define GCTL_MOVELEFT(os, x) do {os << "\033[" << x << "D";} while (0); ///< 终端光标左移x列
|
||
#define GCTL_MOVETO(os, r, c) do {os << "\033[" << c << ";" << r << "H";} while (0); ///< 终端光标移动至r行c列位置
|
||
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 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 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;
|
||
}
|
||
}
|
||
|
||
#endif // _GCTL_STREAM_TEMPLATE_H
|