Idea: Adding from_string to enum metafunction (#1185)

* Added from_string to enum metafunction

* Changed string to string_view

* Changed string to string_view in test result now too

* Enable from_string for flag_enums too, and use contract violation handling

Changed failures from unconditional abort to a type_safety violation (which defaults to abort but allows a customizable handler) because it really is a precondition violation so a contract makes sense

* Fix typo in regression test case

* For flag_enums, let from_string take a "( list, of_multiple, flags )"

* Changed flag_enum to_string from (a,b) to (a|b)

And fixed bug to correct error case `break`

* Provide {to|from}_{string|code}

to_string/from_string round-trip, don't enum_name::-qualify, and represent a list with comma separators

to_code/from_code round-trip, do enum_name::-qualify, and represent a list with | separators

* Avoid repeated eval of to_string(prefix)

Add regress test case for to_code / from_code

Update regression test and generated files

---------

Signed-off-by: Herb Sutter <[email protected]>
Co-authored-by: Herb Sutter <[email protected]>

Author: tsoj

include/cpp2regex.h

@@ -211,7 +211,11 @@ public: constexpr auto operator=(expression_flags const& that) -> expression_fla
 public: constexpr expression_flags(expression_flags&& that) noexcept;
 public: constexpr auto operator=(expression_flags&& that) noexcept -> expression_flags& ;
 public: [[nodiscard]] auto operator<=>(expression_flags const& that) const& -> std::strong_ordering = default;
+public: [[nodiscard]] auto to_string_impl(cpp2::impl::in<std::string_view> prefix, cpp2::impl::in<std::string_view> separator) const& -> std::string;
 public: [[nodiscard]] auto to_string() const& -> std::string;
+public: [[nodiscard]] auto to_code() const& -> std::string;
+public: [[nodiscard]] static auto from_string(cpp2::impl::in<std::string_view> s) -> expression_flags;
+public: [[nodiscard]] static auto from_code(cpp2::impl::in<std::string_view> s) -> expression_flags;
 
 #line 55 "cpp2regex.h2"
 };
@@ -1540,21 +1544,51 @@ constexpr expression_flags::expression_flags(expression_flags&& that) noexcept
 constexpr auto expression_flags::operator=(expression_flags&& that) noexcept -> expression_flags& {
                                               _value = std::move(that)._value;
                                               return *this;}
