basic_regex< _Elem, _RxTraits > Class Template Reference

Inheritance diagram for basic_regex< _Elem, _RxTraits >:

Public Types
enum	{ _EEN_VIS }
typedef basic_regex< _Elem, _RxTraits >	_Myt
typedef _Elem	value_type
typedef _RxTraits	traits_type
typedef _RxTraits::locale_type	locale_type
typedef _RxTraits::string_type	string_type
typedef regex_constants::syntax_option_type	flag_type

Public Member Functions
	basic_regex ()
	basic_regex (_In_z_ const _Elem *_Ptr, flag_type _Flags=regex_constants::ECMAScript)
	basic_regex (_In_reads_(_Count) const _Elem *_Ptr, size_t _Count, flag_type _Flags=regex_constants::ECMAScript)
template<class _STtraits , class _STalloc >
	basic_regex (const basic_string< _Elem, _STtraits, _STalloc > &_Str, flag_type _Flags=regex_constants::ECMAScript)
template<class _InIt >
	basic_regex (_InIt _First, _InIt _Last, flag_type _Flags)
template<class _InIt >
	basic_regex (_InIt _First, _InIt _Last)
	basic_regex (const _Myt &_Right)
	basic_regex (_XSTD initializer_list< _Elem > _Ilist, flag_type _Flags=regex_constants::ECMAScript)
_Myt &	operator= (_XSTD initializer_list< _Elem > _Ilist)
_Myt &	assign (_XSTD initializer_list< _Elem > _Ilist, flag_type _Flags=regex_constants::ECMAScript)
	basic_regex (_Myt &&_Right) _NOEXCEPT
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT
void	_Assign_rv (_Myt &&_Right)
_Myt &	assign (_Myt &&_Right) _NOEXCEPT
	~basic_regex () _NOEXCEPT
_Myt &	operator= (const _Myt &_Right)
_Myt &	operator= (_In_z_ const _Elem *_Ptr)
template<class _STtraits , class _STalloc >
_Myt &	operator= (const basic_string< _Elem, _STtraits, _STalloc > &_Str)
unsigned int	_Loop_count () const
unsigned int	mark_count () const
_Myt &	assign (const _Myt &_Right)
_Myt &	assign (_In_z_ const _Elem *_Ptr, flag_type _Flags=regex_constants::ECMAScript)
_Myt &	assign (_In_reads_(_Count) const _Elem *_Ptr, size_t _Count, flag_type _Flags=regex_constants::ECMAScript)
template<class _STtraits , class _STalloc >
_Myt &	assign (const basic_string< _Elem, _STtraits, _STalloc > &_Str, flag_type _Flags=regex_constants::ECMAScript)
template<class _InIt >
_Myt &	assign (_InIt _First, _InIt _Last, flag_type _Flags=regex_constants::ECMAScript)
flag_type	flags () const
locale_type	imbue (locale_type _Loc)
locale_type	getloc () const
void	swap (_Myt &_Right) _THROW0()
_Root_node *	_Get () const
bool	_Empty () const
const _RxTraits &	_Get_traits () const

Static Public Attributes
static const flag_type	icase = regex_constants::icase
static const flag_type	nosubs = regex_constants::nosubs
static const flag_type	optimize = regex_constants::optimize
static const flag_type	collate = regex_constants::collate
static const flag_type	ECMAScript = regex_constants::ECMAScript
static const flag_type	basic = regex_constants::basic
static const flag_type	extended = regex_constants::extended
static const flag_type	awk = regex_constants::awk
static const flag_type	grep = regex_constants::grep
static const flag_type	egrep = regex_constants::egrep

Private Member Functions
void	_Tidy ()
template<class _InIt >
void	_Reset (_InIt _First, _InIt _Last, flag_type _Flags, input_iterator_tag)
template<class _FwdIt >
void	_Reset (_FwdIt _First, _FwdIt _Last, flag_type _Flags, forward_iterator_tag)
void	_Reset (_Root_node *_Rx)

