wildcards.hpp File Reference

#include <cstddef>
#include <initializer_list>
#include <ostream>
#include <stdexcept>
#include <type_traits>
#include <utility>

Include dependency graph for wildcards.hpp:

This graph shows which files directly or indirectly include this file:

Classes
class	cx::basic_string_view< T >
struct	wildcards::cards< T >
struct	wildcards::cards< char >
struct	wildcards::cards< char16_t >
struct	wildcards::cards< char32_t >
struct	wildcards::cards< wchar_t >
struct	wildcards::const_iterator< C >
struct	wildcards::container_item< C >
struct	cx::equal_to< T >
struct	cx::equal_to< void >
struct	wildcards::full_match_result< SequenceIterator, PatternIterator >
struct	wildcards::iterated_item< It >
struct	wildcards::iterator< C >
struct	cx::less< T >
struct	cx::less< void >
struct	wildcards::detail::match_result< SequenceIterator, PatternIterator >
class	wildcards::matcher< Pattern, EqualTo >

Namespaces
namespace	cx
namespace	cx::literals
namespace	wildcards
namespace	wildcards::detail
namespace	wildcards::literals

Macros
#define	WILDCARDS_CARDS_HPP
#define	WILDCARDS_VERSION_MAJOR   1
#define	WILDCARDS_VERSION_MINOR   5
#define	WILDCARDS_VERSION_PATCH   0

Typedefs
template<typename C>
using	wildcards::const_iterator_t = typename const_iterator<C>::type
template<typename C>
using	wildcards::container_item_t = typename container_item<C>::type
template<typename It>
using	wildcards::iterated_item_t = typename iterated_item<It>::type
template<typename C>
using	wildcards::iterator_t = typename iterator<C>::type
using	cx::string_view = basic_string_view<char>
using	cx::u16string_view = basic_string_view<char16_t>
using	cx::u32string_view = basic_string_view<char32_t>
using	cx::wstring_view = basic_string_view<wchar_t>

Enumerations
enum class	wildcards::detail::alt_end_state { wildcards::detail::open , wildcards::detail::next , wildcards::detail::escape }
enum class	wildcards::detail::alt_sub_end_state { wildcards::detail::next , wildcards::detail::escape }
enum class	wildcards::cards_type { wildcards::standard , wildcards::extended }
enum class	wildcards::detail::is_alt_state { wildcards::detail::open , wildcards::detail::next , wildcards::detail::escape }
enum class	wildcards::detail::is_set_state { wildcards::detail::open , wildcards::detail::not_or_first , wildcards::detail::first , wildcards::detail::next }
enum class	wildcards::detail::match_set_state {   wildcards::detail::open , wildcards::detail::not_or_first_in , wildcards::detail::first_out , wildcards::detail::next_in ,   wildcards::detail::next_out }
enum class	wildcards::detail::set_end_state { wildcards::detail::open , wildcards::detail::not_or_first , wildcards::detail::first , wildcards::detail::next }

