/*

* Copyright (c) 2006-2009 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 _HANODEITERATOR_H_

#define _HANODEITERATOR_H_

#include "CmdGlobals.h"

#ifdef __WIN__

#pragma warning(disable:4786)

#endif

#include <assert.h>

#include <map>

#include <list>

#include <xercesc/dom/DOM.hpp>

#include "ReportGenerator.h"

#include "Issues.h"

#include "NodeIndex.h"

using namespace std;

XERCES_CPP_NAMESPACE_USE

/**

* The BBCAnalyser utilizes the HANodeIterator for easy access to a GCCXML 

* generated XML document. The HANodeIterator provides methods for an 

* indexed access to the XML nodes with a node ID and a fully qualified 

* name. The issues are also reported through the HANodeIterator

*/

class HANodeIterator

{

public:

    /**

    * Constructor

    * @param aRootnode root DOM node

    * @param aNodemap referencce to NodeIndex

    * @param aReport reference to ReportGenerator

    * @param aFilesToAnalyse list of files to analyse

    * @param aBaselineNode true if currently handling baseline node

    */

    HANodeIterator(DOMNode * aRootnode, NodeIndex & aNodemap, ReportGenerator & aReport,

        const list< pair<string,string> >& aFilesToAnalyse, bool aBaselineNode );

    /**

    * Returns node

    * @return pointer to DOMNode

    */

    DOMNode* operator->() const;

    /**

    * Finds node from the XML tree by the attribute "id"

    * @param nodeId ID of the searchable node

    * @return true if the node is found

    */

    bool FindNodeById(const XMLCh * nodeId);

    /**

    * Finds node from the XML tree by the fully qualified name (C++) of it 

    * @param nodeName name the searchable node

    * @return true if the node is found

    */

    bool FindNodeByName(pair<const XMLCh *,const XMLCh *> nodeName);

    /**

    * Gets the fully qualified name of this node

    * @return fully qualified name of the node

    */

    pair<const XMLCh *,const XMLCh *> GetFullyQualifiedName();

    /**

    * Adds this node in the index    

    */

    void IndexNode();

    /**

    * Adds this file node to the file index

    * @param filetoanalyse file to be anylysed

    */

    void IndexFileNode(bool filetoanalyse);

    /**

    * Generates fully qualified name for this node and adds it to index

    * if parameter index is true

    * @param index when this is true the node is added to index 

    */

    void NameNode(bool index = false);

    /**

    * Gets the attribute of this node

    * @param attribute attribute to get

    * @return attribute value or NULL

    */    

    const XMLCh* GetAttribute(const char* attribute) const;

    /**

    * Gets the attribute of this node

    * @param attribute attribute to get

    * @return attribute value or NULL

    */    

    const XMLCh* GetAttribute(const XMLCh* attribute) const;

    /**

    * Checks if the attribute that can have values 0 or 1 has value 1 (true)

    * or 0 (false). If the attribute is missing return false.

    *

    * @param attribute attribute to search for

    * @return true if attribute is found

    */

    bool CheckForBooleanAttribute(const XMLCh* attribute) const;

    /**

    * Checks if the attribute that can have values 0 or 1 has value 1 (true)

    * or 0 (false). If the attribute is missing return false.

    *

    * @param attribute attribute to search for

    * @return true if attribute is found

    */

    bool CheckForBooleanAttribute(const char* attribute) const;

    /**

    * Set value to this node

    *

    * @param attribute attribute to set

    * @param value attribute value to set

    */

    void SetAttribute(const char* attribute, const char* value);

    /**

    * Set value to this node

    *

    * @param attribute attribute to set

    * @param value attribute value to set

    */

    void SetAttribute(const XMLCh* attribute, const XMLCh* value);

    /**

    * Set value to this node

    *

    * @param attribute attribute to set

    * @param value attribute value to set

    */

    void SetAttribute(const char* attribute, const XMLCh* value);

    /**

    * Set value to this node

    *

    * @param attribute attribute to set

    * @param value attribute value to set

    */

	void SetAttribute(const XMLCh* attribute, const char* value);

    /**

    * Get elements by tagname

    * @param tag tagname

    * @return pointer to DOMNodeList

    */ 

    DOMNodeList* GetElementsByTagName(const char* tag) const;

    /**

    * Get elements by tagname

    * @param tag tagname

    * @return pointer to DOMNodeList

    */ 

