ROOT logo
ROOT » CORE » BASE » TRegexp

class TRegexp


Regular expression class.

'^'             // start-of-line anchor
'$'             // end-of-line anchor
'.'             // matches any character
'['             // start a character class
']'             // end a character class
'^'             // negates character class if 1st character
'*'             // Kleene closure (matches 0 or more)
'+'             // Positive closure (1 or more)
'?'             // Optional closure (0 or 1)

Note that the '|' operator (union) is not supported, nor are
parentheses (grouping). Therefore "a|b" does not match "a".

   Standard classes like [:alnum:], [:alpha:], etc. are not supported,
only [a-zA-Z], [^ntf] and so on.

Function Members (Methods)

TRegexp(const TString& re)
TRegexp(const TRegexp& re)
TRegexp(const char* re, Bool_t wildcard = kFALSE)
static TClass*Class()
Ssiz_tIndex(const TString& str, Ssiz_t* len, Ssiz_t start = 0) const
virtual TClass*IsA() const
TRegexp&operator=(const TRegexp& re)
TRegexp&operator=(const TString& re)
TRegexp&operator=(const char* re)
virtual voidShowMembers(TMemberInspector& insp)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
voidCopyPattern(const TRegexp& re)
voidGenPattern(const char* re)
const char*MakeWildcard(const char* re)

Data Members

enum EStatVal { kOK
unsigned short*fPatternCompiled pattern
static const unsigned intfgMaxpatMax length of compiled pattern

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TRegexp(const char* re, Bool_t wildcard = kFALSE)
 Create a regular expression from the input string. If wildcard is
 true then the input string will first be interpreted as a wildcard
 expression by MakeWildcard(), and the result then interpreted as a
 regular expression.
TRegexp(const TString& re)
 Create a regular expression from a TString.
TRegexp(const TRegexp& re)
 Copy ctor.
TRegexp& operator=(const TRegexp& re)
 Assignment operator.
TRegexp& operator=(const char* re)
 Assignment operator taking a char* and assigning it to a regexp.
TRegexp& operator=(const TString& re)
 Assignment operator taking a TString.
void GenPattern(const char* re)
 Generate the regular expression pattern.
void CopyPattern(const TRegexp& re)
 Copy the regular expression pattern.
const char * MakeWildcard(const char* re)
 This routine transforms a wildcarding regular expression into
 a general regular expression used for pattern matching.
 When using wildcards the regular expression is assumed to be
 preceded by a "^" (BOL) and terminated by a "$" (EOL). Also, all
 "*"'s and "?"'s (closures) are assumed to be preceded by a "." (i.e. any
 character, except "/"'s) and all .'s are escaped (so *.ps is different
 from *.eps). The special treatment of "/" allows the easy matching of
 pathnames, e.g. "*.root" will match "aap.root", but not "pipo/aap.root".
Ssiz_t Index(const TString& str, Ssiz_t* len, Ssiz_t start = 0) const
 Find the first occurance of the regexp in string and return the
 position, or -1 if there is no match. Len is length of the matched
 string and i is the offset at which the matching should start.
EStatVal Status()