mi32/fixedstr.h

Go to the documentation of this file.

/**
*  mi32/fixedstr.h - FIXEDSTRING<> template class.
*
*  \if NODOC
*  $Id: fixedstr.h_v 1.50 2003/11/19 23:03:08 scowan Exp $
*
*  $Log: fixedstr.h_v $
*  Revision 1.50  2003/11/19 23:03:08  scowan
*  Comment out cast operator to mistring.
*
*  Revision 1.49  2003/09/15 13:49:56  fileserver!dwilliss
*  Doxygen
*
*  Revision 1.48  2003/04/15 17:06:40  scowan
*  Make sure string is cleared to zero from the terminator to the end in generate unique name.
*
*  Revision 1.47  2003/04/15 16:33:59  scowan
*  Added a generate unique name method with filter.
*
*  Revision 1.46  2003/04/10 15:55:58  scowan
*  nc.
*
*  Revision 1.45  2003/04/10 15:42:09  dwilliss
*  Don't use _T in templates.  Mac's ctype.h defines a global _T
*
*  Revision 1.44  2003/02/06 17:33:27  scowan
*  Made get max size a static method.
*
*  Revision 1.43  2002/09/09 13:21:52  mju
*  Remove deprecated methods.
*
*  Revision 1.42  2002/08/28 13:34:25  mju
*  Remove prompt stuff as causes lots of header conflicts with Windows.
*
*  Revision 1.41  2002/08/27 16:58:25  mju
*  Use Widget, not MDLGPARENT.
*
*  Revision 1.40  2002/08/27 14:13:57  scowan
*  Hack for lack of function template support in some compilers.
*
*  Revision 1.39  2002/08/22 19:38:43  scowan
*  Damn annoying compilers.  Made the concatinate operator work again.
*
*  Revision 1.38  2002/08/22 19:02:59  scowan
*  Oops.
*
*  Revision 1.37  2002/08/22 17:33:46  scowan
*  UNIX compiler confusion.
*
*  Revision 1.36  2002/08/22 17:07:06  scowan
*  *** empty log message ***
*
*  Revision 1.35  2002/08/22 17:05:52  scowan
*  Check for null in constructor.
*
*  Revision 1.34  2002/08/19 15:38:22  scowan
*  Fixed g++3.1 warnings.
*
*  Revision 1.33  2002/07/08 14:49:16  scowan
*  nc.
*
*  Revision 1.32  2002/05/17 17:37:29  mju
*  Add GetTail() methods.
*
*  Revision 1.31  2002/05/17 16:53:55  mju
*  Add FIXEDSTRCHAR template defn.
*
*  Revision 1.30  2002/05/02 16:03:46  scowan
*  Nothing.
*
*  Revision 1.29  2002/04/25 22:07:24  mju
*  Remove confusing comment.
*
*  Revision 1.28  2002/04/08 16:48:04  mju
*  Remove sprintf methods.
*
*  Revision 1.27  2002/04/08 16:01:45  mju
*  Add dEPRECATE_FIXEDSTR check.
*
*  Revision 1.26  2002/04/04 22:10:36  mju
*  Remove AssignMsgf as no longer used.
*
*  Revision 1.24  2002/03/28 15:05:02  scowan
*  Deprecated assign message.
*
*  Revision 1.23  2002/03/27 16:36:19  mju
*  Add ctor, op= using TEXTID.
*  Deprecate varargs.
*
*  Revision 1.21  2002/03/25 18:06:10  scowan
*  Added pad to end method.
*
*  Revision 1.20  2002/03/19 18:11:23  mju
*  Rename SetString() as AssignMsgF and add AssignMsg() which does no formatting.
*
*  Revision 1.19  2002/02/19 23:20:58  scowan
*  Added upper and lower case methods.
*
*  Revision 1.18  2002/02/19 18:18:53  scowan
*  Added a conversion to a non-const unicode.
*
*  Revision 1.1  1999/08/26 16:11:28  scowan
*  Initial revision
*  \endif
**/

