stringc.h

linux下的E_MAIL客户端源码

   }
   inline friend int	operator!=(const char* cs, const StringC& s) {
      return (::compare(cs, s) != 0);
   }

// CONCATENATION

   StringC		operator+(const StringC&) const;
   StringC		operator+(const SubStringC&) const;
   StringC		operator+(const CharC&) const;
   StringC		operator+(const char*) const;
   StringC		operator+(char) const;
   StringC		operator+(int) const;
   friend StringC	operator+(const char*, const StringC&);
   friend StringC	operator+(const char*, const SubStringC&);
   friend StringC	operator+(char, const StringC&);
   friend StringC	operator+(int, const StringC&);

// APPENDING

   StringC&	operator+=(const StringC&);
   StringC&	operator+=(const SubStringC&);
   StringC&	operator+=(const CharC&);
   StringC&	operator+=(const char*);
   StringC&	operator+=(char c);
   StringC&	operator+=(int);
   void		Append(const char*, u_int);

// GETTING SUBSTRINGS

   SubStringC		operator()(u_int, u_int);
   const SubStringC	operator()(u_int, u_int) const;
   SubStringC		operator()(const RangeC&);
   const SubStringC	operator()(const RangeC&) const;
   CharC		Range(u_int, u_int);
   const CharC		Range(u_int, u_int) const;
   CharC		Range(const RangeC&);
   const CharC		Range(const RangeC&) const;

// LENGTH AND SIZE

   inline u_int		length() const	{ return (_len); }
   inline u_int		size() const	{ return (_len); }
   inline u_int		capacity() const{ return (_alloc-1); }
   u_int		reSize(u_int new_capacity);

// CLEARING

   void		Clear(int start=0);

// CONVERSION

   void		toAscii();
   void		toLower();
   void		toUpper();


// FILE I/O

   int	AppendFile(char*);
   int	AppendFile(FILE*, u_int count=(u_int)-1);
   int	GetWord(FILE*);
   int	GetLine(FILE*, int trim = 0);
   int	ReadFile(char*);
   int	ReadFile(FILE*, u_int count=(u_int)-1);
   int	WriteFile(char*);
   int	WriteFile(FILE*);

// PRINTING

   inline ostream&	printOn(ostream& strm=cout) const {
      if ( _p ) strm << _p;
      return strm;
   }

//
// Searching at beginning
//
   int StartsWith(const char *cs, u_int clen, u_int offset,
   		  Boolean checkCase=True) const;

   int StartsWith(char, u_int offset, Boolean checkCase=True) const;
   int StartsWith(char c, Boolean checkCase=True) const
      { return StartsWith(c,  0, checkCase); }

   int StartsWith(const char *cs, u_int offset, Boolean checkCase=True) const
      { return StartsWith(cs, cs?strlen(cs):0, offset, checkCase); }
   int StartsWith(const char *cs, Boolean checkCase=True) const
      { return StartsWith(cs, 0, checkCase); }

   int StartsWith(const StringC& s, u_int offset, Boolean checkCase=True) const
      { return StartsWith(s._p, s._len, offset, checkCase); }
   int StartsWith(const StringC& s, Boolean checkCase=True) const
      { return StartsWith(s, 0, checkCase); }

   int StartsWith(const CharC&, u_int offset, Boolean checkCase=True) const;
   int StartsWith(const CharC& c, Boolean checkCase=True) const
      { return StartsWith(c, 0, checkCase); }

//
// Searching at end
//
   int EndsWith(const char *cs, u_int clen, u_int offset,
   		Boolean checkCase=True) const;

   int EndsWith(char c, u_int offset, Boolean checkCase=True) const
      { return StartsWith(c, offset, checkCase); }
   int EndsWith(char c, Boolean checkCase=True) const
      { return StartsWith(c, _len-1, checkCase); }

   int EndsWith(const char *cs, u_int offset, Boolean checkCase=True) const
      { return EndsWith(cs, cs?strlen(cs):0, offset, checkCase); }
   int EndsWith(const char *cs, Boolean checkCase=True) const
      { return EndsWith(cs, _len-1, checkCase); }

   int EndsWith(const StringC& s, u_int offset, Boolean checkCase=True) const
      { return EndsWith(s._p, s._len, offset, checkCase); }
   int EndsWith(const StringC& s, Boolean checkCase=True) const
      { return EndsWith(s, _len-1, checkCase); }

   int EndsWith(const CharC&, u_int offset, Boolean checkCase=True) const;
   int EndsWith(const CharC& c, Boolean checkCase=True) const
      { return EndsWith(c, _len-1, checkCase); }