Functions
template<typename PatternIterator>
constexpr PatternIterator	wildcards::detail::alt_end (PatternIterator p, PatternIterator pend, const cards< iterated_item_t< PatternIterator > > &c=cards< iterated_item_t< PatternIterator > >(), alt_end_state state=alt_end_state::open, int depth=0)
template<typename PatternIterator>
constexpr PatternIterator	wildcards::detail::alt_sub_end (PatternIterator p, PatternIterator pend, const cards< iterated_item_t< PatternIterator > > &c=cards< iterated_item_t< PatternIterator > >(), alt_sub_end_state state=alt_sub_end_state::next, int depth=1)
template<typename C>
constexpr auto	cx::begin (C &c) -> decltype(c.begin())
template<typename C>
constexpr auto	cx::begin (const C &c) -> decltype(c.begin())
template<typename E>
constexpr const E *	cx::begin (std::initializer_list< E > il)
template<typename T, std::size_t N>
constexpr T *	cx::begin (T(&array)[N])
template<typename C>
constexpr auto	cx::cbegin (const C &c) -> decltype(cx::begin(c))
template<typename C>
constexpr auto	cx::cend (const C &c) -> decltype(cx::end(c))
template<typename C>
constexpr auto	cx::empty (const C &c) -> decltype(c.empty())
template<typename T, std::size_t N>
constexpr bool	cx::empty (const T(&)[N])
template<typename E>
constexpr bool	cx::empty (std::initializer_list< E > il)
template<typename C>
constexpr auto	cx::end (C &c) -> decltype(c.end())
template<typename C>
constexpr auto	cx::end (const C &c) -> decltype(c.end())
template<typename E>
constexpr const E *	cx::end (std::initializer_list< E > il)
template<typename T, std::size_t N>
constexpr T *	cx::end (T(&array)[N])
template<typename Iterator1, typename Iterator2>
constexpr bool	cx::equal (Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2)
template<typename PatternIterator>
constexpr bool	wildcards::detail::is_alt (PatternIterator p, PatternIterator pend, const cards< iterated_item_t< PatternIterator > > &c=cards< iterated_item_t< PatternIterator > >(), is_alt_state state=is_alt_state::open, int depth=0)
template<typename PatternIterator>
constexpr bool	wildcards::detail::is_set (PatternIterator p, PatternIterator pend, const cards< iterated_item_t< PatternIterator > > &c=cards< iterated_item_t< PatternIterator > >(), is_set_state state=is_set_state::open)
template<typename T>
constexpr cards< T >	wildcards::make_cards (T &&a, T &&s, T &&e)
template<typename T>
constexpr cards< T >	wildcards::make_cards (T &&a, T &&s, T &&e, T &&so, T &&sc, T &&sn, T &&ao, T &&ac, T &&ar)
template<typename SequenceIterator, typename PatternIterator>
constexpr full_match_result< SequenceIterator, PatternIterator >	wildcards::detail::make_full_match_result (SequenceIterator s, SequenceIterator send, PatternIterator p, PatternIterator pend, match_result< SequenceIterator, PatternIterator > mr)
template<typename SequenceIterator, typename PatternIterator>
constexpr match_result< SequenceIterator, PatternIterator >	wildcards::detail::make_match_result (bool res, SequenceIterator s, PatternIterator p)
template<typename Pattern, typename EqualTo = cx::equal_to<void>>
constexpr matcher< Pattern, EqualTo >	wildcards::make_matcher (Pattern &&pattern, const cards< container_item_t< Pattern > > &c=cards< container_item_t< Pattern > >(), const EqualTo &equal_to=EqualTo())
template<typename Pattern, typename EqualTo = cx::equal_to<void>, typename = typename std::enable_if<!std::is_same<EqualTo, cards_type>::value>::type>
constexpr matcher< Pattern, EqualTo >	wildcards::make_matcher (Pattern &&pattern, const EqualTo &equal_to)
template<typename T>
constexpr basic_string_view< T >	cx::make_string_view (const T *str, std::size_t s)
template<typename T, std::size_t N>
constexpr basic_string_view< T >	cx::make_string_view (const T(&str)[N])
template<typename SequenceIterator, typename PatternIterator, typename EqualTo = cx::equal_to<void>>
constexpr match_result< SequenceIterator, PatternIterator >	wildcards::detail::match (SequenceIterator s, SequenceIterator send, PatternIterator p, PatternIterator pend, const cards< iterated_item_t< PatternIterator > > &c=cards< iterated_item_t< PatternIterator > >(), const EqualTo &equal_to=EqualTo(), bool partial=false, bool escape=false)
template<typename Sequence, typename Pattern, typename EqualTo = cx::equal_to<void>>
constexpr full_match_result< const_iterator_t< Sequence >, const_iterator_t< Pattern > >	wildcards::match (Sequence &&sequence, Pattern &&pattern, const cards< container_item_t< Pattern > > &c=cards< container_item_t< Pattern > >(), const EqualTo &equal_to=EqualTo())
template<typename Sequence, typename Pattern, typename EqualTo = cx::equal_to<void>, typename = typename std::enable_if<!std::is_same<EqualTo, cards_type>::value>::type>
constexpr full_match_result< const_iterator_t< Sequence >, const_iterator_t< Pattern > >	wildcards::match (Sequence &&sequence, Pattern &&pattern, const EqualTo &equal_to)
template<typename SequenceIterator, typename PatternIterator, typename EqualTo = cx::equal_to<void>>
constexpr match_result< SequenceIterator, PatternIterator >	wildcards::detail::match_alt (SequenceIterator s, SequenceIterator send, PatternIterator p1, PatternIterator p1end, PatternIterator p2, PatternIterator p2end, const cards< iterated_item_t< PatternIterator > > &c=cards< iterated_item_t< PatternIterator > >(), const EqualTo &equal_to=EqualTo(), bool partial=false)
template<typename SequenceIterator, typename PatternIterator, typename EqualTo = cx::equal_to<void>>
constexpr match_result< SequenceIterator, PatternIterator >	wildcards::detail::match_set (SequenceIterator s, SequenceIterator send, PatternIterator p, PatternIterator pend, const cards< iterated_item_t< PatternIterator > > &c=cards< iterated_item_t< PatternIterator > >(), const EqualTo &equal_to=EqualTo(), match_set_state state=match_set_state::open)
template<typename It>
constexpr It	cx::next (It it)
template<typename T>
constexpr bool	cx::operator!= (const basic_string_view< T > &lhs, const basic_string_view< T > &rhs)
constexpr string_view	cx::literals::operator""_sv (const char *str, std::size_t s)
constexpr u16string_view	cx::literals::operator""_sv (const char16_t *str, std::size_t s)
constexpr u32string_view	cx::literals::operator""_sv (const char32_t *str, std::size_t s)
constexpr wstring_view	cx::literals::operator""_sv (const wchar_t *str, std::size_t s)
constexpr auto	wildcards::literals::operator""_wc (const char *str, std::size_t s) -> decltype(make_matcher(cx::make_string_view(str, s+1)))
constexpr auto	wildcards::literals::operator""_wc (const char16_t *str, std::size_t s) -> decltype(make_matcher(cx::make_string_view(str, s+1)))
constexpr auto	wildcards::literals::operator""_wc (const char32_t *str, std::size_t s) -> decltype(make_matcher(cx::make_string_view(str, s+1)))
constexpr auto	wildcards::literals::operator""_wc (const wchar_t *str, std::size_t s) -> decltype(make_matcher(cx::make_string_view(str, s+1)))
template<typename T>
std::basic_ostream< T > &	cx::operator<< (std::basic_ostream< T > &o, const basic_string_view< T > &s)
template<typename T>
constexpr bool	cx::operator== (const basic_string_view< T > &lhs, const basic_string_view< T > &rhs)
template<typename It>
constexpr It	cx::prev (It it)
template<typename PatternIterator>
constexpr PatternIterator	wildcards::detail::set_end (PatternIterator p, PatternIterator pend, const cards< iterated_item_t< PatternIterator > > &c=cards< iterated_item_t< PatternIterator > >(), set_end_state state=set_end_state::open)
template<typename C>
constexpr auto	cx::size (const C &c) -> decltype(c.size())
template<typename T, std::size_t N>
constexpr std::size_t	cx::size (const T(&)[N])

Macro Definition Documentation

WILDCARDS_CARDS_HPP

#define WILDCARDS_CARDS_HPP

Definition at line 13 of file wildcards.hpp.

WILDCARDS_VERSION_MAJOR

#define WILDCARDS_VERSION_MAJOR   1

Definition at line 9 of file wildcards.hpp.

WILDCARDS_VERSION_MINOR

#define WILDCARDS_VERSION_MINOR   5

Definition at line 10 of file wildcards.hpp.

WILDCARDS_VERSION_PATCH

#define WILDCARDS_VERSION_PATCH   0

Definition at line 11 of file wildcards.hpp.