mpusz/mp-units
1
0
Fork 1
mirror of https://github.com/mpusz/mp-units.git synced 2025-08-01 03:14:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

feat: 💥 symbol_text definition simplified

Browse Source
This commit is contained in:
Mateusz Pusz
2023-11-30 09:25:29 +01:00
parent 97d5bb569b
commit 29c83c0d84
5 changed files with 24 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/core/include/mp-units/bits/magnitude.h
View File

@@ -869,23 +869,23 @@ template<Magnitude auto M>
if constexpr (num_value == 1 && den_value == 1 && exp10 != 0) {
return base_multiplier + superscript<exp10>();
} else if constexpr (num_value != 1 || den_value != 1 || exp10 != 0) {
auto txt = basic_fixed_string("[") + regular<num_value>();
auto txt = basic_symbol_text("[") + regular<num_value>();
if constexpr (den_value == 1) {
if constexpr (exp10 == 0) {
return txt + basic_fixed_string("]");
return txt + basic_symbol_text("]");
} else {
return txt + " " + base_multiplier + superscript<exp10>() + basic_fixed_string("]");
return txt + basic_symbol_text(" ") + base_multiplier + superscript<exp10>() + basic_symbol_text("]");
}
} else {
if constexpr (exp10 == 0) {
return txt + basic_fixed_string("/") + regular<den_value>() + basic_fixed_string("]");
return txt + basic_symbol_text("/") + regular<den_value>() + basic_symbol_text("]");
} else {
return txt + basic_fixed_string("/") + regular<den_value>() + " " + base_multiplier + superscript<exp10>() +
basic_fixed_string("]");
return txt + basic_symbol_text("/") + regular<den_value>() + basic_symbol_text(" ") + base_multiplier +
superscript<exp10>() + basic_symbol_text("]");
}
}
} else {
return basic_fixed_string("");
return basic_symbol_text("");
}
}

67
src/core/include/mp-units/bits/symbol_text.h
View File

