/*
* Copyright (c) 2003-2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 related utility methods.
*
*/



// INCLUDE FILES
#include <e32base.h>
#include <e32hal.h>
#include <e32svr.h>

#include "StringUtils.h"
#include "nwx_string.h"


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

// -----------------------------------------------------------------------------
// StringUtils::CopyUsc2ToAscii
// Convert a UCS2 buffer to ascii.
// -----------------------------------------------------------------------------
//
TUint8* StringUtils::CopyUsc2ToAscii(const TUint16* aUsc2Buf)
    {
    if (aUsc2Buf == NULL)
	    {
        return NULL;
        }
	
	TUint len = User::StringLength(aUsc2Buf) + 1;
    TUint8* asciiBuf = new TUint8 [len];
    if (asciiBuf != NULL)
        {
        TPtr8 asciiPtr(asciiBuf, 0, len);
        TPtrC16 ucs2Ptr(aUsc2Buf);
        asciiPtr.Copy(ucs2Ptr);
        asciiPtr.ZeroTerminate();
        }
    return asciiBuf;
    }


// -----------------------------------------------------------------------------
// StringUtils::CopyAsciiToUsc2
// Convert a ascii buffer to UCS2.
// -----------------------------------------------------------------------------
//
TUint16* StringUtils::CopyAsciiToUsc2(const TUint8* aAsciiBuf)
    {
    if (aAsciiBuf == NULL)
	    {
        return NULL;
        }

	TUint len = User::StringLength(aAsciiBuf) + 1;
    TUint16* usc2Buf = new TUint16 [len];
    if (usc2Buf != NULL)
        {
        TPtrC8 asciiPtr(aAsciiBuf);
        TPtr16 ucs2Ptr(usc2Buf, 0, len);
        ucs2Ptr.Copy(asciiPtr);
        ucs2Ptr.ZeroTerminate();
        }
    return usc2Buf;
    }

// -----------------------------------------------------------------------------
// StringUtils::CopyUsc2ToUcs2
// Copy a UCS2 buffer.
// -----------------------------------------------------------------------------
//
TUint16* StringUtils::CopyUsc2ToUcs2(const TUint16* aUsc2Buf)
    {
    if (aUsc2Buf == NULL)
	    {
        return NULL;
        }
	
	TUint len = User::StringLength(aUsc2Buf) + 1;
    TUint16* buf = new TUint16[len];
    if (buf != NULL)
        {
        TPtr16 ptr(buf, 0, len);
        TPtrC16 ucs2Ptr(aUsc2Buf);
        ptr.Copy(ucs2Ptr);
        ptr.ZeroTerminate();
        }
    return buf;
    }

// -----------------------------------------------------------------------------
// StringUtils::CopyAsciiToAscii
// Copy a ascii buffer.
// -----------------------------------------------------------------------------
//
TUint8* StringUtils::CopyAsciiToAscii(const TUint8* aAsciiBuf)
    {
    if (aAsciiBuf == NULL)
	    {
        return NULL;
        }

	TUint len = User::StringLength(aAsciiBuf) + 1;
    TUint8* buf = new TUint8[len];
    if (buf != NULL)
        {
        TPtrC8 asciiPtr(aAsciiBuf);
        TPtr8 ptr(buf, 0, len);
        ptr.Copy(asciiPtr);
        ptr.ZeroTerminate();
        }
    return buf;
    }

// -----------------------------------------------------------------------------
// StringUtils::CopyStringToDes
// Convert a NW_String_t (holding an usc2 null-terminated string) to a TDesC16.
// -----------------------------------------------------------------------------
//
TDesC16* StringUtils::CopyStringToDes(const NW_String_t& aUcs2String)
    {
    HBufC16* des = NULL;

    TUint length = NW_String_getCharCount((NW_String_t*) &aUcs2String, 
            HTTP_iso_10646_ucs_2);

    des = HBufC16::New(length + 1);

    if (des)
        {
        des->Des().Append((const TUint16*) aUcs2String.storage, length);
        des->Des().ZeroTerminate();
        }

    return des;
    }

