/*

* 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 "ncdstoragebase.h"

#include <s32buf.h>

#include "ncddatabasestorageimpl.h"

#include "ncdstoragedataitem.h"

#include "ncdstoragepanics.pan"

#include "catalogsutils.h"

#include "catalogsdebug.h"

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

// 

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

//

CNcdStorageBase::~CNcdStorageBase()

    {

    DLTRACEIN(( "" ));

    delete iUid;

    delete iStorageFolder;

    delete iName;

    iOpenItems.Reset();

    iRemovedItems.Reset();

    iItems.ResetAndDestroy();

    }

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

// 

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

//

CNcdStorageBase::CNcdStorageBase( HBufC* aUid, HBufC* aStorageFolder, 

        HBufC* aName ) :

    iUid( aUid ),

    iStorageFolder( aStorageFolder ),

    iName( aName ),

    iOpen( EFalse ),

    iListener( NULL )

    {

    }

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

// 

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

//

CNcdStorageBase* CNcdStorageBase::NewL(

    RFs& aFs,

    const TDesC& aUid,

    const TDesC& aStorageFolder,

    const TDesC& aStorageName )

    {

    DLTRACE( ( _L("Path: %S"), &aStorageFolder ) );

    CNcdStorageBase* storage = 

        storage = CNcdDatabaseStorage::NewL( 

            aFs, aUid, aStorageFolder, 

            aStorageName ); 

    return storage;

    }

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

// 

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

//

const TDesC& CNcdStorageBase::Uid() const

    {

    DASSERT( iUid );

    DLTRACE( ( _L("Uid: %S"), iUid ) );

    return *iUid;

    }

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

// 

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

//

const TDesC& CNcdStorageBase::StorageFolder() const

    {

    DASSERT( iStorageFolder );

    return *iStorageFolder;

    }

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

// 

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

//

const TDesC& CNcdStorageBase::Name() const

    {

    DASSERT( iName );

    return *iName;

    }

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

// 

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

//

TInt CNcdStorageBase::Open()

    {

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

    if( IsOpen() )

        {

        User::Panic( KNcdStoragePanic, ENcdStoragePanicAlreadyOpen );

        }

    TRAPD( err, DoOpenL() );

    if( err == KErrNone )

        {

        iOpen = ETrue;

        }

    return err;

    }

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

// 

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

//

void CNcdStorageBase::Close()

    {

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

    if( IsOpen() )

        {

        DoClose();

        iOpen = EFalse;

        }

    }

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

// 

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

//

TBool CNcdStorageBase::IsOpen() const

    {

    return iOpen;

    }

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

// 

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

//

CNcdStorageItem* CNcdStorageBase::StorageItemL( const TDesC& aUid, TInt aType )

    {

    DLTRACEIN( (_L("aUid: %S, aType: %d"), &aUid, aType ) );

    DPROFILING_BEGIN( x );

    CNcdStorageItem* item = FindStorageItem( aUid, aType );

    if ( !item )

        {

        TRAPD( err,

            {

            // Create item

            item = CreateStorageItemLC( aUid, aType );            

            // Store item to array

            iItems.InsertInAddressOrderL( item );

            DLTRACE(("Items: %d", iItems.Count() ));

            CleanupStack::Pop( item );

            });

        if( err == KErrNone )

            {

            iListener->CacheOpened();

            TRAP( err, iListener->CacheReadyL() );

            }

        if( err != KErrNone )

            {

            if( !ItemsOpen() )

                {

                DoRollback();

                }

            User::Leave( err );

            }

        }

    DPROFILING_END( x );

    DLTRACEOUT((""));

    return item;

    }

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

// 

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

//

void CNcdStorageBase::StorageItemsL( RPointerArray<MNcdStorageItem>& aItems )

    {

    RPointerArray<CNcdStorageItemIdentifier> items;

    CleanupResetAndDestroyPushL( items );

    // Get storage item identifiers from storage

    GetAllItemsFromStorageL( items );

    // Get storage items

    TInt count = items.Count();

    aItems.ReserveL( aItems.Count() + count );

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

        {

        aItems.AppendL( StorageItemL( items[i]->Id(), items[i]->Type() ) );

        }

    CleanupStack::PopAndDestroy( &items );    

    }

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

// 

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

//

void CNcdStorageBase::RemoveItemsL( 

    const RArray<RNcdDatabaseItems>& aDoNotRemoveItems )

    {

    DLTRACEIN((""));

    DoRemoveItemsL( aDoNotRemoveItems );

    // reset arrays so that removed items are not left hanging aroung

    iOpenItems.Reset();

    iRemovedItems.Reset();

    iItems.ResetAndDestroy();

    }

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

// 

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

//

void CNcdStorageBase::OpenItemL( CNcdStorageItem* aItem )

    {

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

    iOpenItems.ReserveL( iOpenItems.Count() + 1 );

    DoOpenItemL( aItem );

    // Same item can't be opened multiple times (CNcdStorageItem::OpenL)

    // so we don't have to worry about adding it many times to the open item

    // array. Also we can't run out of memory because we already reserved 

    // memory for the item so we can ignore the error

    iOpenItems.InsertInAddressOrder( aItem );

    if( iListener && iOpenItems.Count() == 1 )

        {

        iListener->CacheOpened();

        }

    }

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

// 

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

//

void CNcdStorageBase::SaveItemL( CNcdStorageItem* aItem )

    {

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

    TInt index = iOpenItems.FindInAddressOrder( aItem );

    if( index < 0 )

        {

        User::Panic( KNcdStoragePanic, ENcdStoragePanicItemNotOpen );

        }

    iOpenItems.Remove( index );

    if( iListener && iOpenItems.Count() == 0 )

        {

        iListener->CacheReadyL();

        }

    }

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

// 

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

//

void CNcdStorageBase::RollbackItems()

    {

    DLTRACEIN((""));

    Rollback();

    iListener->NotifyRollback();

    }

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

// 

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

//

TInt CNcdStorageBase::Commit()

    {

    DLTRACEIN((""));

    TInt err = DoCommit();

    if( err == KErrNone )

        {

        TInt count = iRemovedItems.Count();

        TInt index = 0;

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

            {

            index = iItems.FindInAddressOrder( iRemovedItems[i] );

            if( index >= 0 )

                {

                iItems.Remove( index );

                }

            DLTRACE(("Items: %d", iItems.Count() ));

            delete iRemovedItems[i];

            iRemovedItems[i] = NULL;

            }

        }

    iRemovedItems.Reset();    

    return err;

    }

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

// 

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

//

void CNcdStorageBase::RemoveItemL( CNcdStorageItem* aItem )

    {

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

    TInt insertError( iRemovedItems.InsertInAddressOrder( aItem ) );

    if ( insertError == KErrAlreadyExists )

        {

        DLINFO(("Remove item was already in the array."));

        return;

        }

    User::LeaveIfError( insertError );

    TRAPD( err, DoRemoveItemL( aItem ) );

    if( err != KErrNone )

        {

        TInt index = iRemovedItems.FindInAddressOrder( aItem );

        if( index >= 0 )

            {

            iRemovedItems.Remove( index );

            }

        DLERROR(("Error: %d occurred when removing", err));

        User::Leave( err );

        }

    }

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

// 

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

//

void CNcdStorageBase::Rollback()

    {

    DoRollback();

    TInt count = iOpenItems.Count();

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

        {

        iOpenItems[i]->SetOpen( EFalse );

        }

    iOpenItems.Reset();

    iRemovedItems.Reset();

    }

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

// 

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

//

void CNcdStorageBase::ReadDataL( CNcdStorageItem* aItem, 

    MNcdStorageDataItem& aDataItem )

    {

    DoReadDataL( aItem, aDataItem );

    }

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

// 

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

//

void CNcdStorageBase::WriteDataL( CNcdStorageItem* aItem, 

    MNcdStorageDataItem& aDataItem )

    {

    DoWriteDataL( aItem, aDataItem );

    }

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

// 

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

//

TBool CNcdStorageBase::ItemsOpen() const

    {

    DLTRACEIN(("this: %x, items open: %d", this, iOpenItems.Count() ));

    return ( iOpenItems.Count() > 0 );

    }

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

// 

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

//

HBufC8* CNcdStorageBase::GetDataL( CNcdStorageItem* aItem )

    {

    return DoGetDataL( aItem );

    }

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

// 

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

//

CNcdStorageItem* CNcdStorageBase::FindStorageItem( const TDesC& aUid, 

    TInt aType )

    {

    TInt count = iItems.Count();

    CNcdStorageItem* item = NULL;

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

        {

        item = iItems[i];

        if( item->Type() == aType && 

            item->Uid().Compare( aUid ) == 0 )

            {

            return item;

            }

        }    

    return NULL;

    }

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

// 

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

//

void CNcdStorageBase::SetListener( CNcdStorageBaseListener* aListener )

    {

    iListener = aListener;

    }

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

// 

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

//

TBool CNcdStorageBase::ItemExistsInStorageL( const TDesC& aUid, TInt aType )

    {

    return ItemExistsL( aUid, aType );

    }

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

// 

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

//

HBufC8* CNcdStorageBase::GetAllDataLC( RReadStream& aStream )

    {

    MStreamBuf* streamBuf = aStream.Source();

    TInt size = streamBuf->SizeL();

    HBufC8* dataBuffer = HBufC8::NewLC( size );

    TPtr8 data = dataBuffer->Des();

    aStream.ReadL( data, size );

    return dataBuffer;

    }

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

// 

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

//

HBufC8* CNcdStorageBase::GetAllDataL( RReadStream& aStream )

    {

    HBufC8* dataBuffer = GetAllDataLC( aStream );

    CleanupStack::Pop( dataBuffer );    

    return dataBuffer;

    }

// ********************************

//         CNcdStorageItem

// ********************************

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

// 

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

//

CNcdStorageItem* CNcdStorageItem::NewL( CNcdStorageBase* aStorage, 

    const TDesC& aUid, TInt aType )

    {

    CNcdStorageItem* item = new (ELeave) CNcdStorageItem( aStorage );

    CleanupStack::PushL( item );

    item->ConstructL( aUid, aType );

    CleanupStack::Pop( item );

    return item;

    }