yyc12345/YYCCommonplace
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add parse and stringify

Browse Source
This commit is contained in:
yyc12345 2025-06-22 19:53:49 +08:00
parent ab8d74efe6
commit 28ff7008a8
9 changed files with 347 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/CMakeLists.txt
View File

@ -37,6 +37,7 @@ FILES
yycc/prelude/core.hpp
yycc/prelude/rust.hpp
yycc/macro/version_cmp.hpp
yycc/macro/feature_probe.hpp
yycc/macro/os_detector.hpp
yycc/macro/class_copy_move.hpp
yycc/string.hpp

30
src/yycc/macro/feature_probe.hpp Normal file
View File

@ -0,0 +1,30 @@
#pragma once
// Hint for C++ feature detection:
// __cplusplus macro need special compiler switch enabled when compiling.
// So we use _MSVC_LANG check it instead.
// Detect C++ 20
#if __cplusplus >= 202002L || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
#define YYCC_CPPFEAT_GE_CPP20
#endif
// Detect C++ 23
#if __cplusplus >= 202302L || (defined(_MSVC_LANG) && _MSVC_LANG >= 202302L)
#define YYCC_CPPFEAT_GE_CPP23
#endif
// Check whether there is support of `contains` for `set` and `map` including their varients.
#if defined(YYCC_CPPFEAT_GE_CPP20)
#define YYCC_CPPFEAT_CONTAINS
#endif
// Check whether there is support of `starts_with` and `ends_with` for `basic_string`.
#if defined(__cpp_lib_starts_ends_with) || defined(YYCC_CPPFEAT_GE_CPP20)
#define YYCC_CPPTEST_STARTS_ENDS_WITH
#endif
// Check whether there is support of `std::expected`.
#if defined(__cpp_lib_expected) || defined(YYCC_CPPFEAT_GE_CPP23)
#define YYCC_CPPTEST_EXPECTED
#endif

4
src/yycc/string/op.cpp
View File

