/*

* 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:  

*

*/

#include "ncddbstoragemanager.h"

#include "ncdstoragebase.h"

#include "ncdstoragepanics.pan"

#include "catalogsdebug.h"

#include <f32file.h>

#include <bautils.h>

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

// 

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

//

CNcdDbStorageManager* CNcdDbStorageManager::NewLC(

    RFs& aFs,

    const TDesC& aStorageUid,

    const TDesC& aStorageFolder,

    const TDesC& aStorageName )

    {

    CNcdDbStorageManager* manager = new (ELeave) CNcdDbStorageManager;

    CleanupStack::PushL( manager );

    manager->ConstructL( aFs, aStorageUid, aStorageFolder, aStorageName );

    return manager;

    }

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

// 

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

//

CNcdDbStorageManager::~CNcdDbStorageManager()

    {

    DLTRACEIN(("this-ptr: %X", this));        

    delete iStorage;

    delete iData;

    }

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

// 

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

//

CNcdDbStorageManager::CNcdDbStorageManager() :

    iLocallyOpenCount( 0 ),

    iForceOpen( EFalse )

    {

    DLTRACEIN(( "this-ptr: %X", this ));

    }

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

// 

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

//

void CNcdDbStorageManager::ConstructL( 

    RFs& aFs,

    const TDesC& aStorageUid, 

    const TDesC& aStorageFolder, const TDesC& aStorageName )

    {

    DLTRACEIN((""));    

    iStorage = CNcdStorageBase::NewL( aFs, aStorageUid, aStorageFolder, 

        aStorageName );

    DLTRACE(("CNcdStorageBase created"));

    iStorage->SetListener( this );

    User::LeaveIfError( iStorage->Open() );

    // Create data object

    iData = new (ELeave) CNcdDbStorageManagerData( this );

    DLTRACEOUT( ("") );

    }

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

// 

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

//

MNcdStorageItem* CNcdDbStorageManager::StorageItemL( const TDesC& aUid, 

    TInt aType )

    {

    return (MNcdStorageItem*)iStorage->StorageItemL( aUid, aType );

    }

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

// 

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

//

void CNcdDbStorageManager::StorageItemsL( 

    RPointerArray<MNcdStorageItem>& aItems )

    {

    iStorage->StorageItemsL( aItems );

    }

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

// 

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

//

void CNcdDbStorageManager::RemoveItemsL( 

    const RArray<RNcdDatabaseItems>& aDoNotRemoveItems )

    {

    iStorage->RemoveItemsL( aDoNotRemoveItems );

    }

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

// 

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

//

void CNcdDbStorageManager::Begin()

    {

    iForceOpen = ETrue;

    iData->StorageOpened();

    }

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

// 

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

//

void CNcdDbStorageManager::CommitL()

    {

    DLTRACEIN((""));

    iForceOpen = EFalse;

    iData->StorageClosedL();

    }

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

// 

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

//

void CNcdDbStorageManager::Rollback()

    {

    iForceOpen = EFalse;

    iData->Rollback();

    }

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

// 

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

//

TBool CNcdDbStorageManager::ItemExistsInStorageL( 

    MNcdStorageItem& aStorageItem )

    {

    return ItemExistsInStorageL( aStorageItem.Uid(), aStorageItem.Type() );

    }

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

// 

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

//

TBool CNcdDbStorageManager::ItemExistsInStorageL( const TDesC& aUid, 

    TInt aType )

    {

    return iStorage->ItemExistsInStorageL( aUid, aType );

    }

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

// 

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

//

MNcdDatabaseStorage::TNcdDatabaseSize CNcdDbStorageManager::Size() const

    {

    return iStorage->Size();

    }

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

// Compact

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

//

void CNcdDbStorageManager::Compact() 

    {

    DLTRACEIN((""));

    CommitCachedItems();

    iStorage->Compact();

    }

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

// 

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

//

void CNcdDbStorageManager::CacheOpened()

    {

    DLTRACEIN(("this: %x", this));

    iLocallyOpenCount++;

    iData->StorageOpened();

    }

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

// 

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

//

void CNcdDbStorageManager::CacheReadyL()

    {

    DLTRACEIN(("this: %x", this));

    iLocallyOpenCount--;

    iData->StorageClosedL();

    DLTRACEOUT((""));

    }

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

// 

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

//

TInt CNcdDbStorageManager::CommitCachedItems()

    {

    DLTRACEIN(("this: %x", this));

    iForceOpen = EFalse;

    TInt err = iStorage->Commit();

    if( err == KErrNone )

        {

        iLocallyOpenCount = 0;

        }

    DLTRACEOUT(("err: %d", err));

    return err;

    }

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

// 

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

//

void CNcdDbStorageManager::NotifyRollback()

    {

    iLocallyOpenCount--;

    iData->Rollback();

    }

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

// 

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

//

void CNcdDbStorageManager::RollbackItems()

    {

    iLocallyOpenCount = 0;

    iForceOpen = EFalse;

    iStorage->Rollback();

    }

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

// 

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

//

CNcdDbStorageManager::CNcdDbStorageManagerData::CNcdDbStorageManagerData( 

    CNcdDbStorageManager* aRoot ) :

    iRoot( aRoot ),

    iOpenStorages( 0 )

    {

    }

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

// 

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

//

CNcdDbStorageManager::CNcdDbStorageManagerData::~CNcdDbStorageManagerData()

    {

    }

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

// 

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

//

void CNcdDbStorageManager::CNcdDbStorageManagerData::StorageOpened()

    {

    DLTRACEIN(("this: %x, open storages: %d", this, iOpenStorages + 1 ));

    iOpenStorages++;

    }

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

// 

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

//

void CNcdDbStorageManager::CNcdDbStorageManagerData::StorageClosedL()

    {

    DLTRACEIN(("OpenStorages: %d", iOpenStorages));

    if ( iOpenStorages != 0 ) 

        {

        iOpenStorages--;

        }

    else

        {

        DLTRACE(("All storages were already closed by tried to close one again"));

        }

    if( iOpenStorages == 0 )

        {

        DLTRACE(("Committing cached items"));

        TInt err = iRoot->CommitCachedItems();

        DLINFO(( "Commit error: %d", err ));

        User::LeaveIfError( err );

        }

    DLTRACEOUT((""));

    }

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

// 

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

//

TInt CNcdDbStorageManager::CNcdDbStorageManagerData::OpenStorages()

    {

    DLTRACEIN(( "this: %x, open storages: %d", this, iOpenStorages ));

    return iOpenStorages;

    }

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

// 

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

//

void CNcdDbStorageManager::CNcdDbStorageManagerData::Rollback()

    {

    if( iOpenStorages > 0 )

        {

        iRoot->RollbackItems();

        iOpenStorages = 0;

        }

    }

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

// UID getter

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

//

const TDesC& CNcdDbStorageManager::Uid() const

    {

    return iStorage->Uid();

    }