/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


// no include "precompiled_tools.hxx" because this is included in other cxx files.

// -----------------------------------------------------------------------

void ByteString::ImplUpdateStringFromUniString(
    const sal_Unicode* pUniStr, sal_Size nUniLen,
    rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags )
{
	ByteStringData* pNewStringData = NULL;
	rtl_uString2String( (rtl_String **)(&pNewStringData),
						pUniStr, nUniLen,
						eTextEncoding, nCvtFlags );
	STRING_RELEASE((STRING_TYPE *)mpData);
	mpData = pNewStringData;
}

// =======================================================================

ByteString::ByteString( const UniString& rUniStr, rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags )
{
	DBG_CTOR( ByteString, DbgCheckByteString );
	DBG_CHKOBJ( &rUniStr, UniString, DbgCheckUniString );

	mpData = NULL;
	rtl_uString2String( (rtl_String **)(&mpData),
						rUniStr.mpData->maStr, rUniStr.mpData->mnLen,
						eTextEncoding, nCvtFlags );
}

// -----------------------------------------------------------------------

ByteString::ByteString( const UniString& rUniStr, xub_StrLen nPos, xub_StrLen nLen,
						rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags )
{
	DBG_CTOR( ByteString, DbgCheckByteString );
	DBG_CHKOBJ( &rUniStr, UniString, DbgCheckUniString );

	// Stringlaenge ermitteln
	if ( nPos > rUniStr.mpData->mnLen )
		nLen = 0;
	else
	{
		// Laenge korrigieren, wenn noetig
		sal_Int32 nMaxLen = rUniStr.mpData->mnLen-nPos;
		if ( nLen > nMaxLen )
			nLen = static_cast< xub_StrLen >(nMaxLen);
	}

	mpData = NULL;
	rtl_uString2String( (rtl_String **)(&mpData),
						rUniStr.mpData->maStr+nPos, nLen,
						eTextEncoding, nCvtFlags );
}

// -----------------------------------------------------------------------

ByteString::ByteString( const sal_Unicode* pUniStr,
						rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags )
{
	DBG_CTOR( ByteString, DbgCheckByteString );
	DBG_ASSERT( pUniStr, "ByteString::ByteString() - pUniStr is NULL" );

	mpData = NULL;
	rtl_uString2String( (rtl_String **)(&mpData),
						pUniStr, ImplStringLen( pUniStr ),
						eTextEncoding, nCvtFlags );
}

// -----------------------------------------------------------------------

ByteString::ByteString( const sal_Unicode* pUniStr, xub_StrLen nLen,
						rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags )
{
	DBG_CTOR( ByteString, DbgCheckByteString );
	DBG_ASSERT( pUniStr, "ByteString::ByteString() - pUniStr is NULL" );

	if ( nLen == STRING_LEN )
		nLen = ImplStringLen( pUniStr );

	mpData = NULL;
	rtl_uString2String( (rtl_String **)(&mpData),
						pUniStr, nLen,
						eTextEncoding, nCvtFlags );
}

// =======================================================================

static sal_uChar aImplByteTab[256] =
{
	0,	 1,   2,   3,	4,	 5,   6,   7,
	8,	 9,  10,  11,  12,	13,  14,  15,
   16,	17,  18,  19,  20,	21,  22,  23,
   24,	25,  26,  27,  28,	29,  30,  31,
   32,	33,  34,  35,  36,	37,  38,  39,
   40,	41,  42,  43,  44,	45,  46,  47,
   48,	49,  50,  51,  52,	53,  54,  55,
   56,	57,  58,  59,  60,	61,  62,  63,
   64,	65,  66,  67,  68,	69,  70,  71,
   72,	73,  74,  75,  76,	77,  78,  79,
   80,	81,  82,  83,  84,	85,  86,  87,
   88,	89,  90,  91,  92,	93,  94,  95,
   96,	97,  98,  99, 100, 101, 102, 103,
  104, 105, 106, 107, 108, 109, 110, 111,
  112, 113, 114, 115, 116, 117, 118, 119,
  120, 121, 122, 123, 124, 125, 126, 127,
  128, 129, 130, 131, 132, 133, 134, 135,
  136, 137, 138, 139, 140, 141, 142, 143,
  144, 145, 146, 147, 148, 149, 150, 151,
  152, 153, 154, 155, 156, 157, 158, 159,
  160, 161, 162, 163, 164, 165, 166, 167,
  168, 169, 170, 171, 172, 173, 174, 175,
  176, 177, 178, 179, 180, 181, 182, 183,
  184, 185, 186, 187, 188, 189, 190, 191,
  192, 193, 194, 195, 196, 197, 198, 199,
  200, 201, 202, 203, 204, 205, 206, 207,
  208, 209, 210, 211, 212, 213, 214, 215,
  216, 217, 218, 219, 220, 221, 222, 223,
  224, 225, 226, 227, 228, 229, 230, 231,
  232, 233, 234, 235, 236, 237, 238, 239,
  240, 241, 242, 243, 244, 245, 246, 247,
  248, 249, 250, 251, 252, 253, 254, 255
};