@@ -66,88 +66,44 @@ struct basic_symbol_text {
basic_fixed_string<UnicodeCharT, N> unicode_;
basic_fixed_string<char, M> ascii_;
constexpr explicit(false) basic_symbol_text(char txt) noexcept : unicode_(txt), ascii_(txt)
constexpr explicit(false) basic_symbol_text(char txt) : unicode_(txt), ascii_(txt)
{
detail::validate_ascii_char(txt);
}
constexpr basic_symbol_text(UnicodeCharT u, char a) noexcept : unicode_(u), ascii_(a)
{
detail::validate_ascii_char(a);
}
constexpr explicit(false) basic_symbol_text(const char (&txt)[N + 1]) noexcept : unicode_(txt), ascii_(txt)
constexpr explicit(false) basic_symbol_text(const char (&txt)[N + 1]) : unicode_(txt), ascii_(txt)
{
detail::validate_ascii_string<N>(txt);
}
constexpr explicit(false) basic_symbol_text(const basic_fixed_string<char, N>& txt) noexcept :
unicode_(txt), ascii_(txt)
constexpr explicit(false) basic_symbol_text(const basic_fixed_string<char, N>& txt) : unicode_(txt), ascii_(txt)
{
detail::validate_ascii_string<N>(txt.data_);
}
constexpr basic_symbol_text(const UnicodeCharT (&u)[N + 1], const char (&a)[M + 1]) noexcept : unicode_(u), ascii_(a)
constexpr basic_symbol_text(const UnicodeCharT (&u)[N + 1], const char (&a)[M + 1]) : unicode_(u), ascii_(a)
{
detail::validate_ascii_string<M>(a);
}
constexpr basic_symbol_text(const basic_fixed_string<UnicodeCharT, N>& u,
const basic_fixed_string<char, M>& a) noexcept :
constexpr basic_symbol_text(const basic_fixed_string<UnicodeCharT, N>& u, const basic_fixed_string<char, M>& a) :
unicode_(u), ascii_(a)
{
detail::validate_ascii_string<M>(a.data_);
}
[[nodiscard]] constexpr auto& unicode() { return unicode_; }
[[nodiscard]] constexpr const auto& unicode() const { return unicode_; }
[[nodiscard]] constexpr auto& ascii() { return ascii_; }
[[nodiscard]] constexpr const auto& ascii() const { return ascii_; }
[[nodiscard]] constexpr bool empty() const { return unicode().empty() && ascii().empty(); }
template<std::size_t N2, std::size_t M2>
[[nodiscard]] constexpr friend basic_symbol_text<UnicodeCharT, N + N2, M + M2> operator+(
const basic_symbol_text& lhs, const basic_symbol_text<UnicodeCharT, N2, M2>& rhs) noexcept
const basic_symbol_text& lhs, const basic_symbol_text<UnicodeCharT, N2, M2>& rhs)
{
return basic_symbol_text<UnicodeCharT, N + N2, M + M2>(lhs.unicode() + rhs.unicode(), lhs.ascii() + rhs.ascii());
}
template<std::size_t N2>
[[nodiscard]] constexpr friend basic_symbol_text<UnicodeCharT, N + N2, M + N2> operator+(
const basic_symbol_text& lhs, const basic_fixed_string<UnicodeCharT, N2>& rhs) noexcept
{
return lhs + basic_symbol_text<UnicodeCharT, N2, N2>(rhs);
}
template<std::size_t N2>
[[nodiscard]] constexpr friend basic_symbol_text<UnicodeCharT, N + N2, M + N2> operator+(
const basic_fixed_string<UnicodeCharT, N2>& lhs, const basic_symbol_text& rhs) noexcept
{
return basic_symbol_text<UnicodeCharT, N2, N2>(lhs) + rhs;
}
template<std::size_t N2>
[[nodiscard]] constexpr friend basic_symbol_text<UnicodeCharT, N + N2 - 1, M + N2 - 1> operator+(
const basic_symbol_text& lhs, const UnicodeCharT (&rhs)[N2]) noexcept
{
return lhs + basic_symbol_text<UnicodeCharT, N2 - 1, N2 - 1>(rhs);
}
template<std::size_t N2>
[[nodiscard]] constexpr friend basic_symbol_text<UnicodeCharT, N + N2 - 1, M + N2 - 1> operator+(
const UnicodeCharT (&lhs)[N2], const basic_symbol_text& rhs) noexcept
{
return basic_symbol_text<UnicodeCharT, N2 - 1, N2 - 1>(lhs) + rhs;
}
[[nodiscard]] constexpr friend basic_symbol_text<UnicodeCharT, N + 1, M + 1> operator+(const basic_symbol_text& lhs,
UnicodeCharT rhs) noexcept
{
return lhs + basic_symbol_text<UnicodeCharT, 1, 1>(rhs);
}
[[nodiscard]] constexpr friend basic_symbol_text<UnicodeCharT, N + 1, M + 1> operator+(
UnicodeCharT lhs, const basic_symbol_text& rhs) noexcept
{
return basic_symbol_text<UnicodeCharT, 1, 1>(lhs) + rhs;
}
template<typename UnicodeCharT2, std::size_t N2, std::size_t M2>
[[nodiscard]] friend constexpr auto operator<=>(const basic_symbol_text& lhs,
const basic_symbol_text<UnicodeCharT2, N2, M2>& rhs) noexcept
@@ -169,9 +125,6 @@ struct basic_symbol_text {
basic_symbol_text(char) -> basic_symbol_text<char, 1, 1>;
template<typename UnicodeCharT>
basic_symbol_text(UnicodeCharT, char) -> basic_symbol_text<UnicodeCharT, 1, 1>;
template<std::size_t N>
basic_symbol_text(const char (&)[N]) -> basic_symbol_text<char, N - 1, N - 1>;

2
src/core/include/mp-units/bits/text_tools.h
View File

@@ -77,7 +77,7 @@ template<std::intmax_t Value>
[[nodiscard]] consteval auto regular()
{
if constexpr (Value < 0)
return basic_fixed_string("-") + superscript_helper<-Value>();
return basic_symbol_text("-") + superscript_helper<-Value>();
else if constexpr (Value < 10)
return basic_symbol_text(static_cast<char>('0' + Value));
else

4
src/core/include/mp-units/unit.h
View File

@@ -720,8 +720,8 @@ constexpr auto unit_symbol_impl(Out out, const power<F, Num, Den...>&, unit_symb
constexpr ratio r = power<F, Num, Den...>::exponent;
if constexpr (r.den != 1) {
// add root part
constexpr auto txt = basic_fixed_string("^(") + regular<r.num>() + basic_fixed_string("/") + regular<r.den>() +
basic_fixed_string(")");
constexpr auto txt =
basic_symbol_text("^(") + regular<r.num>() + basic_symbol_text("/") + regular<r.den>() + basic_symbol_text(")");
return copy<CharT>(txt, fmt.encoding, out);
} else if constexpr (r.num != 1) {
// add exponent part

20
test/unit_test/static/symbol_text_test.cpp
View File

@@ -39,12 +39,6 @@ static_assert(sym1 >= 'a');
static_assert(sym1.unicode() == "b");
static_assert(sym1.ascii() == "b");
constexpr basic_symbol_text sym2('a', 'b');
static_assert(sym2 == basic_symbol_text('a', 'b'));
static_assert(sym2 != 'b');
static_assert(sym2.unicode() == 'a');
static_assert(sym2.ascii() == 'b');
constexpr basic_symbol_text sym3("ab");
static_assert(sym3.unicode() == "ab");
static_assert(sym3.ascii() == "ab");
@@ -77,19 +71,13 @@ static_assert(sym6 >= basic_symbol_text("bc"));
static_assert(basic_symbol_text("a") + sym4 == basic_symbol_text("abc"));
static_assert(sym4 + basic_symbol_text("f") == basic_symbol_text("bcf"));
static_assert(basic_fixed_string("a") + sym4 == basic_symbol_text("abc"));
static_assert(sym4 + basic_fixed_string("f") == basic_symbol_text("bcf"));
static_assert(basic_symbol_text("a", "f") + sym6 == basic_symbol_text("abc", "fde"));
static_assert(sym6 + basic_symbol_text("a", "f") == basic_symbol_text("bca", "def"));
static_assert('a' + sym6 == basic_symbol_text("abc", "ade"));
static_assert(sym6 + 'f' == basic_symbol_text("bcf", "def"));
static_assert(basic_symbol_text('a') + sym6 == basic_symbol_text("abc", "ade"));
static_assert(sym6 + basic_symbol_text('f') == basic_symbol_text("bcf", "def"));
static_assert(basic_fixed_string("a") + sym6 == basic_symbol_text("abc", "ade"));
static_assert(sym6 + basic_fixed_string("f") == basic_symbol_text("bcf", "def"));
static_assert("a" + sym6 == basic_symbol_text("abc", "ade"));
static_assert(sym6 + "f" == basic_symbol_text("bcf", "def"));
static_assert(basic_symbol_text("a") + sym6 == basic_symbol_text("abc", "ade"));
static_assert(sym6 + basic_symbol_text("f") == basic_symbol_text("bcf", "def"));
} // namespace