mi32/fixedstrchar.h

Go to the documentation of this file.

#ifndef  INC_MI32_FIXEDSTRCHAR_H
#define  INC_MI32_FIXEDSTRCHAR_H

#ifndef INC_MI32_INIBASE_H
   #include <mi32/inibase.h>
#endif

#ifndef INC_MEMORY_H
   #include <memory.h>     // For memcpy
   #define INC_MEMORY_H
#endif

template <int _CT> class FIXEDSTRCHAR {
   public:

      FIXEDSTRCHAR (                         
         ) { Clear(); }

      FIXEDSTRCHAR (                         
         const FIXEDSTRCHAR& rhs
         ) { memcpy(m_String, rhs.m_String, sizeof(m_String)); }

      FIXEDSTRCHAR (                         
         const char* string
         ) { Clear(); strncpy(m_String, string, _CT - 1); }

      ~FIXEDSTRCHAR (                           
         ) { m_String[0] = 0; }

      FIXEDSTRCHAR& operator= (                 
         const FIXEDSTRCHAR& rhs          
         ) {
         if (this != &rhs) {
            memcpy(m_String, rhs.m_String, sizeof(m_String));
            }
         return (*this);
         }

      FIXEDSTRCHAR& operator= (              
         const char* rhs               
         ) {
         if (m_String != rhs) {
            Clear();
            strncpy(m_String, rhs, _CT - 1);
            }
         return (*this);
         }

      FIXEDSTRCHAR& operator+= (                
         const FIXEDSTRCHAR& rhs          
         ) {
         strncat(m_String, rhs.m_String, _CT - (strlen(m_String) + 1));
         return (*this);
         }

      FIXEDSTRCHAR& operator+= (                
         const char* rhs               
         ) {
         strncat(m_String, rhs, _CT - (strlen(m_String) + 1));
         return (*this);
         }
         
      bool operator== (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) == 0); }

      bool operator== (
         const char *rhs
         ) const { return (Compare(rhs) == 0); }

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

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

      bool operator< (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) < 0); }

      bool operator< (
         const char *rhs
         ) const { return (Compare(rhs) < 0); }

      bool operator<= (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) <= 0); }

      bool operator<= (
         const char *rhs
         ) const { return (Compare(rhs) <= 0); }

      bool operator> (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) > 0); }

      bool operator> (
         const char *rhs
         ) const { return (Compare(rhs) > 0); }

      bool operator>= (
         const FIXEDSTRCHAR& rhs
         ) const { return (Compare(rhs) >= 0); }

      bool operator>= (
         const char *rhs
         ) const { return (Compare(rhs) >= 0); }

      operator const char* (
         ) const { return (m_String); }

      void Assign (
         const char* name                 
         ) { strncpy(m_String, name, _CT - 1); }

      void Assign (                          
         const char* name,                
         int len
         ) { strncpy(m_String, name, MIN(_CT - 1, len)); }

      void Clear (                           
         ) { memset(m_String, 0, sizeof(m_String)); }
      
      int Compare (
         const FIXEDSTRCHAR& str                
         ) const { return (strcmp(m_String, str.m_String)); }

      int Compare (
         const char *str                  
         ) const { return (strcmp(m_String, str)); }

      int CompareNoCase (
         const FIXEDSTRCHAR& str                
         ) const { return (stricmp(m_String, str.m_String)); }

      int CompareNoCase (
         const char *str                  
         ) const { return (stricmp(m_String, str)); }
         
      bool IsEmpty (                         
         ) const { return (m_String[0] == 0); }
         
      bool IniRead (
         INIHANDLE inih,
         const char *group,
         const char*const field
         ) { return (_iniReadString(inih, group, field, INITYPE_ASCII, m_String, _CT * sizeof(char)) > 0); }

      void IniWrite (
         INIHANDLE inih,
         const char *group,
         const char*const field
         ) { _iniWriteString(inih, group, field, INITYPE_ASCII, m_String); }

      int GetLength (                        
         ) const { return (strlen(m_String)); }

      int GetMaxSize (                       
         ) const { return (_CT-1); }

      const char* GetTail (
         int maxlen
         ) const { int len = strlen(m_String); return ((len <= maxlen) ? m_String : (m_String + (len - maxlen))); }
         
      void PadToEnd (
         char item
         ) {
         for (int j = strlen(m_String);(j < _CT-1);++j) m_String[j] = item;
         m_String[_CT-1] = 0;
         }
         
      void SetLowerCase (
         ) { strlwr(m_String); }

      void SetUpperCase (
         ) { strupr(m_String); }
         
      void Terminate (                       
         ) { m_String[_CT - 1] = 0; }

      void Truncate (                           
         int 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_FIXEDSTRCHAR_H

---