// =======================================================================

struct Impl1ByteUnicodeTabData
{
	rtl_TextEncoding			meTextEncoding;
	sal_Unicode 				maUniTab[256];
	Impl1ByteUnicodeTabData*	mpNext;
};

// -----------------------------------------------------------------------

struct Impl1ByteConvertTabData
{
	rtl_TextEncoding			meSrcTextEncoding;
	rtl_TextEncoding			meDestTextEncoding;
	sal_uChar					maConvertTab[256];
	sal_uChar					maRepConvertTab[256];
	Impl1ByteConvertTabData*	mpNext;
};

// =======================================================================

sal_Unicode* ImplGet1ByteUnicodeTab( rtl_TextEncoding eTextEncoding )
{
#ifndef BOOTSTRAP
	TOOLSINDATA*				pToolsData = ImplGetToolsInData();
#else
	TOOLSINDATA*				pToolsData = 0x0;
#endif
	Impl1ByteUnicodeTabData*	pTab = pToolsData->mpFirstUniTabData;

	while ( pTab )
	{
		if ( pTab->meTextEncoding == eTextEncoding )
			return pTab->maUniTab;
		pTab = pTab->mpNext;
	}

	// get TextEncodingInfo
	rtl_TextEncodingInfo aTextEncInfo;
	aTextEncInfo.StructSize = sizeof( aTextEncInfo );
	rtl_getTextEncodingInfo( eTextEncoding, &aTextEncInfo );

	if ( aTextEncInfo.MaximumCharSize == 1 )
	{
		pTab = new Impl1ByteUnicodeTabData;
		pTab->meTextEncoding = eTextEncoding;
		pTab->mpNext = pToolsData->mpFirstUniTabData;

		rtl_TextToUnicodeConverter	hConverter;
		sal_uInt32					nInfo;
		sal_Size					nSrcBytes;
		sal_Size					nDestChars;
		hConverter = rtl_createTextToUnicodeConverter( eTextEncoding );
		nDestChars = rtl_convertTextToUnicode( hConverter, 0,
											   (const sal_Char*)aImplByteTab, 256,
											   pTab->maUniTab, 256,
											   RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE |
											   RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
											   RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT,
											   &nInfo, &nSrcBytes );
		rtl_destroyTextToUnicodeConverter( hConverter );

		if ( (nSrcBytes != 256) || (nDestChars != 256) )
			delete pTab;
		else
		{
			pToolsData->mpFirstUniTabData = pTab;
			return pTab->maUniTab;
		}
	}

	return NULL;
}

// -----------------------------------------------------------------------

