mi32/mistring.h

Go to the documentation of this file.

#ifndef  INC_MI32_MISTRING_H
#define  INC_MI32_MISTRING_H

#ifndef  INC_MI32_CHARENCODING_H
#include <mi32/charencoding.h>
#endif

#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class MISTRINGLIST;
class STRUTF8;
class UCREGEXP;
#endif // GENERATING_DOXYGEN_OUTPUT


enum STR_OP {
   STR_Clear = 0,             
   STR_BoolL = 1,             
   STR_BoolM = 2,             
   STR_BoolU = 3,             
   STR_FillA = 4,             
   STR_FillB = 5,             
   STR_FillD = 6,             
   STR_Sep000 = 7,            
   STR_SepNone = 8,           
   STR_Strip0 = 9,            
   STR_FillSubs = 10,         
   STR_FltE = 11,             
   STR_FltF = 12,             
   STR_FltG = 13,             
   STR_FltM = 60,             
   STR_Bin = 14,              
   STR_Dec = 15,              
   STR_Hex = 16,              
   STR_FillSp = 17,           
   STR_Fill0 = 18,            
   STR_PrecA = 19,            
   STR_Prec0 = 20,            
   STR_Prec1 = 21,            
   STR_Prec2 = 22,
   STR_Prec3 = 23,
   STR_Prec4 = 24,
   STR_Prec5 = 25,
   STR_Prec6 = 26,
   STR_Prec7 = 27,
   STR_Prec8 = 28,
   STR_Prec9 = 29,
   STR_Prec10 = 30,
   STR_Prec11 = 31,
   STR_Prec12 = 32,
   STR_Prec13 = 33,
   STR_Prec14 = 34,
   STR_Prec15 = 35,
   STR_Prec16 = 36,           
   STR_Width0 = 40,           
   STR_Width1 = 41,           
   STR_Width2 = 42,           
   STR_Width3 = 43,
   STR_Width4 = 44,
   STR_Width5 = 45,
   STR_Width6 = 46,
   STR_Width7 = 47,
   STR_Width8 = 48,
   STR_Width9 = 49,
   STR_Width10 = 50,
   STR_Width11 = 51,
   STR_Width12 = 52,
   STR_Width13 = 53,
   STR_Width14 = 54,
   STR_Width15 = 55
   };


class CLASSLIBEXPORT MISTRING {
   public:

      enum ENCODING {
         ENCODING_URI = 0,    
         ENCODING_XML = 1,    
         ENCODING_HTML = 2    
         };

      enum FLOATFMT {
         FLOATFMT_General =      0,    
         FLOATFMT_Fixed =        1,    
         FLOATFMT_Scientific =   2,    
         FLOATFMT_MaxPrecision = 3     
         };

      enum LINETERM {
         LINETERM_LF =           0,    
         LINETERM_CR =           1,    
         LINETERM_CRLF =         2     
         };

      MISTRING (
         );

      MISTRING (
         const MISTRING& rhs
         );

      MISTRING (
         const MIUNICODE *ustr
         );
      
      explicit MISTRING (
         const char *str
         );

      MISTRING (
         const STRUTF8& rhs
         );

   #ifndef NODLLLINKAGE
      MISTRING (
         TEXTID textid                       
         );
   #endif

   #if 0    // Systems where wchar_t is not same as UINT16(MIUNICODE)
      #ifndef GENERATING_DOXYGEN_OUTPUT
      explicit MISTRING (
         const wchar_t *str
         );
      #endif // GENERATING_DOXYGEN_OUTPUT
   #endif

      MISTRING (
         const void *str,
         CHAR_ENCODING encoding
         );

      explicit MISTRING (
         int value
         );

      explicit MISTRING (
         long value
         );

   #ifndef LONGS_ARE_64_BIT
      explicit MISTRING (
         INT64 value
         );
   #endif

      explicit MISTRING (
         unsigned int value
         );

      explicit MISTRING (
         unsigned long value
         );

   #ifndef LONGS_ARE_64_BIT
      explicit MISTRING (
         UINT64 value
         );
   #endif

      explicit MISTRING (
         double value
         );

      ~MISTRING (
         );

      MISTRING& operator= (
         const MISTRING& rhs
         );

      MISTRING& operator= (
         const STRUTF8& rhs
         );

   #ifndef NODLLLINKAGE
      MISTRING& operator= (
         TEXTID textid
         );
   #endif

      MISTRING& operator= (
         const MIUNICODE* rhs
         );

      MISTRING& operator= (
         const char* rhs
         );

