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

refactor: finish rust parse and add testbench for it.

Browse Source
This commit is contained in:
yyc12345 2025-06-26 10:27:33 +08:00
parent a6382d6a22
commit e166dc41ac
11 changed files with 229 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/CMakeLists.txt
View File

@ -51,6 +51,7 @@ FILES
yycc/rust/option.hpp
yycc/rust/result.hpp
yycc/rust/parse.hpp
yycc/rust/stringify.hpp
yycc/windows/unsafe_suppressor.hpp
yycc/windows/import_guard_head.hpp
yycc/windows/import_guard_tail.hpp

11
src/yycc/prelude/rust.hpp
View File

@ -5,6 +5,9 @@
// Rust prelude section
#include "../rust/primitive.hpp"
#include "../rust/result.hpp"
#include "../rust/option.hpp"
#include "../rust/panic.hpp"
#include <vector>
namespace yycc::prelude::rust {
@ -35,6 +38,14 @@ namespace yycc::prelude::rust {
using String = ::yycc::string::u8string;
template<typename T>
using Vec = std::vector<T>;
// Expose Result and Option
using namespace ::yycc::rust::option;
using namespace ::yycc::rust::result;
// Panic are introduced by including header file
// so we do not need re-expose it.
} // namespace yycc::prelude::rust
// Expose all members

2
src/yycc/rust/option.hpp
View File

@ -20,4 +20,4 @@ namespace yycc::rust::option {
return OptionType(std::nullopt);
}
}
} // namespace yycc::rust::option

79
src/yycc/rust/parse.hpp
View File

@ -4,21 +4,96 @@
#include "panic.hpp"
#include "result.hpp"
#define NS_YYCC_STRING ::yycc::string
#define NS_YYCC_STRING_PARSE ::yycc::string::parse
#define NS_YYCC_RUST_RESULT ::yycc::rust::result
/**
* @namespace yycc::rust::parse
* @brief Provides Rust-inspired parsing utilities for converting strings to various types.
* @details
* This namespace contains template functions for parsing strings into different types
* (floating-point, integral, boolean) with Rust-like Result error handling.
*/
namespace yycc::rust::parse {
#if defined(YYCC_CPPFEAT_EXPECTED)
/// @brief The error type of parsing.
using Error = NS_YYCC_STRING_PARSE::ParseError;
// template<typename T>
// using Result = std::expected<T, Error>;
/// @brief The result type of parsing.
/// @tparam T The expected value type in result.
template<typename T>
using Result = NS_YYCC_RUST_RESULT::Result<T, Error>;
/**
* @brief Parses a string into a floating-point value.
* @tparam T Floating-point type to parse into (float, double, etc.)
* @param strl String view to parse
* @param fmt Formatting flags for parsing (default: general)
* @return Result<T> containing either the parsed value or an error
*/
template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
Result<T> parse(const NS_YYCC_STRING::u8string_view& strl,
std::chars_format fmt = std::chars_format::general) {
auto rv = NS_YYCC_STRING_PARSE::priv_parse<T>(strl, fmt);
if (const auto* ptr = std::get_if<T>(&rv)) {
return NS_YYCC_RUST_RESULT::Ok<Result<T>>(*ptr);
} else if (const auto* ptr = std::get_if<Error>(&rv)) {
return NS_YYCC_RUST_RESULT::Err<Result<T>>(*ptr);
} else {
// Unreachable
RS_PANIC("unreachable code.");
}
}
/**
* @brief Parses a string into an integral value (excluding bool).
* @tparam T Integral type to parse into (int, long, etc.)
* @param strl String view to parse
* @param base Numeric base for parsing (default: 10)
* @return Result<T> containing either the parsed value or an error
*/
template<typename T, std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
Result<T> parse(const NS_YYCC_STRING::u8string_view& strl, int base = 10) {
auto rv = NS_YYCC_STRING_PARSE::priv_parse<T>(strl, base);
if (const auto* ptr = std::get_if<T>(&rv)) {
return NS_YYCC_RUST_RESULT::Ok<Result<T>>(*ptr);
} else if (const auto* ptr = std::get_if<Error>(&rv)) {
return NS_YYCC_RUST_RESULT::Err<Result<T>>(*ptr);
} else {
// Unreachable
RS_PANIC("unreachable code.");
}
}
/**
* @brief Parses a string into a boolean value.
* @tparam T Must be bool type
* @param strl String view to parse
* @return Result<bool> containing either the parsed value or an error
*/
template<typename T, std::enable_if_t<std::is_same_v<T, bool>, int> = 0>
Result<T> parse(const NS_YYCC_STRING::u8string_view& strl) {
auto rv = NS_YYCC_STRING_PARSE::priv_parse<T>(strl);
if (const auto* ptr = std::get_if<T>(&rv)) {
return NS_YYCC_RUST_RESULT::Ok<Result<T>>(*ptr);
} else if (const auto* ptr = std::get_if<Error>(&rv)) {
return NS_YYCC_RUST_RESULT::Err<Result<T>>(*ptr);
} else {
// Unreachable
RS_PANIC("unreachable code.");
}
}
#endif
}
#undef NS_YYCC_RUST_RESULT
#undef NS_YYCC_STRING_PARSE
#undef NS_YYCC_STRING

