/*

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

*

*

*/

#include "CMMCScBkupIndexJavaData.h"

// User includes

#include "MMMCScBkupArchiveDataInterface.h"

#include "MMCScBkupLogger.h"

    /**

     * Registration Data

     * =================

     * 

     * 

     *  REG DATA for DO 0

     *  {

     *      RD for DO 0, 1st drive

     *      RD for DO 0, 2nd drive

     *      RD for DO 0, 'n'th drive

     *  },

     *  REG DATA for DO 1

     *  {

     *      RD for DO 0, 1st drive

     *      RD for DO 0, 2nd drive

     *      RD for DO 0, 'n'th drive

     *  },

     *  REG DATA for DO n

     *  {

     *      RD for DO 0, 1st drive

     *      RD for DO 0, 2nd drive

     *      RD for DO 0, 'n'th drive

     *  }

     * 

     * Registration Data Index

     * =======================

     * 

     * This is the format of the data written by this object.

     * The format allows the possibility of a future partial

     * restore (hopefully).

     * 

     * 

     *  4 bytes = count of registration data entries

     *

     *  FOR EACH DATA OWNER

     *  {

     *      4 bytes = secure id of data owner's process

     *      4 bytes = the number of different registration data files

     *                for this particular data owner (one for each drive that

     *                was backed up)

     *      ENTRY

     *      {

     *          1 byte = Associated TDriveNumber of the registration data 

     *          8 bytes = offset & length of actual registration data

     *      }

     *  }

     *

     **/

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

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

// CMMCScBkupIndexJavaDataEntry::CMMCScBkupIndexJavaDataEntry()

// 

// C++ constructor.

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

CMMCScBkupIndexJavaDataEntry::CMMCScBkupIndexJavaDataEntry()

    {

    }

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

// CMMCScBkupIndexJavaDataEntry::CMMCScBkupIndexJavaDataEntry()

// 

// C++ destructor.

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

CMMCScBkupIndexJavaDataEntry::~CMMCScBkupIndexJavaDataEntry()

    {

    delete iHash;

    }

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

// CMMCScBkupIndexJavaDataEntry::ConstructL()

// 

// 

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

void CMMCScBkupIndexJavaDataEntry::ConstructL()

    {

    iHash = KNullDesC().AllocL();

    }

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

// CMMCScBkupIndexJavaDataEntry::NewLC()

// 

// 

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

