/*

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

*

*

*/

#include "CMMCScBkupDriveDataSizeManager.h"

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

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

// CMMCScBkupDriveSizer::CMMCScBkupDriveSizer()

// 

// C++ constructor.

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

CMMCScBkupDriveSizer::CMMCScBkupDriveSizer( TMMCScBkupOwnerDataType aType )

:   iDataType( aType )

    {

    }

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

// CMMCScBkupDriveSizer::~CMMCScBkupDriveSizer()

// 

// Destructor.

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

CMMCScBkupDriveSizer::~CMMCScBkupDriveSizer()

    {

    iEntries.Close();

    }

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

// CMMCScBkupDriveSizer::ConstructL()

// 

// 

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

void CMMCScBkupDriveSizer::ConstructL()

    {

    }

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

// CMMCScBkupDriveSizer::NewLC()

// 

// 

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

CMMCScBkupDriveSizer* CMMCScBkupDriveSizer::NewLC( TMMCScBkupOwnerDataType aType )

    {

    CMMCScBkupDriveSizer* self = new(ELeave) CMMCScBkupDriveSizer( aType );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CMMCScBkupDriveSizer::NewLC()

// 

// 

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

CMMCScBkupDriveSizer* CMMCScBkupDriveSizer::NewLC( RReadStream& aStream )

    {

    CMMCScBkupDriveSizer* self = new(ELeave) CMMCScBkupDriveSizer( EMMCScBkupOwnerDataTypeAny );

    CleanupStack::PushL(self);

    aStream >> *self;

    return self;

    }

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

// CMMCScBkupDriveSizer::AddToSizeL()

// 

// 

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

void CMMCScBkupDriveSizer::AddToSizeL( TInt64 aAmount, TDriveNumber aDrive )

    {

    TMMCScBkupDriveAndSize* entry = EntryByDrive( aDrive );

    //

    if  ( entry == NULL )

        {

        if  ( aAmount > 0 )

            {

            TMMCScBkupDriveAndSize newEntry( aDrive, aAmount );

            iEntries.AppendL( newEntry );

            }

        }

    else

        {

        entry->AddToSize( aAmount );

        }

    }

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

// CMMCScBkupDriveSizer::Reset()

// 

// 

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

void CMMCScBkupDriveSizer::Reset()

    {

    const TInt count = iEntries.Count();

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

        {

        TMMCScBkupDriveAndSize& entry = iEntries[ i ];

        entry.SetSize( 0 );

        }

    }

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

// CMMCScBkupDriveSizer::Reset()

// 

// 

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

void CMMCScBkupDriveSizer::Reset( TDriveNumber aDrive )

    {

    TMMCScBkupDriveAndSize* entry = EntryByDrive( aDrive );

    //

    if  ( entry != NULL )

        {

        entry->SetSize( 0 );

        }

    }

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

// CMMCScBkupDriveSizer::Size()

// 

// 

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

TInt64 CMMCScBkupDriveSizer::Size() const

    {

    TInt64 size = 0;

    //

    const TInt count = iEntries.Count();

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

        {

        const TMMCScBkupDriveAndSize& entry = iEntries[ i ];

        size += entry.Size();

        }

    //

    return size;

    }

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

// CMMCScBkupDriveSizer::Size()

// 

// 

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

TInt64 CMMCScBkupDriveSizer::Size( TDriveNumber aDrive ) const

    {

    TInt64 size = 0;

    TMMCScBkupDriveAndSize* entry = const_cast< CMMCScBkupDriveSizer* >( this )->EntryByDrive( aDrive );

    //

    if  ( entry != NULL )

        {

        size = entry->Size();

        }

    //

    return size;

    }

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

// CMMCScBkupDriveSizer::InternalizeL()

// 

// 

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

void CMMCScBkupDriveSizer::InternalizeL(RReadStream& aStream)

    {

    aStream.ReadInt32L(); // EStreamFormatVersion1 

    aStream.ReadInt32L(); // spare1

    aStream.ReadInt32L(); // spare2

    //

    iDataType = static_cast< TMMCScBkupOwnerDataType >( aStream.ReadInt8L() );

    const TInt count = aStream.ReadInt8L();

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

        {

        TMMCScBkupDriveAndSize entry;

        aStream >> entry;

        iEntries.AppendL( entry );

        }

    }

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

// CMMCScBkupDriveSizer::ExternalizeL()

// 

// 

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

void CMMCScBkupDriveSizer::ExternalizeL(RWriteStream& aStream) const

    {

    aStream.WriteInt32L( EStreamFormatVersion1 );

    aStream.WriteInt32L( 0 ); // spare1

    aStream.WriteInt32L( 0 ); // spare2

    //

    aStream.WriteInt8L( iDataType );

    // Work out how many non-zero entries we need to write.

    TInt i = 0;

    const TInt count = iEntries.Count();

    TInt numberOfExternalisedEntries = 0;

    //    

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

        {

        const TMMCScBkupDriveAndSize& entry = iEntries[ i ];

        if  ( entry.Size() > 0 )

            {

            ++numberOfExternalisedEntries;

            }

        }

    // Now really write the entries...

    aStream.WriteInt8L( numberOfExternalisedEntries );

    if  ( numberOfExternalisedEntries > 0 )

        {

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

            {

            const TMMCScBkupDriveAndSize& entry = iEntries[ i ];

            if  ( entry.Size() > 0 )

                {

                aStream << entry;

                }

            }

        }

    }

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

// CMMCScBkupDriveSizer::EntryByDrive()

// 

// 

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

TMMCScBkupDriveAndSize* CMMCScBkupDriveSizer::EntryByDrive( TDriveNumber aDrive )

    {

    TMMCScBkupDriveAndSize* ret = NULL;

    //

    const TInt count = iEntries.Count();

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

        {

        TMMCScBkupDriveAndSize& entry = iEntries[ i ];

        //

        if  ( entry.Drive() == aDrive )

            {

            ret = &entry;

            break;

            }

        }

    //

    return ret;

    }

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

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

// CMMCScBkupDataTypeSizer::CMMCScBkupDataTypeSizer()

// 

// C++ constructor.

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

CMMCScBkupDataTypeSizer::CMMCScBkupDataTypeSizer()

    {

    }

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

// CMMCScBkupDataTypeSizer::~CMMCScBkupDataTypeSizer()

// 

// Destructor.

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

CMMCScBkupDataTypeSizer::~CMMCScBkupDataTypeSizer()

    {

    iSizers.Close();

    }

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

// CMMCScBkupDataTypeSizer::ConstructL()

// 

// 

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

void CMMCScBkupDataTypeSizer::ConstructL()

    {

    iSizers.AppendL( CMMCScBkupDriveSizer::NewLC( EMMCScBkupOwnerDataTypeDataOwner ) );

    CleanupStack::Pop(); // sizer

    iSizers.AppendL( CMMCScBkupDriveSizer::NewLC( EMMCScBkupOwnerDataTypeJavaData ) );

    CleanupStack::Pop(); // sizer

    iSizers.AppendL( CMMCScBkupDriveSizer::NewLC( EMMCScBkupOwnerDataTypePublicData ) );

    CleanupStack::Pop(); // sizer

    iSizers.AppendL( CMMCScBkupDriveSizer::NewLC( EMMCScBkupOwnerDataTypeSystemData ) );

    CleanupStack::Pop(); // sizer

    iSizers.AppendL( CMMCScBkupDriveSizer::NewLC( EMMCScBkupOwnerDataTypeActiveData ) );

    CleanupStack::Pop(); // sizer

    iSizers.AppendL( CMMCScBkupDriveSizer::NewLC( EMMCScBkupOwnerDataTypePassiveData ) );

    CleanupStack::Pop(); // sizer

    }

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

// CMMCScBkupDataTypeSizer::NewL()

// 

// 

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

CMMCScBkupDataTypeSizer* CMMCScBkupDataTypeSizer::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMMCScBkupDataTypeSizer::NewLC()

// 

// 

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

CMMCScBkupDataTypeSizer* CMMCScBkupDataTypeSizer::NewLC( RReadStream& aStream )

    {

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

    CleanupStack::PushL(self);

    aStream >> *self;

    return self;

    }

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

// CMMCScBkupDataTypeSizer::AddToSizeL()

// 

// 

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

void CMMCScBkupDataTypeSizer::AddToSizeL( TMMCScBkupOwnerDataType aDataType, TInt64 aAmount, TDriveNumber aDrive )

    {

    CMMCScBkupDriveSizer* sizer = SizerByDataType( aDataType );

    ASSERT( sizer != NULL );

    sizer->AddToSizeL( aAmount, aDrive );

    }

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

// CMMCScBkupDataTypeSizer::Reset()

// 

// 

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

void CMMCScBkupDataTypeSizer::Reset( TMMCScBkupOwnerDataType aDataType )

    {

    CMMCScBkupDriveSizer* sizer = SizerByDataType( aDataType );

    ASSERT( sizer != NULL );

    sizer->Reset();

    }

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

// CMMCScBkupDataTypeSizer::Reset()

// 

// 

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

void CMMCScBkupDataTypeSizer::Reset( TMMCScBkupOwnerDataType aDataType, TDriveNumber aDrive )

    {

    CMMCScBkupDriveSizer* sizer = SizerByDataType( aDataType );

    ASSERT( sizer != NULL );

    sizer->Reset( aDrive );

    }

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

// CMMCScBkupDataTypeSizer::Size()

// 

// 

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

TInt64 CMMCScBkupDataTypeSizer::Size( TMMCScBkupOwnerDataType aDataType ) const

    {

    CMMCScBkupDriveSizer* sizer = const_cast< CMMCScBkupDataTypeSizer* >( this )->SizerByDataType( aDataType );

    ASSERT( sizer != NULL );

    const TInt64 size = sizer->Size();

    return size;

    }

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

// CMMCScBkupDataTypeSizer::Size()

// 

// 

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

TInt64 CMMCScBkupDataTypeSizer::Size( TMMCScBkupOwnerDataType aDataType, TDriveNumber aDrive ) const

    {

    CMMCScBkupDriveSizer* sizer = const_cast< CMMCScBkupDataTypeSizer* >( this )->SizerByDataType( aDataType );

    ASSERT( sizer != NULL );

    const TInt64 size = sizer->Size( aDrive );

    return size;

    }

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

// CMMCScBkupDataTypeSizer::GetSizesL()

// 

// 

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

void CMMCScBkupDataTypeSizer::GetSizesL( RArray<TMMCScBkupDriveAndSize>& aSizes ) const

    {

    CleanupClosePushL( aSizes );

    aSizes.Reset();

    //

    for( TInt d = EDriveA; d<=EDriveZ; d++ )

        {

        // Get the size of each data type for this drive.

        const TDriveNumber drive = static_cast< TDriveNumber >( d );

        TMMCScBkupDriveAndSize driveAndSize( drive, 0 );

        const TInt count = iSizers.Count();

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

            {

            const CMMCScBkupDriveSizer* sizer = iSizers[ i ];

            const TInt sizeOfDataForDrive = sizer->Size( drive );

            //

            driveAndSize.AddToSize( sizeOfDataForDrive );

            }

        // Add the entry if the size is more than 0

        if  ( driveAndSize.Size() > 0 )

            {

            aSizes.AppendL( driveAndSize );

            }

        }

    CleanupStack::Pop( &aSizes );

    }

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

// CMMCScBkupDataTypeSizer::CombinedSize()

// 

// 

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

TInt64 CMMCScBkupDataTypeSizer::CombinedSize( TDriveNumber aDrive ) const

    {

    TInt64 size = 0;

    //

    const TInt count = iSizers.Count();

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

        {

        const CMMCScBkupDriveSizer* sizer = iSizers[ i ];

        size += sizer->Size( aDrive );

        }

    //

    return size;

    }

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

// CMMCScBkupDataTypeSizer::InternalizeL()

// 

// 

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

void CMMCScBkupDataTypeSizer::InternalizeL(RReadStream& aStream)

    {

    aStream.ReadInt32L(); // EStreamFormatVersion1 

    aStream.ReadInt32L(); // spare1

    aStream.ReadInt32L(); // spare2

    //

    const TInt count = aStream.ReadInt8L();

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

        {

        CMMCScBkupDriveSizer* sizer = CMMCScBkupDriveSizer::NewLC( aStream );

        iSizers.AppendL( sizer );

        CleanupStack::Pop( sizer );

        }

    }

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

// CMMCScBkupDataTypeSizer::ExternalizeL()