C:/temp/src/j2k/Deprecated/old_18mar_diff/String/String.hpp Source File

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