/*

* Copyright (c) 2006 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:  

*

*/

#include <utf.h>

#include "ncdprotocolutils.h"

_LIT8(KTrueString8, "true");

_LIT8(KFalseString8, "false");

_LIT16(KTrueString16, "true");

_LIT16(KFalseString16, "false");

// This circumvents an API "feature" and adds the XML prefix to the

// name itself. The API changed (AFAIK) so that a certain parameter

// set caused the prefix to be ignored.

#define XML_PREFIX_HACK

void NcdProtocolUtils::AssignEmptyDesL( HBufC16*& aDes )

    {

    delete aDes;

    aDes = 0;

    aDes = KNullDesC16().AllocL();

    }

void NcdProtocolUtils::AssignEmptyDesL( HBufC8*& aDes )

    {

    delete aDes;

    aDes = 0;

    aDes = KNullDesC8().AllocL();

    }

void NcdProtocolUtils::AssignDesL( HBufC16*& aDes, const TDesC16& aSource )

    {

    delete aDes;

    aDes = 0;

    aDes = aSource.AllocL();

    }

void NcdProtocolUtils::AssignDesL( HBufC16*& aDes, const TDesC8& aSource )

    {

    delete aDes;

    aDes = 0;

    aDes = ConvertUtf8ToUnicodeL( aSource );

    }

void NcdProtocolUtils::AssignDesL( HBufC8*& aDes, const TDesC8& aSource )

    {

    delete aDes;

    aDes = 0;

    aDes = aSource.AllocL();

    }

HBufC16* NcdProtocolUtils::ConvertUtf8ToUnicodeLC( const TDesC8& aUtfText )

    {

    HBufC16* t = ConvertUtf8ToUnicodeL( aUtfText );

    CleanupStack::PushL( t );

    return t;

    }

HBufC16* NcdProtocolUtils::ConvertUtf8ToUnicodeL( const TDesC8& aUtfText )

    {

    HBufC16* buffer = HBufC16::NewLC( aUtfText.Length() );

    TPtr ptr( buffer->Des() );

    User::LeaveIfError( 

        CnvUtfConverter::ConvertToUnicodeFromUtf8( ptr, aUtfText ) );

    CleanupStack::Pop( buffer );

    return buffer;

    }

HBufC8* NcdProtocolUtils::ConvertUnicodeToUtf8L( const TDesC16& aUnicodeText )

    {

    const TInt KConvertBufferSize = 32;

    // Place converted data here, initial size double the conversion buffer.

    HBufC8* convertedData = HBufC8::NewL( KConvertBufferSize*2 );

    CleanupStack::PushL( convertedData );

    TPtr8 destination( convertedData->Des() );

    // Create a small output buffer

    TBuf8<KConvertBufferSize> outputBuffer;

    // Create a buffer for the unconverted text - initialised with the input text

    TPtrC16 remainderOfUnicodeText( aUnicodeText );

    for ( ;; ) // conversion loop

        {

        // Start conversion. When the output buffer is full, return the 

        // number of characters that were not converted

        const TInt returnValue

            = CnvUtfConverter::ConvertFromUnicodeToUtf8( outputBuffer, 

                                                        remainderOfUnicodeText );

        // check to see that the descriptor isn’t corrupt - leave if it is

        if ( returnValue==CnvUtfConverter::EErrorIllFormedInput )

            User::Leave( KErrCorrupt );

        else if ( returnValue<0 ) // future-proof against "TError" expanding

            User::Leave( KErrGeneral );

        // Do something here to store the contents of the output buffer.

        if ( destination.Length() + outputBuffer.Length() >= destination.MaxLength() )

            {

            HBufC8* newBuffer = convertedData->ReAllocL(

                ( destination.MaxLength() + outputBuffer.Length() ) * 2 );

            CleanupStack::Pop( convertedData );

            convertedData = newBuffer;

            CleanupStack::PushL( convertedData );

            destination.Set( convertedData->Des() );

            }

        destination.Append( outputBuffer );

        outputBuffer.Zero();

        // Finish conversion if there are no unconverted characters in the remainder buffer

        if ( returnValue==0 )

            break; 

        // Remove the converted source text from the remainder buffer.

        // The remainder buffer is then fed back into loop

        remainderOfUnicodeText.Set( remainderOfUnicodeText.Right( returnValue));

        }

    CleanupStack::Pop( convertedData );

    return convertedData;

    }