static sal_uChar* ImplGet1ByteConvertTab( rtl_TextEncoding eSrcTextEncoding,
										  rtl_TextEncoding eDestTextEncoding,
										  sal_Bool bReplace )
{
#ifndef BOOTSTRAP
	TOOLSINDATA*				pToolsData = ImplGetToolsInData();
#else
	TOOLSINDATA*				pToolsData = 0x0;
#endif
	Impl1ByteConvertTabData*	pTab = pToolsData->mpFirstConvertTabData;

	while ( pTab )
	{
		if ( (pTab->meSrcTextEncoding == eSrcTextEncoding) &&
			 (pTab->meDestTextEncoding == eDestTextEncoding) )
		{
			if ( bReplace )
				return pTab->maRepConvertTab;
			else
				return pTab->maConvertTab;
		}
		pTab = pTab->mpNext;
	}

	// get TextEncodingInfo
	rtl_TextEncodingInfo aTextEncInfo1;
	aTextEncInfo1.StructSize = sizeof( aTextEncInfo1 );
	rtl_getTextEncodingInfo( eSrcTextEncoding, &aTextEncInfo1 );
	rtl_TextEncodingInfo aTextEncInfo2;
	aTextEncInfo2.StructSize = sizeof( aTextEncInfo2 );
	rtl_getTextEncodingInfo( eDestTextEncoding, &aTextEncInfo2 );

	if ( (aTextEncInfo1.MaximumCharSize == 1) &&
		 (aTextEncInfo2.MaximumCharSize == 1) )
	{
		pTab = new Impl1ByteConvertTabData;
		pTab->meSrcTextEncoding = eSrcTextEncoding;
		pTab->meDestTextEncoding = eDestTextEncoding;
		pTab->mpNext = pToolsData->mpFirstConvertTabData;

		rtl_TextToUnicodeConverter	hConverter;
		rtl_UnicodeToTextConverter	hConverter2;
		sal_uInt32					nInfo;
		sal_Size					nSrcBytes;
		sal_Size					nDestChars;
		sal_Size					nSrcChars;
		sal_Size					nDestBytes;
		sal_Unicode 				aTempBuf[256];
		hConverter = rtl_createTextToUnicodeConverter( eSrcTextEncoding );
		nDestChars = rtl_convertTextToUnicode( hConverter, 0,
											   (const sal_Char*)aImplByteTab, 256,
											   aTempBuf, 256,
											   RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT |
											   RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
											   RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT,
											   &nInfo, &nSrcBytes );
		rtl_destroyTextToUnicodeConverter( hConverter );
		if ( (nSrcBytes != 256) || (nDestChars != 256) )
			delete pTab;
		else
		{
			hConverter2 = rtl_createUnicodeToTextConverter( eDestTextEncoding );
			nDestBytes = rtl_convertUnicodeToText( hConverter2, 0,
												   aTempBuf, 256,
												   (sal_Char*)pTab->maConvertTab, 256,
												   RTL_UNICODETOTEXT_FLAGS_UNDEFINED_0 |
												   RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT,
												   &nInfo, &nSrcChars );
			if ( (nDestBytes == 256) || (nSrcChars == 256) )
			{
				nDestBytes = rtl_convertUnicodeToText( hConverter2, 0,
													   aTempBuf, 256,
													   (sal_Char*)pTab->maRepConvertTab, 256,
													   RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT |
													   RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT |
													   RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE,
													   &nInfo, &nSrcChars );
			}
			rtl_destroyUnicodeToTextConverter( hConverter2 );
			if ( (nDestBytes != 256) || (nSrcChars != 256) )
				delete pTab;
			else
			{
				pToolsData->mpFirstConvertTabData = pTab;
				if ( bReplace )
					return pTab->maRepConvertTab;
				else
					return pTab->maConvertTab;
			}
		}
	}

	return NULL;
}

// =======================================================================

void ImplDeleteCharTabData()
{
#ifndef BOOTSTRAP
	TOOLSINDATA*				pToolsData = ImplGetToolsInData();
#else
	TOOLSINDATA*				pToolsData = 0x0;
#endif
	Impl1ByteUnicodeTabData*	pTempUniTab;
	Impl1ByteUnicodeTabData*	pUniTab = pToolsData->mpFirstUniTabData;
	while ( pUniTab )
	{
		pTempUniTab = pUniTab->mpNext;
		delete pUniTab;
		pUniTab = pTempUniTab;
	}
	pToolsData->mpFirstUniTabData = NULL;

	Impl1ByteConvertTabData*	pTempConvertTab;
	Impl1ByteConvertTabData*	pConvertTab = pToolsData->mpFirstConvertTabData;
	while ( pConvertTab )
	{
		pTempConvertTab = pConvertTab->mpNext;
		delete pConvertTab;
		pConvertTab = pTempConvertTab;
	}
	pToolsData->mpFirstConvertTabData = NULL;
}

// =======================================================================