2
src/yycc/rust/result.hpp
View File

@ -82,4 +82,4 @@ namespace yycc::rust::result {
#endif
}
} // namespace yycc::rust::result

10
src/yycc/rust/stringify.hpp Normal file
View File

@ -0,0 +1,10 @@
#pragma once
#include "../string/stringify.hpp"
namespace yycc::rust::stringify {
// There is no modification for legacy "stringify" functions like "parse".
// So we simply expose all functions into this namespace.
using namespace ::yycc::string::stringify;
} // namespace yycc::rust::stringify

2
testbench/CMakeLists.txt
View File

@ -10,6 +10,8 @@ PRIVATE
yycc/string/reinterpret.cpp
yycc/string/parse.cpp
yycc/string/stringify.cpp
yycc/rust/parse.cpp
yycc/rust/stringify.cpp
)
# Setup headers
target_include_directories(YYCCTestbench

87
testbench/yycc/rust/parse.cpp Normal file
View File

@ -0,0 +1,87 @@
#include <gtest/gtest.h>
#include <yycc.hpp>
#include <yycc/rust/parse.hpp>
#include <yycc/prelude/rust.hpp>
#define PARSE ::yycc::rust::parse
namespace yycctest::rust::parse {
// We only want to test it if C++ support it.
#if defined(YYCC_CPPFEAT_EXPECTED)
// This namespace is just a wrapper for legacy "parse" module.
// So the test is just a copy of original implementation.
// Please update this if original test was updated.
#define TEST_SUCCESS(type_t, expected_value, string_value, ...) \
{ \
u8string cache_string(YYCC_U8(string_value)); \
auto rv = PARSE::parse<type_t>(cache_string, ##__VA_ARGS__); \
ASSERT_TRUE(rv.has_value()); \
EXPECT_EQ(rv.value(), expected_value); \
}
#define TEST_FAIL(type_t, string_value, ...) \
{ \
u8string cache_string(YYCC_U8(string_value)); \
auto rv = PARSE::parse<type_t>(cache_string, ##__VA_ARGS__); \
EXPECT_FALSE(rv.has_value()); \
}
TEST(RustParse, Common) {
TEST_SUCCESS(i8, INT8_C(-61), "-61");
TEST_SUCCESS(u8, UINT8_C(200), "200");
TEST_SUCCESS(i16, INT16_C(6161), "6161");
TEST_SUCCESS(u16, UINT16_C(32800), "32800");
TEST_SUCCESS(i32, INT32_C(61616161), "61616161");
TEST_SUCCESS(u32, UINT32_C(4294967293), "4294967293");
TEST_SUCCESS(i64, INT64_C(616161616161), "616161616161");
TEST_SUCCESS(u64, UINT64_C(9223372036854775807), "9223372036854775807");
TEST_SUCCESS(float, 1.0f, "1.0");
TEST_SUCCESS(double, 1.0, "1.0");
TEST_SUCCESS(bool, true, "true");
TEST_SUCCESS(bool, false, "false");
}
TEST(RustParse, Radix) {
TEST_SUCCESS(u32, UINT32_C(0xffff), "ffff", 16);
TEST_SUCCESS(u32, UINT32_C(032), "032", 8);
TEST_SUCCESS(u32, UINT32_C(0B1011), "1011", 2);
}
TEST(RustParse, CaseInsensitive) {
TEST_SUCCESS(bool, true, "tRUE");
}
TEST(RustParse, Overflow) {
TEST_FAIL(i8, "6161");
TEST_FAIL(u8, "32800");
TEST_FAIL(i16, "61616161");
TEST_FAIL(u16, "4294967293");
TEST_FAIL(i32, "616161616161");
TEST_FAIL(u32, "9223372036854775807");
TEST_FAIL(i64, "616161616161616161616161");
TEST_FAIL(u64, "92233720368547758079223372036854775807");
TEST_FAIL(float, "1e40");
TEST_FAIL(double, "1e114514");
}
TEST(RustParse, BadRadix) {
TEST_FAIL(u32, "fghj", 16);
TEST_FAIL(u32, "099", 8);
TEST_FAIL(u32, "12345", 2);
}
TEST(RustParse, InvalidWords) {
TEST_FAIL(u32, "hello, world!");
TEST_FAIL(bool, "hello, world!");
}
#endif
} // namespace yycctest::rust::parse

14
testbench/yycc/rust/stringify.cpp Normal file
View File

@ -0,0 +1,14 @@
#include <gtest/gtest.h>
#include <yycc.hpp>
#include <yycc/rust/stringify.hpp>
#include <yycc/prelude/rust.hpp>
#define STRINGIFY ::yycc::string::stringify
namespace yycctest::rust::stringify {
// There is not testbench for this
// because it just a map to original implementation without any modification.
}

8
testbench/yycc/string/parse.cpp
View File

@ -12,7 +12,8 @@ namespace yycctest::string::parse {
// These 2 test macros build string container via given string.
// Check `try_parse` first, and then check `parse`.
#define TEST_SUCCESS(type_t, value, string_value, ...) { \
#define TEST_SUCCESS(type_t, value, string_value, ...) \
{ \
u8string cache_string(YYCC_U8(string_value)); \
type_t cache; \
ASSERT_TRUE(PARSE::try_parse<type_t>(cache_string, cache, ##__VA_ARGS__)); \
@ -20,7 +21,8 @@ namespace yycctest::string::parse {
EXPECT_EQ(PARSE::parse<type_t>(cache_string, ##__VA_ARGS__), value); \
}
#define TEST_FAIL(type_t, string_value, ...) { \
#define TEST_FAIL(type_t, string_value, ...) \
{ \
u8string cache_string(YYCC_U8(string_value)); \
type_t cache; \
EXPECT_FALSE(PARSE::try_parse<type_t>(cache_string, cache, ##__VA_ARGS__)); \
@ -79,4 +81,4 @@ namespace yycctest::string::parse {
TEST_FAIL(bool, "hello, world!");
}
}
} // namespace yycctest::string::parse

7
testbench/yycc/string/stringify.cpp
View File

@ -1,7 +1,7 @@
#include <gtest/gtest.h>
#include <yycc.hpp>
#include <yycc/string/stringify.hpp>
#include <yycc/string/reinterpret.hpp>
#include <yycc/string/stringify.hpp>
#include <yycc/prelude/rust.hpp>
@ -9,7 +9,8 @@
namespace yycctest::string::stringify {
#define TEST_SUCCESS(type_t, value, string_value, ...) { \
#define TEST_SUCCESS(type_t, value, string_value, ...) \
{ \
type_t cache = value; \
u8string ret = STRINGIFY::stringify<type_t>(cache, ##__VA_ARGS__); \
EXPECT_EQ(ret, YYCC_U8(string_value)); \
@ -38,4 +39,4 @@ namespace yycctest::string::stringify {
TEST_SUCCESS(u32, UINT32_C(0B1011), "1011", 2);
}
}
} // namespace yycctest::string::stringify