rnr::RegEx Class Reference

Regular Express Class. More...

#include <RegEx.h>

Classes
struct	ReMatch
	Regular expression match structure. More...

Public Types
typedef std::vector< ReMatch >	ReMatchVec
	vector of matches

Public Member Functions
	RegEx (int nFlags=ReFlagDefaults)
	Default constructor. More...
	RegEx (const std::string &strRegEx, int nFlags=ReFlagDefaults)
	String initialization constructor. More...
	RegEx (const char *sRegEx, int nFlags=ReFlagDefaults)
	Null-terminated char* initialization constructor. More...
	RegEx (const RegEx &src)
	Copy constructor. More...
virtual	~RegEx ()
	Default destructor.
RegEx &	operator= (const RegEx &rhs)
	Assignment copy operator. More...
RegEx &	operator= (const std::string &rhs)
	Assignment operator. More...
RegEx &	operator= (const char *rhs)
	Assignment operator. More...
bool	match (const char *sInput, const int nFlags=ReFlagDefaults)
	Match the input char* against the regular expression. More...
bool	match (const char *sInput, const int nFlags=ReFlagDefaults) const
size_t	match (const std::string &strInput, ReMatchVec &matches, const size_t uMaxSubMatches=ReMaxSubMatchesDft, const int nFlags=ReFlagDefaults)
	Find all substrings in the input that match the regular expression. More...
size_t	match (const std::string &strInput, ReMatchVec &matches, const size_t uMaxSubMatches=ReMaxSubMatchesDft, const int nFlags=ReFlagDefaults) const
size_t	match (const char *sInput, ReMatchVec &matches, const size_t uMaxSubMatches=ReMaxSubMatchesDft, const int nFlags=ReFlagDefaults)
	Find all substrings in input that match the regular expression. More...
size_t	match (const char *sInput, ReMatchVec &matches, const size_t uMaxSubMatches=ReMaxSubMatchesDft, const int nFlags=ReFlagDefaults) const
const std::string &	getRegEx () const
	Get the pre-compiled regular expression. More...
bool	isValid () const
	Test if in a valid state (i.e. compiled). More...
int	getFlags () const
	Get compile behavior flags. More...
void	setFlags (int nFlags)
	Set new compile behavior flags. More...
int	getReturnCode () const
	Get the extened return code from the last RegEx operation. More...
const std::string &	getErrorStr () const
	Get the last RegExs operation error string. More...
bool	match (const std::string &strInput, const int nFlags=ReFlagDefaults)
	Match the input string against the regular expression. More...
bool	match (const std::string &strInput, const int nFlags=ReFlagDefaults) const

Static Public Attributes
static const int	ReOk = REG_NOERROR
	Special return and error codes. More...
static const int	ReENoExpr = -1000
	no pre-compiled express
static const int	ReENotComp = -1001
	not compiled
static const int	ReFlagDefaults = 0
	Regular expression compile and matching behavior flags. More...
static const int	ReFlagICase = REG_ICASE
	ignore case when matching
static const int	ReFlagNewLine = REG_NEWLINE
	force bol/eol matching
static const int	ReFlagNotBoL = REG_NOTBOL
	input not begin of line
static const int	ReFlagNotEoL = REG_NOTEOL
	input not end of line
static const char *	ReInvalid = "inre"
	Concerning, in reality, in regards to invalid regular expressions.
static const size_t	ReMaxSubMatchesDft = 32

Protected Member Functions
bool	compile ()
	Compile the regular expression string. More...
void	groomFlags (const int nFlags)
	Groom compile behavior flags, disabling any unsupported flags. More...
void	setError (const int nCode)
	Set the error code and associated error string. More...
void	freeReMem ()
	Free compiled regular expression memory.

Protected Attributes
std::string	m_strRegEx
	pre-compiled regular expression string
int	m_nFlags
	compile and matching flags
bool	m_bIsValid
	expression [not] successfully compiled
regex_t	m_regex
	compiled reqular expression
int	m_nReCode
	compiled regular expression return code
std::string	m_strReError
	compiled regualar expresson error string

Friends
std::ostream &	operator<< (std::ostream &os, const RegEx &re)
	Insert object into output stream. More...