CMMCScBkupIndexJavaDataEntry* CMMCScBkupIndexJavaDataEntry::NewLC()

    {

    CMMCScBkupIndexJavaDataEntry* self = new(ELeave) CMMCScBkupIndexJavaDataEntry();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CMMCScBkupIndexJavaDataEntry::NewLC()

// 

// 

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

CMMCScBkupIndexJavaDataEntry* CMMCScBkupIndexJavaDataEntry::NewLC( RReadStream& aStream )

    {

    CMMCScBkupIndexJavaDataEntry* self = new(ELeave) CMMCScBkupIndexJavaDataEntry();

    CleanupStack::PushL( self );

    aStream >> *self;

    return self;

    }

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

// CMMCScBkupIndexJavaDataEntry::SetHashL()

// 

// 

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

void CMMCScBkupIndexJavaDataEntry::SetHashL( const TDesC& aHash )

    {

    HBufC* hash  = aHash.AllocL();

    delete iHash;

    iHash = hash;

    }

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

// CMMCScBkupIndexJavaDataEntry::InternalizeL()

// 

// 

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

void CMMCScBkupIndexJavaDataEntry::InternalizeL( RReadStream& aStream )

    {

    aStream.ReadInt32L(); // EStreamFormatVersion1 

    aStream.ReadInt32L(); // spare1

    aStream.ReadInt32L(); // spare2

    aStream.ReadInt32L(); // spare3

    //

    HBufC* hash = HBufC::NewL( aStream, KMaxTInt );

    delete iHash;

    iHash = hash;

    //

    aStream >> iMidletInfo;

    aStream >> iMidletDataInfo;

    iDrive = static_cast< TDriveNumber>( aStream.ReadInt8L() );

	//

	__LOG6("CMMCScBkupIndexJavaDataEntry::InternalizeL() - hash: %S, iDrive: %c:, MIDLET[offset: %8d, length: %8d], MIDLETDATA[offset: %8d, length: %8d]", iHash, iDrive + 'A', iMidletInfo.Offset(), iMidletInfo.Length(), iMidletDataInfo.Offset(), iMidletDataInfo.Length() );

    }

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

// CMMCScBkupIndexJavaDataEntry::ExternalizeL()

// 

// 

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

void CMMCScBkupIndexJavaDataEntry::ExternalizeL( RWriteStream& aStream ) const

    {

    aStream.WriteInt32L( EStreamFormatVersion1 );

    aStream.WriteInt32L( 0 ); // spare1

    aStream.WriteInt32L( 0 ); // spare2

    aStream.WriteInt32L( 0 ); // spare3

    //

    aStream << Hash();

    aStream << iMidletInfo;

    aStream << iMidletDataInfo;

    aStream.WriteInt8L( iDrive );

	//

	__LOG6("CMMCScBkupIndexJavaDataEntry::ExternalizeL() - hash: %S, iDrive: %c:, MIDLET[offset: %8d, length: %8d], MIDLETDATA[offset: %8d, length: %8d]", iHash, iDrive + 'A', iMidletInfo.Offset(), iMidletInfo.Length(), iMidletDataInfo.Offset(), iMidletDataInfo.Length() );

	}

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

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

// CMMCScBkupIndexJavaData::CMMCScBkupIndexJavaData()

// 

// C++ constructor.

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

CMMCScBkupIndexJavaData::CMMCScBkupIndexJavaData()

:   CMMCScBkupIndexBase( EMMCScBkupOwnerDataTypeJavaData )

    {

    }

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

// CMMCScBkupIndexJavaData::~CMMCScBkupIndexJavaData()

// 

// C++ destructor.

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

CMMCScBkupIndexJavaData::~CMMCScBkupIndexJavaData()

    {

    iEntries.Close();

    }

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

// CMMCScBkupIndexJavaData::NewLC()

// 

// 

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

CMMCScBkupIndexJavaData* CMMCScBkupIndexJavaData::NewLC()

    {

    CMMCScBkupIndexJavaData* self = new(ELeave) CMMCScBkupIndexJavaData();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CMMCScBkupIndexJavaData::AddIndexRecordL()

// 

// 

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

void CMMCScBkupIndexJavaData::AddIndexRecordL( const TMMCScBkupArchiveVector& aInfo, const TDesC& aHash, TDriveNumber aDrive, TJavaTransferType aType )

    {

    // Check if we already have an entry for this item...

    CMMCScBkupIndexJavaDataEntry* entry = EntryByHash( aHash, aDrive );

    if  ( !entry )

        {

		__LOG1("CMMCScBkupIndexJavaData::AddIndexRecordL() - making new entry for hash: %S", &aHash);

		//

        entry = CMMCScBkupIndexJavaDataEntry::NewLC();

        //

        entry->SetHashL( aHash );

        entry->SetDrive( aDrive );

        iEntries.AppendL( entry );

        //

        CleanupStack::Pop( entry );

        }

	else

		{

		__LOG1("CMMCScBkupIndexJavaData::AddIndexRecordL() - found existing entry for hash: %S", &aHash);

		}

    if  ( aType == EJavaMIDlet )

        {

        entry->SetMidletInfo( aInfo );

        }

    else if ( aType == EJavaMIDletData )

        {

        entry->SetMidletDataInfo( aInfo );

        }

    }

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

// CMMCScBkupIndexJavaData::At()

// 

// 

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

const CMMCScBkupIndexJavaDataEntry& CMMCScBkupIndexJavaData::At( TInt aIndex ) const

    {

    const CMMCScBkupIndexJavaDataEntry* entry = iEntries[ aIndex ];

    return *entry;

    }

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

// CMMCScBkupIndexJavaData::StoreL()

// 

// 

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

void CMMCScBkupIndexJavaData::StoreL(MMMCScBkupDriver& aDriver)

    {

    MMMCScBkupArchiveDataInterface& archiveDataInterface = aDriver.DrvADI();

    RWriteStream stream(archiveDataInterface.ADIWriteStreamUncompressedLC());

    //    

    stream.WriteInt32L( EStreamFormatVersion1 );

    stream.WriteInt32L( 0 ); // spare1

    stream.WriteInt32L( 0 ); // spare2

    stream.WriteInt32L( 0 ); // spare3

    //

    const TInt count = iEntries.Count();

    stream.WriteInt32L(count);

    //

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

        {

        const CMMCScBkupIndexJavaDataEntry* entry = iEntries[i];

        stream << *entry;

        }

    //

    stream.CommitL();

    CleanupStack::PopAndDestroy(); // stream

    // Update our base class info with the offset to the index

    SetVector( archiveDataInterface.ADICurrentArchiveVectorInfo() );

    }

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

// CMMCScBkupIndexJavaData::RestoreL()

// 

// 

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

void CMMCScBkupIndexJavaData::RestoreL(MMMCScBkupDriver& aDriver)

    {

    MMMCScBkupArchiveDataInterface& archiveDataInterface = aDriver.DrvADI();

    RReadStream& stream = archiveDataInterface.ADIReadStreamUncompressedLC( Vector().Offset() );

    //

    stream.ReadInt32L(); // EStreamFormatVersion1 

    stream.ReadInt32L(); // spare1

    stream.ReadInt32L(); // spare2

    stream.ReadInt32L(); // spare3

    //

    const TInt count = stream.ReadInt32L();

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

        {

        CMMCScBkupIndexJavaDataEntry* entry = CMMCScBkupIndexJavaDataEntry::NewLC( stream );

        iEntries.AppendL( entry );

        CleanupStack::Pop( entry );

        }

    //

    CleanupStack::PopAndDestroy(); // stream

    //

    const TMMCScBkupArchiveVector& readInfo = archiveDataInterface.ADICurrentArchiveVectorInfo();

    if  ( readInfo.Length() > Vector().Length() )

        {

        // We've read too much!

        User::Leave( KErrCorrupt );

        }

    }

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

// CMMCScBkupIndexJavaData::EntryByHash()

// 

// 

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

CMMCScBkupIndexJavaDataEntry* CMMCScBkupIndexJavaData::EntryByHash( const TDesC& aHash, TDriveNumber aDrive ) const

    {

    CMMCScBkupIndexJavaDataEntry* ret = NULL;

    const TInt count = iEntries.Count();

    //

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

        {

        CMMCScBkupIndexJavaDataEntry* entry = iEntries[ i ];

        //

        if  ( entry->Hash() == aHash && entry->Drive() == aDrive )

            {

            ret = entry;

            break;

            }

        }

    //

    return ret;

    }