#ifndef INC_MI32_FIXEDSTR_H
#define INC_MI32_FIXEDSTR_H

#ifndef INC_MI32_STDDEFNS_H
   #include <mi32/stddefns.h>
#endif
   
#ifndef INC_MI32_STDANSIC_H
   #include <mi32/stdansic.h>
#endif

#ifndef INC_MI32_UCSTRING_H
   #include <mi32/ucstring.h>
#endif

#ifndef INC_MI32_MEMBUF_H
   #include <mi32/membuf.h>
#endif

#ifndef INC_MI32_INIDEFNS_H
   #include <mi32/inidefns.h>
#endif

#ifndef INC_MI32_MISTRING_H
   #include <mi32/mistring.h>
#endif

//! Fixed-size array-based UNICODE string.
//!   This class is designed to replace fixed size UNICODE array string constructs in other classes and structures.
//! It is not meant as a STRING class implementation.  Therefore, the class cannot have virtual methods nor any
//!   other members except for the string storage itself.
template <size_t _CT> class FIXEDSTRING {
   public:

      //! Default constructor, clears the string.
      FIXEDSTRING (                          
         ) { Clear(); }

      //! Copy constructor.
      FIXEDSTRING (                          
         const FIXEDSTRING& rhs
         ) { memcpy(m_String, rhs.m_String, sizeof(m_String)); }

      //! Construct from UNICODE string.
      FIXEDSTRING (                          
         const UNICODE* string
         ) { 
         Clear(); 
         if (string != 0) ucstrncpy(m_String, string, _CT - 1);
         }

      //! Construct from MISTRING string.
      FIXEDSTRING (                          
         const MISTRING& string
         ) { 
         Clear(); 
         ucstrncpy(m_String, string, _CT - 1);
         }

      //! Construct from TEXTID.
      FIXEDSTRING (
         TEXTID textid
         ) { Clear(); MISTRING str(textid); ucstrncpy(m_String,str,_CT-1); }

      //! Destructor.
      ~FIXEDSTRING (                         
         ) { m_String[0] = 0; }

      //! Assignment operator.
      FIXEDSTRING& operator= (                  
         const FIXEDSTRING& rhs           //!< String to assign from
         ) {
         if (this != &rhs) {
            memcpy(m_String, rhs.m_String, sizeof(m_String));
            }
         return (*this);
         }

      //! Assign from UNICODE string.
      FIXEDSTRING& operator= (               
         const UNICODE* rhs               //!< String to assign from
         ) {
         if (m_String != rhs) {
            Clear();
            if (rhs != 0) ucstrncpy(m_String, rhs, _CT - 1);
            }
         return (*this);
         }

      //! Assign from MISTRING string.
      FIXEDSTRING& operator= (               
         const MISTRING& rhs              //!< String to assign from
         ) {
         Clear();
         ucstrncpy(m_String, rhs, _CT - 1);
         return (*this);
         }

      //! Assign from TEXTID.
      FIXEDSTRING& operator= (
         TEXTID textid                    //!< Message text ID
         ) { Clear(); MISTRING str(textid); ucstrncpy(m_String,str,_CT-1); return(*this); }

      //! Concatenate operator.
      template <int _T2>
      FIXEDSTRING<_CT>& operator+= (
         const FIXEDSTRING<_T2>& rhs            //!< String to concatinate from
         ) {
         ucstrncat(m_String, static_cast<const UNICODE*>(rhs), _CT - (ucstrlen(m_String) + 1));
         return (*this);
         }

      //! Concatenate from UNICODE string.
      FIXEDSTRING& operator+= (                 
         const UNICODE* rhs               //!< String to concatinate from
         ) {
         if (rhs != 0) ucstrncat(m_String, rhs, _CT - (ucstrlen(m_String) + 1));
         return (*this);
         }
         
      //! Equality.
      bool operator== (
         const FIXEDSTRING& rhs
         ) const { return (Compare(rhs) == 0); }

      //! Equality.
      bool operator== (
         const UNICODE *rhs
         ) const { return (Compare(rhs) == 0); }

      //! Inequality.
      bool operator!= (
         const FIXEDSTRING& rhs
         ) const { return (!(*this == rhs)); }

      //! Inequality.
      bool operator!= (
         const UNICODE *rhs
         ) const { return (!(*this == rhs)); }

      //! Less Than
      bool operator< (
         const FIXEDSTRING& rhs
         ) const { return (Compare(rhs) < 0); }

      //! Less Than
      bool operator< (
         const UNICODE *rhs
         ) const { return (Compare(rhs) < 0); }

      //! Less Than or Equal to
      bool operator<= (
         const FIXEDSTRING& rhs
         ) const { return (Compare(rhs) <= 0); }

      //! Less Than or Equal to
      bool operator<= (
         const UNICODE *rhs
         ) const { return (Compare(rhs) <= 0); }

      //! Greater Than
      bool operator> (
         const FIXEDSTRING& rhs
         ) const { return (Compare(rhs) > 0); }

      //! Greater Than
      bool operator> (
         const UNICODE *rhs
         ) const { return (Compare(rhs) > 0); }

      //! Greater Than or Equal to
      bool operator>= (
         const FIXEDSTRING& rhs
         ) const { return (Compare(rhs) >= 0); }

      //! Greater Than or Equal to
      bool operator>= (
         const UNICODE *rhs
         ) const { return (Compare(rhs) >= 0); }

      //! Cast to <const UNICODE*>.
      operator const UNICODE* (
         ) const { return (m_String); }

      //! Cast to <const MISTRING>.
//    operator const MISTRING (
//       ) const { return (MISTRING(m_String)); }

      //! Append from character string, not a constructor so that it is locatable in code.
      void Append (                          
         const char* name                 //!< Character string to append from
         ) {
         UNICODE *p = ucstrchr(m_String, 0);
         strntouc(p, name, _CT - (p - m_String) - 1);
         return;
         }

      //! Assign from character string, not a constructor so that it is locatable in code.
      void Assign (                          
         const char* name                 //!< Character string to assign from
         ) { strntouc(m_String, name, _CT - 1); }

      //! Assign from UNICODE string with a max length given
      void Assign (                          
         const UNICODE* name,                //!< UNICODE string to assign from
         size_t len
         ) { ucstrncpy(m_String, name, MIN(_CT - 1, len)); }

      //! Clear the whole string.
      void Clear (                           
         ) { memset(m_String, 0, sizeof(m_String)); }
      
      //! Case-sensitive comparison, length limited (similar to strncmp).
      //! @return 0 if strings equal, -1 if this < str, 1 if this > str.
      int Compare (
         const FIXEDSTRING& str                 //!< String to compare to
         ) const { return (ucstrcmp(m_String, str.m_String)); }

      //! Case-sensitive comparison, length limited (similar to strncmp).
      //! @return 0 if strings equal, -1 if this < str, 1 if this > str.
      int Compare (
         const UNICODE *str                  //!< String to compare to
         ) const { return (ucstrcmp(m_String, str)); }

      //! Case-insensitive comparison (similar to stricmp).
      //! @return 0 if strings equal, -1 if this < str, 1 if this > str.
      int CompareNoCase (
         const FIXEDSTRING& str                 //!< String to compare to
         ) const { return (ucstricmp(m_String, str.m_String)); }

      //! Case-insensitive comparison (similar to stricmp).
      //! @return 0 if strings equal, -1 if this < str, 1 if this > str.
      int CompareNoCase (
         const UNICODE *str                  //!< String to compare to
         ) const { return (ucstricmp(m_String, str)); }
         
      //! Find out if the string is empty.   
      bool IsEmpty (                         
         ) const { return (m_String[0] == 0); }
         
      //! Set the string according to values in ini file
      //! @return: 'true' if entry found and information read, false if empty field or field does not exist
      bool IniRead (
         INIHANDLE inih,
         const char *group,
         const char*const field
         ) { return (::IniRead(inih, group, field, m_String, _CT * sizeof(UNICODE)) > 0); }

      //! Save the string to values in ini file
      void IniWrite (
         INIHANDLE inih,
         const char *group,
         const char*const field
         ) { ::IniWrite(inih, group, field, m_String); }

      //! Unique name filter class to determine if the name given is unique               
      class UNIQUENAMEFILTER {
         public:
            UNIQUENAMEFILTER () {}

            //! Filter called to determine if the name is unique
            //! @return '1' if unique, '0' if not, < 0 error
            int Filter (const FIXEDSTRING<_CT>& string) { return (v_Filter(string)); }
         private:
            virtual int v_Filter (const FIXEDSTRING<_CT>& string) = 0;
         };

      //! Generate an unique name based on the filter passed in
      ERRVALUE GenerateUniqueName (
         UNIQUENAMEFILTER& FilterInst
         ) {
         ERRVALUE err;
         if ((err = FilterInst.Filter(*this)) < 0) return (err);
         if (err > 0) return (0);      //! String is already unique

         //! Initialize string and pointer for character replacement 
         int k = 0, len = GetLength();
         memset(&m_String[len], 0, (_CT - len) * sizeof(UNICODE));         //! Make sure rest of m_String is set to 0
         UNICODE* where = &m_String[len];
         if (len == (_CT-1)) where --;
         UNICODE* start = where;
         UINT8 count[_CT];
         memset(count, 0, _CT);

         static char *AddArray = "1234567890abcdefghijklmnopqrstuvwxyz_?";
         do {
            *where = static_cast<UNICODE>(AddArray[k++]);
            if (*where == static_cast<UNICODE>('?')) {
               k = 1;
               *where = static_cast<UNICODE>(AddArray[0]);
               UNICODE *p;
               for (p = where - 1;(p >= start);--p) {
                  *p = static_cast<UNICODE>(AddArray[count[p-m_String]++]);
                  if (*p == static_cast<UNICODE>('?')) {
                     *p = static_cast<UNICODE>(AddArray[0]);
                     count[p-m_String] = 0;
                     }
                  else break;
                  }
               if (p < start) {     //! Reset system and increment where
                  ++where;
                  if (where - start == 4) return (EProgramError); //! Reality check, if need to increase, it can be. 37 ^ 4 tried!
                  memset(count, 0, _CT);
                  if (where - m_String == (_CT-1)) {     //! As far out a possible, retreat until a match is not found
                     start --;
                     where = start;
                     if (start < m_String) return (EProgramError);      //! Out of 37 ^ (_CT-1) possible combinations, none found
                     }  
                  for (p = where;(p >= start);--p) *p = static_cast<UNICODE>(AddArray[0]);
                  }
               }
            err = FilterInst.Filter(*this);
            } while (err == 0);
         if (err < 0) return (err);
         return (0);
         }

      //! Return length of string, not including terminator.
      size_t GetLength (                        
         ) const { return (ucstrlen(m_String)); }

      //! Return maximum string size, not including terminator.
      static size_t GetMaxSize (                      
         ) { return (_CT-1); }
         
      //! Return const string pointer, used for sprintf type parameters
      const UNICODE* GetReference (
         ) const { return (m_String); }
         
      //! Get tail of string having up to specified number of characters.
      const UNICODE* GetTail (
         int maxlen
         ) const { int len = ucstrlen(m_String); return ((len <= maxlen) ? m_String : (m_String + (len - maxlen))); }
         
      //! Pad the string with a char to the end of the buffer
      void PadToEnd (
         char item
         ) {
         for (int j = ucstrlen(m_String);(j < _CT-1);++j) m_String[j] = item;
         m_String[_CT-1] = 0;
         }
         
      //! Set the string to lower case letters
      void SetLowerCase (
         ) { ucstrlwr(m_String); }

      //! Set the string to upper case letters
      void SetUpperCase (
         ) { ucstrupr(m_String); }
         
      //! Swap bytes of the string, used for RVC strings
      void SwapBytes (
         ) { ::SwapBytes(m_String, _CT); }

      //! Force termination of string at the end.
      void Terminate (                       
         ) { m_String[_CT - 1] = 0; }

      //! Truncate the string, has no effect if the string is shorter than NewLength.
      void Truncate (                           
         size_t NewLength
         ) { if (NewLength < (_CT - 1)) m_String[NewLength] = 0; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UNICODE m_String[_CT];
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//! Fixed-size array-based 'char' string.
//!   This class is designed to replace fixed size 'char' array string constructs in other classes and structures.
//! It is not meant as a STRING class implementation.  Therefore, the class cannot have virtual methods nor any
//!   other members except for the string storage itself.
template <size_t _CT> class FIXEDSTRCHAR {
   public:

      //! Default constructor, clears the string.
      FIXEDSTRCHAR (                         
         ) { Clear(); }

      //! Copy constructor.
      FIXEDSTRCHAR (                         
         const FIXEDSTRCHAR& rhs
         ) { memcpy(m_String, rhs.m_String, sizeof(m_String)); }

      //! Construct from char string.
      FIXEDSTRCHAR (                         
         const char* string
         ) { Clear(); strncpy(m_String, string, _CT - 1); }

      //! Destructor.
      ~FIXEDSTRCHAR (                           
         ) { m_String[0] = 0; }

      //! Assignment operator.
      FIXEDSTRCHAR& operator= (                 
         const FIXEDSTRCHAR& rhs          //!< String to assign from
         ) {
         if (this != &rhs) {
            memcpy(m_String, rhs.m_String, sizeof(m_String));
            }
         return (*this);
         }

      //! Assign from char string.
      FIXEDSTRCHAR& operator= (              
         const char* rhs               //!< String to assign from
         ) {
         if (m_String != rhs) {
            Clear();
            strncpy(m_String, rhs, _CT - 1);
            }
         return (*this);
         }

      //! Concatenate operator.
      FIXEDSTRCHAR& operator+= (                
         const FIXEDSTRCHAR& rhs          //!< String to concatinate from
         ) {
         strncat(m_String, rhs.m_String, _CT - (strlen(m_String) + 1));
         return (*this);
         }

      //! Concatenate from char string.
      FIXEDSTRCHAR& operator+= (                
         const char* rhs               //!< String to concatinate from
         ) {
         strncat(m_String, rhs, _CT - (strlen(m_String) + 1));
         return (*this);
         }
         
      //! Equality.
      bool operator== (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) == 0); }

      //! Equality.
      bool operator== (
         const char *rhs
         ) const { return (Compare(rhs) == 0); }

      //! Inequality.
      bool operator!= (
         const FIXEDSTRCHAR& rhs
         ) const { return (!(*this == rhs)); }

      //! Inequality.
      bool operator!= (
         const char *rhs
         ) const { return (!(*this == rhs)); }

      //! Less Than
      bool operator< (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) < 0); }

      //! Less Than
      bool operator< (
         const char *rhs
         ) const { return (Compare(rhs) < 0); }

      //! Less Than or Equal to
      bool operator<= (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) <= 0); }

      //! Less Than or Equal to
      bool operator<= (
         const char *rhs
         ) const { return (Compare(rhs) <= 0); }

      //! Greater Than
      bool operator> (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) > 0); }

      //! Greater Than
      bool operator> (
         const char *rhs
         ) const { return (Compare(rhs) > 0); }

      //! Greater Than or Equal to
      bool operator>= (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) >= 0); }

      //! Greater Than or Equal to
      bool operator>= (
         const char *rhs
         ) const { return (Compare(rhs) >= 0); }

      //! Cast to <const char*>.
      operator const char* (
         ) const { return (m_String); }

      //! Assign from character string.
      void Assign (
         const char* name                 //!< Character string to assign from
         ) { strncpy(m_String, name, _CT - 1); }

      //! Assign from char string with a max length given
      void Assign (                          
         const char* name,                //!< char string to assign from
         size_t len
         ) { strncpy(m_String, name, MIN(_CT - 1, len)); }

      //! Clear the whole string.
      void Clear (                           
         ) { memset(m_String, 0, sizeof(m_String)); }
      
      //! Case-sensitive comparison, similar to strcmp.
      //! @return 0 if strings equal, -1 if this < str, 1 if this > str.
      int Compare (
         const FIXEDSTRCHAR& str                //!< String to compare to
         ) const { return (strcmp(m_String, str.m_String)); }

      //! Case-sensitive comparison, (similar to strcmp).
      //! @return 0 if strings equal, -1 if this < str, 1 if this > str.
      int Compare (
         const char *str                  //!< String to compare to
         ) const { return (strcmp(m_String, str)); }

      //! Case-insensitive comparison (similar to stricmp).
      //! @return 0 if strings equal, -1 if this < str, 1 if this > str.
      int CompareNoCase (
         const FIXEDSTRCHAR& str                //!< String to compare to
         ) const { return (stricmp(m_String, str.m_String)); }

      //! Case-insensitive comparison (similar to stricmp).
      //! @return 0 if strings equal, -1 if this < str, 1 if this > str.
      int CompareNoCase (
         const char *str                  //!< String to compare to
         ) const { return (stricmp(m_String, str)); }
         
      //! Find out if the string is empty.   
      bool IsEmpty (                         
         ) const { return (m_String[0] == 0); }
         
      //! Set the string according to values in ini file
      //! @return: 'true' if entry found and information read, false if empty field or field does not exist
      bool IniRead (
         INIHANDLE inih,
         const char *group,
         const char*const field
         ) { return (::IniRead(inih, group, field, m_String, _CT * sizeof(char)) > 0); }

      //! Save the string to values in ini file
      void IniWrite (
         INIHANDLE inih,
         const char *group,
         const char*const field
         ) { ::IniWrite(inih, group, field, m_String); }

      //! Return length of string, not including terminator.
      size_t GetLength (                        
         ) const { return (strlen(m_String)); }

      //! Return maximum string size, not including terminator.
      size_t GetMaxSize (                       
         ) const { return (_CT-1); }

      //! Get tail of string having up to specified number of characters.
      const char* GetTail (
         int maxlen
         ) const { int len = strlen(m_String); return ((len <= maxlen) ? m_String : (m_String + (len - maxlen))); }
         
      //! Pad the string with a char to the end of the buffer
      void PadToEnd (
         char item
         ) {
         for (int j = strlen(m_String);(j < _CT-1);++j) m_String[j] = item;
         m_String[_CT-1] = 0;
         }
         
      //! Set the string to lower case letters
      void SetLowerCase (
         ) { strlwr(m_String); }

      //! Set the string to upper case letters
      void SetUpperCase (
         ) { strupr(m_String); }
         
      //! Force termination of string at the end.
      void Terminate (                       
         ) { m_String[_CT - 1] = 0; }

      //! Truncate the string, has no effect if the string is shorter than NewLength.
      void Truncate (                           
         size_t NewLength
         ) { if (NewLength >= 0 && NewLength < (_CT - 1)) m_String[NewLength] = 0; }

   protected:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      char m_String[_CT];
      #endif //!< GENERATING_DOXYGEN_OUTPUT
   };

#endif      //!< INC_MI32_FIXEDSTR_H

---