gstring.h

自编的一个String类

{
   String Target1, Target2;
   int Ends; // 0 neither boundary, 1 last, 2 first, 3 both
   bool Selected, ChangeNext;
public:
   StringList_Range(StringList& sl, const String& t1, const String& t2,
      int ends) : TaggedStringList(sl), Target1(t1), Target2(t2),
      Ends(ends), Selected(false), ChangeNext(false) {}
   bool Select(const StringListItem& SLI) const;
};



/*
class MaskedStringList : public TaggedStringList
{
   String Mask;
public:
   MaskedStringList(StringList& sl)
      : TaggedStringList(sl), Mask((sl.size()+7)/8, (char)0) {}
   MaskedStringList(const MaskedStringList& tsl)
      : TaggedStringList(tsl.SL), Mask(tsl.Mask) {}
   friend ostream& operator<<(ostream& os, MaskedStringList& tsl);
   friend class StringList;
};
*/

// Carry out a one of a series of translations
// case independent not done yet

class SubstitutionList
{
   StringList input;        // what we are searching for
   StringList output;       // what we convert to
   bool first;              // next input will be an input one
   bool ci;                 // true for case independent
public:
   SubstitutionList() : first(true), ci(false) {}
   SubstitutionList& operator<<(const String& S);
   void SetCaseIndependent(bool cix = true) { ci = cix; }
   void CleanUp()
      { input.CleanUp(); output.CleanUp(); first = true; ci = false;}
   friend class TaggedStringList;
};

// GString is something we can match a string to

class GString
{
protected:
   GString() {}
public:
   virtual ~GString() {}
   NotGString operator~();
   PlusGString operator+(const GString& g);
   GTGString operator>(const GString& g);
   LTGString operator<(const GString& g);
   AndGString operator&(const GString& g);
   OrGString operator|(const GString& g);
   XorGString operator^(const GString& g);

   PlusGString operator+(const ExplicitString& es);
   GTGString operator>(const ExplicitString& es);
   LTGString operator<(const ExplicitString& es);
   AndGString operator&(const ExplicitString& es);
   OrGString operator|(const ExplicitString& es);
   XorGString operator^(const ExplicitString& es);
   virtual bool Matches(const String& s) = 0;
   virtual bool Matches_i(const String& s, unsigned int&)
      { return Matches(s); }
   virtual int ShortLong() const { return 0; }      // -1 = short, +1 = long
   virtual unsigned int FixedLength() const { return String::npos; }
   virtual void Collect(const String& s, StringList& SL);
   virtual void Translate(String& s, StringList& SL);
};

class ExplicitString : public GString
{
   const String S;
public:
   ExplicitString(const String& s) : S(s) {}
   ExplicitString(const char* s) : S(s) {}
   ExplicitString(const ExplicitString& es) : S(es.S) {}
   bool Matches(const String& s);
   unsigned int FixedLength() const { return S.size(); }
   void Translate(String& s, StringList& SL);
   ~ExplicitString() {}
};

class PairGString : public GString
{
protected:
   const GString* G1;
   const GString* G2;
   PairGString(const GString* g1, const GString* g2) : G1(g1), G2(g2) {}
   int ShortLong() const;
};

class AndGString : public PairGString
{
public:
   AndGString(const GString* g1, const GString* g2) : PairGString(g1, g2) {}
   bool Matches(const String& s);
   unsigned int FixedLength() const;
   void Collect(const String& s, StringList& SL);
   void Translate(String& s, StringList& SL);
};

class OrGString : public PairGString
{
   int which;      // 1 for first branch, 2 for second
public:
   OrGString(const GString* g1, const GString* g2) : PairGString(g1, g2) {}
   bool Matches(const String& s);
   unsigned int FixedLength() const;
   void Collect(const String& s, StringList& SL);
   void Translate(String& s, StringList& SL);
};

class XorGString : public PairGString
{
   int which;      // 1 for first branch, 2 for second
public:
   XorGString(const GString* g1, const GString* g2) : PairGString(g1, g2) {}
   bool Matches(const String& s);
   unsigned int FixedLength() const;
   void Collect(const String& s, StringList& SL);
   void Translate(String& s, StringList& SL);
};

class PlusGString : public PairGString
{
protected:
   int split;     // where the string was split
public:
   PlusGString(const GString* g1, const GString* g2) : PairGString(g1, g2) {}
   bool Matches(const String& s);
   unsigned int FixedLength() const;
   void Collect(const String& s, StringList& SL);
   void Translate(String& s, StringList& SL);
};

class GTGString : public PlusGString
{
public:
   GTGString(const GString* g1, const GString* g2) : PlusGString(g1, g2) {}
   GTGString2 operator>(const GString& g);
   GTGString2 operator>(const ExplicitString& es);
   bool Matches(const String& s);
   bool Matches_i(const String& s, unsigned int& ix);
};

// this is for iterated '>' symbols
class GTGString2 : public GTGString
{
public:
   GTGString2(const GTGString* g1, const GString* g2) : GTGString(g1, g2) {}
   GTGString2(const GTGString2* g1, const GString* g2) : GTGString(g1, g2) {}
   GTGString2 operator>(const GString& g);
   GTGString2 operator>(const ExplicitString& es);
   bool Matches(const String& s);
   bool Matches_i(const String& s, unsigned int& ix);
};

