/*

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

#define CLASSNODEANALYSIS_H_

#ifdef __WIN__

#pragma warning(disable:4786)

#endif

#include <xercesc/dom/DOM.hpp>

#include <vector>

#include <list>

#include <string>

#include "HANodeIterator.h"

#include "NodeAnalysis.h"

#include "NodeIndex.h"

#include "NodeTypeComparator.h"

using namespace std;

XERCES_CPP_NAMESPACE_USE

template <TIssueType IssueType>

void AddIssueClass(const HANodeIterator* self,TIssueIdentity classType, const HANodeIterator& ignorenode, int lineNo, 

				   const string& issueloc,const XMLCh* fileid=NULL)

{

	switch (classType)

	{

    case EIssueIdentityClass:

		AddIssue<EIssueIdentityClass,IssueType>(self,ignorenode,lineNo,issueloc,fileid);

		break;

    case EIssueIdentityStruct:

		AddIssue<EIssueIdentityStruct,IssueType>(self,ignorenode,lineNo,issueloc,fileid);

		break;

    case EIssueIdentityUnion:

		AddIssue<EIssueIdentityUnion,IssueType>(self,ignorenode,lineNo,issueloc,fileid);

		break;

	default:

		assert(false);

		break;

	};

}

template <TIssueType IssueType>

void AddIssueField(const HANodeIterator* self,TIssueIdentity classType, const HANodeIterator& ignorenode, int lineNo, 

				   const string& issueLoc, const XMLCh* fileid=NULL, const string name = "")

{

	switch (classType)

	{

    case EIssueIdentityField:

		AddIssue<EIssueIdentityField,IssueType>(self,ignorenode,lineNo,issueLoc,fileid,name);

		break;

    case EIssueIdentityFieldInaccessible:

		AddIssue<EIssueIdentityFieldInaccessible,IssueType>(self,ignorenode,lineNo,issueLoc,fileid, name);

		break;

	default:

		assert(false);

		break;

	};

}

/**

* Add issue field

* @param self pointer to self 

* @param classType type of issue 

* @param ignorenode reference to node

* @param fileid pointer to fileid 

* @param name reference to name

*/

template <TIssueType IssueType>

void AddIssueField(const HANodeIterator* self,TIssueIdentity classType, const HANodeIterator& ignorenode, int lineNo,

				   const string& issueLoc, const XMLCh* fileid, const DataMember & name)

{

	switch (classType)

	{

    case EIssueIdentityField:

		AddIssue<EIssueIdentityField,IssueType>(self,ignorenode,lineNo,issueLoc,fileid,name);

		break;

    case EIssueIdentityFieldInaccessible:

		AddIssue<EIssueIdentityFieldInaccessible,IssueType>(self,ignorenode,lineNo,issueLoc,fileid, name);

		break;

	default:

		assert(false);

		break;

	};

}

/**

* The member variables are analyzed for changes in order, type, removal, addition

* and visibility. Any change, including removal and addition, of the accessible

* data members of a class is reported.

*/

class ClassNodeAnalysis: public NodeAnalysis

{

public:

    static NodeAnalysis* Construct();

public:

    /**

    * Constructor

    */

    ClassNodeAnalysis();

    /**

    * Finds node to analyse it

    * @param baseline baseline node

    * @param current current node

    * @return 0, if there was no issues

    */

    int FindNodeAndAnalyse(HANodeIterator baseline,HANodeIterator current);

    /**

    * Analyse

    * @param baseline baseline node

    * @param current current node

    * @param report report or not (default= true)

    * @return 0, if there was no issues

    */

    int Analyse(HANodeIterator baseline,HANodeIterator current, bool report = true);

    /**

    * Destructor

    */

    ~ClassNodeAnalysis(){}

protected:

    /**

    * Analyses fields

    * @param baseline baseline version

    * @param current current version

    * @param bfields base fields vector

    * @param cfields current fields vector 

    * @param report to report or not report issues

    * @return 0 if compared fields are equal

    */

	virtual int compareFields(HANodeIterator baseline,HANodeIterator current, 

                                                  const vector<DOMNode*>& bfields, const vector<DOMNode*>& cfields, 

                                                  bool report);

    /**

    * Analyses non-virtual functions 

    * @param baseline baseline version

    * @param current current version

    * @param bexportedMethods base exported methods vector

    * @param cexportedMethods current exported methods vector 

    * @param identity identity of the issue

    * @param report to report or not report issues

    * @return 0 if compared fields are equal

    */

    virtual int compareNonvirtualFunctions( HANodeIterator baseline,

                                            HANodeIterator current, 

                                            const vector<DOMNode*>& bexportedMethods, 

                                            const vector<DOMNode*>& cexportedMethods, 

                                            TIssueIdentity identity,

                                            bool report);

    // First bool for signature

    struct MethodMatchFlags

    {

        MethodMatchFlags(bool sM, bool rM) : signatureMatch(sM),returnValueMatch(rM){};

        bool signatureMatch;

