liststr.cpp

自编的一个String类

// character string manipulation library and string list

#define WANT_STREAM
#define WANT_MATH

#include "include.h"
#include "str.h"
#include "gstring.h"
#include "str_fns.h"


void StringListItem::InsertBefore(const String& s)
{
   StringListItem* SLI = new StringListItem(s, SL);
   SLI->next = this; SLI->previous = previous;
   previous->next = SLI; previous = SLI;
   SL->N++;
}

void StringListItem::InsertAfter(const String& s)
{
   StringListItem* SLI = new StringListItem(s, SL);
   SLI->next = next; SLI->previous = this;
   next->previous = SLI; next = SLI;
   SL->N++;
}

StringListItem* StringListItem::Find(const String& s) const
{
   for (StringListItem* SLI = next; SLI != SL; SLI = SLI->next)
      if (SLI->S == s) return SLI;
   return 0;
}

StringList::StringList(StringList& sl): StringListItem("", this), N(0)
{
   previous = this; next = this;
   for (StringList::iterator i = sl.begin(); i != sl.end(); i++) push_back(*i);
}

void StringList::operator=(StringList& sl)
{
   CleanUp();
   for (StringList::iterator i = sl.begin(); i != sl.end(); i++) push_back(*i);
}




StringList::iterator StringList::find(const String& s)
   { return find(s, begin()); }

StringList::reverse_iterator StringList::rfind(const String& s)
   { return rfind(s, rbegin()); }

StringList::iterator StringList::find(const String& s, StringList::iterator i)
{
   for (; i != end(); i++) if (*i == s) return i;
   return end();
}

StringList::reverse_iterator
   StringList::rfind(const String& s, StringList::reverse_iterator i)
{
   for (; i != rend(); i++) if (*i == s) return i;
   return rend();
}


StringList::const_iterator StringList::find(const String& s) const
   { return find(s, begin()); }

StringList::const_reverse_iterator StringList::rfind(const String& s) const
   { return rfind(s, rbegin()); }

StringList::const_iterator
   StringList::find(const String& s, StringList::const_iterator i) const
{
   for (; i != end(); i++) if (*i == s) return i;
   return end();
}

StringList::const_reverse_iterator
   StringList::rfind(const String& s, StringList::const_reverse_iterator i)
   const
{
   for (; i != rend(); i++) if (*i == s) return i;
   return rend();
}


StringListItem::~StringListItem()
   { previous->next = next; next->previous = previous; SL->N--; }

String StringList::pop_back()
   { String s = previous->S; previous->Delete(); return s; }

String StringList::pop_front()
   { String s = next->S; next->Delete(); return s; }

void StringList::CleanUp()
{
   StringListItem* SLI1;
   for (StringListItem* SLI = next; SLI != this; SLI = SLI1)
   {  SLI1 = SLI->next; delete SLI; }
}

// word wrap to fit into page of width "width"
void StringList::Format(unsigned int width, StringList& sl)
{
   String S2; S2.reserve(512);
   unsigned int q = 0;            // location on output string
   for (StringList::iterator i = begin(); i != end(); i++)
   {
      unsigned int p = 0;         // location on input string
      String& S1 = *i; unsigned int n = S1.size(); unsigned int s;

      if (n == 0)                 // blank line
      {
         if (q > 0) { sl.push_back(S2); S2.erase(); }   // clear pending
         sl.push_back(S2); q = 0;                       // blank line
         continue;
      }
      else if (S1[0] == ' ')      // line beginning with space
      {
         if (q > 0) { sl.push_back(S2); S2.erase(); }   // clear pending
         q = S1.find_first_not_of(' ');
         if (q != String::npos) { S2.append(q, ' '); p = q; }
         else { sl.push_back(S2); q = 0; continue; }    // only spaces on line
      }
      else if (q > 0) { S2 += ' '; q++; }

      do
      {
         unsigned int w = S1.find(' ', p);         // char after next word
         if (w == String::npos) { w = n; s = n; }
         else
         {
            s = S1.find_first_not_of(' ',w);       // beg. of following word
            if (s == String::npos) s = n;
         }
         // p = letters processed so far
         // w = letters processed so far plus next word
         // s = letters processed so far plus next word plus next spaces
         if (q + w - p >= width && q != 0)     // won't fit in space
                                               // & word would fit in a line
         {
            if (S2[q-1] == ' ') S2.erase(q-1,1);
            sl.push_back(S2); S2.erase(); q=0;
         }
         S2 += S1.substr(p, s-p); q += s-p; p=s;
      }
      while (s != n);
   }
   if (q>0)
   {
      if (S2[q-1] == ' ') S2.erase(q-1,1);
      sl.push_back(S2);
   }
}

