charc.h

linux下的E_MAIL客户端源码

      { 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 CharC& c, u_int offset, Boolean checkCase=True)const
      { return Search(c.p, c.len, offset, checkCase); }
   const char *Search(const CharC& c, Boolean checkCase=True) const
      { return Search(c, 0, checkCase); }

   const char *Search(const StringC&, u_int offset, Boolean chkCase=True) const;
   const char *Search(const StringC& s, Boolean checkCase=True) const
      { return Search(s, 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 CharC& c, u_int off, Boolean checkCase=True)const
      { return RevSearch(c.p, c.len, off, checkCase); }
   const char *RevSearch(const CharC& c, Boolean checkCase=True) const
      { return RevSearch(c, len-1, checkCase); }

   const char *RevSearch(const StringC&,u_int off,Boolean checkCase=True) const;
   const char *RevSearch(const StringC& s, Boolean checkCase=True) const
      { return RevSearch(s, 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 CharC& c, u_int offset, Boolean checkCase=True) const
      { return NumberOf(c.p, c.len, offset, checkCase); }
   u_int NumberOf(const CharC& c, Boolean checkCase=True) const
      { return NumberOf(c, 0, checkCase); }

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

//
// I/O
//
   int		WriteFile(char*) const;
   int		WriteFile(FILE*) const;
   int		WriteFile(int) const;
   inline ostream&	printOn(ostream& strm=cout) const {
      if ( p ) for (u_int i=0; i<len; i++) strm << p[i];
      return strm;
   }

//
// Misc
//
   void		Trim();	// Adjust pointer and length to ignore whitespace
   			//    at either end
   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

   CharC	operator()(u_int, u_int);
   const CharC	operator()(u_int, u_int) const;

   CharC	operator()(const RangeC&);
   const CharC	operator()(const RangeC&) const;
};

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

#define CHECK_CASE	(Boolean)True
#define IGNORE_CASE	(Boolean)False

#endif // _CharC_h_