Utilisation d'OpenXML pour réaliser un mailing en C++ et C

<NOM> <PRENOM>
<ADRESSE1>
<ADRESSE2>
<CDP> <VILLE>

//-------------------------------------------------------------------------
CStringA  UTF8EncodeString(const CStringA str)
{
   CStringW input(str);
   CStringA output;

#if _MSC_VER <= 1200
   for(int i=0; i < input.GetLength(); i++)
#else
   for(unsigned int i=0; i < input.GetLength(); i++)
#endif
   {
      // 0xxxxxxx
	  if(input[i] < 0x80)
      {
		output+=input[i];         
      }	   
	  // C0		  80	
      // 110xxxxx 10xxxxxx	  
      else if((input[i] > 0x7F) && (input[i] < 0x800))
      {
	     output+=static_cast<unsigned char>(0xC0 | (input[i] >> 6));
         output+=static_cast<unsigned char>(0x80 | (input[i] & 0x3F));			          
      }
	  // E0       80       80
      // 1110xxxx 10xxxxxx 10xxxxxx
      else if(input[i] < 0x8000)
      {
		output+=static_cast<unsigned char>(0xE0 | (input[i] >> 12));         
		output+=static_cast<unsigned char>(0x80 | (input[i] >> 6 & 0x3F));         
        output+=static_cast<unsigned char>(0x80 | (input[i] & 0x3F));
      }
	  else
	  {  // F0      80       80       80
		 //11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
		output+=static_cast<unsigned char>(0xF0 | (input[i] >> 12)>>6);
		output+=static_cast<unsigned char>(0x80 | (input[i] >> 12 & 0x3F));
		output+=static_cast<unsigned char>(0x80 | (input[i] >> 6 & 0x1F));
        output+=static_cast<unsigned char>(0x80 | (input[i] & 0x3F));
	  }
   }
   return output;
} 
//-------------------------------------------------------------------------
CStringA UTF8DecodeString(const CStringA input)
{   
   CStringW output;
   #if _MSC_VER <= 1200
   for(int i=0; i < input.GetLength();i++)
   #else
   for(unsigned int i=0; i < input.GetLength();i++)
   #endif
   {  
	  // F0      80       80       80
	  //11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
	  if((input[i] & 0xFE) == 0xFE)
	  {
		output+= static_cast<wchar_t>(((input[i] & 7 )<< 18) | ((input[i+1] & 0x3F) << 12) | ((input[i+2] & 0x3F) << 6) | (input[i+3] & 0x3F));
		i += 3;
	  }
	  else
      // E0       80       80
      // 1110xxxx 10xxxxxx 10xxxxxx
      if((input[i] & 0xE0) == 0xE0)
      {
         output+= static_cast<wchar_t>(((input[i] & 0x0F) << 12) | ((input[i+1] & 0x3F) << 6) | (input[i+2] & 0x3F));
         i += 2;
      }
	  // C0       80
      // 110xxxxx 10xxxxxx
      else if((input[i] & 0xC0) == 0xC0)
      {
         output+= static_cast<wchar_t>(((input[i] & 0x1F) << 6) | (input[i+1] & 0x3F));
         i ++;
      }
      // 0xxxxxxx
      else if(input[i] < 0x80)   output+=input[i];           
   }
   return CStringA(output);
}
// tests:
CStringA input,output;
input="é";
output=UTF8EncodeString(input);
TRACE("\n output é:%s",static_cast<const char *>(output));
output=UTF8DecodeString(output);
TRACE("\n output é:%s",static_cast<const char *>(output));
input="€";
output=UTF8EncodeString(input);
TRACE("\n output €:%s",static_cast<const char *>(output));
output=UTF8DecodeString(output);
TRACE("\n output é:%s",static_cast<const char *>(output));

	WXML_EXPORT int				WXmlSetModelDocument(const XML_CHAR *szDocument);
	WXML_EXPORT const XML_CHAR *WXmlGetModelDocument();

	WXML_EXPORT void			WXmlSetDestinationFolder(const XML_CHAR *szFolder);

	WXML_EXPORT void			WXmlSetDocument(const XML_CHAR* szDocument);
	WXML_EXPORT const XML_CHAR *WXmlGetDocument();

	WXML_EXPORT void			WXmlListClearReplace();
	WXML_EXPORT void			WXmlListAddReplace(const XML_CHAR *szKeyWord,const XML_CHAR *szValue);
	WXML_EXPORT int				WXmlListReplace();
	WXML_EXPORT int				WXmlReplaceText(const XML_CHAR *szKeyWord,const XML_CHAR *szValue);
	WXML_EXPORT int				WXmlFindText(const XML_CHAR *szText);

	WXML_EXPORT int				WXmlGetGrid(const XML_CHAR *szText);		
	WXML_EXPORT int				WXmlGetGridRow(int nRow);		
	WXML_EXPORT int				WXmlDuplicateGridRow(int nRow,int nAddRow);		
	WXML_EXPORT int				WXmlSetGridTextCol(int nCol,XML_CHAR *szText);		
	WXML_EXPORT int				WXmlGetGridTextCol(int nCol,XML_CHAR *szText,int nBufSizeMax);
	WXML_EXPORT int				WXmlGetGridColSize();		
	WXML_EXPORT int				WXmlGetGridRowSize();

	WXML_EXPORT int				WXmlSaveDocument(const XML_CHAR *szFileName);
	WXML_EXPORT int				WXmlPrintDocument(const XML_CHAR *szPrinterName);
	WXML_EXPORT int				WXmlViewDocument(const XML_CHAR *szDocument);
	WXML_EXPORT int				WXmlCloseModel();

	WXML_EXPORT int				WXmlSetDefaultPrinter(const XML_CHAR *szPrinterName);
	WXML_EXPORT const XML_CHAR *WXmlGetDefaultPrinter();
	WXML_EXPORT int				WXmlRestoreDefaultPrinter();

	WXML_EXPORT const char*		WXmlGetLastError();
	WXML_EXPORT int				WXmlEmptyDirectory(const XML_CHAR *szDir,int bRemoveDir);

	WXML_EXPORT	int				WXmlGetSizeJobForPrinter(const XML_CHAR *szPrinterName);
	WXML_EXPORT void			WXmlSetPdfFileName(const XML_CHAR *szFilename);
	WXML_EXPORT const XML_CHAR* WXmlGetLastPdfFileName();
	WXML_EXPORT void			WXmlSetPdfAppRun(int bEnable);