ostream& operator<<(ostream& os, StringList& sl)
{
   for (StringListItem* word = sl.Next(); word != &sl; word = word->Next())
      os << word->Value() << endl;
   return os;
}

void operator>>(istream& is, StringList& sl)
   { while (!is.eof()) { String s; getline(is, s); sl.push_back(s); } }

TaggedStringList StringList::All()
   { return TaggedStringList(*this); }


TaggedStringList::iterator
   TaggedStringList::iterator::operator++()
{
   do SLI = SLI->Next();
   while (! TSL->Select(*SLI)  && SLI != &(TSL->SL) );
   return *this;
}

TaggedStringList::iterator
   TaggedStringList::iterator::operator--()
{
   do SLI = SLI->Previous();
   while (! TSL->Select(*SLI)  && SLI != &(TSL->SL) );
   return *this;
}

TaggedStringList::reverse_iterator
   TaggedStringList::reverse_iterator::operator++()
{
   do SLI = SLI->Previous();
   while (! TSL->Select(*SLI)  && SLI != &(TSL->SL) );
   return *this;
}

TaggedStringList::reverse_iterator
   TaggedStringList::reverse_iterator::operator--()
{
   do SLI = SLI->Next();
   while (! TSL->Select(*SLI)  && SLI != &(TSL->SL) );
   return *this;
}


TaggedStringList::const_iterator
   TaggedStringList::const_iterator::operator++()
{
   do SLI = SLI->Next();
   while (! TSL->Select(*SLI)  && SLI != &(TSL->SL) );
   return *this;
}

TaggedStringList::const_iterator
   TaggedStringList::const_iterator::operator--()
{
   do SLI = SLI->Previous();
   while (! TSL->Select(*SLI)  && SLI != &(TSL->SL) );
   return *this;
}

TaggedStringList::const_reverse_iterator
   TaggedStringList::const_reverse_iterator::operator++()
{
   do SLI = SLI->Previous();
   while (! TSL->Select(*SLI)  && SLI != &(TSL->SL) );
   return *this;
}

TaggedStringList::const_reverse_iterator
   TaggedStringList::const_reverse_iterator::operator--()
{
   do SLI = SLI->Next();
   while (! TSL->Select(*SLI)  && SLI != &(TSL->SL) );
   return *this;
}


ostream& operator<<(ostream& os, const TaggedStringList& tsl)
{
   Tracer("<< TaggedStringList");
   for (TaggedStringList::const_iterator i = tsl.begin(); i != tsl.end(); i++)
      os << *i << endl;
   return os;
}

void TaggedStringList::sf(const String& s1, const String& s2, iterator i)
{
   Tracer TR("TaggedStringList::sf");
   unsigned int p = i->find(s1); if (p == String::npos) return;
   i->replace(p, s1.size(), s2);
}

void TaggedStringList::sl(const String& s1, const String& s2, iterator i)
{
   Tracer TR("TaggedStringList::sl");
   unsigned int p = i->rfind(s1); if (p == String::npos) return;
   i->replace(p, s1.size(), s2);
}

void TaggedStringList::sa(const String& s1, const String& s2, iterator i)
{
   Tracer TR("TaggedStringList::sa");
   int n = s1.size(); if (n == 0) return;
   for (unsigned int p = 0; ;)
   {
      p = i->find(s1, p); if (p == String::npos) return;
      i->replace(p, n, s2); p += s2.size();
   }
}

void TaggedStringList::sf(SubstitutionList& sx, iterator i)
{
   StringList::iterator m = sx.output.begin();
   for (StringList::iterator k = sx.input.begin(); k != sx.input.end(); ++k)
      { sf(*k, *m, i); ++m; }
}

void TaggedStringList::sl(SubstitutionList& sx, iterator i)
{
   StringList::iterator m = sx.output.begin();
   for (StringList::iterator k = sx.input.begin(); k != sx.input.end(); ++k)
      { sl(*k, *m, i); ++m; }
}

void TaggedStringList::sa(SubstitutionList& sx, iterator i)
{
   StringList::iterator m = sx.output.begin();
   for (StringList::iterator k = sx.input.begin(); k != sx.input.end(); ++k)
      { sa(*k, *m, i); ++m; }
}

void TaggedStringList::s(const GString& g1, const GString& g2, iterator i)
{
   Tracer TR("TaggedStringList::s");
   String& S = *i;
   if (!((GString&)g1).Matches(S)) return;    // can we do this better
   StringList Input;
   ((GString&)g1).Collect(S, Input);          // can we do this better
   S.erase();
   ((GString&)g2).Translate(S, Input);        // can we do this better
}

