gstring.h

自编的一个String类

// String list

#ifndef GSTRING_LIB
#define GSTRING_LIB

class StringListItem;
   class StringList;
class TaggedStringList;
   class StringList_String;
   class StringList_GString;
   class StringList_Range;
   // class MaskedStringList;
class SubstitutionList;
class GString;
   class ExplicitString;
   class PairGString;
      class AndGString;
      class OrGString;
      class XorGString;
      class PlusGString;
         class GTGString;
            class GTGString2;
         class LTGString;
   class NotGString;
   class AnyString;
      class LongestString;
      class ShortestString;
      class FixedLengthString;
   class Dots;
      class LongestDots;
      class ShortestDots;
      class FixedLengthDots;
   class WhiteSpace;
class InitialGString;


class StringListItem
{
protected:
   String S;                          // the string in this item
   StringListItem* previous;          // previous item in list
   StringListItem* next;              // next item in list
   StringList* SL;                    // parent StringList object
   StringListItem(const String& s, StringList* sl) : S(s), SL(sl) {}
public:
   String& Value() { return S; }
   const String& ConstValue() const { return S; }
   StringListItem* Next() const { return next; }
   StringListItem* Previous() const { return previous; }
   void Replace(const String& s) { S = s; }
   void InsertBefore(const String& s);
   void InsertAfter(const String& s);
   void Delete() { delete this; }
   StringListItem* Find(const String& s) const;   // next example of this
   ~StringListItem();
   friend class StringList;
};

class StringList : public StringListItem
{
// previous points to last item in list
// next points to next item in list
// S is left blank

   unsigned int N;                 // length of list
public:
   void push_back(const String& s) { InsertBefore(s); }
   void push_front(const String& s) { InsertAfter(s); }
   String pop_back();              // return last in and remove it from list
   String pop_front();             // return first in and remove it from list
   void CleanUp();
   StringList() : StringListItem("", this), N(0)
      { previous = this; next = this; }
   StringList(StringList& SL);
   void operator=(StringList& SL);
   ~StringList() { CleanUp(); }
   StringList_String operator()(const String& s);
   StringList_GString operator()(const GString& g);
   StringList_Range operator()
      (const String& s1, const String& s2, int ends = 3);
   //StringList_GString operator()(GString& g1, GString& g2);
   TaggedStringList All();
   void Format(unsigned int width, StringList& sl);
   int size() { return N; }
   friend class StringListItem;
   friend class TaggedStringList;
   friend ostream& operator<<(ostream& os, StringList& sl);
   friend void operator>>(istream& is, StringList& sl);

   class iterator
   {
      StringListItem* SLI;
      iterator(StringListItem* sli) : SLI(sli) {}
   public:
      iterator() : SLI(0) {}
      iterator operator++() { SLI = SLI->Next(); return *this; }
      iterator operator--() { SLI = SLI->Previous(); return *this; }
      iterator operator++(int)
         { iterator i = *this; SLI = SLI->Next(); return i; }
      iterator operator--(int)
         { iterator i = *this; SLI = SLI->Previous(); return i; }
      String& operator*() { return SLI->Value(); }
      bool operator==(const iterator& i) const { return SLI == i.SLI; }
      bool operator!=(const iterator& i) const { return SLI != i.SLI; }
      String* operator->() { return &(SLI->Value()); }
      friend class StringList;
   };
   iterator begin() { return iterator(Next()); }
   iterator end() { return iterator(this); }

   class const_iterator
   {
      const StringListItem* SLI;
      const_iterator(const StringListItem* sli) : SLI(sli) {}
   public:
      const_iterator() : SLI(0) {}
      const_iterator operator++() { SLI = SLI->Next(); return *this; }
      const_iterator operator--() { SLI = SLI->Previous(); return *this; }
      const_iterator operator++(int)
         { const_iterator i = *this; SLI = SLI->Next(); return i; }
      const_iterator operator--(int)
         { const_iterator i = *this; SLI = SLI->Previous(); return i; }
      const String operator*() { return SLI->ConstValue(); }
      bool operator==(const const_iterator& i) const { return SLI == i.SLI; }
      bool operator!=(const const_iterator& i) const { return SLI != i.SLI; }
      const String* operator->() { return &(SLI->ConstValue()); }
      friend class StringList;
   };
   const_iterator begin() const { return const_iterator(Next()); }
   const_iterator end() const { return const_iterator(this); }