void test()
{
	struct ZONEWORD
	{
		const TCHAR *szLabel;
		TCHAR *pszItem;	
	};
	struct ZONEWORD zoneWord[]=
	{
		_T("<PREFIXE>")		,_T("Monsieur "),
		_T("<NOM>")			,_T("Dawkins"),
		_T("<PRENOM>")		,_T("Richard  "),
		_T("<ADRESSE1>")	,_T("P.O. Box 13604"),
		_T("<ADRESSE2>")	,_T("Savannah,"),
		_T("<CP>")			,_T("GA 31416"),
		_T("<VILLE>")		,_T("USA"),
		_T("<COMPTE>")		,_T("0000001"),
		_T("<DEBIT>")		,_T("200.00"),
		_T("<CREDIT>")		,_T("50.00"),
		_T("<SOLDEB>")		,_T("150.00"),
		_T("<SOLCRE>")		,_T(""),
		_T("<SOLDE>")		,_T("150.00"),
	};
	
	int i,nRow,nCol;
	// fixe le nom du modèle
	WXmlSetModelDocument(_T("RELANCECLIENT.docx"));
	// Le nom du document à générer
	WXmlSetDocument(_T("cour0001.docx"));
	// vide la liste interne de remplacement de zones.
	WXmlListClearReplace();
	// prepare la liste des remplacements a effectuer.
	for(i=0;i<sizeof(zoneWord)/sizeof(struct ZONEWORD);i++)
	{		
		WXmlListAddReplace(zoneWord[i].szLabel,zoneWord[i].pszItem);
	}
	// affecte le grid.
	if(WXmlGetGrid(_T("<GRID>")))
	{
		WXmlDuplicateGridRow(1,1);
		nRow=WXmlGetGridRowSize();
		nCol=WXmlGetGridColSize();
		
		WXmlGetGridRow(1);
		WXmlSetGridTextCol(0,_T("01/08/08"));
		WXmlSetGridTextCol(1,_T("31/08/2008"));
		WXmlSetGridTextCol(2,_T("Libellé"));
		WXmlSetGridTextCol(3,_T("2008150"));
		WXmlSetGridTextCol(4,_T("libellé essai"));
		WXmlSetGridTextCol(5,_T("100.00"));
		WXmlSetGridTextCol(6,_T("24.00"));

		WXmlGetGridRow(2);
		WXmlSetGridTextCol(0,_T("15/08/08"));
		WXmlSetGridTextCol(1,_T("15/09/2008"));
		WXmlSetGridTextCol(2,_T("Libellé 2"));
		WXmlSetGridTextCol(3,_T("2008151"));
		WXmlSetGridTextCol(4,_T("libellé essai2"));
		WXmlSetGridTextCol(5,_T("100.00"));
		WXmlSetGridTextCol(6,_T("26.00"));
	}
	// désactive le lancement de l'application pdf associée.
	WXmlSetPdfAppRun(0);
	// remplace les zones
	WXmlListReplace();
	// sauvegarde le document
	WXmlSaveDocument(NULL);
	// fixe le nom du document pdf à générer
	WXmlSetPdfFileName(_T("letter0001"));
	// imprime sur l'imprimante pdf.
	WXmlPrintDocument(_T("GhostScript PDF Writer"));

	// le nouveau nom du document à générer
	WXmlSetDocument(_T("cour0002.docx"));

	WXmlListClearReplace();
	for(i=0;i<sizeof(zoneWord)/sizeof(struct ZONEWORD);i++)
	{		
		WXmlListAddReplace(zoneWord[i].szLabel,zoneWord[i].pszItem);
	}
	WXmlListReplace();
	if(WXmlGetGrid(_T("<GRID>")))
	{
		WXmlDuplicateGridRow(1,1);
		nRow=WXmlGetGridRowSize();
		nCol=WXmlGetGridColSize();

		WXmlGetGridRow(1);
		WXmlSetGridTextCol(0,_T("01/08/08"));
		WXmlSetGridTextCol(1,_T("31/08/2008"));
		WXmlSetGridTextCol(2,_T("Libellé"));
		WXmlSetGridTextCol(3,_T("2008150"));
		WXmlSetGridTextCol(4,_T("libellé essai"));
		WXmlSetGridTextCol(5,_T("100.00"));
		WXmlSetGridTextCol(6,_T("24.00"));

		WXmlGetGridRow(2);
		WXmlSetGridTextCol(0,_T("15/08/08"));
		WXmlSetGridTextCol(1,_T("15/09/2008"));
		WXmlSetGridTextCol(2,_T("Libellé 2"));
		WXmlSetGridTextCol(3,_T("2008151"));
		WXmlSetGridTextCol(4,_T("libellé essai2"));
		WXmlSetGridTextCol(5,_T("100.00"));
		WXmlSetGridTextCol(6,_T("26.00"));
	}
	// fixe le nouveau nom du document pdf à générer
	WXmlSetPdfFileName(_T("letter0002"));
	WXmlSaveDocument(NULL);	
	WXmlPrintDocument(_T("GhostScript PDF Writer"));
	// attente de la fin d'impression
	while(WXmlGetSizeJobForPrinter(_T("GhostScript PDF Writer")));
	
	// active le lancement de l'application par defaut associée à l'imprimante pdf.
	WXmlSetPdfAppRun(1);
}