void ByteString::ImplStringConvert(
    rtl_TextEncoding eSource, rtl_TextEncoding eTarget, sal_Bool bReplace )
{
	sal_uChar* pConvertTab = ImplGet1ByteConvertTab( eSource, eTarget, bReplace );
	if ( pConvertTab )
	{
		char* pStr = mpData->maStr;
		while ( *pStr )
		{
			sal_uChar c = (sal_uChar)*pStr;
			sal_uChar cConv = pConvertTab[c];
			if ( c != cConv )
			{
				pStr = ImplCopyStringData( pStr );
				*pStr = (char)cConv;
			}

			pStr++;
		}
	}
	else
	{
		rtl_UnicodeToTextConverter	hSrcConverter = rtl_createTextToUnicodeConverter( eSource );
		sal_uInt32					nInfo;
		sal_Size					nSrcBytes;
		sal_Size					nDestChars;
		sal_Size					nTempLen;
		sal_Unicode*				pTempBuf;
		nTempLen = mpData->mnLen;
		pTempBuf = new sal_Unicode[nTempLen];
		nDestChars = rtl_convertTextToUnicode( hSrcConverter, 0,
											   mpData->maStr, mpData->mnLen,
											   pTempBuf, nTempLen,
											   RTL_TEXTTOUNICODE_FLAGS_FLUSH |
											   RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_MAPTOPRIVATE |
											   RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
											   RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT,
											   &nInfo, &nSrcBytes );
		rtl_destroyTextToUnicodeConverter( hSrcConverter );
		// Hier werten wir bReplace nicht aus, da fuer MultiByte-Textencodings
		// sowieso keine Ersatzdarstellung moeglich ist. Da sich der String
		// sowieso in der Laenge aendern kann, nehmen wir auch sonst keine
		// Ruecksicht darauf, das die Laenge erhalten bleibt.
		ImplUpdateStringFromUniString( pTempBuf, nDestChars, eTarget,
									   RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT |
									   RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT |
									   RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE |
									   RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR |
									   RTL_UNICODETOTEXT_FLAGS_PRIVATE_MAPTO0 |
									   RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE |
									   RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE );
		delete [] pTempBuf;
	}
}

// =======================================================================

ByteString& ByteString::Convert( rtl_TextEncoding eSource, rtl_TextEncoding eTarget, sal_Bool bReplace )
{
	DBG_CHKTHIS( ByteString, DbgCheckByteString );

	// rtl_TextEncoding Dontknow kann nicht konvertiert werden
	if ( (eSource == RTL_TEXTENCODING_DONTKNOW) || (eTarget == RTL_TEXTENCODING_DONTKNOW) )
		return *this;

	// Wenn Source und Target gleich sind, muss nicht konvertiert werden
	if ( eSource == eTarget )
		return *this;

	// rtl_TextEncoding Symbol nur nach Unicode oder von Unicode wandeln, ansonsten
	// wollen wir die Zeichencodes beibehalten
	if ( (eSource == RTL_TEXTENCODING_SYMBOL) &&
		 (eTarget != RTL_TEXTENCODING_UTF7) &&
		 (eTarget != RTL_TEXTENCODING_UTF8) )
		return *this;
	if ( (eTarget == RTL_TEXTENCODING_SYMBOL) &&
		 (eSource != RTL_TEXTENCODING_UTF7) &&
		 (eSource != RTL_TEXTENCODING_UTF8) )
		return *this;

	// Zeichensatz umwandeln
	ImplStringConvert( eSource, eTarget, bReplace );

	return *this;
}

// =======================================================================

char ByteString::Convert( char c,
						  rtl_TextEncoding eSource, rtl_TextEncoding eTarget,
						  sal_Bool bReplace )
{
	// TextEncoding Dontknow kann nicht konvertiert werden
	if ( (eSource == RTL_TEXTENCODING_DONTKNOW) || (eTarget == RTL_TEXTENCODING_DONTKNOW) )
		return '\0';

	// Wenn Source und Target gleich sind, muss nicht konvertiert werden
	if ( eSource == eTarget )
		return c;

	// TextEncoding Symbol nur nach Unicode oder von Unicode wandeln, ansonsten
	// wollen wir die Zeichencodes beibehalten
	if ( (eSource == RTL_TEXTENCODING_SYMBOL) &&
		 (eTarget != RTL_TEXTENCODING_UTF7) &&
		 (eTarget != RTL_TEXTENCODING_UTF8) )
		return '\0';
	if ( (eTarget == RTL_TEXTENCODING_SYMBOL) &&
		 (eSource != RTL_TEXTENCODING_UTF7) &&
		 (eSource != RTL_TEXTENCODING_UTF8) )
		return '\0';

	sal_uChar* pConvertTab = ImplGet1ByteConvertTab( eSource, eTarget, bReplace );
	if ( pConvertTab )
		return (char)pConvertTab[(sal_uChar)c];
	else
		return '\0';
}

// =======================================================================

sal_Unicode ByteString::ConvertToUnicode( char c, rtl_TextEncoding eTextEncoding )
{
	sal_Size nLen = 1;
	return ConvertToUnicode( &c, &nLen, eTextEncoding );
}

// -----------------------------------------------------------------------

char ByteString::ConvertFromUnicode( sal_Unicode c, rtl_TextEncoding eTextEncoding, sal_Bool bReplace )
{
	sal_Size	nLen;
	char		aBuf[30];
	nLen = ConvertFromUnicode( c, aBuf, sizeof( aBuf ), eTextEncoding, bReplace );
	if ( nLen == 1 )
		return aBuf[0];
	else
		return 0;
}