        bool returnValueMatch;

        bool IsMatch() {return signatureMatch && returnValueMatch;};

    }; 

   /**

    * Analyses virtual functions 

    * @param baseline baseline version

    * @param current current version

    * @param bvirtualMethods base virtual methods vector

    * @param cvirtualMethods current virtual methods vector 

    * @param report to report or not report issues

    * @return 0 if compared fields are equal

    */

	virtual int compareVirtualFunctions(HANodeIterator baseline,HANodeIterator current, 

                                                  const vector<DOMNode*>& bvirtualMethods, 

												  const vector<DOMNode*>& cvirtualMethods, 

                                                  bool report);

   /**

    * Analyses other members

    * @param baseline baseline version

    * @param current current version

    * @param bothers base other items vector

    * @param cothers current other items vector 

    * @param report to report or not report issues

    * @return 0 if compared fields are equal

    */

	virtual int compareOthers(HANodeIterator baseline,HANodeIterator current, 

                                                  const vector<DOMNode*>& bothers, const vector<DOMNode*>& cothers, 

                                                  bool report);

    /**

    * Compares the base sizes of the classes

    * @param baseline to which to compare

    * @param current what to compare

    * @param bfields base data member table

    * @param cfields current data member table

    * @param report if true finding are reported

    * @return 0 if compared fields are equal

    */ 

	virtual int compareBaseSizes(HANodeIterator baseline, HANodeIterator current, const NodeIndex::dtable_t& bfields, const NodeIndex::dtable_t& cfields, bool report);			

protected:

    /**

    * Compares changes in inheritance

    * @param baseline to which to compare

    * @param current what to compare

    * @param report if true findings are reported

    * @return 0 if compared fields are equal

    */ 

    int compareBases(HANodeIterator baseline,HANodeIterator current, bool report);

    /**

    * Compares methods by function signature (return value is not involved)

    * @param basemethod basemethod to compare

    * @param currentmethod current to compare

    * @return true if signature isn't changed

    */

    bool compareMethodsSignature(HANodeIterator basemethod,HANodeIterator currentmethod, const NodeTypeComparator& comparator);

    /**

    * Compares all the members of the class

    * @param baseline baseline version

    * @param current current version

    * @param report if true findings are reported

    * @return 0 if there was no issues

    */

    int	compareClassMembers(HANodeIterator baseline,HANodeIterator current, bool report);

    /**

    * Analyses and reports the differences between two fields

    * @param basefield baseline field

    * @param currentfield current field

    * @param report if true findings are reported

    * @return 0 if compared fields are equal

    */

    //int compareField(HANodeIterator basefield,HANodeIterator currentfield, bool report);

    /**

    * Analyses and reports the differences between two fields

    * @param baseline baseline version

    * @param current current version

    * @param basemember base member to compare

    * @param currentmember current member to compare

    * @param report if true findings are reported

    * @return 0 if compared fields are equal

    */

	int compareField(HANodeIterator baseline, HANodeIterator current, const DataMember& basemember,const DataMember& currentmember, bool report);

    /**

    * Analyses the methods return value

    * @param basemethod baseline method

    * @param currentmethod current method

    * @return true if method returns are equal

    */

    bool compareMethodsReturn(HANodeIterator basemethod,HANodeIterator currentmethod,NodeTypeComparator& cmp);

    /**

    * Index virtual methods

    * @param node node to index

    * @param virtualMethods virtual methods in node

    * @param vtable virtual method table

    * @param virtualMethodsWithIndex methods indexed

    */

    void indexVirtualMethods(HANodeIterator node, 

											const vector<DOMNode*>& virtualMethods, 

											const NodeIndex::vtable_t& vtable,

											vector<pair<DOMNode*,int> >& virtualMethodsWithIndex);

    /**

    * Compare virtual methods

    * @param baseline baseline version

    * @param current current version

    * @param basevtable base virtual method table

    * @param currentvtable current virtual method table

    * @param report if true findings are reported

    */

    int compareVirtualTables(HANodeIterator baseline,HANodeIterator current,

											const NodeIndex::vtable_t& basevtable, 

											const NodeIndex::vtable_t& currentvtable,

                                            bool report);

    // Contains basemethod pointer and a boolean flag telling whether

    // the method was found in current methods or not.

    typedef map<DOMNode*, MethodMatchFlags> MethodMatchMap;

    virtual int compareNonvirtualFunctions( HANodeIterator baseline,

                                            HANodeIterator current, 

                                            const vector<DOMNode*>& bexportedMethods, 

                                            const vector<DOMNode*>& cexportedMethods, 

                                            TIssueIdentity identity,

								            bool report, 

                                            ComparatorVector::const_iterator comparator, 

                                            MethodMatchMap& baseMap,

                                            MethodMatchMap& currMap,

                                            int comparatorRound);

protected:

    //! To report added members

    bool iReportAddedMembers;

    //! Identity of the issue found

    TIssueIdentity iIdentity;

};

#endif