#ifdef WXML_VC6_STRING
#define WXML_MFC_STRING
#endif

#ifdef WXML_MFC_STRING
#pragma once

#include <assert.h>
#include <string.h>
#include <wchar.h>
#include <mbstring.h>
#include <stdio.h> 
#include <stdarg.h>

/*
   CStringT est une emulation de la classe CStringT MFC, seules les fonctions courantes sont implémentées,
   on disposera des classes CString,CStringW,CStringA
*/
template<typename TYPE> 
class CStringT
{
  public :
	// The size type used
  	typedef size_t size_type;

	// Error value for find primitive
	const size_type npos; // = -1;

	
	// CStringT empty constructor
	CStringT () : npos(static_cast<size_type >(-1))
	{
		nullrep_.size=0;
		nullrep_.capacity=0;
		nullrep_.str[0]='\0';			
		rep_=&nullrep_;
	}

	// CStringT copy constructor
	CStringT ( const CStringT & copy) : rep_(0),npos(static_cast<size_type >(-1))
	{
		nullrep_.size=0;
		nullrep_.capacity=0;
		nullrep_.str[0]='\0';					
		init(copy.length());
		StringMemcpy(start(),copy.data(), length());		
	}

	// CStringT constructor, based on a string
	CStringT ( const char * copy) : rep_(0),npos(static_cast<size_type >(-1))
	{
		nullrep_.size=0;
		nullrep_.capacity=0;
		nullrep_.str[0]='\0';
		int nlen=strlen(copy);
		init( static_cast<size_type>( nlen ));
		if(sizeof(TYPE)==sizeof(char))	memcpy(reinterpret_cast<void *>(start()),static_cast<const char*>(copy), length());
		else
		{			
			wchar_t *wsz= new wchar_t[nlen+1];
			MultiByteToWideChar( CP_ACP, 0, copy,nlen,wsz,nlen);
			wmemcpy(reinterpret_cast<wchar_t *>(start()),reinterpret_cast<const wchar_t*>(wsz), length());
			delete [] wsz;
		}
	}

