Re: Split up MyString

Andrew,
	This does not link because CMyString::CMyString(..) is already defined 
in MFCString.

	I think we should work on a base class called CSafeString which is 
basicly an interface.

	Each platform would implement a class that inheritied from CSafeString.


Andrew Turner wrote:
> Hello
> 
> I have been working on porting Password safe to FreeBSD to achieve this 
> I can't use any MFC classes. I have started by removing CString from 
> CMyString.
> 
> To make the having two different string classes within CMyString easier 
> I would like corelib/MyString.cpp to be split in to two. One will 
> contain the common methods. The other file will have the methods that 
> require calling m_mystring.
> 
> I have attached a patch to achieve this. I would appreciate if it could 
> be tested as I have no way of doing it myself. You will need to copy 
> corelib/MyString.cpp to corelib/MyStringMFC.cpp to apply the patch.
> 
> Andrew
> 
> 
> ------------------------------------------------------------------------
> 
> Index: corelib/MyString.h
> ===================================================================
> --- corelib/MyString.h	(revision 754)
> +++ corelib/MyString.h	(working copy)
> @@ -8,7 +8,14 @@
>  
>  #ifndef _MYSTRING_H_
>  #define _MYSTRING_H_
> +
> +#ifdef MFCString
> +#undef MFCString
> +#endif
> +
>  #include <AFX.H>
> +#define StrType CString
> +#define MFCString
>  //-----------------------------------------------------------------------------
>  class CMyString
>  {
> @@ -17,13 +24,13 @@
>     CMyString(LPCTSTR lpsz);
>     CMyString(LPCTSTR lpsz, int nLength);
>     CMyString(const CMyString& stringSrc);
> -   CMyString(const CString& stringSrc);
> +   CMyString(const StrType& stringSrc);
>     ~CMyString();
>  
>     TCHAR operator[](int nIndex) const;
>     void SetAt(int nIndex, TCHAR ch);
> -   operator CString() const;
> -   operator CString&();
> +   operator StrType() const;
> +   operator StrType&();
>     operator LPCTSTR() const;
>     BOOL IsEmpty() const;
>  
> @@ -62,18 +69,19 @@
>     int Replace(TCHAR chOld, TCHAR chNew) ;
>     int Replace(LPCTSTR lpszOld, LPCTSTR lpszNew) ;
>     int Remove(TCHAR ch) ;
> -   CString Left(int nCount) const;
> -   CString Right(int nCount) const;
> -   CString Mid(int nFirst) const;
> -   CString Mid(int nFirst, int nCount) const;
> -  void TrimRight() {m_mystring.TrimRight();}
> -  void TrimLeft() {m_mystring.TrimLeft();}
> -  void MakeLower() {m_mystring.MakeLower();}
>  
> +   StrType Left(int nCount) const;
> +   StrType Right(int nCount) const;
> +   StrType Mid(int nFirst) const;
> +   StrType Mid(int nFirst, int nCount) const;
> +   void TrimRight();
> +   void TrimLeft();
> +   void MakeLower();
> +
>    void Trash() {trashstring();}
>  
>  private:
> -  CString m_mystring;
> +  StrType m_mystring;
>    void trashstring();
>  };
>  //-----------------------------------------------------------------------------
> Index: corelib/MyString.cpp
> ===================================================================
> --- corelib/MyString.cpp	(revision 754)
> +++ corelib/MyString.cpp	(working copy)
> @@ -1,6 +1,7 @@
>  /// \file MyString.cpp
>  //-----------------------------------------------------------------------------
>  
> +#include "PwsPlatform.h"
>  #include "Util.h"
>  
>  #include "MyString.h"
> @@ -28,7 +29,7 @@
>  {
>  }
>  
> -CMyString::CMyString(const CString& stringSrc) : m_mystring(stringSrc)
> +CMyString::CMyString(const StrType& stringSrc) : m_mystring(stringSrc)
>  {
>  }
>  
> @@ -37,33 +38,6 @@
>     trashstring();
>  }
>  
> -
> -void
> -CMyString::trashstring()
> -{
> -   trashMemory((unsigned char*)m_mystring.GetBuffer(m_mystring.GetLength()),
> -               m_mystring.GetLength());
> -}
> -
> -
> -LPTSTR
> -CMyString::GetBuffer(int nMinBufLength)
> -{
> -   return m_mystring.GetBuffer(nMinBufLength);
> -}
> -
> -void
> -CMyString::ReleaseBuffer(int nNewLength)
> -{
> -   m_mystring.ReleaseBuffer(nNewLength);
> -}
> -
> -int
> -CMyString::GetLength() const
> -{
> -   return m_mystring.GetLength();
> -}
> -
>  const CMyString&
>  CMyString::operator=(const CMyString& stringSrc)
>  {
> @@ -93,7 +67,7 @@
>  CMyString::operator=(const unsigned char* psz)
>  {
>     trashstring();
> -   m_mystring = psz;
> +   m_mystring = (const char *)psz;
>     return *this;
>  }
>  #endif
> @@ -165,33 +139,16 @@
>     return m_mystring[nIndex];
>  }
>  
> -void
> -CMyString::SetAt(int nIndex, TCHAR ch)
> +CMyString::operator StrType() const
>  {
> -   m_mystring.SetAt(nIndex,ch);
> -}
> -
> -CMyString::operator CString() const
> -{
>     return m_mystring;
>  }
>  
> -CMyString::operator CString&()
> +CMyString::operator StrType&()
>  {
>     return m_mystring;
>  }
>  
> -CMyString::operator LPCTSTR() const
> -{
> -   return (LPCTSTR)m_mystring;
> -}
> -
> -BOOL
> -CMyString::IsEmpty() const
> -{
> -   return m_mystring.IsEmpty();
> -}
> -
>  int
>  CMyString::FindByte(char ch) const
>  {
> @@ -216,110 +173,40 @@
>    return nRetVal;
>  }
>  
> -int
> -CMyString::Find(TCHAR ch) const
> -{
> -   return m_mystring.Find(ch);
> -}
> -
> -int
> -CMyString::Find(LPCTSTR lpszSub) const
> -{
> -   return m_mystring.Find(lpszSub);
> -}
> -
> -int
> -CMyString::Find(TCHAR ch, int nstart) const
> -{
> -   return m_mystring.Find(ch, nstart);
> -}
> -
> -int
> -CMyString::Find(LPCTSTR lpszSub, int nstart) const
> -{
> -   return m_mystring.Find(lpszSub, nstart);
> -}
> -
> -int
> -CMyString::Replace(TCHAR chOld, TCHAR chNew) 
> -{
> -   return m_mystring.Replace(chOld,chNew);
> -}
> -
> -int
> -CMyString::Replace(LPCTSTR lpszOld, LPCTSTR lpszNew) 
> -{
> -   return m_mystring.Replace(lpszOld,lpszNew);
> -}
> -
> -int
> -CMyString::Remove(TCHAR ch) 
> -{
> -   return m_mystring.Remove(ch);
> -}
> -
> -//Can't properly trash the memory here, so it is better to just return a CString
> -CString
> -CMyString::Left(int nCount) const
> -{
> -   return m_mystring.Left(nCount);
> -}
> -
> -//Can't properly trash the memory here, so it is better to just return a CString
> -CString
> -CMyString::Right(int nCount) const
> -{
> -   return m_mystring.Right(nCount);
> -}
> -
> -//Can't properly trash the memory here, so it is better to just return a CString
> -CString
> -CMyString::Mid(int nFirst) const
> -{
> -   return m_mystring.Mid(nFirst);
> -}
> -
> -//Can't properly trash the memory here, so it is better to just return a CString
> -CString
> -CMyString::Mid(int nFirst, int nCount) const
> -{
> -   return m_mystring.Mid(nFirst, nCount);
> -}
> -
>  bool
>  operator==(const CMyString& s1, const CMyString& s2)
>  {
> -   return (const CString)s1 == (const CString)s2;
> +   return (const StrType)s1 == (const StrType)s2;
>  }
>  
>  bool
>  operator==(const CMyString& s1, LPCTSTR s2)
>  {
> -   return (const CString)s1==s2;
> +   return (const StrType)s1==s2;
>  }
>  
>  bool
>  operator==(LPCTSTR s1, const CMyString& s2)
>  {
> -   return s1==(const CString)s2;
> +   return s1==(const StrType)s2;
>  }
>  
>  bool
>  operator!=(const CMyString& s1, const CMyString& s2)
>  {
> -   return (const CString)s1 != (const CString)s2;
> +   return (const StrType)s1 != (const StrType)s2;
>  }
>  
>  bool
>  operator!=(const CMyString& s1, LPCTSTR s2)
>  {
> -   return (const CString)s1 != s2;
> +   return (const StrType)s1 != s2;
>  }
>  
>  bool
>  operator!=(LPCTSTR s1, const CMyString& s2)
>  {
> -   return s1 != (const CString)s2;
> +   return s1 != (const StrType)s2;
>  }
>  
>  //-----------------------------------------------------------------------------
> Index: corelib/MyStringMFC.cpp
> ===================================================================
> --- corelib/MyStringMFC.cpp	(revision 742)
> +++ corelib/MyStringMFC.cpp	(working copy)
> @@ -5,39 +5,13 @@
>  
>  #include "MyString.h"
>  
> +#ifdef MFCString
>  #ifdef _DEBUG
>  #define new DEBUG_NEW
>  #undef THIS_FILE
>  static char THIS_FILE[] = __FILE__;
>  #endif
>  
> -
> -CMyString::CMyString() : m_mystring(_T(""))
> -{
> -}
> -
> -CMyString::CMyString(LPCTSTR lpsz) : m_mystring(lpsz)
> -{
> -}
> -
> -CMyString::CMyString(LPCTSTR lpsz, int nLength) : m_mystring(lpsz, nLength)
> -{
> -}
> -
> -CMyString::CMyString(const CMyString& stringSrc) : m_mystring(stringSrc.m_mystring)
> -{
> -}
> -
> -CMyString::CMyString(const CString& stringSrc) : m_mystring(stringSrc)
> -{
> -}
> -
> -CMyString::~CMyString()
> -{
> -   trashstring();
> -}
> -
> -
>  void
>  CMyString::trashstring()
>  {
> @@ -45,7 +19,6 @@
>                 m_mystring.GetLength());
>  }
>  
> -
>  LPTSTR
>  CMyString::GetBuffer(int nMinBufLength)
>  {
> @@ -64,123 +37,12 @@
>     return m_mystring.GetLength();
>  }
>  
> -const CMyString&
> -CMyString::operator=(const CMyString& stringSrc)
> -{
> -   trashstring();
> -   m_mystring = stringSrc.m_mystring;
> -   return *this;
> -}
> -
> -const CMyString&
> -CMyString::operator=(TCHAR ch)
> -{
> -   trashstring();
> -   m_mystring = ch;
> -   return *this;
> -}
> -
> -const CMyString&
> -CMyString::operator=(LPCTSTR lpsz)
> -{
> -   trashstring();
> -   m_mystring = lpsz;
> -   return *this;
> -}
> -
> -#ifndef UNICODE // do we need this at all?
> -const CMyString&
> -CMyString::operator=(const unsigned char* psz)
> -{
> -   trashstring();
> -   m_mystring = psz;
> -   return *this;
> -}
> -#endif
> -
> -const CMyString&
> -CMyString::operator+=(const CMyString& string)
> -{
> -   m_mystring += string.m_mystring;
> -   return *this;
> -}
> -
> -const CMyString&
> -CMyString::operator+=(TCHAR ch)
> -{
> -   m_mystring += ch;
> -   return *this;
> -}
> -
> -const CMyString&
> -CMyString::operator+=(LPCTSTR lpsz)
> -{
> -   m_mystring += lpsz;
> -   return *this;
> -}
> -
> -CMyString AFXAPI
> -operator+(const CMyString& string1,const CMyString& string2)
> -{
> -   CMyString s;
> -   s = (CMyString)(string1.m_mystring+string2.m_mystring);
> -   return s;
> -}
> -
> -CMyString AFXAPI
> -operator+(const CMyString& string, TCHAR ch)
> -{
> -   CMyString s;
> -   s = (CMyString)(string.m_mystring + ch);
> -   return s;
> -}
> -
> -CMyString AFXAPI
> -operator+(TCHAR ch, const CMyString& string)
> -{
> -   CMyString s;
> -   s = (CMyString)(ch + string.m_mystring);
> -   return s;
> -}
> -
> -CMyString AFXAPI
> -operator+(const CMyString& string, LPCTSTR lpsz)
> -{
> -   CMyString s;
> -   s = (CMyString)(string.m_mystring + lpsz);
> -   return s;
> -}
> -
> -CMyString AFXAPI
> -operator+(LPCTSTR lpsz, const CMyString& string)
> -{
> -   CMyString s;
> -   s = (CMyString)(lpsz + string.m_mystring);
> -   return s;
> -}
> -
> -TCHAR
> -CMyString::operator[](int nIndex) const
> -{
> -   return m_mystring[nIndex];
> -}
> -
>  void
>  CMyString::SetAt(int nIndex, TCHAR ch)
>  {
>     m_mystring.SetAt(nIndex,ch);
>  }
>  
> -CMyString::operator CString() const
> -{
> -   return m_mystring;
> -}
> -
> -CMyString::operator CString&()
> -{
> -   return m_mystring;
> -}
> -
>  CMyString::operator LPCTSTR() const
>  {
>     return (LPCTSTR)m_mystring;
> @@ -193,30 +55,6 @@
>  }
>  
>  int
> -CMyString::FindByte(char ch) const
> -{
> -  int		nRetVal = -1;	// default to not found
> -  int		nIndex	= 0;;
> -
> -  LPCTSTR pszString = LPCTSTR(m_mystring);
> -
> -  while ( pszString[nIndex] ) {
> -#ifndef UNICODE
> -    if ( pszString[nIndex] == ch ) {
> -#else
> -    if ( LOBYTE(pszString[nIndex]) == ch ) {
> -#endif
> -      nRetVal = nIndex;
> -      break;
> -    }
> -
> -    ++nIndex;
> -  }
> -
> -  return nRetVal;
> -}
> -
> -int
>  CMyString::Find(TCHAR ch) const
>  {
>     return m_mystring.Find(ch);
> @@ -258,70 +96,52 @@
>     return m_mystring.Remove(ch);
>  }
>  
> -//Can't properly trash the memory here, so it is better to just return a CString
> -CString
> +//Can't properly trash the memory here, so it is better to just return a StrType
> +StrType
>  CMyString::Left(int nCount) const
>  {
>     return m_mystring.Left(nCount);
>  }
>  
> -//Can't properly trash the memory here, so it is better to just return a CString
> -CString
> +//Can't properly trash the memory here, so it is better to just return a StrType
> +StrType
>  CMyString::Right(int nCount) const
>  {
>     return m_mystring.Right(nCount);
>  }
>  
> -//Can't properly trash the memory here, so it is better to just return a CString
> -CString
> +//Can't properly trash the memory here, so it is better to just return a StrType
> +StrType
>  CMyString::Mid(int nFirst) const
>  {
>     return m_mystring.Mid(nFirst);
>  }
>  
> -//Can't properly trash the memory here, so it is better to just return a CString
> -CString
> +//Can't properly trash the memory here, so it is better to just return a StrType
> +StrType
>  CMyString::Mid(int nFirst, int nCount) const
>  {
>     return m_mystring.Mid(nFirst, nCount);
>  }
>  
> -bool
> -operator==(const CMyString& s1, const CMyString& s2)
> +void
> +CMyString::TrimRight()
>  {
> -   return (const CString)s1 == (const CString)s2;
> +   m_mystring.TrimRight();
>  }
>  
> -bool
> -operator==(const CMyString& s1, LPCTSTR s2)
> +void
> +CMyString::TrimLeft()
>  {
> -   return (const CString)s1==s2;
> +   m_mystring.TrimLeft();
>  }
>  
> -bool
> -operator==(LPCTSTR s1, const CMyString& s2)
> +void
> +CMyString::MakeLower()
>  {
> -   return s1==(const CString)s2;
> +   m_mystring.MakeLower();
>  }
>  
> -bool
> -operator!=(const CMyString& s1, const CMyString& s2)
> -{
> -   return (const CString)s1 != (const CString)s2;
> -}
> -
> -bool
> -operator!=(const CMyString& s1, LPCTSTR s2)
> -{
> -   return (const CString)s1 != s2;
> -}
> -
> -bool
> -operator!=(LPCTSTR s1, const CMyString& s2)
> -{
> -   return s1 != (const CString)s2;
> -}
> -
>  //-----------------------------------------------------------------------------
>  //-----------------------------------------------------------------------------
> -
> +#endif


-------------------------------------------------------
This SF.Net email is sponsored by xPML, a groundbreaking scripting language
that extends applications into web and mobile media. Attend the live webcast
and join the prime developer group breaking into this new coding territory!
http://sel.as-us.falkag.net/sel?cmd=lnk&kid=110944&bid=241720&dat=121642