/*

* Copyright (c) 2002-2007 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: Helper class for using strings/Uri etc.

*

*

*/

// INCLUDE FILES

#include <utf.h>

#include <uriutils.h>

#include <EPos_Landmarks.h>

#include "EPos_PosLmConverterUtils.h"

#include "EPos_LmConverter.h"

// CONSTANTS

_LIT(KLineFeed,     "\r");

_LIT(KNewLine,      "\n");

_LIT(KTab,          "\t");

_LIT(KSlash,        "/");

_LIT(KLt,           "<");

_LIT(KGt,           ">");

_LIT(KAmp,          "&");

_LIT(KApos,         "'");

_LIT(KQuot,         "\"");

_LIT(KLtXmlStr,     "<");

_LIT(KGtXmlStr,     ">");

_LIT(KAmpXmlStr,    "&");

_LIT(KAposXmlStr,   "'");

_LIT(KQuotXmlStr,   """);

_LIT(KPosNaN,       "NaN");

_LIT(KPosInfinity,  "INF");

_LIT(KPosNegativeInfinity, "-INF");

_LIT8(KNaN,       "NaN");

_LIT8(KInfinity,  "INF");

_LIT8(KNegativeInfinity, "-INF");

const TUint KPosXmlRealPoint = '.';

// ============================ MEMBER FUNCTIONS ===============================

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

// PosLmConverterUtils::IsTokenL

//

// (other items were commented in a header).

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

//

TBool PosLmConverterUtils::IsTokenL(

    const TDesC& aDesC,

    TInt aCorrectLength)

    {

    if (aDesC.Find(KLineFeed) != KErrNotFound &&

        aDesC.Find(KNewLine) != KErrNotFound &&

        aDesC.Find(KTab) != KErrNotFound)

        {

        return EFalse;

        }

    // Check for leading, trailing or internal sequences of two or more spaces.

    HBufC* copy = aDesC.AllocLC();

    copy->Des().TrimAll();

    TInt trimmedLength = copy->Length();

    CleanupStack::PopAndDestroy(copy);

    if (trimmedLength != aDesC.Length())

        {

        return EFalse;

        }

    if (aDesC.Length() == aCorrectLength)

        {

        return ETrue;

        }

    return EFalse;

    }

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

// PosLmConverterUtils::SeparateMediaLink

//

// (other items were commented in a header).

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

//

TInt PosLmConverterUtils::SeparateMediaLink(

    const TDesC& aMediaLink,

    HBufC* aMimeType,

    HBufC* aUrl)

    {

    _LIT(KPosGenericUrlSeparator, "://");

    TInt result = SeparateMediaLink(

        KPosGenericUrlSeparator, aMediaLink, aMimeType, aUrl);

    if (result != KErrNone)

        {

        _LIT(KPosGeneralUrlSeparator, ":");

        result = SeparateMediaLink(

            KPosGeneralUrlSeparator, aMediaLink, aMimeType, aUrl);

        }

    if (*aMimeType == KSlash)

        {

        // Handle mime type "/" as a missing mime type.

        aMimeType->Des().Zero();

        }

    return result;

    }

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

// PosLmConverterUtils::ConcatenateMediaLinkLC

//

// (other items were commented in a header).

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

//

HBufC* PosLmConverterUtils::ConcatenateMediaLinkLC(

    const TDesC& aMimeType,

    const TDesC& aUrl)

    {

    // Concat mimetype + "/" + url

    TInt mimeTypeLen = KSlash().Length();

    if (&aMimeType)

        {

        mimeTypeLen = aMimeType.Length();

        }

    ASSERT( &aUrl );

    TInt urlLen = aUrl.Length();

    HBufC* medialink = HBufC::NewLC(mimeTypeLen + KSlash().Length() + urlLen);

    if (&aMimeType)

        {

        medialink->Des().Append(aMimeType);

        }

    else

        {

        medialink->Des().Append(KSlash);

        }

    // Append delimiter

    medialink->Des().Append(KSlash);

    // Don't need to check aUrl since it is mandatory

    medialink->Des().Append(aUrl);

    return medialink;

    }

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

// PosLmConverterUtils::IsAnyUri

//

// (other items were commented in a header).

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

//

TBool PosLmConverterUtils::IsAnyUri(

    const TDesC& aDesC)

    {

    TUriParser uriParser;

    TInt errorCode = uriParser.Parse(aDesC);

    if (errorCode != KErrNone)

        {

        return EFalse;

        }

    if (!uriParser.IsSchemeValid())

        {

        return EFalse;

        }

    TPtrC16 uriNoFrag;

    uriParser.UriWithoutFragment(uriNoFrag);

    TBool hasInvalidChars = UriUtils::HasInvalidChars(uriNoFrag);

    return !hasInvalidChars;

    }

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

// PosLmConverterUtils::RealToDesL

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::RealToDesL(TReal aReal, TDes& aDes)

    {

    if (Math::IsNaN(aReal))

        {

        aDes = KPosNaN;

        }

    else if (Math::IsInfinite(aReal))

        {

        if (aReal > 0)

            {

            aDes = KPosInfinity;

            }

        else

            {

            aDes = KPosNegativeInfinity;

            }

        }

    else

        {

        TRealFormat realFormat;

        realFormat.iPoint = KPosXmlRealPoint;

        User::LeaveIfError(aDes.Num(aReal, realFormat));

        }

    }

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

// PosLmConverterUtils::DesToRealL

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::DesToRealL(const TDesC& aDes, TReal32& aReal)

    {

    if (ConvertIfTRealSpecialValueL(aDes, aReal))

        {

        return;

        }

    TLex lexer(aDes);

    TInt status = lexer.Val(aReal, TChar(KPosXmlRealPoint));

    ValidateConversionL(lexer, status);

    }

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

// PosLmConverterUtils::DesToRealL

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::DesToRealL(const TDesC& aDes, TReal64& aReal)

    {

    if (ConvertIfTRealSpecialValueL(aDes, aReal))

        {

        return;

        }

    TLex lexer(aDes);

    TInt status = lexer.Val(aReal, TChar(KPosXmlRealPoint));

    ValidateConversionL(lexer, status);

    }

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

// PosLmConverterUtils::DesToRealL

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::DesToRealL(const TDesC8& aDes, TReal32& aReal)

    {

    if (ConvertIfTRealSpecialValueL(aDes, aReal))

        {

        return;

        }

    TLex8 lexer(aDes);

    TInt status = lexer.Val(aReal, TChar(KPosXmlRealPoint));

    ValidateConversionL(lexer, status);

    }

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

// PosLmConverterUtils::DesToRealL

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::DesToRealL(const TDesC8& aDes, TReal64& aReal)

    {

    if (ConvertIfTRealSpecialValueL(aDes, aReal))

        {

        return;

        }

    TLex8 lexer(aDes);

    TInt status = lexer.Val(aReal, TChar(KPosXmlRealPoint));

    ValidateConversionL(lexer, status);

    }

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

// PosLmConverterUtils::DesToTUintL

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::DesToTUintL(const TDesC& aDes, TUint16& aUint)

    {

    TLex lexer(aDes);

    TInt status = lexer.Val(aUint, EDecimal);

    ValidateConversionL(lexer, status);

    }

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

// PosLmConverterUtils::SetNaN

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::SetNaN(TReal32& aReal)

    {

    TRealX floatX;

    floatX.SetNaN();

    aReal = floatX;

    }

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

// PosLmConverterUtils::SetNaN

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::SetNaN(TReal64& aReal)

    {

    TRealX floatX;

    floatX.SetNaN();

    aReal = floatX;

    }

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

// PosLmConverterUtils::SetInfinite

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::SetInfinite(TBool aNegative, TReal32& aReal)

    {

    TRealX floatX;

    floatX.SetInfinite(aNegative);

    aReal = floatX;

    }

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

// PosLmConverterUtils::SetInfinite

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::SetInfinite(TBool aNegative, TReal64& aReal)

    {

    TRealX floatX;

    floatX.SetInfinite(aNegative);

    aReal = floatX;

    }

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

// PosLmConverterUtils::AssertL

//

// (other items were commented in a header).

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

//

void PosLmConverterUtils::AssertL(TBool aCondition, TInt aErrorCode)

    {

    if (!aCondition)

        {

        User::Leave(aErrorCode);

        }

    }

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

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

//

HBufC* PosLmConverterUtils::Utf8ToUnicodeLC( const TDesC8& aUtf8 )

    {

    HBufC* string = HBufC::NewLC( aUtf8.Length() );

    TPtr16 ptr = string->Des();

    PosLmConverterUtils::Utf8ToUnicodeL( aUtf8, ptr );

    return string;

    }

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

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

//

void PosLmConverterUtils::Utf8ToUnicodeL( const TDesC8& aUtf8, TDes16& aUnicode )

    {

    // Create a small output buffer

    TBuf16<30> output;

    // Create a buffer for the unconverted text

    TPtrC8 remUtf8(aUtf8);

    TBool convertingReady = EFalse;

    while (!convertingReady) // conversion loop

        {

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

        // number of characters that were not converted

        const TInt err = CnvUtfConverter::ConvertToUnicodeFromUtf8(

            output, remUtf8);

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

        if (err == CnvUtfConverter::EErrorIllFormedInput)

            {

            User::Leave(KErrCorrupt);

            }

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

            {

            User::Leave(KErrGeneral);

            }

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

        if (aUnicode.Length() + output.Length() > aUnicode.MaxLength())

            {

            User::Leave(KErrNoMemory);

            }

        aUnicode.Append(output);

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

        // remainder buffer

        if (err == 0)

            {

            convertingReady = ETrue;

            }

        else

            {

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

            // The remainder buffer is then fed back into loop

            remUtf8.Set(remUtf8.Right(err));

            }

        }

    }

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

// PosLmConverterUtils::EscapeStringToXmlLC

//

// (other items were commented in a header).

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

//

HBufC* PosLmConverterUtils::EscapeStringToXmlLC(

    const TDesC& aStrToEscape)

    {

    HBufC* string = HBufC::NewLC(CalculateEscapedStringSize(aStrToEscape));

    string->Des().Copy(aStrToEscape);

    // Must start with &, because when escaping other characters & will be

    // added to the string.

    TPtr ptr = string->Des();

    EscapeString(ptr, KAmp, KAmpXmlStr);

    EscapeString(ptr, KLt, KLtXmlStr);

    EscapeString(ptr, KGt, KGtXmlStr);

    EscapeString(ptr, KApos, KAposXmlStr);

    EscapeString(ptr, KQuot, KQuotXmlStr);

    return string;

    }

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

// PosLmConverterUtils::OnlyWhiteSpaces

//

// (other items were commented in a header).

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

//

TBool PosLmConverterUtils::OnlyWhiteSpaces(

    const TDesC8& aStr)

    {

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

        {

        TChar ch = TChar(aStr[i]);

        if (!ch.IsSpace())

            {

            return EFalse;

            }

        }

    return ETrue;

    }

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

// PosLmConverterUtils::SeparateMediaLink

//

// (other items were commented in a header).

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

//

TInt PosLmConverterUtils::SeparateMediaLink(

    const TDesC& aUrlSeparator,

    const TDesC& aMediaLink,

    HBufC* aMimeType,

    HBufC* aUrl)

    {

    _LIT(KPosMimeTypeFirstPart, "*/");

    _LIT(KPosMimeTypeSecondPart, "*");

    _LIT(KPosUrlFirstPart, "*?");

    _LIT(KPosUrlSecondPart, "*?");

    const TInt KMimeTypePatternLength = 5;

    const TInt KUrlPatternLength = 14;

    const TInt KFullPatternLength = 20;

    TBuf<KMimeTypePatternLength> mimeTypePattern;

    mimeTypePattern.Append(KPosMimeTypeFirstPart);

    mimeTypePattern.Append(KPosMimeTypeSecondPart);

    TBuf<KUrlPatternLength> urlPattern;

    urlPattern.Append(KPosUrlFirstPart);

    urlPattern.Append(aUrlSeparator);

    urlPattern.Append(KPosUrlSecondPart);

    TBuf<KFullPatternLength> fullPattern;

    fullPattern.Append(mimeTypePattern);

    fullPattern.Append(KSlash);

    fullPattern.Append(urlPattern);

    // Try matching full url pattern

    TInt offset = aMediaLink.Match(fullPattern);

    if (offset != KErrNotFound)

        {

        // The "*/" part

        *aMimeType = aMediaLink.Left(offset+1);

        // The "*/*?<aUrlSeparator>*?" part

        TPtrC remainder = aMediaLink.Mid(offset+1);

        TBuf<KFullPatternLength> remainderFullPattern;

        remainderFullPattern.Append(KPosMimeTypeSecondPart);

        remainderFullPattern.Append(KSlash);

        remainderFullPattern.Append(urlPattern);

        offset = remainder.Match(remainderFullPattern);

        if (offset == KErrNotFound)

            {

            return offset;