	// CStringT constructor, based on a string
	CStringT ( const wchar_t * copy) : rep_(0),npos(static_cast<size_type >(-1))
	{
		nullrep_.size=0;
		nullrep_.capacity=0;
		nullrep_.str[0]='\0';
		int nlen=wcslen(copy);
		init( static_cast<size_type>( nlen ));
		if(sizeof(TYPE)!=sizeof(char))	wmemcpy(reinterpret_cast<wchar_t *>(start()),copy, length());
		else
		{			
			char *sz= new char[nlen+1];
			WideCharToMultiByte( CP_ACP, 0, copy, -1, sz, nlen+1, NULL, NULL );
			memcpy(reinterpret_cast<void *>(start()),sz, length());
			delete []sz;
		}
	}
	
	// CStringT constructor, based on a string
	explicit CStringT ( const TYPE * str, size_type len) : rep_(0),npos(static_cast<size_type >(-1))
	{
		nullrep_.size=0;
		nullrep_.capacity=0;
		nullrep_.str[0]='\0';			
		init(len);
		StringMemcpy(start(),str, len);
	}

	// CStringT destructor
	~CStringT ()
	{
		quit();
	}

	// = operator
	CStringT& operator = (const wchar_t * copy)
	{	
		return assign(copy, (size_type)StringLen(copy));		
	}
	// = operator
	CStringT& operator = (const char * copy)
	{	
		return assign(copy, (size_type)StringLen(copy));
		
	}

	// = operator
	CStringT& operator = (const CStringT & copy)
	{
		return assign(copy.start(), copy.length());
	}

	//Extracts a substring of length nCount characters from this CStringT object, starting at position iFirst (zero-based).
	CStringT Mid( size_type iFirst, int nCount) const
	{
		CStringT <TYPE>tmp;
		if(iFirst >=size()) return tmp;
		if(iFirst+nCount >=size()) nCount-=((iFirst+nCount)-size());
		tmp.init(nCount);
		memmove(tmp.start(), start()+iFirst, nCount*sizeof(TYPE));
		return tmp;
	}
	//Extracts a substring from this CStringT object, starting at position iFirst (zero-based).
	CStringT Mid(  size_type iFirst ) const
	{
		CStringT <TYPE>tmp;
		if(iFirst >=size()) return tmp;
		int nCount=size()-iFirst;		
		tmp.init(nCount);
		memmove(tmp.start(), start()+iFirst, nCount*sizeof(TYPE));
		return tmp;
	}
	//Extracts the leftmost nCount characters from this CStringT object and returns a copy of the extracted substring.
	CStringT Left(  size_type nCount ) const
	{
		CStringT <TYPE>tmp;
		if(nCount >=size()) nCount=size();
		tmp.init(nCount);
		memmove(tmp.start(), start(), nCount*sizeof(TYPE));
		return tmp;
	}

	//Extracts the last (that is, rightmost) nCount characters from this CStringT object and returns a copy of the extracted substring.
	CStringT Right(  size_type nCount ) const
	{
		CStringT <TYPE>tmp;
		if(nCount >=size()) nCount=size();
		tmp.init(nCount);
		int nOfs=size()-nCount;
		memmove(tmp.start(), start()+nOfs, nCount*sizeof(TYPE));
		return tmp;
	}
	// += operator. Maps to append
	CStringT& operator += (const wchar_t * suffix)
	{			
		return append(suffix, static_cast<size_type>( StringLen(suffix) ));
		
	}

	// += operator. Maps to append
	CStringT& operator += (const char * suffix)
	{		
		return append(suffix, static_cast<size_type>( StringLen(suffix) ));		
	}

	// += operator. Maps to append
	CStringT& operator += (TYPE single)
	{
		return append(&single, 1);
	}

	// += operator. Maps to append
	CStringT& operator += (const CStringT & suffix)
	{
		return append(suffix.data(), suffix.length());
	}
	// Convert a CStringT into a null-terminated char *
	operator const TYPE*() const{ return rep_->str; }

	// Convert a CStringT into a null-terminated char *
	const TYPE * c_str () const { return rep_->str; }

	// Convert a CStringT into a char * (need not be null terminated).
	const TYPE * data () const { return rep_->str; }

	// Return the length of a CStringT
	size_type length () const { return rep_->size; }

