/*

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

* class for imps key.

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    "impskey.h"

#include    "impserrors.h"

#include    "impsconst.h"

#ifdef _DEBUG

#include    <f32file.h>

#endif

// CONSTANTS

const TInt KDefaultKeySize = 20;

const TInt KAddRoom        = 20;

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CImpsKey::CImpsKey() :

iBuffer(NULL),

iCount(0)

    {

    }

// Symbian OS default constructor can leave.

void CImpsKey::ConstructL( )

    {

    iBuffer = HBufC16::NewL( KDefaultKeySize ); // Insert room for the elements

    }

// Two-phased constructor.

EXPORT_C CImpsKey* CImpsKey::NewL( )

    {

    CImpsKey* self = new (ELeave) CImpsKey;

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( );

    return self;

    }

// Two-phased constructor.

EXPORT_C CImpsKey* CImpsKey::NewLC( )

    {

    CImpsKey* self = new (ELeave) CImpsKey;

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

// Destructor

EXPORT_C CImpsKey::~CImpsKey()

    {

    delete iBuffer;    

    }

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

// CImpsKey::AddL

// Adds new element value the key

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

//

void CImpsKey::AddL(

    const TInt aElemvalue ,

    enum TImpsKeyType aKeyType)

    {

    if( iBuffer->Length( ) + 2 > iBuffer->Des().MaxLength() )

        {

        iBuffer = iBuffer->ReAllocL( iBuffer->Length( ) + KAddRoom ); // Insert room

        }

    TPtr16 buffer = iBuffer->Des();

    buffer.AppendFill( 0,2 );

    TUint16 val = STATIC_CAST(TUint16,GET_INDEX(aElemvalue));

    if(aKeyType == EImpsKeyTypeIM)

        val &= 0x7FFF; // High bit is zero

    else

        val |= 0x8000; // High bit is one

    buffer[iCount*2] = val;  // Index value

    buffer[iCount*2+1] = STATIC_CAST(TUint16,GET_ENUM(aElemvalue));       // Enum value

    iCount++;

    }

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

// CImpsKey::PopL

// Remove the last item from the key

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

//

void CImpsKey::PopL( TInt aCount )

   {

    if( iCount - aCount < 0 )

        User::Leave( KImpsErrorKeyEmpty );

    TPtr16 buffer = iBuffer->Des( );

    TInt size = buffer.Length( );

    buffer.SetLength( size - 2*aCount );

    iCount -= aCount;

   }

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

// CImpsKey::GetElementL

// Remove the last item from the key

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

//

TInt CImpsKey::GetElementL( 

   const TInt aIndex, TImpsKeyType& aKeyType ) const

   {

    if( aIndex < 0 )

        User::Leave( KImpsErrorKeyIndexInvalid );

    if( iCount == 0 )  

        User::Leave( KImpsErrorKeyEmpty );

    if( aIndex>=iCount )

        User::Leave( KImpsErrorKeyIndexTooLarge );

    TInt highval = (*iBuffer)[aIndex*2];

    if( IS_PRESENCE( highval*0x10000 ) )

        aKeyType = EImpsKeyTypePre;

    else 

        aKeyType = EImpsKeyTypeIM;

    highval &= 0x7FFF; // Leave out the high bit

    TInt ret = STATIC_CAST( TInt, highval * 0x10000 + (*iBuffer)[aIndex*2+1] );

    return ret;

   }

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

// CImpsKey::ReplaceLastL

// Replace last with new key

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

//

void CImpsKey::ReplaceLastL( 

   const TInt aElemvalue, 

   enum TImpsKeyType aKeyType )

   {

    PopL( );

    AddL( aElemvalue, aKeyType );

   }

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

// CImpsKey::Reset

// Reset to empty key

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

//

void CImpsKey::Reset()

   {

    TPtr16 buffer = iBuffer->Des( );

    buffer.SetLength( 0 );

    iCount = 0;

    }

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

// CImpsKey::Compare

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

//

TInt CImpsKey::Compare( MImpsKey& aKey )

   {

   CImpsKey& alien = (CImpsKey&)aKey;

   return (*this==alien);

   }

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

// CImpsKey::Copy

// Copy the key

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

//

CImpsKey* CImpsKey::CopyL( ) const

    {

    CImpsKey* newKey = new (ELeave) CImpsKey;

    CleanupStack::PushL( newKey );

    HBufC16* newString = iBuffer->AllocL( );

    newKey->iBuffer = newString;

    newKey->iCount = iCount;

    CleanupStack::Pop( );

    return newKey;

    }

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

// CImpsKey::CheckKey

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

//

TBool CImpsKey::CheckKey(

    const CImpsKey *aKey,

    TImpsKeyOptions aOptions ) const

    {

    // Find the string from the buffer

    // if the string is not found return EFalse

    TInt index = iBuffer->Find( aKey->iBuffer->Des() );

    if(index == KErrNotFound )

      return EFalse;

    // If aOptions is PARTIALKEY and index is 0 we know that the

    // key matched to the start of the key.

    // If aOptionms is PARTIALKEYLONGER we want the key to little bit more

    // than just the plain key. The key is not wholekey

    // If aOptions is EWholeKey and the index is 0 and also the

    // lengths must be the same then we have macthed whole key

    switch ( aOptions )

        {

        case EPartialKey:

            if( index==0 )

              return ETrue;

            break;

        case EPartialKeyLonger:

            if( index==0 && aKey->Count( ) < Count( ))

              return ETrue;

            break;

        case EWholeKey:

            if( index == 0 && aKey->Count( ) == Count( ) )

              return ETrue;

            break;

        default:

          break;

        }

    return EFalse;

    }

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

// CImpsKey::Size

// Size of the key

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

//

TInt CImpsKey::Size( ) const

    {

    TInt size = sizeof (TInt); // iCount

    size += iBuffer->Size( );

    return size;

    }

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

// CImpsKey::Pack

// Pack the key

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

//

TInt CImpsKey::Pack(

    const TUint8*& aPtrStart ) const

    {

    Mem::Copy( (void*)aPtrStart, &iCount, sizeof( iCount ) );

    aPtrStart = aPtrStart + sizeof( iCount );

    if( iCount )

        {

//        TInt32 tempSize = 0;

/*

        tempSize = iBuffer->Size();

        Mem::Copy( (void*)aPtrStart, &tempSize, sizeof( tempSize) );

        aPtrStart = aPtrStart + sizeof( tempSize );

        if ( iCount )

            {

            Mem::Copy( (void*)aPtrStart, iBuffer->Ptr(), tempSize);

            aPtrStart = aPtrStart + tempSize ;

            }

*/

        //        tempSize = iBuffer->Size();

        //        Mem::Copy( (void*)aPtrStart, &tempSize, sizeof( tempSize) );

        //        aPtrStart = aPtrStart + sizeof( tempSize );

        if ( iCount )

            {

            Mem::Copy( (void*)aPtrStart, iBuffer->Ptr(), iCount*4);

            aPtrStart = aPtrStart + iCount*4 ;

            }

        }

    return KErrNone;

    }

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

