/*
* Copyright (c) 2007-2008 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 <e32std.h>

#include "hnconvutils.h"
#include "hnglobals.h"

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


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC* HnConvUtils::Str8ToStr( const TDesC8& aStr )
    {
    HBufC* ret = HBufC::New( aStr.Length() );
    if (ret)
    	{
    	TPtr dest( ret->Des() );
    	CnvUtfConverter::ConvertToUnicodeFromUtf8( dest, aStr );
    	}
    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC* HnConvUtils::Str8ToStrLC( const TDesC8& aStr )
    {
    HBufC* ret = HBufC::NewLC( aStr.Length() );
    TPtr dest( ret->Des() );
    CnvUtfConverter::ConvertToUnicodeFromUtf8( dest, aStr );
    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* HnConvUtils::StrToStr8LC( const TDesC16& aStr )
    {
    TInt length = aStr.Length();
    HBufC8* ret = HBufC8::NewL( length );
    TPtr8 dest( ret->Des() );
    TInt num = CnvUtfConverter::ConvertFromUnicodeToUtf8( dest, aStr );
    while( num != 0 )
    	{
    	delete ret;
    	length += num;
    	ret = HBufC8::NewL( length );
    	dest.Set( ret->Des() );
    	num = CnvUtfConverter::ConvertFromUnicodeToUtf8( dest, aStr );
    	}
    CleanupStack::PushL(ret);
    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* HnConvUtils::StrToStr8L( const TDesC16& aStr )
    {
    HBufC8* buf = HnConvUtils::StrToStr8LC( aStr );
    CleanupStack::Pop( buf );
    return buf;
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* HnConvUtils::NumToStr8LC( const TInt& aNum )
    {
    HBufC8* ret = HBufC8::NewLC( KMaxLength );
    ret->Des().AppendNum( aNum );
    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TInt HnConvUtils::Str8ToInt( const TDesC8& aValue, TInt& aResult )
    {
    // if a string starts from '0x' then convert aStr from hex to int.
    // else send aStr to the StrDec2Uint    
    TInt err( KErrNotFound );
    TInt position( aValue.Find( KHexStart8 ) );
    
    TLex8 lexer( aValue );
    if ( position == 0 )
        {
        // is hex, it it can only unsinged
        lexer.SkipAndMark( KHexStart8().Length() );
        TUint tmp;
        err = lexer.Val( tmp, EHex );
        aResult = tmp;
        }
    else
        {
        err = lexer.Val( aResult );
        }
    return err;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TInt HnConvUtils::StrToInt( const TDesC& aValue, TInt& aResult )
    {
    TInt err( KErrNotFound );
    RBuf8 buf;
    err = buf.Create( aValue.Length() );
    if ( KErrNone == err )
        {
        buf.Copy( aValue );
        err = HnConvUtils::Str8ToInt( buf, aResult );
        }
    buf.Close();
    return err;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TInt HnConvUtils::Str8ToInt( const TDesC8& aValue, TInt32& aResult )
    {
    // if a string starts from '0x' then convert aStr from hex to int.
    // else send aStr to the StrDec2Uint    
    TInt err( KErrNotFound );
    TInt position( aValue.Find( KHexStart8 ) );
    
    TLex8 lexer( aValue );
    if ( position == 0 )
        {
        // is hex, it it can only unsinged
        TUint32 tmp;
        lexer.SkipAndMark( KHexStart8().Length() );
        err = lexer.Val( tmp, EHex );
        aResult = tmp;
        }
    else
        {
        err = lexer.Val( aResult );
        }
    return err;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TInt  HnConvUtils::StrToInt( const TDesC& aValue, TInt32& aResult )
    {
    TInt err( KErrNotFound );
    RBuf8 buf; 
    err = buf.Create( aValue.Length() );
    if ( KErrNone == err )
        {
        buf.Copy( aValue );
        err = HnConvUtils::Str8ToInt( buf, aResult );
        }
    buf.Close();
    return err;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TInt HnConvUtils::Str8ToUint( const TDesC8& aValue, TUint& aResult )
    {
    // if a string starts from '0x' then convert aStr from hex to int.
    // else send aStr to the StrDec2Uint    
    TInt err( KErrNotFound );
    TInt position( aValue.Find( KHexStart8 ) );
    
    TLex8 lexer( aValue );
    if ( position == 0 )
        {
        // is hex
        lexer.SkipAndMark( KHexStart8().Length() );
        err = lexer.Val( aResult, EHex );
        }
    else
        {
        err = lexer.Val( aResult );
        }
    return err;
    }