    DOMNodeList* GetElementsByTagName(const XMLCh* tag) const;

    /**

    * Adds issue to the report. This node is marked as the cause for the issue

    * @param aIdentityId  identity= Class, ExportedFunction, Enumeration, etc.

    * @param aTypeId  what was happened ( something was removed, addded, changed..) 

    * @param bcseverity how severe the issue was for binary compatibility

    * @param scseverity how severe the issue was for source compatibility

    * @param ignoreinfo reason to ignore

    * @param fileid ID of the file

    * @param name filename

	* @param lineNumber where the issue is

    * @param issueloc in which file the issue is

    */

    void addIssue(TIssueIdentity aIdentityId, TIssueType aTypeId, TBCSeverity bcseverity, TSCSeverity scseverity, 

		string ignoreinfo, const XMLCh* fileid, const string name, int lineNumber,const string issueloc) const;

    /**

    * Check if this node is in the file that is currently analysed

    * @return true if this node is in the file that is currently analysed

    */

    bool toBeAnalysed();

    /**

    * Generates ignore information

    * @param aIdentityId see above

    * @param aTypeId see above

    * @return ignore info as string

    */    

    string generateIgnoreInformation(const TIssueIdentity& aIdentityId, const TIssueType& aTypeId) const;

    /**

    * Generates ignore information

    * @param other reference to other HANodeIterator object

    * @return true if the same node type found

    */ 

    bool IsSameNodeType(const HANodeIterator& other);

public:  

    //! Does not own

    DOMNode *root;

    //! Does not own

    DOMNode *current;

    //! Does not own

    NodeIndex &iNodeIndex;

    //! Reference to ReporGenerator object (Issue report)

    ReportGenerator &iReport;

    //! Does not own, files that is analysed

    const list< pair<string,string> >& iFilesToAnalyse;

	//! Is this baseline node?

    bool iBaselineNode;

private:

};

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

// A quick fix to disable compiler warnings about CheckAccessibility

/**

* Checks if the member memberNode is visible

* @param memberNode the node which accessibilty is determined

* @return true if accessible

*/ 

bool CheckAccessibility(HANodeIterator memberNode);

/**

* Checks if the member memberNode is visible and if the visibility is

* through inline function

* @param memberNode the node which accessibilty is determined

* @param exposedByInline true if node is exposed by inline

* @return true if accessible

*/

bool CheckAccessibility(HANodeIterator memberNode, bool & exposedByInline);

/**

* Checks to see if a member with access "access" is visible from class classNode

* through inline function

* @param classNode the node which accessibilty is determined

* @param exposedByInline true if node is exposed by inline

* @param access which kind of access this node has

* @return true if accessible

*/

bool CheckAccessibility(HANodeIterator classNode, bool & exposedByInline, TAccess access);

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

template<TIssueIdentity Identity,TIssueType IssueType> 

void AddIssue(const HANodeIterator* self, const HANodeIterator& ignorenode, int lineNumber, const string& aIssueLoc, 

			  const XMLCh* fileid, const DataMember & data)

{

    bool exposedByInline=false;

    CheckAccessibility(*self,exposedByInline,data.iAccess);

	TBCSeverity sev = BCseverityAccessible<Identity,IssueType>(!exposedByInline);

	TSCSeverity scsev = SCseverityAccessible<Identity,IssueType>(!exposedByInline);

	string ign = ignoreInfo<Identity,IssueType>(*self,ignorenode);

	self->addIssue(Identity,IssueType,sev,scsev,ign,fileid, data.iName,lineNumber,aIssueLoc);

}

template<TIssueIdentity Identity,TIssueType IssueType> 

void AddIssue(const HANodeIterator* self, const HANodeIterator& ignorenode, int lineNumber, const string& aIssueLoc, 

			  const XMLCh* fileid=NULL, const string namepostfix="")

{

    bool exposedByInline=false;

    CheckAccessibility(*self,exposedByInline);

	TBCSeverity sev = BCseverityAccessible<Identity,IssueType>(!exposedByInline);

	TSCSeverity scsev = SCseverityAccessible<Identity,IssueType>(!exposedByInline);

	string ign = ignoreInfo<Identity,IssueType>(*self,ignorenode);

	self->addIssue(Identity,IssueType,sev,scsev,ign,fileid, namepostfix,lineNumber,aIssueLoc);

}

#endif