// CImpsKey::UnPackL

// Pack the key

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

//

void CImpsKey::UnPackL(

    TUint8*& aPtr )

    {

    Mem::Copy( &iCount, aPtr, sizeof( iCount ) );

    aPtr += sizeof( iCount );

    if( iCount )

        {

        const TUint8* textPtr = aPtr;

//        TInt32 tempSize = 0;

/*

        Mem::Copy( &tempSize, textPtr, sizeof( tempSize) );

        textPtr = textPtr + sizeof( tempSize );

        if ( iCount > 0 )

            {

            delete iBuffer;

            iBuffer = NULL;

            iBuffer = HBufC16::NewL( tempSize );  

            Mem::Copy( (void*)iBuffer->Ptr(), textPtr, tempSize );

            iBuffer->Des().SetLength( tempSize ); 

            textPtr = textPtr + tempSize; 

*/

        //        Mem::Copy( &tempSize, textPtr, sizeof( tempSize) );

        //        textPtr = textPtr + sizeof( tempSize );

        if ( iCount > 0 )

            {

            delete iBuffer;

            iBuffer = NULL;

            iBuffer = HBufC16::NewL( iCount*2 );  

            Mem::Copy( (void*)iBuffer->Ptr(), textPtr, iCount*4 );

            iBuffer->Des().SetLength( iCount*2 ); 

            textPtr = textPtr + iCount*4; 

            }

        if ( iCount < 0 )

            {

            User::Leave( KErrCorrupt );

            }

        aPtr = (TUint8*) textPtr;

        }

    }

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

// CImpsKey::Destroy

// Destroy the key

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

//

void CImpsKey::Destroy()

    {

    delete this;

    }

#ifdef _DEBUG

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

// CImpsKey::DumpToFileL

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

//

void CImpsKey::DumpToFileL( RFile& aFile ) const

    {

    _LIT8( KImpsKeyDumpBegin, "      ImpsKey dump begin\r\n");

    aFile.Write( KImpsKeyDumpBegin );

    TInt count = iCount;

    TBuf8<256> message; 

    _LIT8(KCount,"        Impskey number of elements = %d\r\n");

    _LIT8(KElement,"       Impskey element %d\r\n");

    _LIT8(KElementIndex,"       Impskey element index %d\r\n");

    _LIT8(KElementEnum,"       Impskey element enum %x\r\n");

    message.Format( KCount, count );

    aFile.Write( message );

    for( TInt k = 0; k< count; k++ )

        {

          TImpsKeyType keyType;

          TInt elem = GetElementL( k, keyType );

          message.Format( KElement, k );

          aFile.Write( message );

          if( keyType == EImpsKeyTypeIM )

              {

              _LIT8( KImpsKeyTypeIM, "      ImpsKey type = EImpsKeyTypeIM\r\n");

              aFile.Write( KImpsKeyTypeIM );

              }

         else

              {

              _LIT8( KImpsKeyTypePresence, "      ImpsKey type = EImpsKeyTypePre\r\n");

              aFile.Write( KImpsKeyTypePresence );

              }

          message.Format( KElementIndex, GET_INDEX(elem) );

          aFile.Write( message );

          message.Format( KElementEnum, GET_ENUM(elem) );

          aFile.Write( message );

        }

    _LIT8( KImpsKeyDumpEnd, "      ImpsKey dump end\r\n");

    aFile.Write( KImpsKeyDumpEnd );

    }

#endif

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

// CImpsKey::SetElementIndex

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

//

void CImpsKey::SetElementIndex( TInt aCount, TInt aNewIndex )

    {

    if( iCount == 0 )  

        return;

    if( aCount < 0 )

        return;

    if( aCount >= iCount )

        return;

    TInt highval = (*iBuffer)[aCount*2];

    TUint16 val = STATIC_CAST(TUint16,aNewIndex );

    if( IS_PRESENCE( highval*0x10000 ) )

        val |= 0x8000;

    else 

        val &= 0x7FFF;

    TPtr16 buffer = iBuffer->Des();

    buffer[aCount*2] = val;  // Index value

    }

//  End of File