Merge branch 'dev'

example/README.md

@@ -1,30 +1,30 @@
-Example 1 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/iQRrnUDkhC6KFJud)
+Example 1 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/fEPatLfGTxGe3023)
 =========
 
 Compile time matching only.
 
-Example 2 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/CQm52i9yjKa47DAo)
+Example 2 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/vwBgISrQkgjoV5I8)
 =========
 
 Compile time and runtime check of ID's validity using a pattern.
 
-Example 3 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/v1AW4oaJuA8gN4Dq)
+Example 3 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/G55AkM150gnC84nv)
 =========
 
 Example 2 extended with a default pattern and with a user-defined string
 literal.
 
-Example 4 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/rvmawltpGjc8y2Mm)
+Example 4 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/naeV9pF2dC6Uey2L)
 =========
 
 Matching of command line arguments.
 
-Example 5 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/Pop4jqw8olYRWQMX)
+Example 5 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/q7J6UbuQEsXf1x8L)
 =========
 
 List files on a given path which match a given pattern.
 
-Example 6 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/k04OU0lN2BJp5n5n)
+Example 6 [![Try it online](https://img.shields.io/badge/try%20it-online-blue.svg)](https://wandbox.org/permlink/b9frVhiZdEnGYWpm)
 =========
 
 Matching of generated DNA sequences.

include/cx.hpp

@@ -7,7 +7,7 @@
 #define CX_HPP
 
 #define CX_VERSION_MAJOR 1
-#define CX_VERSION_MINOR 1
+#define CX_VERSION_MINOR 2
 #define CX_VERSION_PATCH 0
 
 #include "cx/algorithm.hpp"

include/cx/functional.hpp

@@ -11,6 +11,26 @@
 namespace cx
 {
 
+template <typename T>
+struct less
+{
+  constexpr auto operator()(const T& lhs, const T& rhs) const -> decltype(lhs < rhs)
+  {
+    return lhs < rhs;
+  }
+};
+
+template <>
+struct less<void>
+{
+  template <typename T, typename U>
+  constexpr auto operator()(T&& lhs, U&& rhs) const
+      -> decltype(std::forward<T>(lhs) < std::forward<U>(rhs))
+  {
+    return std::forward<T>(lhs) < std::forward<U>(rhs);
+  }
+};
+
 template <typename T>
 struct equal_to
 {

include/wildcards.hpp

@@ -7,7 +7,7 @@
 #define WILDCARDS_HPP
 
 #define WILDCARDS_VERSION_MAJOR 1
-#define WILDCARDS_VERSION_MINOR 1
+#define WILDCARDS_VERSION_MINOR 2
 #define WILDCARDS_VERSION_PATCH 0
 
 #include "wildcards/cards.hpp"

include/wildcards/cards.hpp

@@ -15,29 +15,42 @@ template <typename T>
 struct cards
 {
   constexpr cards(T a, T s, T e)
-      : anything{std::move(a)}, single{std::move(s)}, escape{std::move(e)}, enum_enabled{false}
+      : anything{std::move(a)},
+        single{std::move(s)},
+        escape{std::move(e)},
+        set_enabled{false},
+        alt_enabled{false}
   {
   }
 
-  constexpr cards(T a, T s, T e, T eo, T ec, T ee)
+  constexpr cards(T a, T s, T e, T so, T sc, T sn, T ao, T ac, T ar)
       : anything{std::move(a)},
         single{std::move(s)},
         escape{std::move(e)},
-        enum_enabled{true},
-        enum_open{std::move(eo)},
-        enum_close{std::move(ec)},
-        enum_exclusion{std::move(ee)}
+        set_enabled{true},
+        set_open{std::move(so)},
+        set_close{std::move(sc)},
+        set_not{std::move(sn)},
+        alt_enabled{true},
+        alt_open{std::move(ao)},
+        alt_close{std::move(ac)},
+        alt_or{std::move(ar)}
   {
   }
 
   T anything;
   T single;
   T escape;
 
-  bool enum_enabled;
-  T enum_open;
-  T enum_close;
-  T enum_exclusion;
+  bool set_enabled;
+  T set_open;
+  T set_close;
+  T set_not;
+
+  bool alt_enabled;
+  T alt_open;
+  T alt_close;
+  T alt_or;
 };
 
 enum class cards_type
@@ -50,142 +63,205 @@ template <>
 struct cards<char>
 {
   constexpr cards(cards_type type = cards_type::extended)
-      : enum_enabled{type == cards_type::extended}
+      : set_enabled{type == cards_type::extended}, alt_enabled{type == cards_type::extended}
   {
   }
 
   constexpr cards(char a, char s, char e)
-      : anything{std::move(a)}, single{std::move(s)}, escape{std::move(e)}, enum_enabled{false}
+      : anything{std::move(a)},
+        single{std::move(s)},
+        escape{std::move(e)},
+        set_enabled{false},
+        alt_enabled{false}
   {
   }
 
-  constexpr cards(char a, char s, char e, char eo, char ec, char ee)
+  constexpr cards(char a, char s, char e, char so, char sc, char sn, char ao, char ac, char ar)
       : anything{std::move(a)},
         single{std::move(s)},
         escape{std::move(e)},
-        enum_enabled{true},
-        enum_open{std::move(eo)},
-        enum_close{std::move(ec)},
-        enum_exclusion{std::move(ee)}
+        set_enabled{true},
+        set_open{std::move(so)},
+        set_close{std::move(sc)},
+        set_not{std::move(sn)},
+        alt_enabled{true},
+        alt_open{std::move(ao)},
+        alt_close{std::move(ac)},
+        alt_or{std::move(ar)}
   {
   }
 
   char anything{'*'};
   char single{'?'};
   char escape{'\\'};
 
-  bool enum_enabled{true};
-  char enum_open{'['};
-  char enum_close{']'};
-  char enum_exclusion{'!'};
+  bool set_enabled{true};
+  char set_open{'['};
+  char set_close{']'};
+  char set_not{'!'};
+
+  bool alt_enabled{true};
+  char alt_open{'('};
+  char alt_close{')'};
+  char alt_or{'|'};
 };
 
 template <>
 struct cards<char16_t>
 {
   constexpr cards(cards_type type = cards_type::extended)
-      : enum_enabled{type == cards_type::extended}
+      : set_enabled{type == cards_type::extended}, alt_enabled{type == cards_type::extended}
   {
   }
 
   constexpr cards(char16_t a, char16_t s, char16_t e)
-      : anything{std::move(a)}, single{std::move(s)}, escape{std::move(e)}, enum_enabled{false}
+      : anything{std::move(a)},
+        single{std::move(s)},
+        escape{std::move(e)},
+        set_enabled{false},
+        alt_enabled{false}
   {
   }
 
-  constexpr cards(char16_t a, char16_t s, char16_t e, char16_t eo, char16_t ec, char16_t ee)
+  constexpr cards(char16_t a, char16_t s, char16_t e, char16_t so, char16_t sc, char16_t sn,
+                  char16_t ao, char16_t ac, char16_t ar)
       : anything{std::move(a)},
         single{std::move(s)},
         escape{std::move(e)},
-        enum_enabled{true},
-        enum_open{std::move(eo)},
-        enum_close{std::move(ec)},
-        enum_exclusion{std::move(ee)}
+        set_enabled{true},
+        set_open{std::move(so)},
+        set_close{std::move(sc)},
+        set_not{std::move(sn)},
+        alt_enabled{true},
+        alt_open{std::move(ao)},
+        alt_close{std::move(ac)},
+        alt_or{std::move(ar)}
   {
   }
 
   char16_t anything{u'*'};
   char16_t single{u'?'};
   char16_t escape{u'\\'};
 
-  bool enum_enabled{true};
-  char16_t enum_open{u'['};
-  char16_t enum_close{u']'};
-  char16_t enum_exclusion{u'!'};
+  bool set_enabled{true};
+  char16_t set_open{u'['};
+  char16_t set_close{u']'};
+  char16_t set_not{u'!'};
+
+  bool alt_enabled{true};
+  char16_t alt_open{u'('};
+  char16_t alt_close{u')'};
+  char16_t alt_or{u'|'};
 };
 
 template <>
 struct cards<char32_t>
 {
   constexpr cards(cards_type type = cards_type::extended)
-      : enum_enabled{type == cards_type::extended}
+      : set_enabled{type == cards_type::extended}, alt_enabled{type == cards_type::extended}
   {
   }
 
   constexpr cards(char32_t a, char32_t s, char32_t e)
-      : anything{std::move(a)}, single{std::move(s)}, escape{std::move(e)}, enum_enabled{false}
+      : anything{std::move(a)},
+        single{std::move(s)},
+        escape{std::move(e)},
+        set_enabled{false},
+        alt_enabled{false}
   {
   }
 
-  constexpr cards(char32_t a, char32_t s, char32_t e, char32_t eo, char32_t ec, char32_t ee)
+  constexpr cards(char32_t a, char32_t s, char32_t e, char32_t so, char32_t sc, char32_t sn,
+                  char32_t ao, char32_t ac, char32_t ar)
       : anything{std::move(a)},
         single{std::move(s)},
         escape{std::move(e)},
-        enum_enabled{true},
-        enum_open{std::move(eo)},
-        enum_close{std::move(ec)},
-        enum_exclusion{std::move(ee)}
+        set_enabled{true},
+        set_open{std::move(so)},
+        set_close{std::move(sc)},
+        set_not{std::move(sn)},
+        alt_enabled{true},
+        alt_open{std::move(ao)},
+        alt_close{std::move(ac)},
+        alt_or{std::move(ar)}
   {
   }
 
   char32_t anything{U'*'};
   char32_t single{U'?'};
   char32_t escape{U'\\'};
 
-  bool enum_enabled{true};
-  char32_t enum_open{U'['};
-  char32_t enum_close{U']'};
-  char32_t enum_exclusion{U'!'};
+  bool set_enabled{true};
+  char32_t set_open{U'['};
+  char32_t set_close{U']'};
+  char32_t set_not{U'!'};
+
+  bool alt_enabled{true};
+  char32_t alt_open{U'('};
+  char32_t alt_close{U')'};
+  char32_t alt_or{U'|'};
 };
 
 template <>
 struct cards<wchar_t>
 {
   constexpr cards(cards_type type = cards_type::extended)
-      : enum_enabled{type == cards_type::extended}
+      : set_enabled{type == cards_type::extended}, alt_enabled{type == cards_type::extended}
   {
   }
 
   constexpr cards(wchar_t a, wchar_t s, wchar_t e)
-      : anything{std::move(a)}, single{std::move(s)}, escape{std::move(e)}, enum_enabled{false}
+      : anything{std::move(a)},
+        single{std::move(s)},
+        escape{std::move(e)},
+        set_enabled{false},
+        alt_enabled{false}
   {
   }
 
-  constexpr cards(wchar_t a, wchar_t s, wchar_t e, wchar_t eo, wchar_t ec, wchar_t ee)
+  constexpr cards(wchar_t a, wchar_t s, wchar_t e, wchar_t so, wchar_t sc, wchar_t sn, wchar_t ao,
+                  wchar_t ac, wchar_t ar)
       : anything{std::move(a)},
         single{std::move(s)},
         escape{std::move(e)},
-        enum_enabled{true},
-        enum_open{std::move(eo)},
-        enum_close{std::move(ec)},
-        enum_exclusion{std::move(ee)}
+        set_enabled{true},
+        set_open{std::move(so)},
+        set_close{std::move(sc)},
+        set_not{std::move(sn)},
+        alt_enabled{true},
+        alt_open{std::move(ao)},
+        alt_close{std::move(ac)},
+        alt_or{std::move(ar)}
   {
   }
 
   wchar_t anything{L'*'};
   wchar_t single{L'?'};
   wchar_t escape{L'\\'};
 
-  bool enum_enabled{true};
-  wchar_t enum_open{L'['};
-  wchar_t enum_close{L']'};
-  wchar_t enum_exclusion{L'!'};
+  bool set_enabled{true};
+  wchar_t set_open{L'['};
+  wchar_t set_close{L']'};
+  wchar_t set_not{L'!'};
+
+  bool alt_enabled{true};
+  wchar_t alt_open{L'('};
+  wchar_t alt_close{L')'};
+  wchar_t alt_or{L'|'};
 };
 
 template <typename T>
-constexpr cards<T> make_cards(T&& c1, T&& c2)
+constexpr cards<T> make_cards(T&& a, T&& s, T&& e)
+{
+  return {std::forward<T>(a), std::forward<T>(s), std::forward<T>(e)};
+}
+
+template <typename T>
+constexpr cards<T> make_cards(T&& a, T&& s, T&& e, T&& so, T&& sc, T&& sn, T&& ao, T&& ac, T&& ar)
 {
-  return {std::forward<T>(c1), std::forward<T>(c2)};
+  return {std::forward<T>(a),  std::forward<T>(s),  std::forward<T>(e),
+          std::forward<T>(so), std::forward<T>(sc), std::forward<T>(sn),
+          std::forward<T>(ao), std::forward<T>(ac), std::forward<T>(ar)};
 }
 
 }  // namespace wildcards