//
// Comparison
//
   int Equals(const char *cs, u_int clen, u_int offset,
	      Boolean checkCase=True) const;

   int Equals(char, u_int offset, Boolean checkCase=True) const;
   int Equals(char c, Boolean checkCase=True) const
      { return Equals(c,  0, checkCase); }

   int Equals(const char *cs, u_int offset, Boolean checkCase=True) const
      { return Equals(cs, cs?strlen(cs):0, offset, checkCase); }
   int Equals(const char *cs, Boolean checkCase=True) const
      { return Equals(cs, 0, checkCase); }

   int Equals(const StringC& s, u_int offset, Boolean checkCase=True) const
      { return Equals(s._p, s._len, offset, checkCase); }
   int Equals(const StringC& s, Boolean checkCase=True) const
      { return Equals(s, 0, checkCase); }

   int Equals(const CharC&, u_int offset, Boolean checkCase=True) const;
   int Equals(const CharC& c, Boolean checkCase=True) const
      { return Equals(c, 0, checkCase); }

//
// Searching forwards
//
   const char *Search(const char *cs, u_int clen, u_int offset,
	      Boolean checkCase=True) const;

   const char *Search(char, u_int offset, Boolean checkCase=True) const;
   const char *Search(char c, Boolean checkCase=True) const
      { return Search(c,  0, checkCase); }

   const char *Search(const char *cs, u_int offset, Boolean checkCase=True)const
      { return Search(cs, cs?strlen(cs):0, offset, checkCase); }
   const char *Search(const char *cs, Boolean checkCase=True) const
      { return Search(cs, 0, checkCase); }

   const char *Search(const StringC& s, u_int offset, Boolean checkCase=True)
									   const
      { return Search(s._p, s._len, offset, checkCase); }
   const char *Search(const StringC& s, Boolean checkCase=True) const
      { return Search(s, 0, checkCase); }

   const char *Search(const CharC&, u_int offset, Boolean chkCase=True) const;
   const char *Search(const CharC& c, Boolean checkCase=True) const
      { return Search(c, 0, checkCase); }

//
// Searching backwards
//
   const char *RevSearch(const char *cs, u_int clen, u_int offset,
	      Boolean checkCase=True) const;

   const char *RevSearch(char, u_int offset, Boolean checkCase=True) const;
   const char *RevSearch(char c, Boolean checkCase=True) const
      { return RevSearch(c,  _len-1, checkCase); }

   const char *RevSearch(const char *cs, u_int off, Boolean checkCase=True)const
      { return RevSearch(cs, cs?strlen(cs):0, off, checkCase); }
   const char *RevSearch(const char *cs, Boolean checkCase=True) const
      { return RevSearch(cs, _len-1, checkCase); }

   const char *RevSearch(const StringC& s, u_int off, Boolean checkCase=True)
   									   const
      { return RevSearch(s._p, s._len, off, checkCase); }
   const char *RevSearch(const StringC& s, Boolean checkCase=True) const
      { return RevSearch(s, _len-1, checkCase); }

   const char *RevSearch(const CharC&, u_int off, Boolean checkCase=True) const;
   const char *RevSearch(const CharC& c, Boolean checkCase=True) const
      { return RevSearch(c, _len-1, checkCase); }

