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


#ifndef NCD_NODE_H
#define NCD_NODE_H


#include <e32cmn.h>
#include <s32mem.h>

#include "catalogscommunicable.h"
#include "ncdstoragedataitem.h"
#include "ncdnodemanager.h"
#include "ncdnodeclassids.h"
#include "ncdnodeidentifier.h"
// This is included for the state enum value
#include "ncdnode.h"

class CNcdNodeLink;
class CNcdNodeMetaData;
class CNcdNodeIdentifier;
class CNcdNodeUserData;
class CNcdNodeSeen;


/**
 *  This class object provides node specific functions.
 *  Node contains additional classes that will contain more node
 *  or metadata specific information.
 *
 *  @lib ?library
 *  @since S60 ?S60_version *** for example, S60 v3.0
 */
class CNcdNode : public CCatalogsCommunicable,
                 public MNcdStorageDataItem
    {
public:

    static TInt Compare( const CNcdNode& aFirst, const CNcdNode& aSecond )
        {
        return CNcdNodeIdentifier::Compare( 
            aFirst.Identifier(), 
            aSecond.Identifier() );
        }
        
public:

    /**
     * Destructor
     */
    virtual ~CNcdNode();
    

    /**
     * @return CNcdNodeIdentifier& Unique identifier of this node.
     */
    virtual const CNcdNodeIdentifier& Identifier() const;
    
    /**
     * Retrieves the data type that informs what class the data is for.
     * By checking the data type information, an InternalizeL function
     * of a right class can be called when the object data is set
     * from the storage.
     * The data type may be decided and set in a factory that creates object.
     * The factory should know which integer is reserved for which class.
     *
     * @return TInt The integer that describes the data type. 
     */
    NcdNodeClassIds::TNcdNodeClassId ClassId() const;


    /**
     * @return The nodemanager that has created this node.
     */
    CNcdNodeManager& NodeManager() const;


    /**
     * Uses CreateLinkL to create the link if the link does not already
     * exist. If a new link is created it is set as a link for the node.
     *
     * @return CNcdNodeLink& The link that has been set for this node.
     */
    CNcdNodeLink& CreateAndSetLinkL();

    /**
     * @return CNcdNodeLink& Reference to the node link. 
     * @exception KErrNotFound if node link has not been set.
     */
    CNcdNodeLink& NodeLinkL() const;

    /**
     * @return CNcdNodeLink Pointer to the node link. NULL if no link
     * is set. Ownership is NOT transferred. 
     */
    CNcdNodeLink* NodeLink() const;
    
    /** 
     * @return The node seen object of the node.
     */
    CNcdNodeSeen& NodeSeen() const; 
   
 
    /**
     * Internalizes data to the node link. If the node link does
     * not exists it is created by callin CreateLinkL which should be
     * overloaded in child classes to give the right kind of link.
     *
     * @param
     * @param
     */
    virtual void InternalizeLinkL( const MNcdPreminetProtocolEntityRef& aData,
                                   const CNcdNodeIdentifier& aParentIdentifier,
                                   const CNcdNodeIdentifier& aRequestParentIdentifier,
                                   const TUid& aClientUid );
    
    
    /**
     * @note Node manager is used to set the metadata
     * that corresponds to the node link.
     *
     * @return CNcdNodeMetaData& Reference to the metadata.
     * @exception KErrNotFound if meta data or node link has not been set.
     */
    CNcdNodeMetaData& NodeMetaDataL() const;
    
    /**
     * @return CNcdNodeMetaData* Pointer to the metadata, NULL if no metadata
     * is set. Ownership is NOT transferred.
     */
    CNcdNodeMetaData* NodeMetaData() const;

    /**
     * Sets the metadata. Does not delete old one because metadata is owned
     * byt the nodemanager.
     *
     * @param aMetaData is the new meta data that this node will contain.
     * @exception KErrBadName if the metadata is not of the accepted type.
     */
    void SetNodeMetaDataL( CNcdNodeMetaData& aMetaData );
    
    /**
     * Gives information about the state of the node. This information can be used to
     * check whether the item data has been loaded or if the data is expired.
     *
     * @return The state of the node.
     */
    MNcdNode::TState State() const;
        

public: // CCatalogsCommunicable

    /**
     * @see CCatalogsCommunicable::ReceiveMessage
     */
    virtual void ReceiveMessage( MCatalogsBaseMessage* aMessage,
                                 TInt aFunctionNumber );

    /**
     * @see CCatalogsCommunicable::CounterPartLost
     */
    virtual void CounterPartLost( const MCatalogsSession& aSession );


public: // MNcdStorageDataItem

    /**
     * @see MNcdStorageDataItem::ExternalizeL
     */
    virtual void ExternalizeL( RWriteStream& aStream );


    /**
     * @see MNcdStorageDataItem::InternalizeL
     */
    virtual void InternalizeL( RReadStream& aStream );


protected:

    /**
     * Constructor
     */
    CNcdNode( CNcdNodeManager& aNodeManager,
              NcdNodeClassIds::TNcdNodeClassId aNodeClassId,
              NcdNodeClassIds::TNcdNodeClassId aAcceptedLinkClassId,
              NcdNodeClassIds::TNcdNodeClassId aAcceptedMetaDataClassId );
    
    /**
     * @param atIdentifier Identifier of this node. The identifier is unique
     * to all the nodes.
     */
    virtual void ConstructL( const CNcdNodeIdentifier& aIdentifier );
        

    /**
     * Child classes should implement this function. 
     * So, the right type of link will be created when this creator is called.
     * This function will create the link only once. If the link has already 
     * been created then the old link will be returned.
     *
     * @param CNcdNodeLink* The created link or the old link if it already existed.
     */
    virtual CNcdNodeLink* CreateLinkL() = 0;


    // Here are all the functions that are used when ReceiveMessageL is called and
    // the functionality is delegated according to the given function number.
    
    /**
     *
     */
    void InternalizeRequestL( MCatalogsBaseMessage& aMessage ) const;

    /**
     * Child classes should overload this or add their own data after
     * the parent class data.
     */    
    virtual void ExternalizeDataForRequestL( RWriteStream& aStream ) const;    


    void LinkHandleRequestL( MCatalogsBaseMessage& aMessage ) const;
    void MetadataHandleRequestL( MCatalogsBaseMessage& aMessage ) const;
    void NodeSeenHandleRequestL( MCatalogsBaseMessage& aMessage ) const;
    void ClassIdRequestL( MCatalogsBaseMessage& aMessage ) const;
    void ReleaseRequest( MCatalogsBaseMessage& aMessage ) const;
    
    
private:
    
    // Prevent if not implemented
    CNcdNode( const CNcdNode& aObject );
    CNcdNode& operator =( const CNcdNode& aObject );


    // This is used to forward the internalization/externalization
    // to the link
    void ExternalizeLinkL(  RWriteStream& aStream ); 
    void InternalizeLinkL( RReadStream& aStream );

    void DoReceiveMessageL( 
        MCatalogsBaseMessage& aMessage, 
        TInt aFunctionNumber );


private: // data

    // Manager manages and owns nodes.
    // This class does not own the manager.    
    CNcdNodeManager& iNodeManager;

    NcdNodeClassIds::TNcdNodeClassId iNodeClassId;

    // The link type is used to check if the given link is of
    // the right type. 
    NcdNodeClassIds::TNcdNodeClassId iAcceptedLinkClassId;
    
    // The metadata type is used to check if the given metadata is of
    // the right type. 
    NcdNodeClassIds::TNcdNodeClassId iAcceptedMetaDataClassId;

    // This is the identifier of the node. Owns.
    CNcdNodeIdentifier* iNodeIdentifier;
    
protected:
    // The message is set when ReceiveMessage is called. The message
    // is used in the CounterPartLost-function that informs the message
    // if the session has been lost.
    MCatalogsBaseMessage* iMessage;
    
private:
    // These objects provide additional functionality for the node.

    // This class owns node link if it has been set.
    CNcdNodeLink* iNodeLink;

    // This class does not own meta data.
    CNcdNodeMetaData* iNodeMetaData;
    
    // This class owns the seen information.
    CNcdNodeSeen* iNodeSeen;
    };


#endif // NCD_NODE_H