TRegexp

class TRegexp

    private:

             void CopyPattern(const TRegexp& re)
             void GenPattern(const char* re)
      const char* MakeWildcard(const char* re) const

    public:

                        TRegexp(const char* re, Bool_t wildcard = kFALSE)
                        TRegexp(const TString& re)
                        TRegexp(const TRegexp& re)
                virtual ~TRegexp()
         static TClass* Class()
                 Ssiz_t Index(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 void ShowMembers(TMemberInspector& insp, char* parent)
      TRegexp::EStatVal Status()
           virtual void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)

Data Members

    private:

                unsigned short* fPattern  Compiled pattern
              TRegexp::EStatVal fStat     Status
      static const unsigned int fgMaxpat  Max length of compiled pattern

    public:

      static const TRegexp::EStatVal kOK       
      static const TRegexp::EStatVal kIllegal  
      static const TRegexp::EStatVal kNomem    
      static const TRegexp::EStatVal kToolong  

Class Description

                                                                      
 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)                       
                                                                      
   Standard classes like [:alnum:], [:alpha:], etc. are not supported,
   only [a-zA-Z], [^ntf] and so on.                                   
                                                                      

 Create a regular expression from the input string. If wildcard is true
 then the input string contains a wildcard expression (see MakeWildcard()).

 Create a regular expression from a TString.

 Copy ctor.

 Destructor.

 Generate the regular expression pattern.

 Copy the regular expression pattern.

 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 (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".

 Find the first occurance of the regexp in string and return the position.
 Len is length of the matched string and i is the offset at which the
 matching should start.

Inline Functions

                 TRegexp& operator=(const TRegexp& re)
                 TRegexp& operator=(const TString& re)
                 TRegexp& operator=(const char* re)
        TRegexp::EStatVal Status()
                  TClass* Class()
                  TClass* IsA() const
                     void ShowMembers(TMemberInspector& insp, char* parent)
                     void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)