   #if 0    
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MISTRING& operator= (
         const wchar_t* rhs
         );
      #endif // GENERATING_DOXYGEN_OUTPUT
   #endif

      MISTRING& operator+= (
         const MISTRING& rhs
         );

      MISTRING& operator+= (
         const MIUNICODE* rhs
         );

      MISTRING& operator+= (
         const char* rhs
         );

   #if 0    // Systems where wchar_t is not same as UINT16(MIUNICODE)
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MISTRING& operator+= (
         const wchar_t* rhs
         );
      #endif // GENERATING_DOXYGEN_OUTPUT
   #endif

      MISTRING& operator+= (
         MIUNICODE c
         );

      MISTRING& operator<< (STR_OP op);

      MISTRING& operator<< (bool b);

      MISTRING& operator<< (char c);

      MISTRING& operator<< (signed char n);

      MISTRING& operator<< (unsigned char n);

      MISTRING& operator<< (short n);

      MISTRING& operator<< (int n);

      MISTRING& operator<< (long n);

   #ifndef LONGS_ARE_64_BIT
      MISTRING& operator<< (INT64 n);
   #endif

      MISTRING& operator<< (unsigned short n);

      MISTRING& operator<< (unsigned int n);

      MISTRING& operator<< (unsigned long n);

   #ifndef LONGS_ARE_64_BIT
      MISTRING& operator<< (UINT64 n);
   #endif

      MISTRING& operator<< (float f);

      MISTRING& operator<< (double f);

      MISTRING& operator<< (const char *s);

      MISTRING& operator<< (const MIUNICODE *s);

      MISTRING& operator<< (const STRUTF8& s);

      MISTRING& operator<< (const MISTRING& s);

   #ifndef NODLLLINKAGE
      MISTRING& operator<< (TEXTID textid);
   #endif

      const MIUNICODE& operator[] (
         int idx
         ) const;

      operator const MIUNICODE* (
         ) const;

      void Append (
         const MISTRING& str,                
         int start = 0,                      
         int end = INT32_MAX                 
         );

      void Assign (
         const MISTRING& str,                
         int start = 0,                      
         int end = INT32_MAX                 
         );

      void Assign (
         const MIUNICODE *str,               
         int start = 0,                      
         int end = INT32_MAX                 
         );

      void Assign (
         const char *str,                    
         int len                             
         );

      void Assign (
         const char *str,                    
         CHAR_ENCODING encoding              
         ) { Assign(static_cast<const void*>(str),encoding); }

      void Assign (
         const void *str,                    
         CHAR_ENCODING encoding              
         );

      void AssignFromSizeAbbr (
         INT64 size                          
         );

      bool CheckLineTermination (
         LINETERM lineterm                   
         ) const;

      void Clear (
         );

      int Compare (
         const MISTRING& str                 
         ) const;

      int Compare (
         const MISTRING& str,                
         int len                             
         ) const;

      int Compare (
         int SrcStart,                       
         const MISTRING& str,                
         int OtherStart,                     
         int len                             
         ) const;

      int Compare (
         const char* str                  
         ) const;

      int Compare (
         const char* str,                 
         int len                             
         ) const;

      int Compare (
         int SrcStart,                       
         const char* str,                 
         int OtherStart,                     
         int len                             
         ) const;

      int Compare (
         const STRUTF8& str                  
         ) const;

      int Compare (
         const STRUTF8& str,                 
         int len                             
         ) const;

      int Compare (
         int SrcStart,                       
         const STRUTF8& str,                 
         int OtherStart,                     
         int len                             
         ) const;

      int CompareNatural (
         const MISTRING& str
         ) const;

      int CompareNoCase (
         const MISTRING& str                 
         ) const;

      int CompareNoCase (
         const MISTRING& str,                
         int len                             
         ) const;

      int CompareNoCase (
         int SrcStart,                       
         const MISTRING& str,                
         int OtherStart,                     
         int len                             
         ) const;

      int CompareNoCase (
         const char* str                  
         ) const;

      int CompareNoCase (
         const char* str,                 
         int len                             
         ) const;

      int CompareNoCase (
         int SrcStart,                       
         const char* str,                 
         int OtherStart,                     
         int len                             
         ) const;

      int CompareNoCase (
         const STRUTF8& str                  
         ) const;

      int CompareNoCase (
         const STRUTF8& str,                 
         int len                             
         ) const;

      int CompareNoCase (
         int SrcStart,                       
         const STRUTF8& str,                 
         int OtherStart,                     
         int len                             
         ) const;