TBool NcdProtocolUtils::IsWhitespace( const TDesC8& aBytes )

    {

    for( TInt i = 0; i < aBytes.Length(); i++ )

        {

        if( ! TChar( aBytes[i] ).IsSpace() )

            {

            return EFalse;

            }

        }

    return ETrue;

    }

TInt NcdProtocolUtils::DesDecToIntL( const TDesC8& aDes )

    {

    TLex8 lex( aDes );

    TInt value;

    TInt error = lex.Val( value );

    if( error != KErrNone )

        {

        DLERROR(("Conversion error %d, %S",error,&aDes));

        User::Leave( error );

        }

    return value;

    }

TInt NcdProtocolUtils::DesDecToIntL( const TDesC16& aDes )

    {

    TLex16 lex( aDes );

    TInt value;

    TInt error = lex.Val( value );

    if( error != KErrNone )

        {

        DLERROR((_L("Conversion error %d, %S"),error,&aDes));

        User::Leave( error );

        }

    return value;

    }

TInt NcdProtocolUtils::DesDecToInt( const TDesC8& aDes, TInt& aValue )

    {

    if ( aDes != KNullDesC8 ) 

        {

        aValue = 0;

        TLex8 lex( aDes );

        return lex.Val( aValue );

        }

    return KErrNone;

    }

TInt NcdProtocolUtils::DesDecToInt( const TDesC16& aDes, TInt& aValue )

    {

    if ( aDes != KNullDesC16 ) 

        {

        aValue = 0;

        TLex16 lex( aDes );

        return lex.Val( aValue );

        }

    return KErrNone;

    }

TReal32 NcdProtocolUtils::DesDecToRealL( const TDesC8& aDes )

    {

    DLTRACEIN(("des8 to real32: %S", &aDes));

    if ( aDes != KNullDesC8 ) 

        {

        TReal32 value = 0;

        TLex8 lex( aDes );

        TInt error = lex.Val(value);

        DLINFO(("real32 value=%f, error=%d", value, error));

        User::LeaveIfError(error);

        return value;

        }

    return 0;

    }

void NcdProtocolUtils::DesToNcdBool( TNcdBool& aBool, const TDesC8& aDes)

    {

    if ( aDes == KTrueString8 ) 

        {

        aBool = EValueTrue;

        }

    else if ( aDes == KFalseString8 )

        {

        aBool = EValueFalse;

        }

    else

        {

        aBool = EValueNotSet;

        }

    }

void NcdProtocolUtils::DesToNcdBool( TNcdBool& aBool, const TDesC16& aDes )

    {

    if ( aDes == KTrueString16 ) 

        {

        aBool = EValueTrue;

        }

    else if ( aDes == KFalseString16 )

        {

        aBool = EValueFalse;

        }

    else

        {

        aBool = EValueNotSet;

        }

    }

void NcdProtocolUtils::DesToBool( TBool& aBool, const TDesC8& aDes )

    {

    if ( aDes == KTrueString8 )

        {

        aBool = ETrue;

        }    

    else if ( aDes == KFalseString8 )

        {

        aBool = EFalse;

        }

    }

void NcdProtocolUtils::DesToBool( TBool& aBool, const TDesC16& aDes )

    { 

    if ( aDes == KTrueString16 )

        {

        aBool = ETrue;

        }    

    else if ( aDes == KFalseString16 )

        {

        aBool = EFalse;

        }

    }

const TDesC8& NcdProtocolUtils::BoolToDes( TBool aValue )

    {

    return aValue ? KTrueString8() : KFalseString8();

    }

const TDesC8& NcdProtocolUtils::NcdBoolToDes( TNcdBool aValue )

    {

    switch( aValue )

        {

        case EValueNotSet:

            return KNullDesC8();

        case EValueTrue:

            return KTrueString8();

        case EValueFalse:

            return KFalseString8();

        default:

            DASSERT( EFalse );

            return KNullDesC8();

        };

    }