   class reverse_iterator
   {
      StringListItem* SLI;
      reverse_iterator(StringListItem* sli) : SLI(sli) {}
   public:
      reverse_iterator() : SLI(0) {}
      reverse_iterator operator++() { SLI = SLI->Previous(); return *this; }
      reverse_iterator operator--() { SLI = SLI->Next(); return *this; }
      reverse_iterator operator++(int)
         { reverse_iterator i = *this; SLI = SLI->Previous(); return i; }
      reverse_iterator operator--(int)
         { reverse_iterator i = *this; SLI = SLI->Next(); return i; }
      String& operator*() { return SLI->Value(); }
      bool operator==(const reverse_iterator& i) const { return SLI == i.SLI; }
      bool operator!=(const reverse_iterator& i) const { return SLI != i.SLI; }
      String* operator->() { return &(SLI->Value()); }
      friend class StringList;
   };
   reverse_iterator rbegin() { return reverse_iterator(Previous()); }
   reverse_iterator rend() { return reverse_iterator(this); }

   class const_reverse_iterator
   {
      const StringListItem* SLI;
      const_reverse_iterator(const StringListItem* sli) : SLI(sli) {}
   public:
      const_reverse_iterator() : SLI(0) {}
      const_reverse_iterator operator++()
         { SLI = SLI->Previous(); return *this; }
      const_reverse_iterator operator--()
         { SLI = SLI->Next(); return *this; }
      const_reverse_iterator operator++(int)
         { const_reverse_iterator i = *this; SLI = SLI->Previous(); return i; }
      const_reverse_iterator operator--(int)
         { const_reverse_iterator i = *this; SLI = SLI->Next(); return i; }
      const String& operator*() { return SLI->ConstValue(); }
      bool operator==(const const_reverse_iterator& i) const
         { return SLI == i.SLI; }
      bool operator!=(const const_reverse_iterator& i) const
         { return SLI != i.SLI; }
      const String* operator->() { return &(SLI->ConstValue()); }
      friend class StringList;
   };
   const_reverse_iterator rbegin() const
      { return const_reverse_iterator(Previous()); }
   const_reverse_iterator rend() const
      { return const_reverse_iterator(this); }

   iterator find(const String& s);
   reverse_iterator rfind(const String& s);
   iterator find(const String& s, iterator i);
   reverse_iterator rfind(const String& s, reverse_iterator i);

   const_iterator find(const String& s) const;
   const_reverse_iterator rfind(const String& s) const;
   const_iterator find(const String& s, const_iterator i) const;
   const_reverse_iterator rfind(const String& s, const_reverse_iterator i)
      const;

   void erase(iterator i) { delete i.SLI; }
   void erase(reverse_iterator i) { delete i.SLI; }
   void insert_before(const String& s, iterator i) { i.SLI->InsertBefore(s); }
   void insert_after(const String& s, iterator i) { i.SLI->InsertAfter(s); }
};

class TaggedStringList
{
protected:
   StringList& SL;
public:
   TaggedStringList(StringList& sl) : SL(sl) {}
   virtual ~TaggedStringList() {}
   virtual bool Select(const StringListItem& SLI) const { return true; }
   friend ostream& operator<<(ostream& os, const TaggedStringList& tsl);
   friend class StringList;

   class iterator
   {
      StringListItem* SLI;
      TaggedStringList* TSL;
      iterator(StringListItem* sli, TaggedStringList* tsl)
         : SLI(sli), TSL(tsl) {}
   public:
      iterator() : SLI(0) {}
      iterator operator++();
      iterator operator--();
      iterator operator++(int)
         { iterator i = *this; operator++(); return i; }
      iterator operator--(int)
         { iterator i = *this; operator--(); return i; }
      String& operator*() { return SLI->Value(); }
      bool operator==(const iterator& i) const { return SLI == i.SLI; }
      bool operator!=(const iterator& i) const { return SLI != i.SLI; }
      String* operator->() { return &(SLI->Value()); }
      friend class TaggedStringList;
   };
   iterator begin() { return ++iterator(&SL, this); }
   iterator end() { return iterator(&SL, this); }

   class const_iterator
   {
      const StringListItem* SLI;
      const TaggedStringList* TSL;
      const_iterator(const StringListItem* sli, const TaggedStringList* tsl)
         : SLI(sli), TSL(tsl) {}
   public:
      const_iterator() : SLI(0) {}
      const_iterator operator++();
      const_iterator operator--();
      const_iterator operator++(int)
         { const_iterator i = *this; operator++(); return i; }
      const_iterator operator--(int)
         { const_iterator i = *this; operator--(); return i; }
      const String& operator*() { return SLI->ConstValue(); }
      bool operator==(const const_iterator& i) const { return SLI == i.SLI; }
      bool operator!=(const const_iterator& i) const { return SLI != i.SLI; }
      const String* operator->() { return &(SLI->ConstValue()); }
      friend class TaggedStringList;
   };
   const_iterator begin() const { return ++const_iterator(&SL, this); }
   const_iterator end() const { return const_iterator(&SL, this); }


