xref: /trunk/main/sal/qa/rtl_strings/rtl_String_Utils.cxx (revision 87d2adbc9cadf14644c3679b041b9226f7630199)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sal.hxx"

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

#include <math.h>
#include <stdlib.h>

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

#ifndef _SAL_TYPES_H_
    #include <sal/types.h>
#endif

#ifndef _RTL_USTRING_H_
    #include <rtl/ustring.h>
#endif

#ifndef _RTL_STRING_HXX_
    #include <rtl/string.hxx>
#endif

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

#ifndef _RTL_STRING_UTILS_CONST_H_
    #include <rtl_String_Utils_Const.h>
#endif

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

using namespace rtl;

sal_uInt32 AStringLen( const sal_Char *pAStr )
{
    sal_uInt32  nStrLen = 0;

    if ( pAStr != NULL )
    {
        const sal_Char *pTempStr = pAStr;

        while( *pTempStr )
        {
            pTempStr++;
        } // while

        nStrLen = (sal_uInt32)( pTempStr - pAStr );
    } // if

    return nStrLen;
} // AStringLen
sal_Char* cpystr( sal_Char* dst, const sal_Char* src )
{
    const sal_Char* psrc = src;
    sal_Char* pdst = dst;

    while( *pdst++ = *psrc++ );
    return ( dst );
}

sal_Char* cpynstr( sal_Char* dst, const sal_Char* src, sal_uInt32 cnt )
{

    const sal_Char* psrc = src;
    sal_Char* pdst = dst;
    sal_uInt32 len = cnt;
    sal_uInt32 i;

    if ( len >= AStringLen(src) )
    {
        return( cpystr( dst, src ) );
    }

    // copy string by char
    for( i = 0; i < len; i++ )
        *pdst++ = *psrc++;
    *pdst = '\0';

    return ( dst );
}

//------------------------------------------------------------------------
sal_Bool cmpstr( const sal_Char* str1, const sal_Char* str2, sal_uInt32 len )
{
    const sal_Char* pBuf1 = str1;
    const sal_Char* pBuf2 = str2;
    sal_uInt32 i = 0;

    while ( (*pBuf1 == *pBuf2) && i < len )
    {
        (pBuf1)++;
        (pBuf2)++;
        i++;
    }
    return( i == len );
}
//------------------------------------------------------------------------
sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2, sal_uInt32 len )
{
    const sal_Unicode* pBuf1 = str1;
    const sal_Unicode* pBuf2 = str2;
    sal_uInt32 i = 0;

    while ( (*pBuf1 == *pBuf2) && i < len )
    {
        (pBuf1)++;
        (pBuf2)++;
        i++;
    }
    return( i == len );
}

//-----------------------------------------------------------------------
sal_Bool cmpustr( const sal_Unicode* str1, const sal_Unicode* str2 )
{
    const sal_Unicode* pBuf1 = str1;
    const sal_Unicode* pBuf2 = str2;
    sal_Bool res = sal_True;

    while ( (*pBuf1 == *pBuf2) && *pBuf1 !='\0' && *pBuf2 != '\0')
    {
        (pBuf1)++;
        (pBuf2)++;
    }
    if (*pBuf1 == '\0' && *pBuf2 == '\0')
        res = sal_True;
    else
        res = sal_False;
    return (res);
}

sal_Char* createName( sal_Char* dst, const sal_Char* meth, sal_uInt32 cnt )
{
    sal_Char* pdst = dst;
    sal_Char nstr[16];
    sal_Char* pstr = nstr;
    rtl_str_valueOfInt32( pstr, cnt, 10 );

    cpystr( pdst, meth );
    cpystr( pdst+ AStringLen(meth), "_" );

    if ( cnt < 100 )
    {
        cpystr(pdst + AStringLen(pdst), "0" );
    }
    if ( cnt < 10 )
    {
        cpystr(pdst + AStringLen(pdst), "0" );
    }

    cpystr( pdst + AStringLen(pdst), nstr );
    return( pdst );
}

//------------------------------------------------------------------------
//  testing the method compareTo( const OString & aStr )
//------------------------------------------------------------------------
void makeComment( char *com, const char *str1, const char *str2,
                                                            sal_Int32 sgn )
{
    cpystr(com, str1);
    int str1Length = AStringLen( str1 );
    const char *sign = (sgn == 0) ? " == " : (sgn > 0) ? " > " : " < " ;
    cpystr(com + str1Length, sign);
    int signLength = AStringLen(sign);
    cpystr(com + str1Length + signLength, str2);
    com[str1Length + signLength + AStringLen(str2)] = 0;
}


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

