wildcards.hpp File Reference

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

Include dependency graph for wildcards.hpp:

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

Go to the source code of 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
	cx
	cx::literals
	wildcards
	wildcards::detail
	wildcards::literals

Macros
#define	cfg_constexpr14
#define	cfg_HAS_CONSTEXPR14   (__cpp_constexpr >= 201304)
#define	cfg_HAS_FULL_FEATURED_CONSTEXPR14   0
#define	CONFIG_HPP
#define	CX_ALGORITHM_HPP
#define	CX_FUNCTIONAL_HPP
#define	CX_ITERATOR_HPP
#define	CX_STRING_VIEW_HPP
#define	QUICKCPPLIB_HAS_FEATURE_H
#define	WILDCARDS_CARDS_HPP
#define	WILDCARDS_MATCH_HPP
#define	WILDCARDS_MATCHER_HPP
#define	WILDCARDS_UTILITY_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	wildcards::detail::alt_end_state { wildcards::detail::alt_end_state::open, wildcards::detail::alt_end_state::next, wildcards::detail::alt_end_state::escape }
enum	wildcards::detail::alt_sub_end_state { wildcards::detail::alt_sub_end_state::next, wildcards::detail::alt_sub_end_state::escape }
enum	wildcards::cards_type { wildcards::cards_type::standard, wildcards::cards_type::extended }
enum	wildcards::detail::is_alt_state { wildcards::detail::is_alt_state::open, wildcards::detail::is_alt_state::next, wildcards::detail::is_alt_state::escape }
enum	wildcards::detail::is_set_state { wildcards::detail::is_set_state::open, wildcards::detail::is_set_state::not_or_first, wildcards::detail::is_set_state::first, wildcards::detail::is_set_state::next }
enum	wildcards::detail::match_set_state {   wildcards::detail::match_set_state::open, wildcards::detail::match_set_state::not_or_first_in, wildcards::detail::match_set_state::first_out, wildcards::detail::match_set_state::next_in,   wildcards::detail::match_set_state::next_out }
enum	wildcards::detail::set_end_state { wildcards::detail::set_end_state::open, wildcards::detail::set_end_state::not_or_first, wildcards::detail::set_end_state::first, wildcards::detail::set_end_state::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 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 (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 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])
constexpr bool	wildcards::detail::throw_invalid_argument (const char *what_arg)
template<typename T >
constexpr T	wildcards::detail::throw_invalid_argument (T t, const char *what_arg)
constexpr bool	wildcards::detail::throw_logic_error (const char *what_arg)
template<typename T >
constexpr T	wildcards::detail::throw_logic_error (T t, const char *what_arg)

Macro Definition Documentation

cfg_constexpr14

#define cfg_constexpr14

Definition at line 568 of file wildcards.hpp.

cfg_HAS_CONSTEXPR14

#define cfg_HAS_CONSTEXPR14   (__cpp_constexpr >= 201304)

Definition at line 564 of file wildcards.hpp.

cfg_HAS_FULL_FEATURED_CONSTEXPR14

#define cfg_HAS_FULL_FEATURED_CONSTEXPR14   0

Definition at line 573 of file wildcards.hpp.

CONFIG_HPP

#define CONFIG_HPP

Definition at line 246 of file wildcards.hpp.

CX_ALGORITHM_HPP

#define CX_ALGORITHM_HPP

Definition at line 1636 of file wildcards.hpp.

CX_FUNCTIONAL_HPP

#define CX_FUNCTIONAL_HPP

Definition at line 577 of file wildcards.hpp.

CX_ITERATOR_HPP

#define CX_ITERATOR_HPP

Definition at line 620 of file wildcards.hpp.

CX_STRING_VIEW_HPP

#define CX_STRING_VIEW_HPP

Definition at line 1632 of file wildcards.hpp.

QUICKCPPLIB_HAS_FEATURE_H

#define QUICKCPPLIB_HAS_FEATURE_H

Definition at line 248 of file wildcards.hpp.

WILDCARDS_CARDS_HPP

#define WILDCARDS_CARDS_HPP

Definition at line 13 of file wildcards.hpp.

WILDCARDS_MATCH_HPP

#define WILDCARDS_MATCH_HPP

Definition at line 241 of file wildcards.hpp.

WILDCARDS_MATCHER_HPP

#define WILDCARDS_MATCHER_HPP

Definition at line 1627 of file wildcards.hpp.

WILDCARDS_UTILITY_HPP

#define WILDCARDS_UTILITY_HPP

Definition at line 713 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.