	// Return the length of a CStringT, Alias for length()
	int GetLength() const { return rep_->size; }

	bool IsEmpty() const {return !size();}

	// Alias for length()
	size_type size () const { return rep_->size; }

	// Checks if a CStringT is empty
	bool empty () const { return rep_->size == 0; }

	// Return capacity of string
	size_type capacity () const { return rep_->capacity; }


	// single char extraction
	const TYPE  at (size_type index) const
	{
		assert( index < length() );
		return rep_->str[ index ];
	}

	// [] operator
	TYPE operator [] (int index) const
	{
		assert(static_cast<unsigned int>( index) < length() );
		return rep_->str[ index ];
	}
	
	// find a char in a string from an offset. Return CStringT::npos if not found
	size_type Find (TYPE tofind, size_type offset=0) const
	{
		if (offset >= length()) return npos;

		for (const TYPE * p = c_str() + offset; *p != '\0'; ++p)
		{
		   if (*p == tofind) return static_cast< size_type >( p - c_str() );
		}
		return npos;
	}
	// find a string in a string from an offset. Return CStringT::npos if not found
	size_type Find (const TYPE* pszSub, size_type offset=0) 
	{
		if (offset >= length() || pszSub == NULL) return npos;
	
		// find first matching substring
		const TYPE *psz = StringFindString( c_str()+offset, pszSub );

		// return -1 for not found, distance from beginning otherwise
		return( (psz == NULL) ? npos : int( psz-c_str() ) );
	}
	// release buffer, setting length to nNewLength (or to first nul if -1)
	void ReleaseBuffer(int nNewLength=-1)
	{
		if (nNewLength == -1)	nNewLength = StringLen(c_str()); 

		assert(static_cast<unsigned int>(nNewLength) <= size());
		CStringT <TYPE>tmp;			
		tmp.init(nNewLength);
		memmove(tmp.start(),start(),nNewLength*sizeof(TYPE));
		swap(tmp);
	}
	
	TYPE* GetBuffer(int nMinBufLength)
	{
		assert(nMinBufLength >= 0);		

		int nOldLen = size();
		if (nMinBufLength < nOldLen) nMinBufLength = nOldLen;
		CStringT <TYPE>tmp;
		tmp.init(nMinBufLength);		
		memcpy(tmp.start(), start(), (nOldLen+1)*sizeof(TYPE));
		swap(tmp);
		set_size(nOldLen);
		return start();
	}
	
	// get pointer to modifiable buffer exactly as long as nNewLength
	TYPE *GetBufferSetLength(int nNewLength)
	{
		assert(static_cast<unsigned int>(nNewLength) >= 0);

		CStringT <TYPE>tmp;
		tmp.init(nNewLength);
		unsigned int nSize=nNewLength;
		if(nSize>size()) nSize=size()+1;
		memmove(tmp.start(),start(),nSize*sizeof(TYPE));
		swap(tmp);
		return const_cast<TYPE *>(c_str());
	}

	// Replace all occurrences of string 'pszOld' with string 'pszNew'
	int Replace( const TYPE *pszOld,const TYPE* pszNew )
	{
		// can't have empty or NULL lpszOld
		// nSourceLen is in TYPE
		int nSourceLen = StringLen( pszOld );
		if( nSourceLen == 0 )			return( 0 );
		// nReplacementLen is in TYPE
		int nReplacementLen = StringLen( pszNew );

		// loop once to figure out the size of the result string
		int nCount = 0;
		{
			TYPE * pszStart =const_cast<TYPE*>(c_str());
			TYPE * pszEnd = pszStart+size();
			while( pszStart < pszEnd )
			{
				TYPE* pszTarget;
				while( (pszTarget =const_cast<TYPE*>( StringFindString( pszStart, pszOld ) )) != NULL)
				{
					nCount++;
					pszStart = pszTarget+nSourceLen;
				}
				pszStart += StringLen( pszStart )+1;
			}
		}

		// if any changes were made, make them
		if( nCount > 0 )
		{
			// if the buffer is too small, just
			//   allocate a new buffer (slow but sure)
			int nOldLength = size();
			int nNewLength = nOldLength+(nReplacementLen-nSourceLen)*nCount;

			CStringT <TYPE>tmp;			
			tmp.init(__max( nNewLength, nOldLength ) );
			memmove(tmp.start(),start(),size()*sizeof(TYPE));

			TYPE * pszBuffer =const_cast<TYPE*>( tmp.c_str());

			TYPE * pszStart = pszBuffer;
			TYPE * pszEnd = pszStart+nOldLength;

			// loop again to actually do the work
			while( pszStart < pszEnd )
			{
				TYPE * pszTarget;
				while( (pszTarget = const_cast<TYPE*>(StringFindString( pszStart, pszOld ) )) != NULL )
				{
					int nBalance = nOldLength-int(pszTarget-pszBuffer+nSourceLen);
					memmove( pszTarget+nReplacementLen,pszTarget+nSourceLen, nBalance*sizeof( TYPE ) );
					memcpy( pszTarget,pszNew, nReplacementLen*sizeof( TYPE ) );
					pszStart = pszTarget+nReplacementLen;
					pszTarget[nReplacementLen+nBalance] = 0;
					nOldLength += (nReplacementLen-nSourceLen);
				}
				pszStart += StringLen( pszStart )+1;
			}
			assert( pszBuffer[nNewLength] == 0 );
			swap(tmp);			
		}
		return( nCount );
	}
	// Converts all the characters in this string to uppercase characters.
	CStringT& MakeUpper()
	{
		StringMemcpy(start(),Strupper(const_cast<TYPE *>(data())), length());
		return *this;
	}

