AOO410/main/tools/source/string/strcvt.cxx - openoffice - Git at Google

 /**************************************************************
  *
  * 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;
 }
	/**************************************************************
	*
	* 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;
	}