sal_Bool AStringToFloatCompare ( const sal_Char  *pStr,
                                 const float      nX,
                                 const float      nEPS
                                )
{
    sal_Bool cmp = sal_False;

    if ( pStr != NULL )
    {
        ::rtl::OString aStr(pStr);

        float actNum = 0;
        float expNum = nX;
        float eps    = nEPS;

        actNum = aStr.toFloat();

        if ( abs( (int)(actNum - expNum) ) <= eps )
        {
            cmp = sal_True;
        } // if
    } // if

    return cmp;
} // AStringToFloatCompare

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

sal_Bool AStringToDoubleCompare ( const sal_Char  *pStr,
                                  const double     nX,
                                  const double     nEPS
                                )
{
    sal_Bool cmp = sal_False;

    if ( pStr != NULL )
    {
        ::rtl::OString aStr(pStr);

        double actNum = 0;
        double expNum = nX;
        double eps    = nEPS;

        actNum = aStr.toDouble();

        if ( abs( (int)(actNum - expNum) ) <= eps )
        {
            cmp = sal_True;
        } // if
    } // if

    return cmp;
} // AStringToDoubleCompare

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


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

sal_uInt32 UStringLen( const sal_Unicode *pUStr )
{
    sal_uInt32 nUStrLen = 0;

    if ( pUStr != NULL )
    {
        const sal_Unicode *pTempUStr = pUStr;

        while( *pTempUStr )
        {
            pTempUStr++;
        } // while

        nUStrLen = (sal_uInt32)( pTempUStr - pUStr );
    } // if

    return nUStrLen;
} // UStringLen

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

sal_Bool AStringIsValid( const sal_Char  *pAStr )
{
    if ( pAStr != NULL )
    {
        sal_uInt32 nLen  = AStringLen( pAStr );
        sal_uChar  uChar = 0;

        while ( ( nLen >= 0 ) && ( *pAStr ) )
        {
            uChar = (unsigned char)*pAStr;

            if ( uChar > 127 )
            {
                return sal_False;
            } // if

            pAStr++;

            // Since we are dealing with unsigned integers
            // we want to make sure that the last number is
            // indeed zero.

            if ( nLen > 0 )
            {
                nLen--;
            } // if
            else
            {
                break;
            } // else
        } // while
    } // if

    return sal_True;
} // AStringIsValid

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

sal_Bool AStringNIsValid( const sal_Char   *pAStr,
                          const sal_uInt32  nStrLen
                        )
{
    sal_uInt32 nLen  = nStrLen;
    sal_uChar  uChar = 0;

    while ( ( nLen >= 0 ) && ( *pAStr ) )
    {
        uChar = (unsigned char)*pAStr;

        if ( uChar > 127 )
        {
            return sal_False;
        } // if

        pAStr++;

        // Since we are dealing with unsigned integers
        // we want to make sure that the last number is
        // indeed zero.

        if ( nLen > 0 )
        {
            nLen--;
        } // if
        else
        {
            break;
        } // else
    } // while

    return sal_True;
} // AStringNIsValid

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

static inline sal_Int32 ACharToUCharCompare( const sal_Unicode *pUStr,
                                             const sal_Char    *pAStr
                                           )
{
    sal_Int32  nCmp   = 0;
    sal_Int32  nUChar = (sal_Int32)*pUStr;
    sal_Int32  nChar  = (sal_Int32)((unsigned char)*pAStr);

    nCmp = nUChar - nChar;

    return  nCmp;
} // ACharToUCharCompare

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

sal_Int32 AStringToUStringCompare( const sal_Unicode *pUStr,
                                   const sal_Char    *pAStr
                                 )
{
    sal_Int32 nCmp = kErrCompareAStringToUString;

    if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
    {
        nCmp = ACharToUCharCompare( pUStr, pAStr );

        while ( ( nCmp == 0 ) && ( *pAStr ) )
        {
            pUStr++;
            pAStr++;

            nCmp = ACharToUCharCompare( pUStr, pAStr );
        } // while
    } // if

    return nCmp;
} // AStringToUStringCompare

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

