/** @file

* Copyright (c) 2005-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:  String handling

*

*/

// INCLUDES

#include <e32base.h>

#include <charconv.h>

#include <f32file.h>

#include <s32mem.h>

#include <escapeutils.h>

#include "upnpcons.h"

#include "upnpstring.h"

#include "upnpcommonupnplits.h"

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

namespace UpnpString

    {

    // PR: following for optimized encode/decodexml functions    

    _LIT8( KGtEntity,       "gt;");

    _LIT8( KLtEntity,       "lt;");

    _LIT8( KQuotEntity,     "quot;");

    _LIT8( KAposEntity,     "apos;");

    _LIT8( KAmpEntity,      "amp;");

    // for formatting a date string (in UT)

    _LIT8( KDay1,"Mon");

    _LIT8( KDay2,"Tue");

    _LIT8( KDay3,"Wed");

    _LIT8( KDay4,"Thu");

    _LIT8( KDay5,"Fri");

    _LIT8( KDay6,"Sat");

    _LIT8( KDay7,"Sun");

    // for formatting a date string (in UT)

    _LIT8( KMonth1,"Jan");

    _LIT8( KMonth2,"Feb");

    _LIT8( KMonth3,"Mar");

    _LIT8( KMonth4,"Apr");

    _LIT8( KMonth5,"May");

    _LIT8( KMonth6,"Jun");

    _LIT8( KMonth7,"Jul");

    _LIT8( KMonth8,"Aug");

    _LIT8( KMonth9,"Sep");

    _LIT8( KMonth10,"Oct");

    _LIT8( KMonth11,"Nov");

    _LIT8( KMonth12,"Dec");

    //for formatting UT

    _LIT8( KTimeGMT,"GMT");

    //for formatting UT

    const static TInt KWidthFour = 4;

    const static TInt KWidthTwo = 2;

    const static TInt KMaxEntityLength = 6; // e.g. "

    const static TInt KEntitiesCount = 5;

    const static TReal KReallocRatio = 1.3;

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

// UpnpString::DeleteArray

// 

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

//

void DeleteArray(TAny* param);

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

// UpnpString::IsColon

// Is char colon.

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

//

EXPORT_C TBool IsColon(const TUint8& aChar)

    {

    return aChar == ':';

    }

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

// UpnpString::FromUnicodeL

// Convert from unicode.

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

//    

EXPORT_C HBufC8* FromUnicodeL(const TDesC& aBuffer)

    {

    return EscapeUtils::ConvertFromUnicodeToUtf8L(aBuffer);

    }

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

// UpnpString::ToUnicodeL

// Convert to unicode.

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

//    

EXPORT_C HBufC16* ToUnicodeL(const TDesC8& aBuffer)

    {

    return EscapeUtils::ConvertToUnicodeFromUtf8L(aBuffer);

    }

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

// UpnpString::CurrentDateLC

// Return current date.

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

//    

EXPORT_C HBufC8* CurrentDateLC()

    {

    HBufC8* timeBuf = NULL;

    TTime time;    

    time.UniversalTime();    

    timeBuf = GetDateLC(time);

    return timeBuf;

    }

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

// UpnpString::GetDateLC

// Return current date.

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

//    

HBufC8* GetDateLC(const TTime& aTime)

    {

    TDateTime datetime = aTime.DateTime();    

    HBufC8* timeBuf = HBufC8::NewLC(KDateTimeStringLen);

    //weekday

    timeBuf->Des().Copy(GetWeekday(aTime));

    timeBuf->Des().Append(KComma);

    timeBuf->Des().Append(KSpace);

    //date

    //days numerated from 0 to 30, so +1

    timeBuf->Des().AppendNumFixedWidth((datetime.Day()+1),EDecimal, KWidthTwo);

    timeBuf->Des().Append(KSpace);

    timeBuf->Des().Append(GetMonth(datetime));

    timeBuf->Des().Append(KSpace);    

    timeBuf->Des().AppendNumFixedWidth(datetime.Year(),EDecimal, KWidthFour);

    timeBuf->Des().Append(KSpace);

    //time

    timeBuf->Des().AppendNumFixedWidth((datetime.Hour()),EDecimal, KWidthTwo);

    timeBuf->Des().Append(KColon);

    timeBuf->Des().AppendNumFixedWidth((datetime.Minute()),EDecimal, KWidthTwo);

    timeBuf->Des().Append(KColon);

    timeBuf->Des().AppendNumFixedWidth((datetime.Second()),EDecimal, KWidthTwo);

    timeBuf->Des().Append(KSpace);

    //GMT

    timeBuf->Des().Append(KTimeGMT);    

    return timeBuf;

    }

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

// UpnpString::GetWeekday

// 

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

//    

const TDesC8& GetWeekday(const TTime& aDate)

    {

    switch (aDate.DayNoInWeek())

        {

        case EMonday:

            return KDay1();            

        case ETuesday:

            return KDay2();    

        case EWednesday:

            return KDay3();

        case EThursday:

            return KDay4();

        case EFriday:

            return KDay5();   

        case ESaturday:

            return KDay6();

        case ESunday:

            return KDay7();

        default:

            return KNullDesC8;                                                    

        }

    }

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

// UpnpString::GetMonth

// 

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

//    

const TDesC8& GetMonth(const TDateTime& aDate)

    {

    switch (aDate.Month())

        {

        case EJanuary:

            return KMonth1();            

        case EFebruary:

            return KMonth2();    

        case EMarch:

            return KMonth3();

        case EApril:

            return KMonth4();

        case EMay:

            return KMonth5();   

        case EJune:

            return KMonth6();

        case EJuly:

            return KMonth7();

        case EAugust:

            return KMonth8();

        case ESeptember:

            return KMonth9();

        case EOctober:

            return KMonth10();

        case ENovember:

            return KMonth11();

        case EDecember:

            return KMonth12();                    

        default:

            return KNullDesC8;        

        }

    }    

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

// UpnpString::CutToPiecesL

// 

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

//    

EXPORT_C void CutToPiecesL( TPtrC8 aPtr, 

                            TChar aDelim, 

                            RPointerArray<TPtrC8>& aArray )

    {

    TInt i = 0;

    CleanupStack::PushL(TCleanupItem(&DeleteArray,&aArray));

    while(KErrNotFound != aPtr.Locate(aDelim))

        {    

        TPtrC8* tmp = new (ELeave)TPtrC8();

        CleanupStack::PushL(tmp);

        User::LeaveIfError( aArray.Append( tmp ) );

        CleanupStack::Pop(tmp);

        aArray[i]->Set(aPtr.Left((aPtr.Locate(aDelim))));

        aPtr.Set(aPtr.Right(aPtr.Length() - (aPtr.Locate(aDelim) + 1)) ); 

        aArray[i]->Set(Trim(*aArray[i], EFalse));

        i++;

        }

    TPtrC8* tmp = new (ELeave)TPtrC8();

    CleanupStack::PushL(tmp);

    User::LeaveIfError( aArray.Append( tmp ) );

    CleanupStack::Pop(tmp);        

    aArray[i]->Set(aPtr);

    aArray[i]->Set(Trim(*aArray[i], EFalse));

    CleanupStack::Pop(&aArray);    

    }

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

// UpnpString::Trim

// 

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

//    

EXPORT_C TPtrC8 Trim(TPtrC8 aPtr, TBool aQuotations)

    {

    if( aPtr.Length() == 0 )

        {

        return aPtr;

        }

    while( ( ('"' == aPtr[0]) && aQuotations ) ||

        (' ' == aPtr[0]) )

        {

            aPtr.Set(aPtr.Right(aPtr.Length() - 1));

        if( aPtr.Length() == 0) 

            {

            return aPtr;

            }

        }

    while( ( ('"' == aPtr[aPtr.Length() - 1] ) && aQuotations ) ||

        (' ' == aPtr[aPtr.Length() - 1] ) )

        {

        aPtr.Set(aPtr.Left(aPtr.Length() - 1 ));

        if( aPtr.Length() == 0 ) 

            {

            return aPtr;

            }

        }

    return aPtr;

    }

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

// CutToPiecesL

// 

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

//

void CutToPiecesL( TPtrC8 aPtr,TChar aDelim, RArray<TPtrC8>& aArray )

    {

    TInt i = 0;

    TInt loc = aPtr.Locate(aDelim);

    while(KErrNotFound != loc)

        {    

        TPtrC8 r(aPtr.Left(loc));

        User::LeaveIfError(aArray.Append(r));

        aPtr.Set(aPtr.Right(aPtr.Length() - (loc + 1)) ); 

        i++;

        loc = aPtr.Locate(aDelim);

        }

    TInt parenthesis;

    parenthesis =  aPtr.Locate(')');

    if( KErrNotFound != parenthesis )

        {

        User::LeaveIfError(aArray.Append(aPtr.Left( parenthesis )));

        }

    else

        {

        User::LeaveIfError(aArray.Append(aPtr));

          }

    }

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

// UpnpString::ValueFromCsvL

// 

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

//

EXPORT_C HBufC8* ValueFromCsvL(const TDesC8& aCSV, TInt aPlace)

    {

    RArray<TPtrC8> array;

    CleanupClosePushL(array);

    CutToPiecesL(aCSV, ',', array);

    HBufC8* value = HBufC8::NewL(array[aPlace].Length());

    value->Des().Copy(array[aPlace]);

    CleanupStack::PopAndDestroy();

    return value;

    }

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

// UpnpString::AddValueToCsvL

// 

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

//

EXPORT_C HBufC8* AddValueToCsvL(const TDesC8& aCSV, const TDesC8& aValue)

    {

    HBufC8* buf=NULL;

    if( 0 == KEmptyString().Compare(aCSV) )

        {

        buf = aValue.AllocL();

        }

    else

        {

        buf = HBufC8::NewL(aCSV.Length() + KComma().Length() + aValue.Length());

        buf->Des().Append(aCSV);

        buf->Des().Append(KComma());

        buf->Des().Append(aValue);

        }

    return buf;

    }

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

// UpnpString::RemoveFromCsvLC

// 

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

//

EXPORT_C HBufC8* RemoveFromCsvLC(const TDesC8& aCSV, const TDesC8& aValue)

    {

    RPointerArray<TPtrC8> array;

    CsvToRPointerArrayL(aCSV, array);

    TPtrC8 val(Trim(aValue, EFalse));

    for( TInt i = 0; i < array.Count(); i++ )

        {

        if( 0 == array[i]->CompareF(val) )

            {

            delete array[i];

            array.Remove(i);

            }

        }

    CleanupStack::PushL(TCleanupItem(&DeleteArray, &array));    

    HBufC8* buf = RPointerArrayToCsvLC( array );

    CleanupStack::Pop( buf ); 

    CleanupStack::PopAndDestroy( &array ); 

    CleanupStack::PushL( buf ); 

    array.Close();

    return buf;

    }

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

// UpnpString::CsvToRPointerArrayL

// 

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

//

EXPORT_C void CsvToRPointerArrayL( const TDesC8& aCSV, 

                                   RPointerArray<TPtrC8>& aArray )

    {

    aArray.ResetAndDestroy();

    CutToPiecesL(aCSV, ',', aArray);

    }

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

// UpnpString::RPointerArrayToCsvLC

// 

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

//

EXPORT_C HBufC8* RPointerArrayToCsvLC( RPointerArray<TPtrC8>& aArray )

    {

    TInt length (0);

    TInt i(0);

    for( ; i< aArray.Count(); ++i)

        {

        length += aArray[i]->Length() + KComma().Length();

        }

    HBufC8* buf = HBufC8::NewLC(length);

    TPtr8 des = buf->Des();

    for( i = 0; i < aArray.Count(); i++ )

        {

        des.Append(*aArray[i]);

        if( i != aArray.Count() - 1 )

            {

            des.Append(KComma());

            }

        }

    return buf;

    }

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

// UpnpString::AppendStringL

// Append to string.

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

//

EXPORT_C void AppendStringL( CBufFlat& aBuffer, const TDesC8& aString )

    {

    RBufWriteStream bufWs(aBuffer, aBuffer.Size());

    CleanupClosePushL(bufWs);

    bufWs.WriteL(aString);

    bufWs.CommitL();

    CleanupStack::PopAndDestroy(); 

    }

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

// UpnpString::AppendStringL

// Append to string.

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

//

EXPORT_C void AppendStringL( HBufC8*& aString, const TDesC8& aString2 )

    {

    if(aString==NULL)

        { 

        if(aString2.Length()==0)

            {

            return;

            }

        aString = HBufC8::NewLC(aString2.Length());

        aString->Des().Append(aString2);

        CleanupStack::Pop();

        }

    else if(aString2.Length()==0)

        {

        return;

        }

    else

        {

        HBufC8* nString = HBufC8::NewLC(aString->Length() + aString2.Length());

        nString->Des().Append(aString->Des());

        nString->Des().Append(aString2);

        delete aString;

        aString = nString;

        CleanupStack::Pop();

        }

    }

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

// UpnpString::StringToInt

// String to integer.

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

//

EXPORT_C TInt StringToInt(const TDesC8& aStr, TInt* aInt)

    {

    if( 0 == aStr.Length() || aInt == NULL)

        {

        return KErrArgument;

        }

    TLex8 lex( aStr );

    return lex.Val( *aInt );

    }

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

// UpnpString::StringReplaceL

// 

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

//    

EXPORT_C void StringReplaceL( const TDesC8& aOrginal, 

                              HBufC8*& aResult, 

                              const TDesC8& aTrg, 

                              const TDesC8& aReplacement )

    {

    TInt place = aOrginal.Find( aTrg );

    if( KErrNotFound != place )

        {

        aResult = StringReplaceL(aOrginal, aTrg, aReplacement);

        }

    else

        {    

        delete aResult;

        aResult = NULL;

        aResult = aOrginal.AllocL();

        }

    }

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

// UpnpString::StringReplaceL

// 

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

//    

EXPORT_C HBufC8* StringReplaceL( const TDesC8& aStr,