C:/temp/src/j2k/Fred/String/String.hpp Source File

00001 #ifndef __J2K__String_HPP__
00002 #define __J2K__String_HPP__
00003 
00004 #include <j2k/Fred/Standard.hpp>
00005 #include <j2k/Fred/String/StrData.hpp>
00006 
00007 class JString {
00008 
00009 public:
00010 
00011 ////////////////////////////////////////////////////////////////////////////
00012 /// Constructor, Copy Constructor and Destructor                         ///
00013 ////////////////////////////////////////////////////////////////////////////
00014 /// Defined in:  StrBuild.cpp                                            ///
00015 ////////////////////////////////////////////////////////////////////////////
00016   JString();
00017   JString( const char* s );
00018   JString( const char* s, size_t nBuffer );
00019 
00020   // Deprecated due to NULL problems
00021   //  JString( size_t nBuffer );
00022 
00023   JString( const JString& src );
00024   JString( char ch );
00025   JString( char ch, size_t nRepeat );
00026   JString( JStringData* sd );  // Verify this.
00027   virtual ~JString();
00028 
00029 ////////////////////////////////////////////////////////////////////////////
00030 /// Simple Attributes & Operations...                                    ///
00031 ////////////////////////////////////////////////////////////////////////////
00032 /// Defined in:  StrTools.cpp                                            ///
00033 ////////////////////////////////////////////////////////////////////////////
00034   BOOL OK()   const;      // Used by Test JString program
00035   BOOL isEmpty()  const;
00036   BOOL isFilled() const;
00037 
00038   void Clear();
00039   void Empty();         // free up the data
00040 
00041   void FillString( char ch );
00042   void FillBuffer( char ch );
00043 
00044   inline void  Display()   const;
00045 
00046   inline size_t length();
00047   inline size_t getLength();
00048 
00049   inline size_t getAllocLength() const;
00050   inline size_t getBufferSize()  const;
00051 
00052   inline int  getLockNb() const;
00053   inline BOOL isLock()  const;
00054   inline BOOL isUnlock() const;
00055 
00056 
00057 ////////////////////////////////////////////////////////////////////////////
00058 /// At X do this...                                                      ///
00059 ////////////////////////////////////////////////////////////////////////////
00060 /// Defined in:  JStringAt.cpp                                           ///
00061 ////////////////////////////////////////////////////////////////////////////
00062 
00063          JString at( size_t startpos );
00064          JString at( size_t startpos,  size_t length   );
00065          JString at( const char* s,    size_t startpos );
00066          JString at( const char* s,    size_t startpos, size_t length );
00067 
00068   // at() == at(  (size_t) 0  )
00069 
00070   inline JString at();
00071   inline JString at( const char* s    );
00072   inline JString at( const JString& S );
00073   inline JString at( const JString& S, size_t startpos );
00074   inline JString at( const JString& S, size_t startpos, size_t length );
00075 
00076   JString& setAt( size_t nIndex, char ch );
00077 
00078   inline char charAt();
00079   inline char charAt( const char* s );
00080   inline char charAt( const JString& S );
00081 
00082   inline const JString& modifyAt( const JString& S );
00083   inline const JString& modifyAt( const JString& S, size_t offset );
00084   inline const JString& modifyAt( const JString& S, size_t offset, size_t length );
00085 
00086   inline const JString& modifyAt( const char* s );
00087   inline const JString& modifyAt( const char* s, size_t offset );
00088   inline const JString& modifyAt( const char* s, size_t offset, size_t length );
00089 
00090   inline char getAt(      size_t nIndex ) const; 
00091   inline char operator[]( long   nIndex ) const;
00092 
00093   inline JString right( size_t length );
00094   inline JString left(  size_t length );
00095 
00096   inline JString mid( const char* s,    size_t startpos, size_t length );
00097   inline JString mid( const JString& S, size_t startpos, size_t length );
00098 
00099   inline JString after( const char* s );
00100   inline JString after( const char* s, size_t startpos );
00101   inline JString after( const char* s, size_t startpos, size_t length );
00102   inline JString before( const char* s );
00103 
00104   // startpos of Search not String!
00105   // Design decision since it's more useful like that.
00106   // startpos of String can be obtained in few steps or with mid
00107   inline JString before( const char* s, size_t startpos );
00108   inline JString beforeStr( const char* s, size_t startpos );
00109   inline JString before( const char* s, size_t startpos, size_t length );
00110 
00111 
00112 
00113 /** ANDREA ***************************************************
00114 
00115   If I remember correctly 'Mid' is an l-value in QuickBasic.
00116   You can write statements like
00117   
00118                    mid(a$,2,3)="Hello!!!"
00119 
00120   both r-value and l-value.
00121 
00122   I implement ONLY the r-value version:
00123 
00124   A$ = "hello"
00125   print mid$(A$, 2, 3)
00126   
00127 *************************************************************/
00128   
00129   JString ltrim( char ch ) const;
00130   JString rtrim( char ch ) const;
00131   JString trim(  char ch ) const;
00132 
00133   JString trimCharset( const char* charset ) const;
00134   JString keepCharset( const char* charset ) const;
00135   
00136   
00137   inline JString operator()( size_t startpos );
00138   inline JString operator()( size_t startpos, size_t length );
00139 
00140   inline JString operator()( const char* s    );
00141   inline JString operator()( const JString& S );
00142   inline JString operator()( const char* s,    size_t startpos );
00143   inline JString operator()( const JString& S, size_t startpos );
00144 
00145   inline JString operator()( const char* s,    size_t startpos, size_t length );
00146   inline JString operator()( const JString& S, size_t startpos, size_t length );
00147 
00148 ////////////////////////////////////////////////////////////////////////////
00149 /// Compare utilities...                                                 ///
00150 ////////////////////////////////////////////////////////////////////////////
00151 /// Defined in:  StrComp.cpp                                             ///
00152 ////////////////////////////////////////////////////////////////////////////
00153 
00154 /* Not Implemented Yet.
00155   int CompareNoCase( const char* s ) const;    // ignore case
00156   int Collate(       const char *s ) const;    // NLS aware
00157 */
00158 
00159   inline int compare( const JString& right ) const;
00160   inline int compare( const char*    right ) const;
00161          int compare( char           right ) const;
00162 
00163   // Left JString (THIS) is less than Right JString?
00164 
00165   inline BOOL operator<( const JString&  right ) const;
00166   inline BOOL operator<( const char*     right ) const;
00167   inline BOOL operator<( char            right ) const;
00168   
00169   inline BOOL operator>( const JString&  right ) const;
00170   inline BOOL operator>( const char*     right ) const;
00171   inline BOOL operator>( char            right ) const;
00172   
00173   inline BOOL operator<=( const JString& right ) const;
00174   inline BOOL operator<=( const char*    right ) const;
00175   inline BOOL operator<=( char           right ) const;
00176   
00177   inline BOOL operator>=( const JString& right ) const;
00178   inline BOOL operator>=( const char*    right ) const;
00179   inline BOOL operator>=( char           right ) const;
00180                                        
00181   inline BOOL operator==( const char*    right ) const;
00182   inline BOOL operator==( const JString& right ) const;
00183   inline BOOL operator==( char           right ) const;
00184 
00185   inline BOOL operator!=( const char*    right ) const;
00186   inline BOOL operator!=( const JString& right ) const;
00187   inline BOOL operator!=( char           right ) const;
00188 
00189 ////////////////////////////////////////////////////////////////////////////
00190 /// Parsing and Casting utilities...                                     ///
00191 ////////////////////////////////////////////////////////////////////////////
00192 /// Defined in:  StrMorph.cpp                                            ///
00193 ////////////////////////////////////////////////////////////////////////////
00194 
00195   inline operator char*()  const;
00196 
00197   // This makes more sense than (int*) operator !
00198   inline operator int()    const;
00199   inline operator long()   const;
00200   inline operator double() const;
00201 
00202   inline int    parseInt()     const;
00203   inline long   parseLong()    const;
00204   inline double parseDouble()  const;
00205          char*  parseString()  const;
00206 
00207   inline char*  toString() const;
00208   inline char*  getText()  const;
00209 
00210 ////////////////////////////////////////////////////////////////////////////
00211 /// Stream utilities...                                                  ///
00212 ////////////////////////////////////////////////////////////////////////////
00213   friend ostream& operator<<( ostream& os, const JString& s ) {
00214     return os << s.pData->data;
00215   }
00216 
00217 ////////////////////////////////////////////////////////////////////////////
00218 /// JString Assignment                                                   ///
00219 ////////////////////////////////////////////////////////////////////////////
00220 /// Defined in:  StrAdd.cpp                                              ///
00221 ////////////////////////////////////////////////////////////////////////////
00222   void  CopyBeforeWrite();
00223 
00224   // IT MUST RETURN CONST !
00225   // JString s = s1 = s2 = "Hello";  will work just fine, if it's const !
00226   const JString& operator=( const JString& s );
00227   const JString& operator=( const char* s );
00228   const JString& operator=( char  ch );
00229 
00230 ////////////////////////////////////////////////////////////////////////////
00231 /// JString Concatenation                                                ///
00232 ////////////////////////////////////////////////////////////////////////////
00233 /// Defined in:  StrAdd.cpp                                              ///
00234 ////////////////////////////////////////////////////////////////////////////
00235   void  Append( const char* s, size_t Len );
00236   const JString& operator+=( const JString& s );
00237   const JString& operator+=( const char* s );
00238   const JString& operator+=( char  ch );
00239 
00240 ////////////////////////////////////////////////////////////////////////////
00241 /// JString Addition                                                     ///
00242 ////////////////////////////////////////////////////////////////////////////
00243 /// Defined in:  StrAdd.cpp                                              ///
00244 ////////////////////////////////////////////////////////////////////////////
00245 private:
00246   // Used for any private addition of JString
00247   // Private since it's usage is trivial...
00248   inline void  Add( const char* s1, const char* s2, size_t Len1, size_t Len2 );
00249          void  Add( const char* s1, const char* s2, size_t Len1, size_t Len2, size_t LenExtra );
00250 
00251 public:
00252   friend JString operator+( const JString& s1, const JString& s2 );
00253 
00254   friend JString operator+( const JString& s1, const char*    s2 );
00255   friend JString operator+( const char*    s1, const JString& s2 );
00256 
00257   friend JString operator+( const JString& s,  char ch );
00258   friend JString operator+( char ch,  const JString& s );
00259 
00260 ////////////////////////////////////////////////////////////////////////////
00261 /// Upper/Lower/Reverse Conversion (QuickBasic Compatible)               ///
00262 ////////////////////////////////////////////////////////////////////////////
00263 /// Defined in:  StrTools.cpp                                            ///
00264 ////////////////////////////////////////////////////////////////////////////
00265   void MakeUpper();
00266   void MakeLower();
00267   void MakeReverse();
00268 
00269   // Might return JString object in the future...
00270   inline void UCase();  // QB format
00271   inline void LCase();
00272   inline void Reverse();
00273 
00274   char*    getLower();
00275   char*    getUpper();
00276   char*    getReverse();
00277 
00278   inline JString& setLower();
00279   inline JString& setUpper();
00280   inline JString& setReverse();
00281 
00282 ////////////////////////////////////////////////////////////////////////////
00283 /// Search/Find/ReverseFind function (QuickBasic Compatible)             ///
00284 ////////////////////////////////////////////////////////////////////////////
00285 /// Defined in:  StrFind.cpp                                             ///
00286 ////////////////////////////////////////////////////////////////////////////
00287 
00288    // searching (return starting index,
00289     // or -1 if not found)
00290    // look for a single character match
00291 
00292   long Find( char ch ) const;
00293   long ReverseFind( char ch ) const;
00294   
00295   inline long Find( const char* s ) const;
00296          long Find( const char* s, size_t offset ) const;
00297 
00298   inline JString getFind( const char* s );
00299          JString getFind( const char* s, size_t offset );
00300 
00301 
00302   inline long Find( const JString& S ) const;
00303   inline long Find( const JString& S, size_t offset ) const;
00304 
00305 ////////////////////////////////////////////////////////////////////////////
00306 /// Every function str* from ANSI definition                             ///
00307 ////////////////////////////////////////////////////////////////////////////
00308 /// Defined in:  StrANSI.cpp                                             ///
00309 ////////////////////////////////////////////////////////////////////////////
00310   
00311   char*    getConcatenate( const char* src );
00312   JString& setConcatenate( const char* src );
00313   char*    getConcatenateWithLimits( const char* src, size_t n );
00314   JString& setConcatenateWithLimits( const char* src, size_t n );
00315 
00316   long     firstCharFound( const int c );
00317   long     lastCharFound( const int c );
00318 
00319 //  int      compare( const char* src );
00320   int      compareIgnoreCase( const char* src );
00321   int      compareUsingLocaleCollate( const char* src );
00322   int      compareWithLimits( const char* src, size_t n );
00323   int      compareIgnoreCaseWithLimits( const char* src, size_t n );
00324 
00325   char*    copy();
00326   JString  getCopy();
00327   char*    copyWithLimits( size_t n );
00328   JString  getCopyWithLimits( size_t n );
00329 
00330   size_t   getNbCharNotFromCharSet( const char* charset );
00331 
00332   JString  getDate();  // MM/DD/YY format (not Y2K complient !)
00333   JString& setDate();  // MM/DD/YY format (not Y2K complient !)
00334   
00335   JString& setTime( size_t maxSize, const char* format,
00336                     const struct tm* currTime );
00337   
00338   char*    duplicate();
00339   JString  duplicateString();
00340   JString  getError( int errnb );
00341   JString& setError( int errnb );
00342 
00343   JString  getTimeFormat( size_t maxSize, const char* format, const struct tm* currTime );
00344   JString& setTimeFormat( size_t maxSize, const char* format, const struct tm* currTime );
00345   JString  getTime();  // HH:MM:SS  (24h)
00346   JString& setTime();  // HH:MM:SS  (24h)
00347 
00348   char*    getFillWithChar( const int ch );
00349   JString& setFillWithChar( const int ch );
00350   char*    getFillWithChar( const int ch, size_t n );
00351   JString& setFillWithChar( const int ch, size_t n );
00352   
00353   // Return Where is the first charset in String
00354   long     locateCharSet( const char* charset );
00355   long     locateCharSet( const char* charset, size_t startAt );
00356   
00357   // Return How much of charset in String
00358   size_t   findCharset( const char* charset );
00359   size_t   findCharset( const char* charset, size_t startAt );
00360   
00361   // Return Where is the first String given in String
00362   long     findString( const char* s );
00363   long     findString( const char* s, size_t startAt );
00364   
00365   double   toDouble();
00366   double   toDouble( size_t startAt );
00367   
00368   long     toLong();
00369   long     toLong( size_t base );
00370   long     toLong( size_t startAt, size_t base );
00371   
00372   ULONG    toULONG();
00373   ULONG    toULONG( size_t base );
00374   ULONG    toULONG( size_t startAt, size_t base );
00375  
00376   char*    getTransform( const char* src, size_t n );
00377   JString& setTransform( const char* src, size_t n );
00378 
00379   char*    getTokens( const char* delims, size_t startAt );
00380   JString  getStringTokens( const char* delims, size_t startAt );
00381   char*    getMoreTokens( const char* delims );
00382   JString  getMoreStringTokens( const char* delims );
00383  
00384 /**************************************************************************
00385  *  NOT DEFINED YET !
00386  **************************************************************************/
00387 
00388  /*
00389 
00390 ////////////////////////////////////////////////////////////////////////////
00391 /// Trimming Space  (QuickBasic compatible)                              ///
00392 ////////////////////////////////////////////////////////////////////////////
00393   void TrimRight();  // lib g++ format
00394   void TrimLeft();
00395 
00396   // Might return JString object in the future...
00397   inline void LTrim();  // QB format
00398   inline void RTrim();
00399   inline void Trim();
00400 
00401 ////////////////////////////////////////////////////////////////////////////
00402 /// Span Include/Exclude function                                        ///
00403 ////////////////////////////////////////////////////////////////////////////
00404   JString SpanIncluding( const char* s ) const;
00405   JString SpanExcluding( const char* s ) const;
00406 
00407 ////////////////////////////////////////////////////////////////////////////
00408 /// Simple formatting function ( using  "sprintf"  Format )              ///
00409 ////////////////////////////////////////////////////////////////////////////
00410    // simple formatting
00411   void Format(  const char* sFormat, ... );
00412   void Format(  size_t nFormatID, ... );
00413   void FormatV( const char* lpszFormat, va_list argList );
00414 
00415 */
00416 
00417 ////////////////////////////////////////////////////////////////////////////
00418 /// Unlock/Lock Buffer turn Ref counting on/off (MFC JString compatible) ///
00419 /// AND everything else related to Buffer and Allocation...              ///
00420 ////////////////////////////////////////////////////////////////////////////
00421 /// Defined in:  StrExtra.cpp  (NOT FULLY SUPPORTED YET)                 ///
00422 ////////////////////////////////////////////////////////////////////////////
00423   inline void AllocBuffer(      size_t nLen );
00424   inline void AllocBeforeWrite( size_t nLen );
00425 
00426   inline char* LockBuffer();
00427   inline void  UnlockBuffer();
00428 
00429   void  FreeExtra();
00430   char* GetBuffer( size_t minBufferLength );
00431 
00432   inline void  ReleaseBuffer();
00433 
00434 /////////////////////////////////////////////////////////////////////////////
00435 /// Extra stuff for compatibility with the widely used Linux String class ///
00436 /////////////////////////////////////////////////////////////////////////////
00437 /// Defined in:  StrLinux.cpp  (NOT FULLY SUPPORTED YET)                  ///
00438 /////////////////////////////////////////////////////////////////////////////
00439 
00440 private:
00441          void Add( const char* s1 = NULL, size_t Len1 = 0, \
00442                    const char* s2 = NULL, size_t Len2 = 0, \
00443                    const char* s3 = NULL, size_t Len3 = 0, \
00444                    const char* s4 = NULL, size_t Len4 = 0, \
00445                    const char* s5 = NULL, size_t Len5 = 0, \
00446                    const char* s6 = NULL, size_t Len6 = 0, \
00447                    const char* s7 = NULL, size_t Len7 = 0, \
00448                    const char* s8 = NULL, size_t Len8 = 0, \
00449                    const char* s9 = NULL, size_t Len9 = 0, \
00450                    size_t LenExtra = 0 );
00451 
00452 public:
00453 
00454   const JString& Add( const JString& S1, const JString& S2, const JString& S3, \
00455                       const JString& S4, const JString& S5, const JString& S6, \
00456                       const JString& S7, const JString& S8 );
00457 
00458   const JString& Add( const JString& S1, const JString& S2, const JString& S3, \
00459                       const JString& S4, const JString& S5, const JString& S6, \
00460                       const JString& S7 );
00461 
00462   const JString& Add( const JString& S1, const JString& S2, const JString& S3, \
00463                       const JString& S4, const JString& S5, const JString& S6 );
00464 
00465   const JString& Add( const JString& S1, const JString& S2, const JString& S3, \
00466                       const JString& S4, const JString& S5 );
00467 
00468   const JString& Add( const JString& S1, const JString& S2, \
00469                       const JString& S3, const JString& S4 );
00470 
00471   const JString& Add( const JString& S1, const JString& S2, const JString& S3 );
00472 
00473 // With Find(), it's VERY EASY to implement the derivates!
00474 
00475   inline BOOL contains( const JString& S, size_t offset ) const;
00476   inline BOOL contains( const char* s,    size_t offset ) const;
00477   inline BOOL contains( char c,           size_t offset ) const;
00478 
00479   inline BOOL contains( const JString& S ) const;
00480   inline BOOL contains( const char* s    ) const;  
00481   inline BOOL contains( char c           ) const; 
00482 
00483   inline const JString& append(  const JString& S );
00484   inline const JString& prepend( const JString& S );
00485 
00486   inline const JString& append(  const char* s );
00487   inline const JString& prepend( const char* s );
00488 
00489   inline const JString& append(  char c );
00490   inline const JString& prepend( char c );
00491 
00492 
00493 private:
00494   JStringData* pData;  // Pointer to the JStringData Rep
00495 
00496 }; // End of JString Class
00497 
00498 #include <j2k/Fred/String/StrData.inl>
00499 #include <j2k/Fred/String/StrAdd.inl>
00500 #include <j2k/Fred/String/StrBuild.inl>
00501 #include <j2k/Fred/String/StrComp.inl>
00502 #include <j2k/Fred/String/StrFind.inl>
00503 #include <j2k/Fred/String/StrMorph.inl>
00504 #include <j2k/Fred/String/StrTools.inl>
00505 #include <j2k/Fred/String/StringAt.inl>
00506 #include <j2k/Fred/String/StrLinux.inl>
00507 
00508 // Real QB Style
00509 
00510 // Not EXTERN C due to class JString ADT
00511 
00512 inline JString Reverse( const JString& S ) {
00513   JString temp( S );
00514   temp.MakeReverse();
00515   return temp;
00516 }
00517 
00518 inline JString UCase( const JString& S ) {
00519   JString temp( S );
00520   temp.MakeUpper();
00521   return temp;
00522 }
00523 
00524 inline JString LCase( const JString& S ) {
00525   JString temp( S );  
00526   temp.MakeLower();
00527   return temp;
00528 }
00529 
00530 
00531 #endif
00532 
00533