std::istream &	operator>> (std::istream &is, RegEx &re)
	Extract from input stream to object. More...

Detailed Description

Regular Express Class.

Regular expression are evaluated using the POSIX Extended Regular Expression syntax.

Definition at line 84 of file RegEx.h.

Constructor & Destructor Documentation

RegEx::RegEx

(

int

nFlags = ReFlagDefaults

)

Default constructor.

No regular expression compile will be attempted.

Parameters

nFlags

Bitwise-or of compile behavior flags.

Definition at line 81 of file RegEx.cxx.

{
  m_bIsValid = false;

  groomFlags(nFlags);
  setError(ReENoExpr);
}

rnr::RegEx::RegEx	(	const std::string &	strRegEx,
		int	nFlags = ReFlagDefaults
	)

String initialization constructor.

Regular expression compile will be attempted.

Parameters

strRegEx	Pre-compile regular expression string.
nFlags	Bitwise-or of compile behavior flags.

RegEx::RegEx	(	const char *	sRegEx,
		int	nFlags = ReFlagDefaults
	)

Null-terminated char* initialization constructor.

If not NULL or empty, regular expression compile will be attempted.

Parameters

sRegEx	Null-terminated pre-compile regular expression string.
nFlags	Bitwise-or of compile behavior flags.

Definition at line 99 of file RegEx.cxx.

{
  m_bIsValid = false;

  groomFlags(nFlags);

  if( (sRegEx != NULL) && (*sRegEx != 0) )
  {
    m_strRegEx = sRegEx;
    compile();
  }
  else
  {
    setError(ReENoExpr);
  }
}

RegEx::RegEx

(

const RegEx &

src

)

Copy constructor.

Regular expression compile will be attempted.

Parameters

src	Source object.

Definition at line 116 of file RegEx.cxx.

References m_nFlags, and m_strRegEx.

{
  m_strRegEx  = src.m_strRegEx;
  m_bIsValid  = false;

  groomFlags(src.m_nFlags);

  compile();
}

Member Function Documentation

bool RegEx::compile ( )

protected

Compile the regular expression string.

Returns

Returns true success, false otherwise. On failure, check the reason with getReturnCode() and/or getErrorStr().

Definition at line 373 of file RegEx.cxx.

{
  int rc;   // return code

  freeReMem();

  if( m_strRegEx.length() == 0 )
  {
    setError(ReENoExpr);
  }
  else if( (rc = regcomp(&m_regex, m_strRegEx.c_str(), m_nFlags)) == ReOk )
  {
    m_bIsValid = true;
    setError(ReOk); // not an error
  }
  else
  {
    setError(rc);
    LOGERROR("'%s': %s", m_strRegEx.c_str(), m_strReError.c_str());
  }

  return m_bIsValid;
}

const std::string& rnr::RegEx::getErrorStr ( ) const

inline

Get the last RegExs operation error string.

Returns

Error string.

Definition at line 401 of file RegEx.h.

References m_strReError, operator<<, and operator>>.

Referenced by rnr::cmd::CommandLine::parseVarRegExpr(), utPr(), and utRun().

    {
      return m_strReError;
    }

int rnr::RegEx::getFlags ( ) const

inline

Get compile behavior flags.

Returns

Bitwise-or of compile behavior flags.

Definition at line 364 of file RegEx.h.

References m_nFlags, and setFlags().

Referenced by utPr().

    {
      return m_nFlags;
    }

const std::string& rnr::RegEx::getRegEx ( ) const

inline

Get the pre-compiled regular expression.

Returns

If a regular expressing exist, then the expression string is returned. Else NULL is returned.

Definition at line 342 of file RegEx.h.

References m_strRegEx.

Referenced by freeReMem(), rnr::cmd::CmdArgDef::getRegEx(), rnr::cmd::CommandLine::parseVarRegExpr(), and utPr().

    {
      return m_strRegEx;
    }

int rnr::RegEx::getReturnCode ( ) const

inline

Get the extened return code from the last RegEx operation.

Return Code	Description
ReOk (REG_NOERROR)	No error
REG_NOMATCH	Input does no match regular expression
REG_BAD*, REG_E*	The regex C interface standard compile errors
ReENoExpr	No regular expression extended error
ReENotComp	Not compiled extended error