	//Trims trailing whitespace characters from the string.
	void TrimRight()
	{
		
		TYPE * lpsz = start();
		TYPE * lpszLast = NULL;

		while (*lpsz != '\0')
		{
			if (isSpace(*lpsz))
			{
				if (lpszLast == NULL) lpszLast = lpsz;
			}
			else lpszLast = NULL;
			lpsz++ ;
		}

		if (lpszLast != NULL)
		{			
			*lpszLast = '\0';
			rep_->size = (lpszLast - start())/sizeof(TYPE);
		}
	}

	// Formats the string as sprintf does.
	void Format(const char *szFormat,... )
	{
		assert(sizeof(TYPE)==sizeof(char));
		va_list arg_ptr;
		va_start(arg_ptr,szFormat);	
	
		CStringT <TYPE>tmp;				
		int nSize=_vscprintf(szFormat,arg_ptr);			
		tmp.init(nSize);
		vsprintf(tmp.start(),szFormat,arg_ptr);
		swap(tmp);
		va_end(arg_ptr);
	}
	void Format(const wchar_t *szFormat,... )
	{
		assert(sizeof(TYPE)==sizeof(wchar_t));
		va_list arg_ptr;
		va_start(arg_ptr,szFormat);	
		
		CStringT <TYPE>tmp;			

		int nSize=_vscwprintf(szFormat,arg_ptr);			
		tmp.init(nSize);
		vswprintf(tmp.start(),szFormat,arg_ptr);
		va_end(arg_ptr);
		swap(tmp);
	}

	// alias of clear
	void Empty(){clear();}

	void clear ()
	{
		//Lee:
		//The original was just too strange, though correct:
		//	CStringT().swap(*this);
		//Instead use the quit & re-init:
		quit();
		init(0,0);
	}

	/*	Function to reserve a big amount of data when we know we'll need it. Be aware that this
		function DOES NOT clear the content of the CStringT if any exists.
	*/
	void reserve (size_type cap)
	{
		if (cap > capacity())
		{
			CStringT<TYPE>tmp;
			tmp.init(length(), cap);
			StringMemcpy(tmp.start(),data(), length());					
			swap(tmp);
		}
	}

	CStringT& assign (const wchar_t * str, size_type len)
	{
		void *pzon=reinterpret_cast<void *>(const_cast <wchar_t *>(str));
		char *sz=NULL;
		if(sizeof(TYPE)==sizeof(char))
		{			
			sz= new char[len];
			WideCharToMultiByte( CP_ACP, 0, str, -1, sz, len, NULL, NULL );
			pzon=sz;
		}
		size_type cap = capacity();
		if (len > cap || cap > 3*(len + 8))
		{
			CStringT <TYPE>tmp;
			tmp.init(len);
			memcpy(reinterpret_cast<void *>(tmp.start()),pzon,len*sizeof(TYPE));			
			swap(tmp);
		}
		else
		{
			memmove(start(), pzon, len*sizeof(TYPE));
			set_size(len);
		}
		delete []sz;
		return *this;
	}
	CStringT& assign (const char * str, size_type len)
	{
		void *pzon=reinterpret_cast<void *>(const_cast <char *>(str));
		wchar_t *wsz=NULL;
		if(sizeof(TYPE)==sizeof(wchar_t))
		{						
			wsz= new wchar_t[len];
			MultiByteToWideChar( CP_ACP, 0, str,len,wsz,len);
			pzon=wsz;
		}
		size_type cap = capacity();
		if (len > cap || cap > 3*(len + 8))
		{
			CStringT <TYPE>tmp;
			tmp.init(len);
			memcpy(reinterpret_cast<void *>(tmp.start()),pzon,len*sizeof(TYPE));			
			swap(tmp);
			
		}
		else
		{
			memmove(start(), pzon, len*sizeof(TYPE));
			set_size(len);
		}
		delete []wsz;
		return *this;
	}