sal_Int32 AStringToUStringNCompare( const sal_Unicode  *pUStr,
                                    const sal_Char     *pAStr,
                                    const sal_uInt32    nAStrCount
                                   )
{
    sal_Int32 nCmp = kErrCompareNAStringToUString;

    if ( ( pUStr != NULL ) && ( pAStr != NULL ) )
    {
        sal_uInt32 nCount = nAStrCount;

        nCmp = ACharToUCharCompare( pUStr, pAStr );

        while ( ( nCmp == 0 ) && ( *pAStr ) && ( nCount ) )
        {
            pUStr++;
            pAStr++;

            nCmp = ACharToUCharCompare( pUStr, pAStr );

            // Since we are dealing with unsigned integers
            // we want to make sure that the last number is
            // indeed zero.

            if ( nCount > 0 )
            {
                nCount--;
            } // if
            else
            {
                break;
            } // else
        } // while
    } // if

    return nCmp;
} // AStringToUStringNCompare

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

sal_Int32 AStringToRTLUStringCompare( const rtl_uString  *pRTLUStr,
                                      const sal_Char     *pAStr
                                    )
{
    sal_Int32 nCmp = kErrCompareAStringToRTLUString;

    if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
    {
        rtl_uString *pRTLUStrCopy = NULL;

        rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );

        if ( pRTLUStrCopy != NULL )
        {
            const sal_Unicode *pUStr = rtl_uString_getStr( pRTLUStrCopy );

            if ( pUStr != NULL )
            {
                nCmp = AStringToUStringCompare( pUStr, pAStr );
            } // if

            rtl_uString_release( pRTLUStrCopy );

            pRTLUStrCopy = NULL;
        } // if
    } // if

    return nCmp;
} // AStringToRTLUStringCompare

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

sal_Int32 AStringToRTLUStringNCompare( const rtl_uString  *pRTLUStr,
                                       const sal_Char     *pAStr,
                                       const sal_uInt32    nAStrCount
                                     )
{
    sal_Int32 nCmp = kErrCompareNAStringToRTLUString;

    if ( ( pRTLUStr != NULL ) && ( pAStr != NULL ) )
    {
        rtl_uString *pRTLUStrCopy = NULL;

        rtl_uString_newFromString( &pRTLUStrCopy, pRTLUStr );

        if ( pRTLUStrCopy != NULL )
        {
            const sal_Unicode  *pUStr = rtl_uString_getStr( pRTLUStrCopy );

            if ( pUStr != NULL )
            {
                nCmp = AStringToUStringNCompare( pUStr, pAStr, nAStrCount );
            } // if

            rtl_uString_release( pRTLUStrCopy );

            pRTLUStrCopy = NULL;
        } // if
    } // if

    return nCmp;
} // AStringToRTLUStringNCompare

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

sal_Bool AStringToUStringCopy( sal_Unicode     *pDest,
                               const sal_Char  *pSrc
                             )
{
    sal_Bool    bCopied = sal_False;
    sal_uInt32  nCount  = AStringLen( pSrc );
    sal_uInt32  nLen    = nCount;

    if (    ( pDest != NULL )
         && ( pSrc  != NULL )
         && ( AStringNIsValid( pSrc, nLen ) )
       )
    {
        while ( nCount >= 0 )
        {
            *pDest = (unsigned char)*pSrc;

            pDest++;
            pSrc++;

            // Since we are dealing with unsigned integers
            // we want to make sure that the last number is
            // indeed zero.

            if ( nCount > 0 )
            {
                nCount--;
            } // if
            else
            {
                break;
            } // else
        } // while

        if ( nCount == 0 )
        {
            bCopied = sal_True;
        } // if
    } // if

    return  bCopied;
} // AStringToUStringCopy

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

sal_Bool AStringToUStringNCopy( sal_Unicode       *pDest,
                                const sal_Char    *pSrc,
                                const sal_uInt32   nSrcLen
                              )
{
    sal_Bool    bCopied = sal_False;
    sal_uInt32  nCount  = nSrcLen;
    sal_uInt32  nLen    = nSrcLen;

    if (    ( pDest != NULL )
         && ( pSrc  != NULL )
         && ( AStringNIsValid( pSrc, nLen ) )
       )
    {
        while ( nCount >= 0 )
        {
            *pDest = (unsigned char)*pSrc;

            pDest++;
            pSrc++;

            // Since we are dealing with unsigned integers
            // we want to make sure that the last number is
            // indeed zero.

            if ( nCount > 0 )
            {
                nCount--;
            } // if
            else
            {
                break;
            } // else
        } // while

        if ( nCount == 0 )
        {
            bCopied = sal_True;
        } // if
    } // if

    return  bCopied;
} // AStringToUStringNCopy

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