class LTGString : public PlusGString
{
public:
   LTGString(const GString* g1, const GString* g2) : PlusGString(g1, g2) {}
   bool Matches(const String& s);
};

class NotGString : public GString
{
   const GString* G;
public:
   NotGString(const GString* g) : G(g) {}
   bool Matches(const String& s);
   void Translate(String& s, StringList& SL);
};

class AnyString : public GString
{
protected:
   String S;
public:
   uint size() const { return S.size(); }
   bool Matches(const String& s);
   AnyString() : S("") {}
   AnyString(const AnyString& us) : S(us.S) {}
   String Value() const { return S; }
   void Translate(String& s, StringList& SL);
};


class LongestString : public AnyString
{
public:
   int ShortLong() const { return 1; }
   LongestString() : AnyString() {}
   LongestString(const LongestString& ls) : AnyString(ls) {}
   void operator=(const String& s) { S = s; }
};

class ShortestString : public AnyString
{
public:
   int ShortLong() const { return -1; }
   ShortestString() : AnyString() {}
   ShortestString(const ShortestString& ss) : AnyString(ss) {}
   void operator=(const String& s) { S = s; }
};

class FixedLengthString : public AnyString
{
   unsigned int N;
public:
   FixedLengthString(unsigned int n) : AnyString(), N(n) {}
   FixedLengthString(const FixedLengthString& fs)
      : AnyString(fs), N(fs.N) {}
   bool Matches(const String& s);
   unsigned int FixedLength() const { return N; }
   void operator=(const String& s) { S = s; }
};

// match any string - don't keep copy of string
class Dots : public GString
{
public:
   bool Matches(const String&);
};

class LongestDots : public Dots
{
public:
   int ShortLong() const { return 1; }
};

class ShortestDots : public Dots
{
public:
   int ShortLong() const { return -1; }
};

class FixedLengthDots : public Dots
{
   unsigned int N;
public:
   FixedLengthDots(int n) : N(n) {}
   FixedLengthDots(const FixedLengthDots& fld) : N(fld.N) {}
   bool Matches(const String& s);
   unsigned int FixedLength() const { return N; }
};


// match sequence of spaces, tabs, lf, cr - must be at least one
class WhiteSpace : public GString
{
public:
   int ShortLong() const { return 1; }     // try to match maximum amount
   bool Matches(const String&);
};

// match sequence of spaces, tabs, lf, cr
class OptionalWhiteSpace : public GString
{
public:
   int ShortLong() const { return 1; }     // try to match maximum amount
   bool Matches(const String&);
};

// put before String or character string to convert to GString
class InitialGString
{
public:
   ExplicitString operator+(const String& s) { return ExplicitString(s); }
   ExplicitString operator>(const String& s) { return ExplicitString(s); }
   ExplicitString operator<(const String& s) { return ExplicitString(s); }
   ExplicitString operator&(const String& s) { return ExplicitString(s); }
   ExplicitString operator|(const String& s) { return ExplicitString(s); }
   ExplicitString operator^(const String& s) { return ExplicitString(s); }
   ExplicitString operator+(const char* s) { return ExplicitString(s); }
   ExplicitString operator>(const char* s) { return ExplicitString(s); }
   ExplicitString operator<(const char* s) { return ExplicitString(s); }
   ExplicitString operator&(const char* s) { return ExplicitString(s); }
   ExplicitString operator|(const char* s) { return ExplicitString(s); }
   ExplicitString operator^(const char* s) { return ExplicitString(s); }
};

// inlines

inline PlusGString GString::operator+(const ExplicitString& es)
   { return operator+((const GString&)es); }
inline GTGString GString::operator>(const ExplicitString& es)
   { return operator>((const GString&)es); }
inline LTGString GString::operator<(const ExplicitString& es)
   { return operator<((const GString&)es); }
inline AndGString GString::operator&(const ExplicitString& es)
   { return operator&((const GString&)es); }
inline OrGString GString::operator|(const ExplicitString& es)
   { return operator|((const GString&)es); }
inline XorGString GString::operator^(const ExplicitString& es)
   { return operator^((const GString&)es); }


inline GTGString2 GTGString::operator>(const ExplicitString& es)
   { return operator>((const GString&)es); }
inline GTGString2 GTGString2::operator>(const ExplicitString& es)
   { return operator>((const GString&)es); }


// Globals

extern InitialGString GS;
extern Dots DOTS;
extern LongestDots LDOTS;
extern ShortestDots SDOTS;
extern FixedLengthDots DOT;
extern WhiteSpace WS;
extern OptionalWhiteSpace OWS;


// ********************** more search string list stuff ********************

class StringList_GString : public TaggedStringList
{
   GString* Target;
   // constructor is not accessible because GString tree will vanish at end
   // of expression where it is built
   // so we don't want a stand-alone StringList_GString object
   StringList_GString(StringList& sl, GString& t)
      : TaggedStringList(sl), Target(&t) {}
public:
   bool Select(const StringListItem& SLI) const
      { return Target->Matches(SLI.ConstValue()); }
   friend class StringList;
};



#endif


// body file: liststr.cpp
// body file: gstring.cpp