regex_error Class Reference

Inheritance diagram for regex_error:

Public Member Functions
	regex_error (regex_constants::error_type _Ex)
regex_constants::error_type	code () const
Public Member Functions inherited from runtime_error
	runtime_error (const string &_Message)
	runtime_error (const char *_Message)
Public Member Functions inherited from exception
__CLR_OR_THIS_CALL	exception (const char *_Message="unknown", int=1) _THROW0()
__CLR_OR_THIS_CALL	exception (const exception &_Right) _THROW0()
exception &__CLR_OR_THIS_CALL	operator= (const exception &_Right) _THROW0()
virtual __CLR_OR_THIS_CALL	~exception () _NOEXCEPT
virtual const char *__CLR_OR_THIS_CALL	what () const _THROW0()
void __CLR_OR_THIS_CALL	_Raise () const

Static Private Member Functions
static const char *	_Stringify (regex_constants::error_type _Ex)

Private Attributes
regex_constants::error_type	_Err

Additional Inherited Members
Static Public Member Functions inherited from exception
static _STD _Prhand	_Set_raise_handler (_STD _Prhand _Pnew)
Protected Member Functions inherited from runtime_error
virtual void	_Doraise () const
Protected Attributes inherited from exception
const char *	_Ptr

Constructor & Destructor Documentation

regex_error::regex_error ( regex_constants::error_type  _Ex )

inlineexplicit

        : runtime_error(_Stringify(_Ex)), _Err(_Ex)
        {   // construct
        }

Member Function Documentation

static const char* regex_error::_Stringify ( regex_constants::error_type  _Ex )

inlinestaticprivate

        {   // map error code to string
        switch (_Ex)
            {   // select known error_type message
            case regex_constants::error_collate:
                return ("regex_error(error_collate): The expression "
                    "contained an invalid collating element name.");
            case regex_constants::error_ctype:
                return ("regex_error(error_ctype): The expression "
                    "contained an invalid character class name.");
            case regex_constants::error_escape:
                return ("regex_error(error_escape): The expression "
                    "contained an invalid escaped character, "
                        "or a trailing escape.");
            case regex_constants::error_backref:
                return ("regex_error(error_backref): The expression "
                    "contained an invalid back reference.");
            case regex_constants::error_brack:
                return ("regex_error(error_brack): The expression "
                    "contained mismatched [ and ].");
            case regex_constants::error_paren:
                return ("regex_error(error_paren): The expression "
                    "contained mismatched ( and ).");
            case regex_constants::error_brace:
                return ("regex_error(error_brace): The expression "
                    "contained mismatched { and }.");
            case regex_constants::error_badbrace:
                return ("regex_error(error_badbrace): The expression "
                    "contained an invalid range in a { expression }.");
            case regex_constants::error_range:
                return ("regex_error(error_range): The expression "
                    "contained an invalid character range, "
                        "such as [b-a] in most encodings.");
            case regex_constants::error_space:
                return ("regex_error(error_space): There was insufficient "
                    "memory to convert the expression into "
                        "a finite state machine.");
            case regex_constants::error_badrepeat:
                return ("regex_error(error_badrepeat): One of *?+{ "
                    "was not preceded by a valid regular expression.");
            case regex_constants::error_complexity:
                return ("regex_error(error_complexity): The complexity of "
                    "an attempted match against a regular expression "
                        "exceeded a pre-set level.");
            case regex_constants::error_stack:
                return ("regex_error(error_stack): There was insufficient "
                    "memory to determine whether the regular expression "
                        "could match the specified character sequence.");
            case regex_constants::error_parse:
                return ("regex_error(error_parse)");
            case regex_constants::error_syntax:
                return ("regex_error(error_syntax)");
            default:
                return ("regex_error");
            }
        }

regex_constants::error_type regex_error::code ( ) const

inline

        {   // return stored error code
        return (_Err);
        }

Member Data Documentation

regex_constants::error_type regex_error::_Err

private

---

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

• VS2017/inc/regex