Private Attributes
_Root_node *	_Rep
_RxTraits	_Traits

Member Typedef Documentation

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

typedef basic_regex<_Elem, _RxTraits> basic_regex< _Elem, _RxTraits >::_Myt

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

typedef regex_constants::syntax_option_type basic_regex< _Elem, _RxTraits >::flag_type

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

typedef _RxTraits::locale_type basic_regex< _Elem, _RxTraits >::locale_type

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

typedef _RxTraits::string_type basic_regex< _Elem, _RxTraits >::string_type

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

typedef _RxTraits basic_regex< _Elem, _RxTraits >::traits_type

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

typedef _Elem basic_regex< _Elem, _RxTraits >::value_type

Member Enumeration Documentation

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

anonymous enum

Enumerator
_EEN_VIS

         {_EEN_VIS =
        _ENHANCED_REGEX_VISUALIZER};    // helper for expression evaluator

Constructor & Destructor Documentation

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

basic_regex< _Elem, _RxTraits >::basic_regex ( )

inline

        : _Rep(0)
        {   // construct empty object
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

basic_regex< _Elem, _RxTraits >::basic_regex ( _In_z_ const _Elem *  _Ptr, flag_type  _Flags = regex_constants::ECMAScript  )

inlineexplicit

        : _Rep(0)
        {   // construct from null terminated character sequence
        _Reset(_Ptr, _Ptr + _RxTraits::length(_Ptr),
            _Flags, random_access_iterator_tag());
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

basic_regex< _Elem, _RxTraits >::basic_regex ( _In_reads_(_Count) const _Elem *  _Ptr, size_t  _Count, flag_type  _Flags = regex_constants::ECMAScript  )

inline

        : _Rep(0)
        {   // construct from character sequence
        if (_Ptr == 0)
            _Xregex_error(regex_constants::error_parse);
        _Reset(_Ptr, _Ptr + _Count, _Flags, random_access_iterator_tag());
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

template<class _STtraits , class _STalloc >

basic_regex< _Elem, _RxTraits >::basic_regex ( const basic_string< _Elem, _STtraits, _STalloc > &  _Str, flag_type  _Flags = regex_constants::ECMAScript  )

inlineexplicit

        : _Rep(0)
        {   // construct from string object
        _Reset(_Str.begin(), _Str.end(), _Flags, random_access_iterator_tag());
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

template<class _InIt >

basic_regex< _Elem, _RxTraits >::basic_regex ( _InIt  _First, _InIt  _Last, flag_type  _Flags  )

inline

        : _Rep(0)
        {   // construct from pair of iterators
        _DEBUG_RANGE(_First, _Last);
        _Reset(_First, _Last, _Flags, _Iter_cat(_First));
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

template<class _InIt >

basic_regex< _Elem, _RxTraits >::basic_regex ( _InIt  _First, _InIt  _Last  )

inline

        : _Rep(0)
        {   // construct from pair of iterators
        _DEBUG_RANGE(_First, _Last);
        _Reset(_First, _Last, regex_constants::ECMAScript,
            _Iter_cat(_First));
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

basic_regex< _Elem, _RxTraits >::basic_regex ( const _Myt &  _Right )

inline

        : _Rep(0), _Traits(_Right._Traits),
            _Visualization(_Right._Visualization)

 #else /* _ENHANCED_REGEX_VISUALIZER */
        : _Rep(0), _Traits(_Right._Traits)
 #endif /* _ENHANCED_REGEX_VISUALIZER */

        {   // construct copy of _Right
        _Reset(_Right._Rep);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

basic_regex< _Elem, _RxTraits >::basic_regex ( _XSTD initializer_list< _Elem >  _Ilist, flag_type  _Flags = regex_constants::ECMAScript  )

inline

        : _Rep(0)
        {   // construct from initializer_list
        _Reset(_Ilist.begin(), _Ilist.end(), _Flags,
            random_access_iterator_tag());
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

basic_regex< _Elem, _RxTraits >::basic_regex ( _Myt &&  _Right )

inline

        : _Rep(0)
        {   // construct by moving _Right
        _Assign_rv(_STD move(_Right));
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

basic_regex< _Elem, _RxTraits >::~basic_regex ( )

inline

        {   // destroy the object
        _Tidy();
        }

Member Function Documentation

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

void basic_regex< _Elem, _RxTraits >::_Assign_rv ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // clear this and steal from _Right
            _Tidy();

 #if _ENHANCED_REGEX_VISUALIZER
            _Visualization = _STD move(_Right._Visualization);
 #endif /* _ENHANCED_REGEX_VISUALIZER */

            _Rep = _Right._Rep;
            _Right._Rep = 0;
            }
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

bool basic_regex< _Elem, _RxTraits >::_Empty ( ) const

inline

        {   // test if empty
        return (_Rep == 0);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Root_node* basic_regex< _Elem, _RxTraits >::_Get ( ) const

inline

        {   // return pointer to root node
        return (_Rep);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const _RxTraits& basic_regex< _Elem, _RxTraits >::_Get_traits ( ) const

inline

        {   // return reference to traits
        return (_Traits);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

unsigned int basic_regex< _Elem, _RxTraits >::_Loop_count ( ) const

inline

        {   // return number of loops
        return (_Rep != 0 ? _Rep->_Loops : 0);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

template<class _InIt >

void basic_regex< _Elem, _RxTraits >::_Reset ( _InIt  _First, _InIt  _Last, flag_type  _Flags, input_iterator_tag    )

inlineprivate

        {   // build regular expression from input iterators
        basic_string<_REGEX_VALT(_InIt)> _Str(_First, _Last);

        _Reset(_Str.begin(), _Str.end(),
            _Flags, forward_iterator_tag());
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

template<class _FwdIt >

void basic_regex< _Elem, _RxTraits >::_Reset ( _FwdIt  _First, _FwdIt  _Last, flag_type  _Flags, forward_iterator_tag    )

inlineprivate

        {   // build regular expression from forward iterators
 #if _ENHANCED_REGEX_VISUALIZER
        _Visualization.assign(_First, _Last);
 #endif /* _ENHANCED_REGEX_VISUALIZER */

        _Parser<_FwdIt, _Elem, _RxTraits>
            _Prs(_Traits, _First, _Last, _Flags);
        _Root_node *_Rx = _Prs._Compile();
        _Reset(_Rx);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

void basic_regex< _Elem, _RxTraits >::_Reset ( _Root_node *  _Rx )

inlineprivate

        {   // build regular expression holding root node _Rx
        if (_Rx != 0)
            ++_Rx->_Refs;
        _Tidy();
        _Rep = _Rx;
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

void basic_regex< _Elem, _RxTraits >::_Tidy ( )

inlineprivate

        {   // free all storage
        if (_Rep != 0 && --_Rep->_Refs == 0)
            _Destroy_node(_Rep);
        _Rep = 0;
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::assign ( _XSTD initializer_list< _Elem >  _Ilist, flag_type  _Flags = regex_constants::ECMAScript  )

inline

        {   // replace with regular expression in initializer_list
        _Reset(_Ilist.begin(), _Ilist.end(),
            _Flags, random_access_iterator_tag());
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::assign ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        _Assign_rv(_STD move(_Right));
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::assign ( const _Myt &  _Right )

inline

        {   // replace with copy of _Right
 #if _ENHANCED_REGEX_VISUALIZER
        _Visualization = _Right._Visualization;
 #endif /* _ENHANCED_REGEX_VISUALIZER */

        _Reset(_Right._Rep);
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::assign ( _In_z_ const _Elem *  _Ptr, flag_type  _Flags = regex_constants::ECMAScript  )

inline

        {   // replace with regular expression constructed from _Ptr
        return (assign(_Ptr, _RxTraits::length(_Ptr), _Flags));
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::assign ( _In_reads_(_Count) const _Elem *  _Ptr, size_t  _Count, flag_type  _Flags = regex_constants::ECMAScript  )

inline

        {   // replace with regular expression constructed from _Ptr, _Count
        _Reset(_Ptr, _Ptr + _Count,
            _Flags, random_access_iterator_tag());
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

template<class _STtraits , class _STalloc >

_Myt& basic_regex< _Elem, _RxTraits >::assign ( const basic_string< _Elem, _STtraits, _STalloc > &  _Str, flag_type  _Flags = regex_constants::ECMAScript  )

inline

        {   // replace with regular expression constructed from _Str
        _Reset(_Str.begin(), _Str.end(),
            _Flags, random_access_iterator_tag());
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

template<class _InIt >

_Myt& basic_regex< _Elem, _RxTraits >::assign ( _InIt  _First, _InIt  _Last, flag_type  _Flags = regex_constants::ECMAScript  )

inline

        {   // replace with regular expression constructed from [_First, _Last)
        _DEBUG_RANGE(_First, _Last);
        _Reset(_First, _Last, _Flags, _Iter_cat(_First));
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

flag_type basic_regex< _Elem, _RxTraits >::flags ( ) const

inline

        {   // return syntax option flags
        return (_Rep ? _Rep->_Fl : (flag_type)0);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

locale_type basic_regex< _Elem, _RxTraits >::getloc ( ) const

inline

        {   // return copy of locale object
        return (_Traits.getloc());
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

locale_type basic_regex< _Elem, _RxTraits >::imbue ( locale_type  _Loc )

inline

        {   // clear regular expression and set locale to argument
        _Tidy();
        return (_Traits.imbue(_Loc));
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

unsigned int basic_regex< _Elem, _RxTraits >::mark_count ( ) const

inline

        {   // return number of capture groups
        return (_Rep != 0 ? _Rep->_Marks - 1 : 0);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::operator= ( _XSTD initializer_list< _Elem >  _Ilist )

inline

        {   // replace with regular expression in initializer_list
        return (assign(_Ilist));
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        _Assign_rv(_STD move(_Right));
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::operator= ( const _Myt &  _Right )

inline

        {   // replace with copy of _Right
        return (assign(_Right));
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Myt& basic_regex< _Elem, _RxTraits >::operator= ( _In_z_ const _Elem *  _Ptr )

inline

        {   // replace with regular expression constructed from _Ptr
        _Reset(_Ptr, _Ptr + _RxTraits::length(_Ptr),
            ECMAScript, random_access_iterator_tag());
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

template<class _STtraits , class _STalloc >

_Myt& basic_regex< _Elem, _RxTraits >::operator= ( const basic_string< _Elem, _STtraits, _STalloc > &  _Str )

inline

        {   // replace with regular expression constructed from _Str
        _Reset(_Str.begin(), _Str.end(),
            ECMAScript, random_access_iterator_tag());
        return (*this);
        }

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

void basic_regex< _Elem, _RxTraits >::swap ( _Myt &  _Right )

inline

        {   // exchange contents with _Right
        _STD swap(_Rep, _Right._Rep);

 #if _ENHANCED_REGEX_VISUALIZER
        _Visualization.swap(_Right._Visualization);
 #endif /* _ENHANCED_REGEX_VISUALIZER */
        }

Member Data Documentation

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_Root_node* basic_regex< _Elem, _RxTraits >::_Rep

private

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

_RxTraits basic_regex< _Elem, _RxTraits >::_Traits

private

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::awk = regex_constants::awk

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::basic = regex_constants::basic

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::collate = regex_constants::collate

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::ECMAScript = regex_constants::ECMAScript

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::egrep = regex_constants::egrep

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::extended = regex_constants::extended

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::grep = regex_constants::grep

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::icase = regex_constants::icase

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::nosubs = regex_constants::nosubs

static

template<class _Elem, class _RxTraits = regex_traits<_Elem>>

const flag_type basic_regex< _Elem, _RxTraits >::optimize = regex_constants::optimize

static

---

The documentation for this class was generated from the following file:

• VS2013/inc/regex