@ -158,7 +158,7 @@ namespace yycc::string::op {
generic_lower_upper<true>(strl);
}
NS_YYCC_STRING::u8string lower(const NS_YYCC_STRING::u8string_view& strl) {
NS_YYCC_STRING::u8string to_lower(const NS_YYCC_STRING::u8string_view& strl) {
NS_YYCC_STRING::u8string ret(strl);
lower(ret);
return ret;
@ -168,7 +168,7 @@ namespace yycc::string::op {
generic_lower_upper<false>(strl);
}
NS_YYCC_STRING::u8string upper(const NS_YYCC_STRING::u8string_view& strl) {
NS_YYCC_STRING::u8string to_upper(const NS_YYCC_STRING::u8string_view& strl) {
// same as Lower, just replace char transform function.
NS_YYCC_STRING::u8string ret(strl);
upper(ret);

4
src/yycc/string/op.hpp
View File

@ -113,7 +113,7 @@ namespace yycc::string::op {
* @param[in] strl The string to be lowercase.
* @return The copy of the string converted to lowercase.
*/
NS_YYCC_STRING::u8string lower(const NS_YYCC_STRING::u8string_view& strl);
NS_YYCC_STRING::u8string to_lower(const NS_YYCC_STRING::u8string_view& strl);
/**
* @brief Convert given string to uppercase.
* @param[in,out] strl The string to be uppercase.
@ -124,7 +124,7 @@ namespace yycc::string::op {
* @param[in] strl The string to be uppercase.
* @return The copy of the string converted to uppercase.
*/
NS_YYCC_STRING::u8string upper(const NS_YYCC_STRING::u8string_view& strl);
NS_YYCC_STRING::u8string to_upper(const NS_YYCC_STRING::u8string_view& strl);
/**
* @brief Split given string with specified delimiter as string view.

218
src/yycc/string/parse.hpp Normal file
View File

@ -0,0 +1,218 @@
#pragma once
#include "../string.hpp"
#include "op.hpp"
#include "reinterpret.hpp"
#include <charconv>
#include <stdexcept>
#include <type_traits>
#include <variant>
#define NS_YYCC_STRING ::yycc::string
#define NS_YYCC_STRING_REINTERPRET ::yycc::string::reinterpret
#define NS_YYCC_STRING_OP ::yycc::string::op
namespace yycc::string::parse {
// Developer Notes:
// Reference: https://zh.cppreference.com/w/cpp/utility/from_chars
/// @brief The error kind when parsing string into number.
enum class ParseError {
PartiallyParsed, ///< Only a part of given string was parsed. The whole string may be invalid.
InvalidString, ///< Given string is a invalid number string.
OutOfRange, ///< Given string is valid but its value out of the range of given number type.
};
template<typename T, std::enable_if_t<!std::is_same_v<T, ParseError>, int> = 0>
using ParseResult = std::variant<T, ParseError>;
template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
ParseResult<T> _priv_parse(const NS_YYCC_STRING::u8string_view& strl, std::chars_format fmt) {
namespace reinterpret = NS_YYCC_STRING_REINTERPRET;
T rv;
const auto* head = reinterpret::as_ordinary(strl.data());
const auto* tail = reinterpret::as_ordinary(strl.data() + strl.size());
auto [ptr, ec] = std::from_chars(head, tail, rv, fmt);
if (ec == std::errc()) {
// Parse completely.
// But we need to check whether the whole string was parsed.
if (ptr == tail) return rv;
else return ParseError::PartiallyParsed;
} else if (ec == std::errc::invalid_argument) {
// Given string is invalid
return ParseError::InvalidString;
} else if (ec == std::errc::result_out_of_range) {
// Given string is out of range
return ParseError::OutOfRange;
} else {
// Unreachable
throw std::runtime_error("invalid ec.");
}
}
template<typename T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
ParseResult<T> _priv_parse(const NS_YYCC_STRING::u8string_view& strl, int base) {
namespace reinterpret = NS_YYCC_STRING_REINTERPRET;
T rv;
const auto* head = reinterpret::as_ordinary(strl.data());
const auto* tail = reinterpret::as_ordinary(strl.data() + strl.size());
auto [ptr, ec] = std::from_chars(head, tail, rv, base);
if (ec == std::errc()) {
// Parse completely.
// But we need to check whether the whole string was parsed.
if (ptr == tail) return rv;
else return ParseError::PartiallyParsed;
} else if (ec == std::errc::invalid_argument) {
// Given string is invalid
return ParseError::InvalidString;
} else if (ec == std::errc::result_out_of_range) {
// Given string is out of range
return ParseError::OutOfRange;
} else {
// Unreachable
throw std::runtime_error("invalid ec.");
}
}
template<typename T, std::enable_if_t<std::is_same_v<T, bool>, int> = 0>
ParseResult<T> _priv_parse(const NS_YYCC_STRING::u8string_view& strl) {
// Get lower case
auto lower_case = NS_YYCC_STRING_OP::to_lower(strl);
// Compare result
if (strl == YYCC_U8("true")) return true;
else if (strl == YYCC_U8("false")) return false;
else return ParseError::InvalidString;
}
/**
* @brief Try parsing given string to floating point types.
* @tparam T The type derived from floating point type.
* @param[in] strl The string need to be parsed.
* @param[out] num
* The variable receiving result.
* There is no guarantee that the content is not modified when parsing failed.
* @param[in] fmt The floating point format used when try parsing.
* @return True if success, otherwise false.
*/
template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
bool try_parse(const NS_YYCC_STRING::u8string_view& strl,
T& num,
std::chars_format fmt = std::chars_format::general) {
auto rv = _priv_parse<T>(strl, fmt);
if (const auto* ptr = std::get_if<T>(rv)) {
num = *ptr;
return true;
} else if (const auto* ptr = std::get_if<ParseError>(rv)) {
return false;
} else {
// Unreachable
throw std::runtime_error("unreachable code.");
}
}
/**
* @brief Try parsing given string to integral types.
* @tparam T The type derived from integral type except bool type.
* @param[in] strl The string need to be parsed.
* @param[out] num
* The variable receiving result.
* There is no guarantee that the content is not modified when parsing failed.
* @param[in] base Integer base to use: a value between 2 and 36 (inclusive).
* @return True if success, otherwise false.
*/
template<typename T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
bool try_parse(const NS_YYCC_STRING::u8string_view& strl, T& num, int base = 10) {
auto rv = _priv_parse<T>(strl, base);
if (const auto* ptr = std::get_if<T>(rv)) {
num = *ptr;
return true;
} else if (const auto* ptr = std::get_if<ParseError>(rv)) {
return false;
} else {
// Unreachable
throw std::runtime_error("unreachable code.");
}
}
/**
* @brief Try parsing given string to bool types.
* @tparam T The type derived from bool type.
* @param[in] strl The string need to be parsed ("true" or "false", case insensitive).
* @param[out] num
* The variable receiving result.
* There is no guarantee that the content is not modified when parsing failed.
* @return True if success, otherwise false.
*/
template<typename T, std::enable_if_t<std::is_same_v<T, bool>, int> = 0>
bool try_parse(const NS_YYCC_STRING::u8string_view& strl, T& num) {
auto rv = _priv_parse<T>(strl);
if (const auto* ptr = std::get_if<T>(rv)) {
num = *ptr;
return true;
} else if (const auto* ptr = std::get_if<ParseError>(rv)) {
return false;
} else {
// Unreachable
throw std::runtime_error("unreachable code.");
}
}
/**
* @brief Parse given string to floating point types.
* @tparam T The type derived from floating point type.
* @param[in] strl The string need to be parsed.
* @param[in] fmt The floating point format used when try parsing.
* @return
* The parsing result.
* There is no guarantee about the content of this return value when parsing failed.
* It may be any possible value but usually is its default value.
* @exception std::invalid_argument Can not parse given string.
*/
template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
T parse(const NS_YYCC_STRING::u8string_view& strl,
std::chars_format fmt = std::chars_format::general) {
T rv;
if (try_parse(strl, rv, fmt)) return rv;
else throw std::invalid_argument("can not parse given string");
}
/**
* @brief Parse given string to integral type types.
* @tparam T The type derived from integral type except bool type.
* @param[in] strl The string need to be parsed.
* @param[in] base Integer base to use: a value between 2 and 36 (inclusive).
* @return
* The parsing result.
* There is no guarantee about the content of this return value when parsing failed.
* It may be any possible value but usually is its default value.
* @exception std::invalid_argument Can not parse given string.
*/
template<typename T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
T parse(const NS_YYCC_STRING::u8string_view& strl, int base = 10) {
T rv;
if (try_parse(strl, rv, base)) return rv;
else throw std::invalid_argument("can not parse given string");
}
/**
* @brief Parse given string to bool types.
* @tparam T The type derived from bool type.
* @param[in] strl The string need to be parsed ("true" or "false", case insensitive).
* @return
* The parsing result.
* There is no guarantee about the content of this return value when parsing failed.
* It may be any possible value but usually is its default value.
* @exception std::invalid_argument Can not parse given string.
*/
template<typename T, std::enable_if_t<std::is_same_v<T, bool>, int> = 0>
T parse(const NS_YYCC_STRING::u8string_view& strl) {
T rv;
if (try_parse(strl, rv)) return rv;
else throw std::invalid_argument("can not parse given string");
}
} // namespace yycc::string::parse
#undef NS_YYCC_STRING_OP
#undef NS_YYCC_STRING_REINTERPRET
#undef NS_YYCC_STRING

92
src/yycc/string/stringify.hpp Normal file
View File

@ -0,0 +1,92 @@
#pragma once
#include "../string.hpp"
#include "reinterpret.hpp"
#include <array>
#include <charconv>
#include <stdexcept>
#include <type_traits>
#define NS_YYCC_STRING ::yycc::string
#define NS_YYCC_STRING_REINTERPRET ::yycc::string::reinterpret
namespace yycc::string::stringify {
// Developer Notes:
// Reference: https://en.cppreference.com/w/cpp/utility/to_chars
// Default float precision = 6 is gotten from: https://en.cppreference.com/w/c/io/fprintf
inline constexpr size_t STRINGIFY_BUFFER_SIZE = 64u;
using StringifyBuffer = std::array<NS_YYCC_STRING::u8char, STRINGIFY_BUFFER_SIZE>;
/**
* @brief Return the string representation of given floating point value.
* @tparam T The type derived from floating point type.
* @param[in] num The value need to get string representation.
* @param[in] fmt The floating point format used when getting string representation.
* @param[in] precision The floating point precision used when getting string representation.
* @return The string representation of given value.
*/
template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
NS_YYCC_STRING::u8string stringify(T num,
std::chars_format fmt = std::chars_format::general,
int precision = 6) {
namespace reinterpret = NS_YYCC_STRING_REINTERPRET;
StringifyBuffer buffer;
auto [ptr, ec] = std::to_chars(reinterpret::as_ordinary(buffer.data()),
reinterpret::as_ordinary(buffer.data() + buffer.size()),
num,
fmt,
precision);
if (ec == std::errc()) {
return NS_YYCC_STRING::u8string(buffer.data(),
reinterpret::as_utf8(ptr) - buffer.data());
} else if (ec == std::errc::value_too_large) {
// Too short buffer. This should not happened
throw std::out_of_range("stringify() buffer is not sufficient.");
} else {
// Unreachable
throw std::runtime_error("unreachable code.");
}
}
/**
* @brief Return the string representation of given integral value.
* @tparam T The type derived from integral type except bool type.
* @param[in] num The value need to get string representation.
* @param[in] base Integer base used when getting string representation: a value between 2 and 36 (inclusive).
* @return The string representation of given value.
*/
template<typename T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
NS_YYCC_STRING::u8string stringify(T num, int base = 10) {
namespace reinterpret = NS_YYCC_STRING_REINTERPRET;
StringifyBuffer buffer;
auto [ptr, ec] = std::to_chars(reinterpret::as_ordinary(buffer.data()),
reinterpret::as_ordinary(buffer.data() + buffer.size()),
num,
base);
if (ec == std::errc()) {
return NS_YYCC_STRING::u8string(buffer.data(),
reinterpret::as_utf8(ptr) - buffer.data());
} else if (ec == std::errc::value_too_large) {
// Too short buffer. This should not happened
throw std::out_of_range("stringify() buffer is not sufficient.");
} else {
// Unreachable
throw std::runtime_error("unreachable code.");
}
}
/**
* @brief Return the string representation of given bool value.
* @tparam T The type derived from bool type.
* @param[in] num The value need to get string representation.
* @return The string representation of given value ("true" or "false").
*/
template<typename T, std::enable_if_t<std::is_same_v<T, bool>, int> = 0>
NS_YYCC_STRING::u8string stringify(T num) {
if (num) return NS_YYCC_STRING::u8string(YYCC_U8("true"));
else return NS_YYCC_STRING::u8string(YYCC_U8("false"));
}
} // namespace yycc::string::stringify
#undef NS_YYCC_STRING_REINTERPRET
#undef NS_YYCC_STRING

1
testbench/CMakeLists.txt
View File

@ -6,7 +6,6 @@ PRIVATE
main.cpp
yycc/constraint.cpp
yycc/constraint/builder.cpp
yycc/string.cpp
yycc/string/op.cpp
yycc/string/reinterpret.cpp
)

2
testbench/yycc/string.cpp
View File

@ -1,2 +0,0 @@
namespace yycctest::string {}

4
testbench/yycc/string/op.cpp
View File

@ -48,12 +48,12 @@ namespace yycctest::string::op {
}
TEST(StringOp, Lower) {
auto rv = OP::lower(YYCC_U8("LOWER"));
auto rv = OP::to_lower(YYCC_U8("LOWER"));
EXPECT_EQ(rv, YYCC_U8("lower"));
}
TEST(StringOp, Upper) {
auto rv = OP::upper(YYCC_U8("upper"));
auto rv = OP::to_upper(YYCC_U8("upper"));
EXPECT_EQ(rv, YYCC_U8("UPPER"));
}