	CStringT& append (const char* str, size_type len)
	{
		void *pzon=reinterpret_cast<void *>(const_cast <char *>(str));
		wchar_t *wsz=NULL;
		if(sizeof(TYPE)==sizeof(wchar_t))
		{						
			wsz= new wchar_t[len];
			MultiByteToWideChar( CP_ACP, 0, str,len,wsz,len);
			pzon=wsz;
		}
		size_type newsize = length() + len;
		if (newsize > capacity())
		{
			reserve (newsize + capacity());
		}
		memmove(finish(), pzon, len*sizeof(TYPE));
		set_size(newsize);
		delete []wsz;
		return *this;
	}
	CStringT& append (const wchar_t* str, size_type len)
	{
		void *pzon=reinterpret_cast<void *>(const_cast <wchar_t *>(str));
		char *sz=NULL;
		if(sizeof(TYPE)==sizeof(char))
		{			
			sz= new char[len];
			WideCharToMultiByte( CP_ACP, 0, str, -1, sz, len, NULL, NULL );
			pzon=sz;
		}
		size_type newsize = length() + len;
		if (newsize > capacity())
		{
			reserve (newsize + capacity());
		}
		memmove(finish(), pzon, len*sizeof(TYPE));
		set_size(newsize);
		delete []sz;
		return *this;
	}

	void swap (CStringT& other)
	{
		Rep* r = rep_;
		// switch avec un chaine null.
		bool bNull=(rep_ == &nullrep_);
		rep_ = other.rep_;
		// improbable ...
		if(other.rep_==&other.nullrep_)	rep_=&nullrep_;
		other.rep_ = r;
		if(bNull) other.rep_=&other.nullrep_;
	}
	static int Compare(const char *sz1,const char *sz2)
	{
		return strcmp(sz1,sz2);
	}
	static int Compare(const wchar_t *sz1,const wchar_t *sz2)
	{
		return wcscmp(sz1,sz2);
	}
	static int StringLen(const char *psz) {return strlen(psz);}
	static int StringLen(const wchar_t *pwsz){return wcslen(pwsz);}

	void init(size_type sz) { init(sz, sz); }
	TYPE* start() const { return rep_->str; }
	TYPE* finish() const { return rep_->str + rep_->size; }

  private:	

	int isSpace(const char t){return isspace(t);}
	int isSpace(const wchar_t t){return iswspace(t);}

	char *Strupper(char *sz)
	{
		return _strupr(sz);
	}
	wchar_t *Strupper(wchar_t *sz)
	{
		return _wcsupr(sz);
	}
	const char *StringFindString( const char *pszBlock, const char *pszMatch )
	{
		return reinterpret_cast< const char* >( _mbsstr( reinterpret_cast< const unsigned char* >( pszBlock ),
			reinterpret_cast< const unsigned char* >( pszMatch ) ) );
	}
	const wchar_t *StringFindString( const wchar_t *pszBlock, const wchar_t *pszMatch )
	{
		return reinterpret_cast< const wchar_t* >( wcsstr(  pszBlock , pszMatch  ) );
	}
	void StringMemcpy(char *dest,const char *src,size_t nlen)
	{
		memcpy(reinterpret_cast<void *>(dest),src,nlen);
	}
	void StringMemcpy(wchar_t *dest,const wchar_t *src,size_t nlen)
	{
		wmemcpy(dest,src,nlen);
	}
	
	
	void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
	

	struct Rep
	{
		size_type size, capacity;
		TYPE str[1];
	};

	void init(size_type sz, size_type cap)
	{
		if (cap)
		{
			// Lee: the original form:
			//	rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
			// doesn't work in some cases of new being overloaded. Switching
			// to the normal allocation, although use an 'int' for systems
			// that are overly picky about structure alignment.			
			const size_type bytesNeeded = sizeof(Rep) + (cap *sizeof(TYPE));
			const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
			rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );

			rep_->str[ rep_->size = sz ] = '\0';
			rep_->capacity = cap;
		}
		else
		{
			rep_ = &nullrep_;
		}
	}

	void quit()
	{
		if (rep_ != &nullrep_)
		{
			// The rep_ is really an array of ints. (see the allocator, above).
			// Cast it back before delete, so the compiler won't incorrectly call destructors.
			delete [] ( reinterpret_cast<int*>( rep_ ) );
		}
	}

	Rep * rep_;
	Rep nullrep_;

} ;

