mi32/fixedstr.h

Go to the documentation of this file.

#ifndef INC_MI32_FIXEDSTR_H
#define INC_MI32_FIXEDSTR_H

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

#ifndef  INC_MI32_UCCHAR_H
   #include <mi32/ucchar.h>
#endif

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

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

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

#ifndef  INC_MI32_DELEGATE_H
   #include <mi32/delegate.h>
#endif

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


inline bool DftValidNameChar (
   MIUNICODE c
   ) { return (c =='_'||(c >='A'&& c <='Z')||( c >='a'&& c <='z')||( c >='0'&& c <='9')|| c >=160); }


template <int _CT> class FIXEDSTRING {
   public:

      FIXEDSTRING (                          
         ) { Clear(); }

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

//    template <int _T2> FIXEDSTRING (
//       const FIXEDSTRING<_T2>& rhs            //!< String to concatinate from
//       ) {
//       Clear();
//       ucstrncpy(m_String, rhs.GetReference(), _CT-1);
//       }

      FIXEDSTRING (                          
         const MIUNICODE* string
         ) { 
         Clear(); 
         if (string != 0) ucstrncpy(m_String, string, _CT - 1);
         }

      FIXEDSTRING (                          
         const MISTRING& string
         ) { 
         Clear(); 
         ucstrncpy(m_String, string, _CT - 1);
         }

      FIXEDSTRING (
         TEXTID textid
         ) { Clear(); MISTRING str(textid); ucstrncpy(m_String,str,_CT-1); }

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

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

//    //! Assignment operator.
//    template <int _T2> FIXEDSTRING<_CT>& operator= (
//       const FIXEDSTRING<_T2>& rhs            //!< String to concatinate from
//       ) {
//       Clear();
//       ucstrncpy(m_String, rhs.GetReference(), _CT-1);
//       return (*this);
//       }

      FIXEDSTRING& operator= (               
         const MIUNICODE* rhs             
         ) {
         if (m_String != rhs) {
            Clear();
            if (rhs != 0) ucstrncpy(m_String, rhs, _CT - 1);
            }
         return (*this);
         }

      FIXEDSTRING& operator= (               
         const MISTRING& rhs              
         ) {
         Clear();
         ucstrncpy(m_String, rhs, _CT - 1);
         return (*this);
         }

      FIXEDSTRING& operator= (
         TEXTID textid                    
         ) { Clear(); MISTRING str(textid); ucstrncpy(m_String,str,_CT-1); return(*this); }

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

      FIXEDSTRING& operator+= (                 
         const MIUNICODE* rhs             
         ) {
         if (rhs != 0) ucstrncat(m_String, rhs, _CT - (ucstrlen(m_String) + 1));
         return (*this);
         }
         
      operator const MIUNICODE* (
         ) const { return (m_String); }

//    bool operator== (
//       const FIXEDSTRING& rhs
//       ) const { return (Compare(rhs) == 0); }

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

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

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

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

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

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

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

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

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

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

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

      void Append (                          
         const char* name                 
         ) {
         MIUNICODE *p = ucstrchr(m_String, 0);
         strntouc(p, name, _CT - (p - m_String) - 1);
         return;
         }

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

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

      void Assign (                          
         const char* name,                
         CHAR_ENCODING encoding           
         ) { 
         if (encoding == CHAR_ENCODING_ASCII) {
            strtouc(m_String, name); 
            }
         else {
            MISTRING mistr(name, encoding);
            Clear();
            ucstrncpy(m_String, mistr, _CT - 1);
            }
         }

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

      void Clear (                           
         ) { memset(m_String, 0, sizeof(m_String)); }
      
//    int Compare (
//       const FIXEDSTRING& str                 //!< String to compare to
//       ) const { return (ucstrcmp(m_String, str.m_String)); }

      int Compare (
         const MIUNICODE *str                
         ) const { return (ucstrcmp(m_String, str)); }

//    int CompareNoCase (
//       const FIXEDSTRING& str                 //!< String to compare to
//       ) const { return (ucstricmp(m_String, str.m_String)); }

      int CompareNoCase (
         const MIUNICODE *str                
         ) const { return (ucstricmp(m_String, str)); }
         
      class UNIQUENAMEFILTER {
         public:
            UNIQUENAMEFILTER () {}

            int Filter (const FIXEDSTRING<_CT>& string) { return (v_Filter(string)); }
         private:
            virtual int v_Filter (const FIXEDSTRING<_CT>& string) = 0;
         };

      ERRVALUE GenerateUniqueName (
         FastDelegate<int(const FIXEDSTRING<_CT>&)> delegate
         ) {
         ERRVALUE err;
         if ((err = delegate(m_String)) < 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(MIUNICODE));       // Make sure rest of m_String is set to 0
         MIUNICODE* where = &m_String[len];
         if (len == (_CT-1)) where --;
         MIUNICODE* start = where;
         UINT8 count[_CT];
         memset(count, 0, _CT);

         static const char *AddArray = "1234567890abcdefghijklmnopqrstuvwxyz_?";
         do {
            *where = static_cast<MIUNICODE>(AddArray[k++]);
            if (*where == static_cast<MIUNICODE>('?')) {
               k = 1;
               *where = static_cast<MIUNICODE>(AddArray[0]);
               MIUNICODE *p;
               for (p = where - 1;(p >= start);--p) {
                  *p = static_cast<MIUNICODE>(AddArray[count[p-m_String]++]);
                  if (*p == static_cast<MIUNICODE>('?')) {
                     *p = static_cast<MIUNICODE>(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<MIUNICODE>(AddArray[0]);
                  }
               }
            err = delegate(m_String);
            } while (err == 0);
         if (err < 0) return (err);
         return (0);
         }
         
      ERRVALUE GenerateUniqueName (
         UNIQUENAMEFILTER& FilterInst
         ) {
         FastDelegate<int(const FIXEDSTRING<_CT>&)> delegate = FastDelegate<int(const FIXEDSTRING<_CT>&)>(&FilterInst, &FIXEDSTRING<_CT>::UNIQUENAMEFILTER::Filter);
         return (GenerateUniqueName(delegate));
         }

      void* GetEncoded (
         CHAR_ENCODING encoding              
         ) const {
         MISTRING tstr(m_String);
         return (tstr.GetEncoded(encoding));
         }

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

      static int GetMaxSize (                      
         ) { return (_CT-1); }
         
      const MIUNICODE* GetReference (
         ) const { return (m_String); }
         
      const MIUNICODE* GetTail (
         int maxlen
         ) const { int len = ucstrlen(m_String); return ((len <= maxlen) ? m_String : (m_String + (len - maxlen))); }
         
      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_Unicode, m_String, _CT * sizeof(MIUNICODE)) > 0); }

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

      bool IsValidName (
         FastDelegate<bool(MIUNICODE)> delegate = FastDelegate<bool(MIUNICODE)>(DftValidNameChar)
         ) const {
         const MIUNICODE* p = m_String;
         if (*p == 0 || (*p >= '0' && *p <= '9') || !delegate(*p)) return (false);

         for (++p;(*p != 0);++p) {
            if (!delegate(*p)) return (false);
            }
         return (true);
         }
      
      void MakeValidName (
         FastDelegate<bool(MIUNICODE)> delegate = FastDelegate<bool(MIUNICODE)>(DftValidNameChar)
         ) {
         if (IsEmpty()) {
            Assign("_1");     // Need to have something
            return;
            }
         if (IsValidName(delegate)) return;
         
         /* First remove any space characters from the end */
         MIUNICODE *p = ucstrchr(m_String, 0) - 1;
         memset(p+1, 0, ((_CT-1) - (p - m_String))*sizeof(MIUNICODE));        /* Zero out rest of the string */
         while (p >= m_String && ucisspace(*p)) *p-- = 0;

         /* Now for the remaining characters not valid, replace with '_' */
         for (p = m_String;(*p != 0);++p) {
            if (!delegate(*p)) *p = '_';
            }

         /* Deal with case of a numeric character in the front of the name */
         if (m_String[0] >= '0' && m_String[0] <= '9') {
            for (p = ucstrchr(m_String, 0);(p != m_String);--p) *p = *(p-1);
            *p = (MIUNICODE)'_';
            m_String[_CT-1] = 0;       /* Extreme case */
            }
         return;
         }  

      void PadToEnd (
         char item
         ) {
         for (int j = ucstrlen(m_String);(j < _CT-1);++j) m_String[j] = item;
         m_String[_CT-1] = 0;
         }
         
      void SetLowerCase (
         ) { ucstrlwr(m_String); }

      void SetUpperCase (
         ) { ucstrupr(m_String); }
         
      void SwapBytes (
         ) { ::SwapBytes(m_String, _CT); }

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

      void Truncate (                           
         int NewLength
         ) { if (NewLength < (_CT - 1)) m_String[NewLength] = 0; }

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

#endif      // INC_MI32_FIXEDSTR_H

---