// -----------------------------------------------------------------------

sal_Unicode ByteString::ConvertToUnicode( const char* pChar, sal_Size* pLen, rtl_TextEncoding eTextEncoding )
{
	// TextEncoding Dontknow wird nicht konvertiert
	if ( eTextEncoding == RTL_TEXTENCODING_DONTKNOW )
		return 0;

	rtl_TextToUnicodeConverter	hConverter;
	sal_uInt32					nInfo;
	sal_Size					nSrcBytes;
	sal_Size					nDestChars;
	sal_Unicode 				nConvChar;
	hConverter = rtl_createTextToUnicodeConverter( eTextEncoding );
	nDestChars = rtl_convertTextToUnicode( hConverter, 0,
										   (const sal_Char*)pChar, *pLen,
										   &nConvChar, 1,
										   RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_DEFAULT |
										   RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_DEFAULT |
										   RTL_TEXTTOUNICODE_FLAGS_INVALID_DEFAULT |
										   RTL_TEXTTOUNICODE_FLAGS_FLUSH,
										   &nInfo, &nSrcBytes );
	rtl_destroyTextToUnicodeConverter( hConverter );

	if ( nDestChars == 1 )
	{
		*pLen = nSrcBytes;
		return nConvChar;
	}
	else
	{
		*pLen = 0;
		return 0;
	}
}

// -----------------------------------------------------------------------

sal_Size ByteString::ConvertFromUnicode( sal_Unicode c, char* pBuf, sal_Size nBufLen, rtl_TextEncoding eTextEncoding,
										 sal_Bool bReplace )
{
	// TextEncoding Dontknow wird nicht konvertiert
	if ( eTextEncoding == RTL_TEXTENCODING_DONTKNOW )
		return '\0';

	rtl_UnicodeToTextConverter	hConverter;
	sal_uInt32					nInfo;
	sal_Size					nSrcChars;
	sal_Size					nDestBytes;
	sal_Unicode 				cUni = c;
	sal_uInt32					nFlags = RTL_UNICODETOTEXT_FLAGS_NONSPACING_IGNORE |
										 RTL_UNICODETOTEXT_FLAGS_CONTROL_IGNORE |
										 RTL_UNICODETOTEXT_FLAGS_FLUSH;
	if ( bReplace )
	{
		nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_DEFAULT |
				  RTL_UNICODETOTEXT_FLAGS_INVALID_DEFAULT;
		nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACE;
		if ( nBufLen > 1 )
			nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_REPLACESTR;
	}
	else
	{
		nFlags |= RTL_UNICODETOTEXT_FLAGS_UNDEFINED_0 |
				  RTL_UNICODETOTEXT_FLAGS_INVALID_0;
	}

	hConverter = rtl_createUnicodeToTextConverter( eTextEncoding );
	nDestBytes = rtl_convertUnicodeToText( hConverter, 0,
										   &cUni, 1,
										   (sal_Char*)pBuf, nBufLen,
										   nFlags,
										   &nInfo, &nSrcChars );
	rtl_destroyUnicodeToTextConverter( hConverter );
	return nDestBytes;
}

// =======================================================================

ByteString::ByteString( const rtl::OString& rStr )
	: mpData(NULL)
{
	DBG_CTOR( ByteString, DbgCheckByteString );

    OSL_ENSURE(rStr.pData->length < STRING_MAXLEN,
               "Overflowing rtl::OString -> ByteString cut to zero length");

	if (rStr.pData->length < STRING_MAXLEN)
	{
		mpData = reinterpret_cast< ByteStringData * >(const_cast< rtl::OString & >(rStr).pData);
	    STRING_ACQUIRE((STRING_TYPE *)mpData);
	}
	else
	{
		STRING_NEW((STRING_TYPE **)&mpData);
	}
}

// -----------------------------------------------------------------------

ByteString& ByteString::Assign( const rtl::OString& rStr )
{
	DBG_CHKTHIS( ByteString, DbgCheckByteString );

    OSL_ENSURE(rStr.pData->length < STRING_MAXLEN,
               "Overflowing rtl::OString -> ByteString cut to zero length");

	if (rStr.pData->length < STRING_MAXLEN)
	{
	    STRING_RELEASE((STRING_TYPE *)mpData);
		mpData = reinterpret_cast< ByteStringData * >(const_cast< rtl::OString & >(rStr).pData);
	    STRING_ACQUIRE((STRING_TYPE *)mpData);
	}
	else
	{
		STRING_NEW((STRING_TYPE **)&mpData);
	}

	return *this;
}