void NcdProtocolUtils::BoolToStringL(TXmlEngString& aString, const TBool aBool) 

    {

    DLTRACEIN((""));

    aBool ? (aString.SetL(KTrueString8)) : (aString.SetL(KFalseString8));

    }

void NcdProtocolUtils::NcdBoolToStringL(TXmlEngString& aString, const TNcdBool aBool) 

    {

    DLTRACEIN((""));

    if ( aBool == EValueTrue ) 

        {

        aString.SetL(KTrueString8);

        }

    else if ( aBool == EValueFalse ) 

        {

        aString.SetL(KFalseString8);

        }

    }

void NcdProtocolUtils::DesToStringL(TXmlEngString& aString, const TDesC8& aValue) 

    {

    if ( aValue != KNullDesC8 ) 

        {

        aString.SetL( aValue );

        }

    else 

        {

        aString.Free();

        aString = TXmlEngString();

        }

    }

void NcdProtocolUtils::DesToStringL(TXmlEngString& aString, const TDesC& aValue) 

    {

    if ( aValue != KNullDesC ) 

        {

        aString.SetL( aValue );

        }

    else 

        {

        aString.Free();

        aString = TXmlEngString();

        }

    }

void NcdProtocolUtils::IntToStringL(TXmlEngString& aString, TInt aValue) 

    {

    TBuf8<256> buf;

    buf.AppendNum(aValue);

    aString.SetL(buf);

    }    

void NcdProtocolUtils::NewBoolAttributeL(

    TXmlEngElement& aParent, const TDesC8& aKey, const TBool aValue)

    {

    DLTRACEIN((""));

    if ( aKey != KNullDesC8 ) 

        {

        aParent.SetAttributeL( aKey, NcdProtocolUtils::BoolToDes( aValue ) );

        }

    }

void NcdProtocolUtils::NewNcdBoolAttributeL(

    TXmlEngElement& aParent, const TDesC8& aKey, const TNcdBool aValue)

    {

    DLTRACEIN((""));

    if ( aKey != KNullDesC8 && aValue != EValueNotSet ) 

        {

        aParent.SetAttributeL( aKey, NcdProtocolUtils::NcdBoolToDes( aValue ) );

        }

    }

void NcdProtocolUtils::NewAttributeL(

    TXmlEngElement& aParent, const TDesC8& aKey, const TInt aValue)

    {

    TBuf8<32> buf;

    buf.Num( aValue );

    aParent.SetAttributeL( aKey, buf );

    }

void NcdProtocolUtils::NewAttributeL(

    TXmlEngElement& aParent, const TDesC8& aKey, const TDesC8& aValue)

    {

    if ( aKey != KNullDesC8 && aValue != KNullDesC8 ) 

        {

        aParent.SetAttributeL( aKey, aValue );

        }

    }

void NcdProtocolUtils::NewAttributeL(

    TXmlEngElement& aParent, const TDesC8& aKey, const TDesC& aValue)

    {

    if ( aKey != KNullDesC8 && aValue != KNullDesC ) 

        {

        HBufC8* utf8 = NcdProtocolUtils::ConvertUnicodeToUtf8L( aValue );

        CleanupStack::PushL( utf8 );

        aParent.SetAttributeL( aKey, *utf8 );

        CleanupStack::PopAndDestroy( utf8 );

        }

    }

void NcdProtocolUtils::NewAttributeL(

    TXmlEngElement& aParent, const TDesC8& aKey, const TXmlEngString& aValue)

    {

    if ( aKey != KNullDesC8 && aValue.NotNull() ) 

        {

        aParent.SetAttributeL( aKey, aValue.PtrC8() );

        }

    }