//
// Searching forwards
//
   inline int	PosOf(      char   c, Boolean checkCase=True) const {
      const char *cs = Search(c, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int	PosOf(const char  *c, Boolean checkCase=True) const {
      const char *cs = Search(c, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int	PosOf(const CharC& c, Boolean checkCase=True) const {
      const char *cs = Search(c, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int	PosOf(const StringC& s, Boolean checkCase=True) const {
      const char *cs = Search(s, checkCase);
      return (cs ? cs - _p : -1);
   }

   inline int	PosOf(      char   c, u_int i, Boolean checkCase=True) const {
      const char *cs = Search(c, i, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int	PosOf(const char  *c, u_int i, Boolean checkCase=True) const {
      const char *cs = Search(c, i, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int	PosOf(const CharC& c, u_int i, Boolean checkCase=True) const {
      const char *cs = Search(c, i, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int	PosOf(const StringC& s, u_int i, Boolean checkCase=True) const {
      const char *cs = Search(s, i, checkCase);
      return (cs ? cs - _p : -1);
   }

//
// Searching backwards
//
   inline int RevPosOf(      char   c, Boolean checkCase=True) const {
      const char *cs = RevSearch(c, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int RevPosOf(const char  *c, Boolean checkCase=True) const {
      const char *cs = RevSearch(c, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int RevPosOf(const CharC& c, Boolean checkCase=True) const {
      const char *cs = RevSearch(c, checkCase);
      return (cs ? cs - _p : -1);
   }
   inline int RevPosOf(const StringC& s, Boolean checkCase=True) const {
      const char *cs = RevSearch(s, checkCase);
      return (cs ? cs - _p : -1);
   }

   inline int RevPosOf(      char   c, u_int i, Boolean chkCase=True) const {
      const char *cs = RevSearch(c, i, chkCase);
      return (cs ? cs - _p : -1);
   }
   inline int RevPosOf(const char  *c, u_int i, Boolean chkCase=True) const {
      const char *cs = RevSearch(c, i, chkCase);
      return (cs ? cs - _p : -1);
   }
   inline int RevPosOf(const CharC& c, u_int i, Boolean chkCase=True) const {
      const char *cs = RevSearch(c, i, chkCase);
      return (cs ? cs - _p : -1);
   }
   inline int RevPosOf(const StringC& s, u_int i, Boolean chkCase=True) const {
      const char *cs = RevSearch(s, i, chkCase);
      return (cs ? cs - _p : -1);
   }

//
// Searching
//
   inline int Contains(      char   c, Boolean checkCase=True) const {
      const char *cs = Search(c, checkCase);
      return (cs != NULL);
   }
   inline int Contains(const char  *c, Boolean checkCase=True) const {
      const char *cs = Search(c, checkCase);
      return (cs != NULL);
   }
   inline int Contains(const CharC& c, Boolean checkCase=True) const {
      const char *cs = Search(c, checkCase);
      return (cs != NULL);
   }
   inline int Contains(const StringC& s, Boolean checkCase=True) const {
      const char *cs = Search(s, checkCase);
      return (cs != NULL);
   }

   inline int Contains(      char   c, u_int i, Boolean chkCase=True) const {
      const char *cs = Search(c, i, chkCase);
      return (cs != NULL);
   }
   inline int Contains(const char  *c, u_int i, Boolean chkCase=True) const {
      const char *cs = Search(c, i, chkCase);
      return (cs != NULL);
   }
   inline int Contains(const CharC& c, u_int i, Boolean chkCase=True) const {
      const char *cs = Search(c, i, chkCase);
      return (cs != NULL);
   }
   inline int Contains(const StringC& s, u_int i, Boolean chkCase=True) const {
      const char *cs = Search(s, i, chkCase);
      return (cs != NULL);
   }

//
// Counting
//
   u_int NumberOf(const char *cs, u_int clen, u_int offset,
   		  Boolean checkCase=True) const;

   u_int NumberOf(char, u_int offset, Boolean checkCase=True) const;
   u_int NumberOf(char c, Boolean checkCase=True) const
      { return NumberOf(c,  0, checkCase); }

   u_int NumberOf(const char *cs, u_int offset, Boolean checkCase=True) const
      { return NumberOf(cs, cs?strlen(cs):0, offset, checkCase); }
   u_int NumberOf(const char *cs, Boolean checkCase=True) const
      { return NumberOf(cs, 0, checkCase); }

   u_int NumberOf(const StringC& s, u_int offset, Boolean checkCase=True) const
      { return NumberOf(s._p, s._len, offset, checkCase); }
   u_int NumberOf(const StringC& s, Boolean checkCase=True) const
      { return NumberOf(s, 0, checkCase); }

   u_int NumberOf(const CharC&, u_int offset, Boolean checkCase=True) const;
   u_int NumberOf(const CharC& c, Boolean checkCase=True) const
      { return NumberOf(c, 0, checkCase); }

//
// Misc
//
   void		Replace(CharC, CharC);	// Replace first string with second
   void		Replace(char, char);	// Replace first character with second
   void		Trim();		// Remove whitespace at ends
   CharC	NextWord(u_int offset, const char *white=" \t\n");
			// Return the range of the next word that is delimited
			//    by any chars in "white"
   CharC	NextWord(u_int offset, char c);
			// Return the range of the next word that is delimited
			//    by the character c
};

// PRINTING

inline ostream&
operator<<(ostream& strm, const StringC& s)
{
   return s.printOn(strm);
}

#endif // _StringC_h_