Turn CaseSensitive into proper enum class

src/catch2/internal/catch_case_sensitive.hpp

@@ -3,9 +3,7 @@
 
 namespace Catch {
 
-    struct CaseSensitive {
+    enum class CaseSensitive { Yes, No };
-        enum Choice { Yes, No };
-    };
 
 } // namespace Catch
 

src/catch2/internal/catch_wildcard_pattern.cpp

@@ -12,7 +12,7 @@
 namespace Catch {
 
     WildcardPattern::WildcardPattern( std::string const& pattern,
-                                      CaseSensitive::Choice caseSensitivity )
+                                      CaseSensitive caseSensitivity )
     :   m_caseSensitivity( caseSensitivity ),
         m_pattern( normaliseString( pattern ) )
     {

src/catch2/internal/catch_wildcard_pattern.hpp

@@ -24,13 +24,13 @@ namespace Catch
 
     public:
 
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+        WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity );
         virtual ~WildcardPattern() = default;
         virtual bool matches( std::string const& str ) const;
 
     private:
         std::string normaliseString( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
+        CaseSensitive m_caseSensitivity;
         WildcardPosition m_wildcard = NoWildcard;
         std::string m_pattern;
     };

src/catch2/matchers/catch_matchers_string.cpp

@@ -12,7 +12,7 @@
 namespace Catch {
 namespace Matchers {
 
-    CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity )
+    CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity )
     :   m_caseSensitivity( caseSensitivity ),
         m_str( adjustString( str ) )
     {}
@@ -74,11 +74,11 @@ namespace Matchers {
 
 
 
-    RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
+    RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
 
     bool RegexMatcher::match(std::string const& matchee) const {
         auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
-        if (m_caseSensitivity == CaseSensitive::Choice::No) {
+        if (m_caseSensitivity == CaseSensitive::No) {
             flags |= std::regex::icase;
         }
         auto reg = std::regex(m_regex, flags);
@@ -86,24 +86,24 @@ namespace Matchers {
     }
 
     std::string RegexMatcher::describe() const {
-        return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
+        return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively");
     }
 
 
-    StringEqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) {
         return StringEqualsMatcher( CasedString( str, caseSensitivity) );
     }
-    StringContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+    StringContainsMatcher Contains( std::string const& str, CaseSensitive caseSensitivity ) {
         return StringContainsMatcher( CasedString( str, caseSensitivity) );
     }
-    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) {
         return EndsWithMatcher( CasedString( str, caseSensitivity) );
     }
-    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
+    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) {
         return StartsWithMatcher( CasedString( str, caseSensitivity) );
     }
 
-    RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
+    RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) {
         return RegexMatcher(regex, caseSensitivity);
     }
 

src/catch2/matchers/catch_matchers_string.hpp

@@ -17,11 +17,11 @@ namespace Catch {
 namespace Matchers {
 
     struct CasedString {
-        CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
+        CasedString( std::string const& str, CaseSensitive caseSensitivity );
         std::string adjustString( std::string const& str ) const;
         std::string caseSensitivitySuffix() const;
 
-        CaseSensitive::Choice m_caseSensitivity;
+        CaseSensitive m_caseSensitivity;
         std::string m_str;
     };
 
@@ -51,25 +51,25 @@ namespace Matchers {
     };
 
     struct RegexMatcher final : MatcherBase<std::string> {
-        RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
+        RegexMatcher( std::string regex, CaseSensitive caseSensitivity );
         bool match( std::string const& matchee ) const override;
         std::string describe() const override;
 
     private:
         std::string m_regex;
-        CaseSensitive::Choice m_caseSensitivity;
+        CaseSensitive m_caseSensitivity;
     };
 
     //! Creates matcher that accepts strings that are exactly equal to `str`
-    StringEqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
     //! Creates matcher that accepts strings that contain `str`
-    StringContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StringContainsMatcher Contains( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
     //! Creates matcher that accepts strings that _end_ with `str`
-    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
     //! Creates matcher that accepts strings that _start_ with `str`
-    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
     //! Creates matcher that accepts strings matching `regex`
-    RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    RegexMatcher Matches( std::string const& regex, CaseSensitive caseSensitivity = CaseSensitive::Yes );
 
 } // namespace Matchers
 } // namespace Catch