xref: /trunk/main/tools/source/string/strcvt.cxx (revision cf6516809c57e1bb0a940545cca99cdad54d4ce2)

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