      MISTRING& ConvertFrom (
         ENCODING Encoding
         );

      MISTRING& ConvertTo (
         ENCODING Encoding
         );

      double ConvertToDouble (
         ) const;

      int FindAndReplace (
         const MISTRING& search,             
         const MISTRING& replace,            
         bool all,                           
         int start = 0                       
         );

      int FindAndReplace (
         const char *search,                 
         const MISTRING& replace,            
         bool all,                           
         int start = 0                       
         );

      int FindAndReplace (
         const char *search,                 
         const char *replace,                
         bool all,                           
         int start = 0                       
         );

      int FindNextAfter (
         const MISTRING& str,                
         int start = 0                       
         ) const;

      int FindNextAfter (
         const char *str,                    
         int start = 0                       
         ) const;

      int FindNextInSet (
         const MISTRING& chars,              
         int start = 0                       
         ) const;

      int FindNextNotInSet (
         const MISTRING& chars,              
         int start = 0                       
         ) const;

      int FindNextOf (
         MIUNICODE c,                        
         int start = 0                       
         ) const;

      int FindNextOf (
         const MISTRING& str,                
         int start = 0                       
         ) const;

      int FindNextOf (
         const char *str,                    
         int start = 0                       
         ) const;

      int FindPrevInSet (
         const MISTRING& chars,              
         int start = INT32_MAX               
         ) const;

      int FindPrevNotInSet (
         const MISTRING& chars,              
         int start = INT32_MAX               
         ) const;

      int FindPrevOf (
         MIUNICODE c,                           
         int start = INT32_MAX               
         ) const;

      void FmtEnableSubstitution (
         bool enable = true                  
         );

      void FmtSetBase (
         int base                            
         );

      void FmtSetFill (
         MIUNICODE fill                      
         );

      void FmtSetFloat (
         FLOATFMT floatmode                  
         );

      void FmtSetPrecision (
         int precision                       
         );

      void FmtSetSign (
         bool sign                           
         );

      void FmtSetThousandSeparator (
         char c                              
         );

      void FmtSetWidth (
         int width                           
         );

      void *GetEncoded (
         CHAR_ENCODING encoding              
         ) const;

      static const MISTRING& GetEmpty (
         );

      int GetLength (
         ) const;

      const MIUNICODE *GetReference (
         ) const;

      MIUNICODE *GetString (
         ) const;

      MISTRING GetSubString (
         int start                           
         ) const;

      MISTRING GetSubString (
         int start,                          
         int end                             
         ) const;

      bool IniRead (
         INIHANDLE handle,                   
         const char *group,                  
         const char *field                   
         );

      bool IniReadML (
         INIHANDLE handle,                   
         const char *group,                  
         const char *field                   
         );

      void IniWrite (
         INIHANDLE handle,                   
         const char *group,                  
         const char *field                   
         ) const;

      void IniWriteML (
         INIHANDLE handle,                   
         const char *group,                  
         const char *field                   
         ) const;

      bool IsEmpty (
         ) const;

#ifdef MISYSTEMDLL
      #ifndef GENERATING_DOXYGEN_OUTPUT
      // This version just calls the new one now.  We still export it from
      // the dll but no new code will see it.  It can go away after 23-Sep-07
      
      bool IsLike (
         const MISTRING& pattern,
         bool bIgnoreCase
         ) const;
      #endif
#endif

      bool IsLike (
         const MISTRING& pattern,
         bool bIgnoreCase = false,
         MIUNICODE WildCard = '%',
         MIUNICODE SingleMatchChar = '_',
         MIUNICODE EscapeChar = '\\'
         ) const;


      void Insert (
         int start,                          
         const MISTRING& str,                
         int strstart = 0,                   
         int strend = INT32_MAX              
         );


      void Join (
         const MISTRINGLIST& list,
         const MIUNICODE* sep
         );

      void Join (
         const MISTRINGLIST& list,
         const char* sep = ""
         );

      void MakeExclusive (
         );

      void Pad (
         MIUNICODE c,                           
         int numchars                        
         );

      void PadToLength (
         MIUNICODE c,                           
         int length                          
         );

      void Remove (
         int start,                          
         int end                             
         );

      void Replace (
         int index,                          
         MIUNICODE c                         
         );

      void Replace (
         int start,                          
         int end,                            
         const MISTRING& str,                
         int strstart = 0,                   
         int strend = INT32_MAX              
         );

      void Replace (
         int start,                          
         int end,                            
         const char *str                     
         );