-[[nodiscard]] auto expression_flags::to_string() const& -> std::string{
+[[nodiscard]] auto expression_flags::to_string_impl(cpp2::impl::in<std::string_view> prefix, cpp2::impl::in<std::string_view> separator) const& -> std::string{
 
-std::string _ret {"("}; 
+std::string ret {"("}; 
 
-std::string _comma {}; 
+std::string sep {}; 
 if ((*this) == none) {return "(none)"; }
-if (((*this) & case_insensitive) == case_insensitive) {_ret += _comma + "case_insensitive";_comma = ", ";}
-if (((*this) & multiple_lines) == multiple_lines) {_ret += _comma + "multiple_lines";_comma = ", ";}
-if (((*this) & single_line) == single_line) {_ret += _comma + "single_line";_comma = ", ";}
-if (((*this) & no_group_captures) == no_group_captures) {_ret += _comma + "no_group_captures";_comma = ", ";}
-if (((*this) & perl_code_syntax) == perl_code_syntax) {_ret += _comma + "perl_code_syntax";_comma = ", ";}
-if (((*this) & perl_code_syntax_in_classes) == perl_code_syntax_in_classes) {_ret += _comma + "perl_code_syntax_in_classes";_comma = ", ";}
-return cpp2::move(_ret) + ")"; 
+if (((*this) & case_insensitive) == case_insensitive) {ret += sep + cpp2::to_string(prefix) + "case_insensitive";sep = separator;}
+if (((*this) & multiple_lines) == multiple_lines) {ret += sep + cpp2::to_string(prefix) + "multiple_lines";sep = separator;}
+if (((*this) & single_line) == single_line) {ret += sep + cpp2::to_string(prefix) + "single_line";sep = separator;}
+if (((*this) & no_group_captures) == no_group_captures) {ret += sep + cpp2::to_string(prefix) + "no_group_captures";sep = separator;}
+if (((*this) & perl_code_syntax) == perl_code_syntax) {ret += sep + cpp2::to_string(prefix) + "perl_code_syntax";sep = separator;}
+if (((*this) & perl_code_syntax_in_classes) == perl_code_syntax_in_classes) {ret += sep + cpp2::to_string(prefix) + "perl_code_syntax_in_classes";sep = separator;}
+return cpp2::move(ret) + ")"; 
 }
 
+[[nodiscard]] auto expression_flags::to_string() const& -> std::string { return to_string_impl("", ", "); }
+[[nodiscard]] auto expression_flags::to_code() const& -> std::string { return to_string_impl("expression_flags::", " | "); }
+[[nodiscard]] auto expression_flags::from_string(cpp2::impl::in<std::string_view> s) -> expression_flags{
+
+auto ret {none}; 
+do {{
+for ( auto const& x : cpp2::string_util::split_string_list(s) ) {
+if ("case_insensitive" == x) {ret |= case_insensitive;}
+else {if ("multiple_lines" == x) {ret |= multiple_lines;}
+else {if ("single_line" == x) {ret |= single_line;}
+else {if ("no_group_captures" == x) {ret |= no_group_captures;}
+else {if ("perl_code_syntax" == x) {ret |= perl_code_syntax;}
+else {if ("perl_code_syntax_in_classes" == x) {ret |= perl_code_syntax_in_classes;}
+else {if ("none" == x) {ret |= none;}
+else {goto BREAK_outer;}
+#line 1 "cpp2regex.h2"
+}}}}}}
+}
+
+return ret; 
+} CPP2_CONTINUE_BREAK(outer) }
+ while ( 
+false
+);
+CPP2_UFCS(report_violation)(cpp2::type_safety, CPP2_UFCS(c_str)(("can't convert string '" + cpp2::to_string(s) + "' to flag_enum of type expression_flags")));
+return none; 
+}
+
+[[nodiscard]] auto expression_flags::from_code(cpp2::impl::in<std::string_view> s) -> expression_flags{
+std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::move(str), "expression_flags::", "")); }
 template <typename Iter> match_group<Iter>::match_group(auto const& start_, auto const& end_, auto const& matched_)
                                                                  : start{ start_ }
                                                                  , end{ end_ }
