/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Collection of string parsing methods.

*

*/

#include "caistrparser.h"

#include "aistrcnv.h"

// CONSTANTS

const TInt KThreeOctets = 3;

const TInt KTwoOctets = 2;

namespace

    {

    _LIT8( KHexPrefix8, "0x" );

    _LIT16( KHexPrefix16, "0x" );

    const TInt KMaxOneOctetValue = 0x007F;

    const TInt KMaxTwoOctetValue = 0x07FF;

    TInt Utf8OctetCount( const TDesC16& aString )

    	{

        TInt numOctets(0);

        TInt length(aString.Length());

        const TUint16* stringData = aString.Ptr();

       	for ( TInt i = 0; i < length; ++i)

        	{

            if (stringData[i] > KMaxOneOctetValue)

            	{

                if (stringData[i] > KMaxTwoOctetValue)

                	{

                    numOctets += KThreeOctets;

                    }

               	else

                    {

                    numOctets += KTwoOctets;

                    }

                }

           	else

               	{

                ++numOctets;

                }

            }

      	return numOctets;

       	}

    TPtr8 EnsureBufMaxLengthL(HBufC8*& aBuffer, TInt aMaxLength )

        {

        if ( !aBuffer )

            {

            aBuffer = HBufC8::NewL( aMaxLength );

            }

        else if ( aBuffer->Des().MaxLength() < aMaxLength )

            {

            aBuffer = aBuffer->ReAllocL( aMaxLength );

            }

        return aBuffer->Des();

        }

    }

namespace AiUtility

    {

template< class DescType, class LexType > inline

TInt ParseIntImpl

        ( TInt32& aValue, const DescType& aStringValue, 

        const DescType& aHexPrefix )

    {

    const TInt pos = aStringValue.FindF( aHexPrefix );

    if (pos != KErrNotFound)

        {

        LexType lex( aStringValue.Mid( pos + aHexPrefix.Length() ) );

        // Hex parsing needs unsigned int

        TUint32 value = 0;

        const TInt parseResult = lex.Val( value, EHex );

        if ( parseResult == KErrNone )

            {

            aValue = value;

            }

        return parseResult;

        }

    else

        {

        LexType lex( aStringValue );

        return lex.Val(aValue);

        }

    }

EXPORT_C TInt ParseInt( TInt32& aResult, const TDesC8& aSourceString )

    {

    return ParseIntImpl< TDesC8, TLex8 >

        ( aResult, aSourceString, KHexPrefix8 );

    }

EXPORT_C TInt ParseInt( TInt32& aResult, const TDesC16& aSourceString )

    {

    return ParseIntImpl< TDesC16, TLex16 >

        ( aResult, aSourceString, KHexPrefix16 );

    }

EXPORT_C HBufC16* CopyToBufferL(HBufC16* aTargetBuffer, const TDesC16& aSourceText)

    {

    EnsureBufMaxLengthL( aTargetBuffer, aSourceText.Length() ).Copy( aSourceText );

    return aTargetBuffer;

    }

EXPORT_C HBufC16* CopyToBufferL(HBufC16* aTargetBuffer, const TDesC8& aSourceText)

    {

    if (!aTargetBuffer)

        {

        return CnvUtfConverter::ConvertToUnicodeFromUtf8L( aSourceText );

        }

    TPtr16 des( EnsureBufMaxLengthL( aTargetBuffer, aSourceText.Length() ) );

    CnvUtfConverter::ConvertToUnicodeFromUtf8( des, aSourceText );

    return aTargetBuffer;

    }

EXPORT_C HBufC8* CopyToBufferL(HBufC8* aTargetBuffer, const TDesC8& aSourceText)

    {

    ::EnsureBufMaxLengthL( aTargetBuffer, aSourceText.Length() ).Copy( aSourceText );

    return aTargetBuffer;

    }

EXPORT_C HBufC8* CopyToBufferL(HBufC8* aTargetBuffer, const TDesC16& aSourceText)

    {

    if ( !aTargetBuffer )

        {

        return CnvUtfConverter::ConvertFromUnicodeToUtf8L( aSourceText );

        }

    TInt length = Utf8OctetCount( aSourceText );

    TPtr8 des( ::EnsureBufMaxLengthL( aTargetBuffer, length ) );    

    CnvUtfConverter::ConvertFromUnicodeToUtf8( des, aSourceText );

    return aTargetBuffer;

    }

EXPORT_C TPtr16 EnsureBufMaxLengthL(HBufC16*& aTargetBuffer, TInt aMaxLength )

    {

    if ( !aTargetBuffer )

        {

        aTargetBuffer = HBufC16::NewL( aMaxLength );

        }

    else

        {

        if ( aTargetBuffer->Des().MaxLength() < aMaxLength )

            {

            aTargetBuffer = aTargetBuffer->ReAllocL( aMaxLength );

            }

        }

    return aTargetBuffer->Des();

    }

    }

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

// CStrParser()

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

//

CStrParser::CStrParser()

    {

    }

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

// CStrParser* NewL()

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

//

CStrParser* CStrParser::NewL()

    { 

    CStrParser* self = new ( ELeave ) CStrParser();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// void ConstructL()

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

//

void CStrParser::ConstructL()

    {

    }

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

// void Release()

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

//

void CStrParser::Release()

    {

    delete this;

    }

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

// TInt ParseInt( TInt32& aValue, const TDesC8& aStringValue )

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

//

TInt CStrParser::ParseInt( TInt32& aResult, const TDesC8& aSourceString )

    {

    return AiUtility::ParseInt( aResult, aSourceString );

    }

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

// HBufC16* CopyToBufferL( HBufC16* aTargetBuffer, const TDesC16& aSourceText )

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

//    

HBufC16* CStrParser::CopyToBufferL( HBufC16* aTargetBuffer, const TDesC16& aSourceText )

    {

    return AiUtility::CopyToBufferL( aTargetBuffer, aSourceText );

    }

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

// HBufC16* CopyToBufferL( HBufC16* aTargetBuffer, const TDesC8& aSourceText )

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

//

HBufC16* CStrParser::CopyToBufferL( HBufC16* aTargetBuffer, const TDesC8& aSourceText )

    {

    return AiUtility::CopyToBufferL( aTargetBuffer, aSourceText );

    }

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

// HBufC8* CopyToBufferL( HBufC8* aTargetBuffer, const TDesC8& aSourceText )

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

//    

HBufC8* CStrParser::CopyToBufferL( HBufC8* aTargetBuffer, const TDesC8& aSourceText )

    {

    return AiUtility::CopyToBufferL( aTargetBuffer, aSourceText );

    }

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

// HBufC8* CopyToBufferL( HBufC8* aTargetBuffer, const TDesC16& aSourceText )

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

//

HBufC8* CStrParser::CopyToBufferL( HBufC8* aTargetBuffer, const TDesC16& aSourceText )

    {

    return AiUtility::CopyToBufferL( aTargetBuffer, aSourceText );

    }

// End of File.