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