TXmlEngElement NcdProtocolUtils::NewElementL( RXmlEngDocument& aDocument,

    TXmlEngElement& aParent, const TDesC8& aName, const TDesC8& aPrefix)

    {

    DLTRACEIN(("1 aName=%S aPrefix=%S",&aName,&aPrefix ));

#ifndef RD_XML_ENGINE_API_CHANGE

    TXmlEngString name;

    NcdProtocolUtils::DesToStringL(name, aName);

    if (aPrefix != KNullDesC8)

        {

        TXmlEngString prefix;

        NcdProtocolUtils::DesToStringL(prefix, aPrefix);

        TXmlEngElement element = aDocument.CreateElementL(name, NULL, prefix);

        aParent.AppendChildL(element);

        if ( name.NotNull() ) name.Free();

        if ( prefix.NotNull() ) prefix.Free();

        return element;

        }

    else 

        {

        TXmlEngElement element = aDocument.CreateElementL(name);

        aParent.AppendChildL(element);

        if ( name.NotNull() ) name.Free();

        return element;

        }

#else

#ifdef XML_PREFIX_HACK

    HBufC8* t = HBufC8::NewLC( aName.Length() + aPrefix.Length() + 1 );

    if( aPrefix != KNullDesC8 )

        {

        t->Des().Append( aPrefix );

        t->Des().Append( ':' );

        }

    t->Des().Append( aName );

    TXmlEngElement element = aDocument.CreateElementL( *t, KNullDesC8, KNullDesC8 );

    DLINFO(("PREFIX HACK DONE 1 %S",t));

    CleanupStack::PopAndDestroy( t );

#else

    TXmlEngElement element = aDocument.CreateElementL( aName, KNullDesC8, aPrefix );

#endif

    aParent.AppendChildL(element);

    return element;

#endif

    }

TXmlEngElement NcdProtocolUtils::NewElementL( RXmlEngDocument& aDocument,

    TXmlEngElement& aParent, const TDesC8& aName, const TXmlEngString& aPrefix )

    {

    DLTRACEIN(("2 aName=%S",&aName ));

#ifndef RD_XML_ENGINE_API_CHANGE

    TXmlEngString name;

    NcdProtocolUtils::DesToStringL(name, aName);

    if (aPrefix.NotNull())

        {

        TNamespace ns = aParent.LookupNamespaceByPrefix(aPrefix);

        TXmlEngElement element = aDocument.CreateElementL(name, NULL, aPrefix);

        aParent.AppendChildL(element);

        if ( name.NotNull() ) name.Free();

        return element;

        }

    else 

        {

        TXmlEngElement element = aDocument.CreateElementL(name);

        aParent.AppendChildL(element);

        if ( name.NotNull() ) name.Free();

        return element;

        }

#else

    return NcdProtocolUtils::NewElementL( aDocument, aParent, aName, aPrefix.PtrC8() );

#endif

    }

TXmlEngElement NcdProtocolUtils::NewElementL(

    RXmlEngDocument& aDocument, const TDesC8& aName, const TDesC8& aPrefix )

    {

    DLTRACEIN(("3 aName=%S aPrefix=%S",&aName,&aPrefix ));

#ifndef RD_XML_ENGINE_API_CHANGE

    TXmlEngString name;

    NcdProtocolUtils::DesToStringL(name, aName);

    if (aPrefix != KNullDesC8)

        {

        TXmlEngString prefix;

        NcdProtocolUtils::DesToStringL(prefix, aPrefix);

        TXmlEngElement element = aDocument.CreateElementL(name, NULL, prefix);

        if ( name.NotNull() ) name.Free();

        if ( prefix.NotNull() ) prefix.Free();

        return element;

        }

    else 

        {

        TXmlEngElement element = aDocument.CreateElementL(name);

        if ( name.NotNull() ) name.Free();

        return element;

        }

#else

#ifdef XML_PREFIX_HACK

    HBufC8* t = HBufC8::NewLC( aName.Length() + aPrefix.Length() + 1 );

    if( aPrefix != KNullDesC8 )

        {

        t->Des().Append( aPrefix );

        t->Des().Append( ':' );

        }

    t->Des().Append( aName );

    TXmlEngElement element = aDocument.CreateElementL( *t, KNullDesC8, KNullDesC8 );

    DLINFO(("PREFIX HACK DONE 2 %S",t));

    CleanupStack::PopAndDestroy( t );

    return element;

#else

    return aDocument.CreateElementL( aName, KNullDesC8, aPrefix );

#endif