   class reverse_iterator
   {
      StringListItem* SLI;
      TaggedStringList* TSL;
      reverse_iterator(StringListItem* sli, TaggedStringList* tsl)
         : SLI(sli), TSL(tsl) {}
   public:
      reverse_iterator() : SLI(0) {}
      reverse_iterator operator++();
      reverse_iterator operator--();
      reverse_iterator operator++(int)
         { reverse_iterator i = *this; operator++(); return i; }
      reverse_iterator operator--(int)
         { reverse_iterator i = *this; operator--(); return i; }
      String& operator*() { return SLI->Value(); }
      bool operator==(const reverse_iterator& i) const { return SLI == i.SLI; }
      bool operator!=(const reverse_iterator& i) const { return SLI != i.SLI; }
      String* operator->() { return &(SLI->Value()); }
      friend class TaggedStringList;
   };
   reverse_iterator rbegin() { return ++reverse_iterator(&SL, this); }
   reverse_iterator rend() { return reverse_iterator(&SL, this); }

   class const_reverse_iterator
   {
      const StringListItem* SLI;
      const TaggedStringList* TSL;
      const_reverse_iterator(const StringListItem* sli,
         const TaggedStringList* tsl) : SLI(sli), TSL(tsl) {}
   public:
      const_reverse_iterator() : SLI(0) {}
      const_reverse_iterator operator++();
      const_reverse_iterator operator--();
      const_reverse_iterator operator++(int)
         { const_reverse_iterator i = *this; operator++(); return i; }
      const_reverse_iterator operator--(int)
         { const_reverse_iterator i = *this; operator--(); return i; }
      const String& operator*() { return SLI->ConstValue(); }
      bool operator==(const const_reverse_iterator& i) const
         { return SLI == i.SLI; }
      bool operator!=(const const_reverse_iterator& i) const
         { return SLI != i.SLI; }
      const String* operator->() { return &(SLI->ConstValue()); }
      friend class TaggedStringList;
   };
   const_reverse_iterator rbegin() const
      { return ++const_reverse_iterator(&SL, this); }
   const_reverse_iterator rend() const
      { return const_reverse_iterator(&SL, this); }

   void erase(iterator i) { delete i.SLI; }
   void erase(reverse_iterator i) { delete i.SLI; }
   void insert_before(const String& s, iterator i) { i.SLI->InsertBefore(s); }
   void insert_after(const String& s, iterator i) { i.SLI->InsertAfter(s); }
   void sf(const String& s1, const String& s2, iterator i); // substitute first
   void sl(const String& s1, const String& s2, iterator i); // substitute last
   void sa(const String& s1, const String& s2, iterator i); // substitute all
   void sf(SubstitutionList&, iterator i); // substitute first
   void sl(SubstitutionList&, iterator i); // substitute last
   void sa(SubstitutionList&, iterator i); // substitute all
   void s(const GString& g1, const GString& g2, iterator i);
   void UpperCase(iterator i);
   void LowerCase(iterator i);

   int size();

   void erase();
   void insert_before(const String& s);
   void insert_after(const String& s);
   void sf(const String& s1, const String& s2);     // substitute first
   void sl(const String& s1, const String& s2);     // substitute last
   void sa(const String& s1, const String& s2);     // substitute all
   void sf(SubstitutionList&);                      // substitute first
   void sl(SubstitutionList&);                      // substitute last
   void sa(SubstitutionList&);                      // substitute all
   void s(const GString& g1, const GString& g2);    // gstring substitute
   void UpperCase();
   void LowerCase();

   friend class TaggedStringList::iterator;
   friend class TaggedStringList::reverse_iterator;
   friend class TaggedStringList::const_iterator;
   friend class TaggedStringList::const_reverse_iterator;
};

class StringList_String : public TaggedStringList
{
   String Target;
public:
   StringList_String(StringList& sl, const String& t)
      : TaggedStringList(sl), Target(t) {}
   bool Select(const StringListItem& SLI) const
      { return SLI.ConstValue().find(Target) != String::npos; }
};

class StringList_Range : public TaggedStringList