/*

* 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:   Contains CNcdNodeDbManager class

*

*/

#ifndef NCD_NODE_DB_MANAGER_H

#define NCD_NODE_DB_MANAGER_H

#include <e32base.h>

#include <f32file.h>

#include <e32cmn.h>

#include <bamdesca.h>

#include "ncdstoragedataitem.h"

#include "ncdnodeclassids.h"

#include "ncddatabaseitems.h"

class MNcdStorageManager;

class MNcdStorage;

class CNcdNodeIdentifier;

/**

 *  CNodeDbManager provides functions manage 

 *  node db information. Functions to read, write and remove

 *  data are provided.

 */

class CNcdNodeDbManager : public CBase

    {

public:

    /**

     * NewL

     *

     * @return CNcdNodeDbManager* Pointer to the created object 

     * of this class.

     */

    static CNcdNodeDbManager* NewL(

        MNcdStorageManager& aStorageManager );

    /**

     * NewLC

     *

     * @return CNcdNodeDbManager* Pointer to the created object 

     * of this class.

     */

    static CNcdNodeDbManager* NewLC(

        MNcdStorageManager& aStorageManager );

    /**

     * Destructor

     *

     * Deletes the nodes from the node cache.

     */

    virtual ~CNcdNodeDbManager();

public: // Node db manager configuration functions    

    /**

     * Adds the given identifier to the list of nodes that are never removed from DB.

     *

     * @param aIdentifier The node identifier.

     */

    void AddDoNotRemoveNodeIdentifierL( const CNcdNodeIdentifier& aNodeIdentifier );

    /**

     * Adds the given identifiers to the list of nodes that are never removed from DB.

     *

     * @param aIdentifiers The node identifiers.

     */

    void AddDoNotRemoveNodeIdentifiersL(

        const RPointerArray<CNcdNodeIdentifier>& aNodeIdentifiers );

    /**

     * Removes the given identifier from the list of nodes that are never removed from DB.

     *

     * @param aIdentifier The node identifier.

     */

    void RemoveDoNotRemoveNodeIdentifier( const CNcdNodeIdentifier& aNodeIdentifier );

public: // Database info functions

    /**

     * @param aClientUid The uid of the client whose storage is 

     * examined.

     * @param aSkipNamespaces The sizes of these namespaces are ignored when

     * the total size is calculated. Ownership is not transferred.

     * @return TInt the size in bytes of the whole storage

     * of the specified client.

     */

    TInt StorageSizeL( const TUid& aClientUid,

                       const MDesCArray& aSkipNamespaces );

public: // Database read functions

    /**

     * Reads binary data from the database

     * @param aIdentifier Contains id information that is

     * used to read right info from db.

     * @param aClassType Type of the data.

     * @return HBufC8* Data from db.

     */

    HBufC8* ReadDataFromDatabaseL( 

        const CNcdNodeIdentifier& aIdentifier,

        const NcdNodeClassIds::TNcdNodeClassType aClassType );

    /**

     * @see CNcdNodeDbManager::ReadDataFromDatabaseL

     */                                

    HBufC8* ReadDataFromDatabaseLC( 

        const CNcdNodeIdentifier& aIdentifier,

        const NcdNodeClassIds::TNcdNodeClassType aClassType );

    /** 

     * This function is used to start the database action

     * that will get the data for some object from the

     * storage database.

     * After the data has been found from the storage,

     * InternalizeL function of the given data item is called.

     *

     * @param aIdentifier Contains id information that is

     * used to read right info from db.

     * @param aDataItem InternalizeL of this object is called

     * when the data is read from db.

     * @param aClassType Type of the data.

     */    

    void StartStorageLoadActionL( 

        const CNcdNodeIdentifier& aIdentifier,

        MNcdStorageDataItem& aDataItem,

        const NcdNodeClassIds::TNcdNodeClassType aClassType );

    /** 

     *  This function will return the array about the identifiers found from

     *  the database. Parameters provide ways to limit what identifiers

     *  should be included in return array.

     *

     *  @note Identifiers are included into the array only once. So, if

     *  multiple db items with different types are having same identifier,

     *  the identifier will be added to target array only once.

     *

     *  @param RPointerArray<CNcdNodeIdentifier> Array that will contain

     *  identifiers of the database items. Ownership of the identifiers

     *  are transmitted for the user of the array.

     *  @param aClientUid Identifies the client whose data is searched.

     *  @param aSkipNamespaces This array contains the namespaces whose

     *  data should not be returned.

     *  @param aAcceptClassType This array contains the class types that

     *  are accepted for the items. The items of the class types 

     *  that are not included in this array will not be included into

     *  the return array.

     */

    void GetAllClientItemIdentifiersL( 

        RPointerArray<CNcdNodeIdentifier>& aItemIdentifiers,

        const TUid& aClientUid,

        const MDesCArray& aSkipNamespaces,

        const RArray<NcdNodeClassIds::TNcdNodeClassType>& aAcceptClassTypes );

public: // Database write functions

    /**

     * This function is used to start the database action

     * that will save the data of the data item into the db.

     * The ExternalizeL function of the data item is called.

     * So, the item may insert its data into the given stream.

     *

     * @param aIdentifier Contains id information that is

     * used to read right info from db.

     * @param aDataItem ExternalizeL of this object is called

     * when the data is written into db.

     * @param aClassType Type of the data.

     */

    void SaveDataIntoDatabaseL( 

        const CNcdNodeIdentifier& aIdentifier,

        MNcdStorageDataItem& aDataItem,

        const NcdNodeClassIds::TNcdNodeClassType aClassType );        

public: // Database remove functions

    /**

     * Removes certain data row from the db table according

     * to the given values that are used as the key values.

     *

     * @param aIdentifier The identifier that contains key values.

     * @param aClassType The class type tells the general type of the data

     * that should be removed.

     */

    void RemoveDataFromDatabaseL( 

        const CNcdNodeIdentifier& aIdentifier,

        const NcdNodeClassIds::TNcdNodeClassType aClassType );        

    /**

     * Removes certain data rows from the db table according

     * to the given values that are used as the key values.

     * This works like the function above, but commits the

     * removal operation rarely. This should speed

     * up the removal process.

     *

     * @see CNcdNodeDbManager::RemoveDataFromDatabaseL

     *

     * @param aIdentifiers The identifier array that contains key values. 

     * Ownership is not tranferred.

     * @param aClassTypes The class type array tells the general types of the data

     * that should be removed. Ownership is not transferred.

     */

    void RemoveDataFromDatabaseL( 

        const RPointerArray<CNcdNodeIdentifier>& aIdentifiers,

        const RArray<NcdNodeClassIds::TNcdNodeClassType>& aClassTypes,

        TBool aCompact = ETrue );

    /**

     * Removes everything except identifiers that are in the do not remove list

     *  

     * @param aNodeIdentifier Used to get the correct storage   

     */

    void RemoveDataFromDatabaseL( 

        const CNcdNodeIdentifier& aNodeIdentifier,

        const RArray<RNcdDatabaseItems>& aDoNotRemoveItems );

    /**

     * Clears client's storage

     *

     * @note All of client's files and databases are 

     * deleted except the ones that are having namespaces

     * defined in the skip array.

     *

     * @param aClientUid Client's uid identifier

     * @param aSkipNamespaces Array contains the descriptors of

     * namespaces that should not be cleared. Ownership is not

     * transferred.

     */

    void ClearClientL( const TUid& aClientUid,

                       const MDesCArray& aSkipNamespaces );

protected:

    /**

     * Constructor

     */

    CNcdNodeDbManager( MNcdStorageManager& aStorageManager );

    /**

     * ConstructL

     */

    virtual void ConstructL();

    /**

     * Returns an old storage or creates a new one if necessary.

     * Storage will contain the information of the certain client

     * that has been identifier by its UID.

     *

     * @param aIdentifier Identifies what storage is wanted.

     * @return MNcdStorage& Storage matching the identifier info.

     * @exception KErrArgument if aIdentifier contains empty fields.

     * In other error situations, system wide error code.

     */

    MNcdStorage& StorageL( const CNcdNodeIdentifier& aIdentifier  ) const;

    TInt RemoveDataFromNamespaceL( 

        const RPointerArray<CNcdNodeIdentifier>& aDoNotRemoveIds,

        TInt aIndex, 

        TInt aEnd );

private:

    // Prevent if not implemented

    CNcdNodeDbManager( const CNcdNodeDbManager& aObject );

    CNcdNodeDbManager& operator =( const CNcdNodeDbManager& aObject );

private: // data

    // Storage manager is used to load and to save data from

    // databases.

    MNcdStorageManager& iStorageManager;

    };

#endif // NCD_NODE_DB_MANAGER_H