// -----------------------------------------------------------------------------
// StringUtils::CopyTDesC8ToTDesC16
// Convert a NW_String_t (holding an usc2 null-terminated string) to a TDesC16.
// -----------------------------------------------------------------------------
//
TDesC16* StringUtils::CopyTDesC8ToTDesC16(const TDesC8& aTDesC8String)
    {
    HBufC16* des = NULL;

    TUint length = aTDesC8String.Length();

    des = HBufC16::New(length + 1);

    if (des)
      {
      des->Des().Copy(aTDesC8String);
      des->Des().ZeroTerminate();
      }

    return des;
    }

// -----------------------------------------------------------------------------
// StringUtils::CopyTUint16ToTDesC16
// Convert a NW_String_t (holding an usc2 null-terminated string) to a TDesC16.
// -----------------------------------------------------------------------------
//
TDesC16* StringUtils::CopyTUint16ToTDesC16(const TUint16* aTUint16String)
    {
    HBufC16* des = NULL;

    TUint length = User::StringLength(aTUint16String);

    des = HBufC16::New(length + 1);

    if (des)
        {
        des->Des().Append((const TUint16*) aTUint16String, length);
        des->Des().ZeroTerminate();
        }

    return des;
    }

// -----------------------------------------------------------------------------
// StringUtils::ConvertPtrUsc2ToAscii
// Convert a UCS2 buffer to ascii.
// -----------------------------------------------------------------------------
//
TInt StringUtils::ConvertPtrUsc2ToAscii(const TPtrC& aUsc2Ptr, TUint8** retPtr)
    {
    TUint len = aUsc2Ptr.Length() + 1; // 1 for NULL terminator

    TUint8* asciiBuf = new TUint8[len];
    if (asciiBuf != NULL)
        {
        TPtr8 asciiPtr(asciiBuf, 0, len);
        asciiPtr.Copy(aUsc2Ptr);
        asciiPtr.ZeroTerminate();
        *retPtr = asciiBuf;
        }
    else
        {
        return KErrNoMemory;
        }
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// StringUtils::ConvertPtrAsciiToUcs2
// Convert a ascii buffer to UCS2.
// -----------------------------------------------------------------------------
//
TInt StringUtils::ConvertPtrAsciiToUcs2(const TPtrC8& aAsciiPtr, TUint16** retPtr)
    {
    TUint len = aAsciiPtr.Length() + 1; // 1 for NULL terminator

    TUint16* ucs2Buf = new TUint16[len];
    if (ucs2Buf != NULL)
        {
        TPtr ucs2Ptr(ucs2Buf, 0, len);
        ucs2Ptr.Copy(aAsciiPtr);
        ucs2Ptr.ZeroTerminate();
        *retPtr = ucs2Buf;
        }
    else
        {
        return KErrNoMemory;
        }
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// StringUtils::ConvertPtrUcs2ToUcs2
// Convert a UCS2 buffer to UCS2.
// -----------------------------------------------------------------------------
//
TInt StringUtils::ConvertPtrUcs2ToUcs2(const TPtrC& aUcs2Ptr, TUint16** retPtr)
    {
    TUint len = aUcs2Ptr.Length() + 1; // 1 for NULL terminator

    TUint16* ucs2Buf = new TUint16[len];
    if (ucs2Buf != NULL)
        {
        TPtr ucs2Ptr(ucs2Buf, 0, len);
        ucs2Ptr.Copy(aUcs2Ptr);
        ucs2Ptr.ZeroTerminate();
        *retPtr = ucs2Buf;
        }
    else
        {
        return KErrNoMemory;
        }
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// StringUtils::ConvertUintToUcs2
// Convert a TUint to UCS2.
// -----------------------------------------------------------------------------
//
TInt StringUtils::ConvertUintToUcs2(TUint aUint, TUint16** retPtr)
    {
    TUint16 buf[10];

    NW_Str_Itoa((TInt) aUint, buf);
    TUint i = User::StringLength(buf);
    TUint16* ret = new TUint16[i + 1];
    if (ret == NULL)
        {
        return KBrsrOutOfMemory;
        }
    Mem::Copy(ret, (void*) buf, (i + 1) * sizeof(TUint16));
    *retPtr = ret;
    return KBrsrSuccess;
    }


// -----------------------------------------------------------------------------
// StringUtils::CopyHBufCZeroTerminateL
// Create HBufC.
// -----------------------------------------------------------------------------
//
HBufC* StringUtils::CopyHBufCZeroTerminateL(const TDesC& aInBuf)
    {
    TPtrC ptr(aInBuf);

    if ((ptr.Length() > 0) && (ptr[ptr.Length() - 1] == '\0'))
        {
        ptr.Set(ptr.Left(ptr.Length() - 1));
        }
    HBufC* buf = HBufC::NewL(ptr.Length() + 1);
    buf->Des().Copy(ptr);
    buf->Des().ZeroTerminate();
    return buf;
    }

// -----------------------------------------------------------------------------
// StringUtils::MakeHBufCLC
// Create HBufC.
// -----------------------------------------------------------------------------
//
HBufC* StringUtils::MakeHBufCLC(const TUint16* aBuffer, TUint aStart, TUint aEnd)
    {

    TPtrC ptr(aBuffer + aStart, aEnd - aStart);
    if (ptr.Length() > 0 && ptr[ptr.Length() - 1] == '\0')
        {
        ptr.Set(ptr.Left(ptr.Length() - 1));
        }

    HBufC* buf = HBufC::NewL(ptr.Length() + 1);
    buf->Des().Copy(ptr);
    buf->Des().ZeroTerminate();
    CleanupStack::PushL(buf);
    return buf;
    }
// -----------------------------------------------------------------------------
// StringUtils::DisplayAvailableMemory
// Show the amount of free memory in the system
// -----------------------------------------------------------------------------
//
void StringUtils::DisplayAvailableMemory()
    {
#ifdef _DEBUG
    RDebug::Print(_L("Available memory"));
#endif
    }

// -----------------------------------------------------------------------------
// StringUtils::ConvertToUcsAndMakeHBufCLC
// Create HBufC.
// -----------------------------------------------------------------------------
//

HBufC* StringUtils::ConvertToUnicodeLC(const TUint8* aBuffer, TUint aStart, TUint aEnd)
    {

    TPtrC8 ptr(aBuffer + aStart, aEnd - aStart);
    if (ptr.Length() > 0 && ptr[ptr.Length() - 1] == '\0')
        {
        ptr.Set(ptr.Left(ptr.Length() - 1));
        }

    HBufC* buf = HBufC::NewL(ptr.Length() + 1);
    buf->Des().Copy(ptr);
    TPtr16 bufDes16 = buf->Des();
    bufDes16.ZeroTerminate();
    CleanupStack::PushL(buf);
    return buf;
    }

// -----------------------------------------------------------------------------
// StringUtils::CopyHBufCZeroTerminateL
// Create HBufC.
// -----------------------------------------------------------------------------
//
HBufC* StringUtils::CopyConvertHBufCZeroTerminateL(const TDesC8& aInBuf)
    {
    TPtrC8 ptr(aInBuf);

    if ((ptr.Length() > 0) && (ptr[ptr.Length() - 1] == '\0'))
        {
        ptr.Set(ptr.Left(ptr.Length() - 1));
        }
    HBufC* buf = HBufC::NewL(ptr.Length() + 1);
    buf->Des().Copy(ptr);
    TPtr16 bufDes16 = buf->Des();
    bufDes16.ZeroTerminate();
    return buf;
    }
// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File