Returns

nCode Extended return code.

Definition at line 391 of file RegEx.h.

References m_nReCode.

Referenced by utPr().

    {
      return m_nReCode;
    }

void RegEx::groomFlags ( const int  nFlags )

protected

Groom compile behavior flags, disabling any unsupported flags.

Parameters

nFlags

Bitwise-or of compile behavior flags.

Definition at line 409 of file RegEx.cxx.

{
  m_nFlags  = nFlags & (ReFlagICase | ReFlagNewLine);
  m_nFlags |= REG_EXTENDED;
}

bool rnr::RegEx::isValid ( ) const

inline

Test if in a valid state (i.e. compiled).

If valid, match operation may be applied.

Returns

Returns true or false;

Definition at line 354 of file RegEx.h.

References m_bIsValid.

Referenced by freeReMem(), rnr::cmd::CommandLine::parseVarRegExpr(), and utPr().

    {
      return m_bIsValid;
    }

bool rnr::RegEx::match	(	const std::string &	strInput,
		const int	nFlags = ReFlagDefaults
	)

Match the input string against the regular expression.

The entire input must match the regular expression.

Parameters

[in]

strInput

Input string to match.

Returns

Returns true if a match, false otherwise. For the non-constant version, an error is set if no match.

Referenced by utConstRe(), and utRun().

bool RegEx::match	(	const char *	sInput,
		const int	nFlags = ReFlagDefaults
	)

Match the input char* against the regular expression.

The entire input must match the regular expression.

Parameters

[in]

sInput

Null-terminated input char* to match.

Returns

Returns true if a match, false otherwise. For the non-constant version, an error is set if no match.

Definition at line 222 of file RegEx.cxx.

References rnr::RegEx::ReMatch::m_strMatch, rnr::RegEx::ReMatch::m_uEnd, and rnr::RegEx::ReMatch::m_uStart.

{
  string strInput;

  if( sInput != NULL )
  {
    strInput = sInput;
  }

  return match(strInput, nFlags);
}

size_t rnr::RegEx::match	(	const std::string &	strInput,
		ReMatchVec &	matches,
		const size_t	uMaxSubMatches = ReMaxSubMatchesDft,
		const int	nFlags = ReFlagDefaults
	)

Find all substrings in the input that match the regular expression.

As an example, the following C++ code snippet:

rnr::RegEx re("[A-Z][a-z ]*[ ]+(cat)[ ]+[a-z ]+[ ]+(dog)[a-z ]*\.");

std::string input("My cat is not a dog. But my cat has dog breath.");

rnr::RegEx::ReMatchVec matches;

re.match(input, matches, 4);

for(size_t i = 0; i < matches.size(); ++i)
{
  std::cout << i << ". (" << matches[i].m_uStart << ","
   << matches[i].m_uEnd << ") '"
   << matches[i].m_strMatch << "'" << std::endl;
}

Produces the output:

0. (0,19) 'My cat is not a dog.'
1. (3,5) 'cat'
2. (16,18) 'dog'
3. (21,46) 'But my cat has dog breath.'
4. (28,30) 'cat'
5. (36,38) 'dog'

Notes:

• The match start and end values are indices into the original input string, marking the location of the matched string.
• In the call match(), the maximum number of specified submatches is 4, but the number of matches found is 6. This is because 2 entire matches occurred, listed on output 0 and 3. Each occurance matched 3 (sub)strings, which is less than the 4 maximum.

Parameters

[in]	strInput	Input string.
[in,out]	Vector	of matches.
	uMaxSubMatches	Maximum number of submatches per match.
	nFlags	Bitwise-or of matching behavior flags.

Returns

Returns number of matches. For the non-constant version, an error is set if no match.

size_t RegEx::match	(	const char *	sInput,
		ReMatchVec &	matches,
		const size_t	uMaxSubMatches = ReMaxSubMatchesDft,
		const int	nFlags = ReFlagDefaults
	)

Find all substrings in input that match the regular expression.

See also

See above for description.

Parameters