@@ -1564,6 +1598,7 @@ template <typename Iter> match_return<Iter>::match_return(auto const& matched_,
                                                          : matched{ matched_ }
                                                          , pos{ pos_ }{}
 template <typename Iter> match_return<Iter>::match_return(){}
+
 #line 38 "cpp2regex.h2"
 //-----------------------------------------------------------------------
 //

include/cpp2util.h

@@ -378,6 +378,40 @@ using _uchar     = unsigned char;    // normally use u8 instead
 
 namespace string_util {
 
+//  Break a string_view into a vector of views of simple qidentifier
+//  substrings separated by other characters
+auto split_string_list(std::string_view str)
+    -> std::vector<std::string_view>
+{
+    std::vector<std::string_view> ret;
+
+    auto is_id_char = [](char c) { 
+        return std::isalnum(c) || c == '_';
+    };
+
+    auto pos = 0;
+    while( pos < std::ssize(str) ) {
+        //  Skip non-alnum
+        while (pos < std::ssize(str) && !is_id_char(str[pos])) {
+            ++pos;
+        }
+        auto start = pos;
+
+        //  Find the end of the current component
+        while (pos < std::ssize(str) && is_id_char(str[pos])) {
+            ++pos;
+        }
+
+        //  Add nonempty substring to the vector
+        if (start < pos) {
+            ret.emplace_back(str.substr(start, pos - start));
+        }
+    }
+
+    return ret;
+}
+
+
 //  From https://stackoverflow.com/questions/216823/how-to-trim-a-stdstring
 
 //  Trim from start (in place)

regression-tests/pure2-enum.cpp2

@@ -35,12 +35,17 @@ main: () = {
     x: skat_game = skat_game::clubs;
     x2 := skat_game::diamonds;
     x2 = x;
+    x3 := skat_game::from_string("hearts");
+    x4 := skat_game::from_code("skat_game::hearts");
 
     // if x == 9 { }                    // error, can't compare skat_game and integer
     // if x == rgb::red { }             // error, can't compare skat_game and rgb color
 
     std::cout << "x.to_string() is (x.to_string())$\n";
     std::cout << "x2.to_string() is (x2.to_string())$\n";
+    std::cout << "x3.to_string() is (x3.to_string())$\n";
+    std::cout << "x3.to_code() is (x3.to_code())$\n";
+    std::cout << "x4.to_string() is (x3.to_string())$\n";
 
     std::cout << "with if else: ";
     if x == skat_game::diamonds {       // ok, can compare two skat_games
@@ -117,4 +122,14 @@ main: () = {
         is (cpp2::has_flags(f2))      = "includes all f2's flags ('cached' and 'current')";
         is _                          = "something else";
     } << "\n";
+
+    f_from_string := file_attributes::from_string("cached_and_current");
+    std::cout << "f_from_string is " << f_from_string.to_string() << "\n";
+
+    f_from_string = file_attributes::from_string("(current, obsolete)");
+    std::cout << "f_from_string is " << f_from_string.to_string() << "\n";
+    std::cout << "f_from_string.to_code() is " << f_from_string.to_code() << "\n";
+
+    f_from_string = file_attributes::from_code("(file_attributes::cached | file_attributes::obsolete)");
+    std::cout << "f_from_string is " << f_from_string.to_string() << "\n";
 }

regression-tests/test-results/clang-12-c++20/pure2-enum.cpp.execution

@@ -1,5 +1,8 @@
 x.to_string() is clubs
 x2.to_string() is clubs
+x3.to_string() is hearts
+x3.to_code() is skat_game::hearts
+x4.to_string() is hearts
 with if else: clubs
 with inspect: clubs
 
@@ -27,3 +30,7 @@ f  is (f2) is false
 f2 is (f ) is false
 (f & f2) == f2 is true
 inspecting f: includes all f2's flags ('cached' and 'current')
+f_from_string is (cached, current, cached_and_current)
+f_from_string is (current, obsolete)
+f_from_string.to_code() is (file_attributes::current | file_attributes::obsolete)
+f_from_string is (cached, obsolete)

regression-tests/test-results/gcc-10-c++20/pure2-enum.cpp.execution

@@ -1,5 +1,8 @@
 x.to_string() is clubs
 x2.to_string() is clubs
+x3.to_string() is hearts
+x3.to_code() is skat_game::hearts
+x4.to_string() is hearts
 with if else: clubs
 with inspect: clubs
 
@@ -27,3 +30,7 @@ f  is (f2) is false
 f2 is (f ) is false
 (f & f2) == f2 is true
 inspecting f: includes all f2's flags ('cached' and 'current')
+f_from_string is (cached, current, cached_and_current)
+f_from_string is (current, obsolete)
+f_from_string.to_code() is (file_attributes::current | file_attributes::obsolete)
+f_from_string is (cached, obsolete)

regression-tests/test-results/gcc-14-c++2b/pure2-enum.cpp.execution

@@ -1,5 +1,8 @@
 x.to_string() is clubs
 x2.to_string() is clubs
+x3.to_string() is hearts
+x3.to_code() is skat_game::hearts
+x4.to_string() is hearts
 with if else: clubs
 with inspect: clubs
 
@@ -27,3 +30,7 @@ f  is (f2) is false
 f2 is (f ) is false
 (f & f2) == f2 is true
 inspecting f: includes all f2's flags ('cached' and 'current')
+f_from_string is (cached, current, cached_and_current)
+f_from_string is (current, obsolete)
+f_from_string.to_code() is (file_attributes::current | file_attributes::obsolete)
+f_from_string is (cached, obsolete)

regression-tests/test-results/msvc-2022-c++latest/pure2-enum.cpp.execution

@@ -1,5 +1,8 @@
 x.to_string() is clubs
 x2.to_string() is clubs
+x3.to_string() is hearts
+x3.to_code() is skat_game::hearts
+x4.to_string() is hearts
 with if else: clubs
 with inspect: clubs
 
@@ -27,3 +30,7 @@ f  is (f2) is false
 f2 is (f ) is false
 (f & f2) == f2 is true
 inspecting f: includes all f2's flags ('cached' and 'current')
+f_from_string is (cached, current, cached_and_current)
+f_from_string is (current, obsolete)
+f_from_string.to_code() is (file_attributes::current | file_attributes::obsolete)
+f_from_string is (cached, obsolete)