      ERRVALUE Reserve (
         int numchars                        
         );

      bool Search (
         const MIUNICODE* str,         
         UINT32& MatchStart,        
         UINT32& MatchEnd,          
         bool bIgnoreCase = false,  
         UINT32 Start = 0           
         ) const;
      
      bool Search (
         const UCREGEXP& regex,     
         UINT32& MatchStart,        
         UINT32& MatchEnd,          
         UINT32 Start = 0           
         ) const;
      
      bool SetLineTermination (
         LINETERM lineterm                   
         );

      void SetLowerCase (
         int start = 0                       
         );

      void SetUpperCase (
         int start = 0                       
         );

      int Split (
         MIUNICODE ch,              
         MISTRINGLIST& list,  
         int maxitems = 0        
         ) const;

      int Split (
         const MIUNICODE *regexp,               
         MISTRINGLIST& list,  
         int maxitems = 0        
         ) const;

      void Terminate (
         MIUNICODE c                         
         );

      void Truncate (
         int length                          
         );

      void WordWrap (
         int MaxLineLength                   
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      static const MIUNICODE s_zero;         
      static MIUNICODE s_dummy;              

   #if defined(DEBUG) || defined(_DEBUG)
      const MIUNICODE *m_string;
   #endif
      PRIV *m_pPriv;

      void GetExclusive ();

      friend class MISTRING::PRIV;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


inline MISTRING operator+ (
   const MISTRING& lhs,
   const MISTRING& rhs
   ) {
   MISTRING result(lhs);
   result += rhs;
   return (result);
   }

inline bool operator== (
   const MISTRING& lhs,
   const MISTRING& rhs
   ) {
   return (lhs.Compare(rhs) == 0);
   }

inline bool operator!= (
   const MISTRING& lhs,
   const MISTRING& rhs
   ) {
   return (lhs.Compare(rhs) != 0);
   }

inline bool operator< (
   const MISTRING& lhs,
   const MISTRING& rhs
   ) {
   return (lhs.Compare(rhs) < 0);
   }

inline bool operator<= (
   const MISTRING& lhs,
   const MISTRING& rhs
   ) {
   return (lhs.Compare(rhs) <= 0);
   }

inline bool operator> (
   const MISTRING& lhs,
   const MISTRING& rhs
   ) {
   return (lhs.Compare(rhs) > 0);
   }

inline bool operator>= (
   const MISTRING& lhs,
   const MISTRING& rhs
   ) {
   return (lhs.Compare(rhs) >= 0);
   }


// Formatting manipulators.

#ifndef GENERATING_DOXYGEN_OUTPUT

struct STR_FILL {
   MIUNICODE m_fill;
   STR_FILL (MIUNICODE fill) : m_fill(fill) { }
   };

inline MISTRING& operator<< (
   MISTRING& lhs,
   const STR_FILL& rhs
   ) { lhs.FmtSetFill(rhs.m_fill); return (lhs); }

struct STR_PAD {
   MIUNICODE m_c;
   int m_n;
   STR_PAD (MIUNICODE c, int n) : m_c(c), m_n(n) { }
   };

inline MISTRING& operator<< (
   MISTRING& lhs,
   const STR_PAD& rhs
   ) { lhs.Pad(rhs.m_c,rhs.m_n); return (lhs); }

struct STR_PREC {
   int m_precision;
   STR_PREC (int precision) : m_precision(precision) { }
   };

inline MISTRING& operator<< (
   MISTRING& lhs,
   const STR_PREC& rhs
   ) { lhs.FmtSetPrecision(rhs.m_precision); return (lhs); }

struct STR_WIDTH {
   int m_width;
   STR_WIDTH (int width) : m_width(width) { }
   };

inline MISTRING& operator<< (
   MISTRING& lhs,
   const STR_WIDTH& rhs
   ) { lhs.FmtSetWidth(rhs.m_width); return (lhs); }

#endif // GENERATING_DOXYGEN_OUTPUT

inline STR_FILL STR_Fill (
   MIUNICODE fill
   ) { return (STR_FILL(fill)); }

inline STR_PAD STR_Pad (
   MIUNICODE c,                                 
   int numchars                              
   ) { return (STR_PAD(c,numchars)); }

inline STR_PREC STR_Prec (
   int precision
   ) { return (STR_PREC(precision)); }

inline STR_WIDTH STR_Width (
   int width
   ) { return (STR_WIDTH(width)); }

#undef   CLASSLIBEXPORT

#endif   // INC_MI32_MISTRING_H

---