/*
* Copyright (c) 2005-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: UniHeaders implementation
*
*/



// INCLUDE FILES
#include <msvstore.h>
#include <badesca.h>
#include <msvids.h>
#include <mtmdef.h>
#include <e32def.h>
#include <e32math.h>
#include <mmsvattachmentmanager.h>
#include <cmsvmimeheaders.h>
#include <mmsgenutils.h>
#include "UniHeaders.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS
const TInt KArrayGranularity = 4;
const TUid KUidUniHeaderStream={0x2000B00A}; 

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS ====================


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

// C++ default constructor can NOT contain any code that
// might leave.
//
CUniHeaders::CUniHeaders()
// in a class derived from CBase all member variables are set initially to 0
    {
    }

// Symbian OS default constructor can leave.
void CUniHeaders::ConstructL()
    {
    iToArray = new ( ELeave )CDesCArrayFlat( KArrayGranularity );
    iCcArray = new ( ELeave )CDesCArrayFlat( KArrayGranularity );
    iBccArray = new ( ELeave )CDesCArrayFlat( KArrayGranularity );
    }

// Two-phased constructor.
CUniHeaders* CUniHeaders::NewL()
    {
    CUniHeaders* self = new ( ELeave ) CUniHeaders;
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

    
// Destructor
CUniHeaders::~CUniHeaders()
    {
    delete iToArray;
    delete iCcArray;
    delete iBccArray;
    delete iSubject;
    }

// ---------------------------------------------------------
// CUniHeaders::RestoreL
//
// ---------------------------------------------------------
//

void CUniHeaders::RestoreL(
    CMsvStore& aStore )
    {

    RMsvReadStream stream;
    Reset(); // all old pointers are deleted here
    if ( aStore.IsPresentL( KUidUniHeaderStream ) )
        {
        stream.OpenLC( aStore, KUidUniHeaderStream ); // pushes 'stream' to the stack
        InternalizeL( stream );
        CleanupStack::PopAndDestroy( &stream );     
        }
    } 

// ---------------------------------------------------------
// CUniHeaders::StoreL
//
// ---------------------------------------------------------
//

void CUniHeaders::StoreL(
    CMsvStore& aStore )
    {    
    // caller must commit the store
    RMsvWriteStream stream;
    stream.AssignLC( aStore, KUidUniHeaderStream ); // pushes 'stream' to the stack
    ExternalizeL( stream );
    stream.CommitL();
    stream.Close();
    CleanupStack::PopAndDestroy( &stream );
    }

// ---------------------------------------------------------
// CUniHeaders::TypedAddresseeList
//
// ---------------------------------------------------------
//
const CDesCArray& CUniHeaders::TypedAddresseeList( 
    TMsvRecipientType aType ) 
    {
    if ( aType == EMsvRecipientTo )
        {
        return *iToArray;
        }
    else if ( aType == EMsvRecipientCc )
        {
        return *iCcArray;
        }
    else 
        {
        return *iBccArray;
        }
    }
   
// ---------------------------------------------------------
// CUniHeaders::AddTypedAddresseeL
//
// ---------------------------------------------------------
//
void CUniHeaders::AddTypedAddresseeL( 
    const TDesC&  aRealAddress, 
    TMsvRecipientType aType  )
    {
    if ( aType == EMsvRecipientTo )
        {
        iToArray->AppendL( aRealAddress );
        }
    if ( aType == EMsvRecipientCc )
        {
        iCcArray->AppendL( aRealAddress );
        }
    if ( aType == EMsvRecipientBcc ) 
        {
        iBccArray->AppendL( aRealAddress );
        }
    }

// ---------------------------------------------------------
// CUniHeaders::RemoveAddresseeL
//
// ---------------------------------------------------------
//
TBool CUniHeaders::RemoveAddressee( const TDesC& aRealAddress )
    {

    if ( RemoveAddressee( *iToArray, aRealAddress) )
        {
        return ETrue;
        }
    if ( RemoveAddressee( *iCcArray, aRealAddress) )
        {
        return ETrue;
        }
    if ( RemoveAddressee( *iBccArray, aRealAddress) )
        {
        return ETrue;
        }
      
    return EFalse;

    }

// ---------------------------------------------------------
// CUniHeaders::SetSubjectL
//
// ---------------------------------------------------------
//
void CUniHeaders::SetSubjectL( const TDesC& aSubject )
    {
    HBufC* newAttrib = aSubject.AllocL();
    delete iSubject;
    iSubject = newAttrib;
    }

// ---------------------------------------------------------
// CUniHeaders::Subject
//
// ---------------------------------------------------------
//
TPtrC CUniHeaders::Subject() const
    {
    return iSubject ? TPtrC( *iSubject ) : TPtrC(); 
    }

// ---------------------------------------------------------
// CUniHeaders::InternalizeL
//
// ---------------------------------------------------------
//
void CUniHeaders::InternalizeL( RMsvReadStream& aStream )
    {

    iSubject = HBufC::NewL( aStream, KMaxHeaderStringLength );
    iMessageTypeSetting = aStream.ReadInt32L();
    iMessageTypeLocking = aStream.ReadInt32L();
    iMessageRoot = aStream.ReadInt32L();
    
    // Internalize fields which may have multiple values.
    InternalizeArrayL( *iToArray, aStream ); //lint !e64 !e1514
    InternalizeArrayL( *iCcArray, aStream ); //lint !e64 !e1514
    InternalizeArrayL( *iBccArray, aStream ); //lint !e64 !e1514
    }

// ---------------------------------------------------------
// CUniHeaders::ExternalizeL
//
// ---------------------------------------------------------
//
void CUniHeaders::ExternalizeL( RMsvWriteStream& aStream ) const
    {

    aStream << Subject(); //lint !e1023 !e1703 not ambiguous
    aStream.WriteInt32L( iMessageTypeSetting );
    aStream.WriteInt32L( iMessageTypeLocking );
    aStream.WriteInt32L( iMessageRoot );

    // Externalize fields which may have multiple values.
    ExternalizeArrayL( *iToArray, aStream ); //lint !e64 !e1514
    ExternalizeArrayL( *iCcArray, aStream ); //lint !e64 !e1514
    ExternalizeArrayL( *iBccArray, aStream ); //lint !e64 !e1514
    }

// ---------------------------------------------------------
// CUniHeaders::RemoveAddressee
//
// ---------------------------------------------------------
//
TBool CUniHeaders::RemoveAddressee(
    CDesCArray& aList,
    const TDesC& aAddress )
    {
    
    TInt pos = 0; 

    // Find the match index from a given addressee list
    aList.Find( aAddress, pos );
    if (pos < aList.Count())
        {
        // remove entry from the heap
        aList.Delete( pos );
        aList.Compress();
        return ETrue;
        }
    return EFalse;
    }

// ---------------------------------------------------------
// CUniHeaders::Reset
//
// ---------------------------------------------------------
//
void CUniHeaders::Reset()
    {
    
    iToArray->Reset();
    iCcArray->Reset(); 
    iBccArray->Reset(); 

    delete iSubject;   
    iSubject = NULL;
    }

// ---------------------------------------------------------
// CUniHeaders::Size
//
// ---------------------------------------------------------
//
TInt CUniHeaders::Size() const
    {

    TInt size = 0;

    TInt i = 0;

    TInt nbr = iToArray->MdcaCount();
    for ( i=0; i < nbr; ++i )
        {
        size += iToArray->MdcaPoint(i).Size();
        }

    nbr = iCcArray->MdcaCount();
    for ( i=0; i < nbr; ++i )
        {
        size+=iCcArray->MdcaPoint(i).Size();
        }

    nbr = iBccArray->MdcaCount();
    for ( i=0; i < nbr; ++i )
        {
        size+=iBccArray->MdcaPoint(i).Size();
        }

    size+= Subject().Size();
    size+= 2 * sizeof( TInt32 ); // iMessageTypeSetting, iMessageTypeLocking
    
    return size;
    }

// ---------------------------------------------------------
// CUniHeaders::ExternalizeArrayL
//
// ---------------------------------------------------------
//
void CUniHeaders::ExternalizeArrayL(
    CDesC16Array& anArray,
    RWriteStream& aStream ) const
    {

    TInt count=anArray.Count();
    aStream << TCardinality( count );       // compressed value
    for ( TInt ii = 0; ii < count; ++ii )
        {
        aStream << anArray[ii].Left( Min( anArray[ii].Length(), KMaxHeaderStringLength ) ) ;
        }
    }

// ---------------------------------------------------------
// CUniHeaders::InternalizeArrayL
//
// ---------------------------------------------------------
//
void CUniHeaders::InternalizeArrayL(
    CDesC16Array& anArray,
    RReadStream& aStream )
    {
    TCardinality card;
    aStream >> card;
    TInt count=card;
    anArray.Reset();
    for ( TInt ii = 0; ii < count; ++ii )
        {
        HBufC16* buf=HBufC16::NewLC( aStream,KMaxHeaderStringLength );
        anArray.CArrayFixBase::InsertL( ii,&buf );
        CleanupStack::Pop( buf );
        }
    }

// ================= OTHER EXPORTED FUNCTIONS ==============


//  End of File