void TaggedStringList::UpperCase(iterator i)
   { ::UpperCase(*i); }

void TaggedStringList::LowerCase(iterator i)
   { ::LowerCase(*i); }

void TaggedStringList::erase()
{
   iterator i1;
   for (iterator i = begin(); i != end(); i = i1) { i1 = i; i1++; erase(i); }
}

void TaggedStringList::insert_before(const String& s)
   { for (iterator i = begin(); i != end(); i++) insert_before(s, i); }

void TaggedStringList::insert_after(const String& s)
{
   iterator i1;
   for (iterator i = begin(); i != end(); i = i1 )
      { i1 = i; i1++; insert_after(s, i); }
}

void TaggedStringList::sf(const String& s1, const String& s2)
   { for (iterator i = begin(); i != end(); i++) sf(s1, s2, i); }

void TaggedStringList::sl(const String& s1, const String& s2)
   { for (iterator i = begin(); i != end(); i++) sl(s1, s2, i); }

void TaggedStringList::sa(const String& s1, const String& s2)
   { for (iterator i = begin(); i != end(); i++) sa(s1, s2, i); }

void TaggedStringList::sf(SubstitutionList& sx)
   { for (iterator i = begin(); i != end(); i++) sf(sx, i); }

void TaggedStringList::sl(SubstitutionList& sx)
   { for (iterator i = begin(); i != end(); i++) sl(sx, i); }

void TaggedStringList::sa(SubstitutionList& sx)
   { for (iterator i = begin(); i != end(); i++) sa(sx, i); }

void TaggedStringList::s(const GString& g1, const GString& g2)
   { for (iterator i = begin(); i != end(); i++) s(g1, g2, i); }

void TaggedStringList::UpperCase()
   { for (iterator i = begin(); i != end(); i++) UpperCase(i); }

void TaggedStringList::LowerCase()
   { for (iterator i = begin(); i != end(); i++) LowerCase(i); }

int TaggedStringList::size()
{
   int n = 0;
   for (iterator i = begin(); i != end(); i++) n++;
   return n;
}


StringList_String StringList::operator()(const String& s)
{
   Tracer TR("StringList::operator()(const String& s)");
   return StringList_String(*this, s);
}

StringList_GString StringList::operator()(const GString& gs)
{
   Tracer TR("StringList::operator()(const GString& gs)");
   return StringList_GString(*this, (GString&)gs);
}

StringList_Range StringList::operator()(const String& s1, const String& s2,
   int ends)
   { return StringList_Range(*this, s1, s2, ends); }

bool StringList_Range::Select(const StringListItem& SLI) const
{
   // assume we are moving in the forward direction
   // and select is called every iteration

   if (ChangeNext)
   {
      ((StringList_Range&)(*this)).ChangeNext = false;
      ((StringList_Range&)(*this)).Selected = !Selected;
   }

   if (Selected)
   {
      if (SLI.ConstValue().find(Target2) != String::npos)     // found Target2
      {
         if (Ends & 1) ((StringList_Range&)(*this)).ChangeNext = true;
         else ((StringList_Range&)(*this)).Selected = false;
      }
   }
   else
   {
      if (SLI.ConstValue().find(Target1) != String::npos)     // found Target1
      {
         if ( !(Ends & 2) ) ((StringList_Range&)(*this)).ChangeNext = true;
         else ((StringList_Range&)(*this)).Selected = true;
      }
   }

   return Selected;
}


//StringList_GString StringList::operator()(GString& gs1, GString& gs2)
//{
//   return StringList_GString(*this, gs1, gs2);
//}


/*
MaskedStringList StringList::operator[](GString& g)
{
   MaskedStringList TSL(*this);
   int m = 0; unsigned char mask = 128;
   for (StringListItem* sli = Next(); sli != this; sli = sli->Next())
   {
      if ( g.Matches(sli->Value()) ) TSL.Mask[m] |= mask;
      mask >>= 1;
      if (!mask) { m++; mask = 128; }
   }
   return TSL;
}

ostream& operator<<(ostream& os, MaskedStringList& tsl)
{
   StringList& sl = tsl.SL;
   int m = 0; unsigned char mask = 128;
   for (StringListItem* word = sl.Next(); word != &sl; word = word->Next())
   {
      if (tsl.Mask[m] & mask) os << word->Value() << endl;
      mask >>= 1;
      if (!mask) { m++; mask = 128; }

   }
   return os;
}

*/

SubstitutionList& SubstitutionList::operator<<(const String& S)
{
   if (first) input.push_back(S); else output.push_back(S);
   first = !first;
   return *this;
}