[in]	sInput	Null-terminated input char*.
[in,out]	Vector	of matches.
	uMaxSubMatches	Maximum number of submatches per match.
	nFlags	Bitwise-or of matching behavior flags.

Returns

Returns number of matches. For the non-constant version, an error is set if no match.

Definition at line 358 of file RegEx.cxx.

{
  string strInput;

  if( sInput != NULL )
  {
    strInput = sInput;
  }

  return match(strInput, matches, uMaxSubMatches, nFlags);
}

RegEx & RegEx::operator=

(

const RegEx &

rhs

)

Assignment copy operator.

Regular expression compile will be attempted.

Parameters

rhs	Regular expression class object.

Returns

This regular expression object.

Definition at line 131 of file RegEx.cxx.

References m_nFlags, and m_strRegEx.

{
  freeReMem();

  m_strRegEx = rhs.m_strRegEx;
 
  groomFlags(rhs.m_nFlags);

  compile();

  return *this;
}

RegEx& rnr::RegEx::operator=

(

const std::string &

rhs

)

Assignment operator.

Regular expression compile will be attempted.

Parameters

rhs	String regular expression.

Returns

This regular expression object.

RegEx & RegEx::operator=

(

const char *

rhs

)

Assignment operator.

If not NULL or empty, regular expression compile will be attempted.

Parameters

rhs	Null-terminated string expression object.

Returns

This regular expression object.

Definition at line 155 of file RegEx.cxx.

{
  freeReMem();

  if( (rhs != NULL) && (*rhs != 0) )
  {
    m_strRegEx = rhs;
    compile();
  }
  else
  {
    m_strRegEx.clear();
    setError(ReENoExpr);
  }

  return *this;
}

void RegEx::setError ( const int  nCode )

protected

Set the error code and associated error string.

Parameters

nCode

Extended return code.

Definition at line 415 of file RegEx.cxx.

{
  m_nReCode = nCode;

  switch( m_nReCode )
  {
    case ReOk:
      m_strReError.clear();
      break;
    case ReENoExpr:
      m_strReError = "No pre-compiled regular expression";
      break;
    case ReENotComp:
      m_strReError = "Not compiled";
      break;
    default:
    {
      char buf[256];

      regerror(m_nReCode, &m_regex, buf, sizeof(buf));

      m_strReError = buf;
    }
    break;
  }
}

void RegEx::setFlags

(

int

nFlags

)

Set new compile behavior flags.

Note

May result in a new regular expression re-compile.

Parameters

nFlags

Bitwise-or of compile behavior flags.

Definition at line 397 of file RegEx.cxx.

Referenced by getFlags(), and rnr::cmd::CommandLine::parseVarRegExpr().

{
  int oldFlags = m_nFlags;

  groomFlags(nFlags);

  if( (m_nFlags != oldFlags) && !m_strRegEx.empty() )
  {
    compile();
  }
}

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os, const RegEx &  re  )

friend

Insert object into output stream.

Output: re"REGEX" string where REGEX is the regular expression pattern.

Parameters

os	Output stream.
re	Object to insert.

Returns

Reference to output stream.

Referenced by getErrorStr().

std::istream& operator>> ( std::istream &  is, RegEx &  re  )

friend

Extract from input stream to object.

Input: re"REGEX" string where REGEX is the regular expression pattern.

Parameters

is	Input stream.
re	Object to extract into.

Returns

Reference to input stream.

Referenced by getErrorStr().

Member Data Documentation

const int rnr::RegEx::ReFlagDefaults = 0

static

Regular expression compile and matching behavior flags.

See regex(3) for further description of flags.

Flags are a bitwise-or of zero or more of these values.default flags

Definition at line 104 of file RegEx.h.

const size_t rnr::RegEx::ReMaxSubMatchesDft = 32

static

default maximum submatches per match

Definition at line 130 of file RegEx.h.

const int rnr::RegEx::ReOk = REG_NOERROR

static

Special return and error codes.

Note

The error codes must to be 'out-of-band' from the the standard regex REG_* codes. Large negative values should do the trick.regex operation success

Definition at line 93 of file RegEx.h.

---

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

• include/rnr/appkit/RegEx.h
• sw/librnr_appkit/RegEx.cxx