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


#ifndef MCSTORAGE_H
#define MCSTORAGE_H


#include <e32base.h>
#include <bamdesca.h>
#include "ncddatabasestorage.h"
#include "ncdstorageitem.h"

class CNcdStorageItem;
class MNcdStorageDataItem;
class CNcdStorageBaseListener;
class CNcdStorageItemIdentifier;



class CNcdStorageBase : public CBase
{

    public:


         virtual ~CNcdStorageBase();


    public:

        /**
        * @note Only ENcdStorageTypeDatabase is currently supported
        */
         static CNcdStorageBase* NewL(
            RFs& aFs,
            const TDesC& aUid,
            const TDesC& aStorageFolder,
            const TDesC& aStorageName );


    public:


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

         void StorageItemsL( RPointerArray<MNcdStorageItem>& aItems );


        void RemoveItemsL( 
            const RArray<RNcdDatabaseItems>& aDoNotRemoveItems );

         void OpenItemL( CNcdStorageItem* aItem );

         void SaveItemL( CNcdStorageItem* aItem );

         void RemoveItemL( CNcdStorageItem* aItem );

         void ReadDataL( CNcdStorageItem* aItem, MNcdStorageDataItem& aDataItem );

         void WriteDataL( CNcdStorageItem* aItem, MNcdStorageDataItem& aDataItem );

         TBool ItemsOpen() const;

         HBufC8* GetDataL( CNcdStorageItem* aItem );


         TInt Commit();

         void RollbackItems();


    public:


         TInt Open();

         void Close();

         TBool IsOpen() const;

         const TDesC& Uid() const;

         const TDesC& StorageFolder() const;

         const TDesC& Name() const;

         void SetListener( CNcdStorageBaseListener* aListener );

         void Rollback();

         TBool ItemExistsInStorageL( const TDesC& aUid, TInt aType );


         virtual void Compact() = 0;
    public:


        virtual RDbDatabase::TSize Size() const = 0;

        
    protected:


         CNcdStorageBase( HBufC* aUid, HBufC* aStorageFolder, HBufC* aName );


    protected:

         CNcdStorageItem* FindStorageItem( const TDesC& aUid, TInt aType );


    protected:

        virtual CNcdStorageItem* CreateStorageItemLC( const TDesC& aUid, TInt aType ) = 0;

        virtual TBool ItemExistsL( const TDesC& aUid, TInt aType ) = 0; 

        virtual void DoOpenItemL( CNcdStorageItem* aItem ) = 0;

        virtual void DoRollback() = 0;

        virtual void DoRemoveItemL( CNcdStorageItem* aItem ) = 0;

        virtual void DoReadDataL( CNcdStorageItem* aItem, MNcdStorageDataItem& aDataItem ) = 0;

        virtual void DoWriteDataL( CNcdStorageItem* aItem, MNcdStorageDataItem& aDataItem ) = 0;

        virtual TInt DoCommit() = 0;

        virtual void GetAllItemsFromStorageL( RPointerArray<CNcdStorageItemIdentifier>& aItems ) = 0;

        virtual HBufC8* DoGetDataL( CNcdStorageItem* aItem ) = 0;
        
        virtual void DoRemoveItemsL( 
            const RArray<RNcdDatabaseItems>& aDoNotRemoveItems ) = 0;


    protected:

        virtual void DoOpenL() = 0;

        virtual void DoClose() = 0;


    protected:

         HBufC8* GetAllDataL( RReadStream& aStream );
        
        
         HBufC8* GetAllDataLC( RReadStream& aStream );


    protected:



        HBufC*                              iUid;

        HBufC*                              iStorageFolder;

        HBufC*                              iName;

        TBool                               iOpen;


    private:

        RPointerArray<CNcdStorageItem>       iItems;

        RPointerArray<CNcdStorageItem>       iOpenItems;

        RPointerArray<CNcdStorageItem>       iRemovedItems;

        CNcdStorageBaseListener*             iListener;
};


class CNcdStorageItem : public CBase, public MNcdStorageItem
    {

    public:

        /**
        * @note Uids must be unique in a type
        */
        static CNcdStorageItem* NewL( CNcdStorageBase* aStorage, const TDesC& aUid, TInt aType );

        ~CNcdStorageItem();

    public:


        void SetOpen( TBool aOpen );


    public: // From MNcdStorageItem


        virtual void OpenL();

        /**
         * Marks the item as saved but doesn't commit it to storage until
         * all open items are saved
         */
        virtual void SaveL();

        /**
         * @note Rollbacks all open & saved items
         */
        virtual void Rollback();

        virtual void RemoveFromStorageL();

        /**
         * Read data item from the storage
         */
        virtual void ReadDataL();

        /**
         * Write data item to the storage
         */
        virtual void WriteDataL();

        virtual TBool IsOpen() const;

        virtual const TDesC& Uid() const;

        virtual TInt Type() const;

        virtual void SetDataItem( MNcdStorageDataItem* aDataItem );


        virtual HBufC8* GetDataLC();


    protected:

        CNcdStorageItem( CNcdStorageBase* aStorage );

        void ConstructL( const TDesC& aUid, TInt aType );


    private:

        CNcdStorageBase*                 iStorage;

        MNcdStorageDataItem*         iDataItem;

        CNcdStorageItemIdentifier*   iIdentifier;

        TBool                       iOpen;

    };
    

class CNcdStorageItemIdentifier : public CBase
    {
    public:
        static CNcdStorageItemIdentifier* NewLC( const TDesC8& aId, TInt aType );
        static CNcdStorageItemIdentifier* NewL( const TDesC16& aId, TInt aType );
        static CNcdStorageItemIdentifier* NewLC( const TDesC16& aId, TInt aType );

        ~CNcdStorageItemIdentifier();

    public:

        const TDesC& Id() const;

        TInt Type() const;


    private:

        void ConstructL( const TDesC16& aId );
        void ConstructL( const TDesC8& aId );

        CNcdStorageItemIdentifier( TInt aType );


    private:


        HBufC*          iId;

        TInt            iType;
    };


class CNcdStorageBaseListener : public CBase
    {

     public:

        virtual void CacheOpened() = 0;

        virtual void CacheReadyL() = 0;

        virtual void NotifyRollback() = 0;

    };


#endif