template<typename TYPE> 
inline bool operator == (const CStringT<TYPE> & a, const CStringT<TYPE> & b)
{
	return CStringT<TYPE>::Compare(a.c_str(),b.c_str())==0;
}
template<typename TYPE> 
inline bool operator == (const CStringT<TYPE> & a, const TYPE* b)
{
	return CStringT<TYPE>::Compare(a.c_str(),b)==0;
}
template<typename TYPE> 
inline bool operator == (const TYPE* a, const CStringT<TYPE> & b) { return b == a; }


template<typename TYPE> 
inline bool operator < (const CStringT<TYPE> & a, const CStringT<TYPE> & b)
{
	return CStringT<TYPE>::Compare(a.c_str(),b.c_str())<0;	
}
template<typename TYPE> 
inline bool operator < (const CStringT<TYPE> & a, const TYPE* b)
{
	return CStringT<TYPE>::Compare(a.c_str(),b)<0;	
}
template<typename TYPE> 
inline bool operator < (const TYPE * a, const CStringT<TYPE> & b)
{
	return CStringT<TYPE>::Compare(a,b.c_str())<0;		
}

template<typename TYPE> 
inline bool operator != (const CStringT<TYPE> & a, const CStringT<TYPE> & b) { return !(a == b); }
template<typename TYPE> 
inline bool operator != (const CStringT<TYPE> & a, const TYPE* b) { return !(a == b); }
template<typename TYPE> 
inline bool operator != (const TYPE* a, const CStringT<TYPE> & b) { return !(b == a); }

template<typename TYPE> 
inline bool operator >  (const CStringT<TYPE> & a, const CStringT<TYPE> & b) { return b < a; }
template<typename TYPE> 
inline bool operator >  (const TYPE* a, const CStringT<TYPE> & b) { return b < a; }
template<typename TYPE> 
inline bool operator >  (const CStringT<TYPE> & a, const TYPE* b) { return b < a; }

template<typename TYPE> 
inline bool operator <= (const CStringT<TYPE> & a, const CStringT<TYPE> & b) { return !(b < a); }
template<typename TYPE> 
inline bool operator <= (const TYPE* a, const CStringT<TYPE> & b) { return !(b < a); }
template<typename TYPE> 
inline bool operator <= (const CStringT<TYPE> & a, const TYPE* b) { return !(b < a); }

template<typename TYPE> 
inline bool operator >= (const CStringT<TYPE> & a, const CStringT<TYPE> & b) { return !(a < b); }
template<typename TYPE> 
inline bool operator >= (const TYPE* a, const CStringT<TYPE> & b) { return !(a < b); }
template<typename TYPE> 
inline bool operator >= (const CStringT<TYPE> & a, const TYPE* b) { return !(a < b); }

template<typename TYPE> 
CStringT<TYPE>operator + (const CStringT<TYPE> & a, const CStringT<TYPE> & b)
{
	CStringT<TYPE>tmp;
	tmp.reserve(a.length() + b.length());
	tmp += a;
	tmp += b;
	return tmp;
}
template<typename TYPE> 
CStringT<TYPE> operator + (const CStringT<TYPE> & a, const TYPE* b)
{
	CStringT <TYPE>tmp;
	unsigned int b_len = CStringT<TYPE>::StringLen(b);
	tmp.reserve(a.length() + b_len);
	tmp += a;
	tmp.append(b, b_len);
	return tmp;
}
template<typename TYPE> 
CStringT<TYPE> operator + (const TYPE* a, const CStringT<TYPE> & b)
{
	CStringT <TYPE>tmp;
	unsigned int a_len = CStringT<TYPE>::StringLen(a);
	tmp.reserve(a_len + b.length());
	tmp.append(a, a_len);
	tmp += b;
	return tmp;
}

#ifdef _UNICODE
	#ifndef WXML_VC6_STRING // en mode MFC et visual 6.0 pas besoin de CString...
		typedef CStringT<wchar_t> CString;
	#endif
#else
	#ifndef WXML_VC6_STRING	// en mode MFC et visual 6.0 pas besoin de CString...
		typedef CStringT<char>    CString;
	#endif
#endif

typedef CStringT<char>    CStringA;
typedef CStringT<wchar_t> CStringW;

#endif	// WXML_MFC_STRING