/*

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

*

*/

#include "CmdGlobals.h"

#ifdef __WIN__

#pragma warning(disable:4786)

#endif

#include <assert.h>

#include <map>

#include <list>

#include <string>

//#include <sstream>

#include <xercesc/dom/DOM.hpp>

#include "BBCAnalyser.h"

#include "Issues.h"

#include "ReportGenerator.h"

#include "ReportIssue.h"

#include "NodeIndex.h"

#include "XMLStringConst.h"

using namespace std;

XERCES_CPP_NAMESPACE_USE

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

// NodeIndex::AddNodeFQNameToMap

// 

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

//

const pair<const XMLCh*,bool>& NodeIndex::FindFileByFileId(const XMLCh* fileid)

    {

    return iIdToFileMap[fileid];

    }

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

// NodeIndex::AddFileNodeToMap

// 

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

//

void NodeIndex::AddFileNodeToMap(const XMLCh* id,pair<const XMLCh*,bool> file)

    {

        this->iIdToFileMap[id] = file;

    }

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

// NodeIndex::AddNodeFQNameToMap

// 

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

//

void NodeIndex::AddNodeFQNameToMap(DOMNode * node, const pair<const XMLCh*,const XMLCh*>& fqname)

    {	

        this->iFQNameToNodeMap[fqname] = node;

    }

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

// NodeIndex::clear

// 

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

// 

void NodeIndex::clear()

    {

        iIdToNodeMap.clear();

        iFQNameToNodeMap.clear();

    }

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

// NodeIndex::AddNodeIdToMap

// Add the node with its id to the map

// 

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

//  

void NodeIndex::AddNodeIdToMap(DOMNode * node)

    {

        const XMLCh * attributeId = ::GetAttribute(node,KXMLIdString);

        if ( attributeId )

        {

            iIdToNodeMap[attributeId] = node;

        }

    }

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

// NodeIndex::FindNodeById

// Finds the node with id

// 

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

//   

DOMNode * NodeIndex::FindNodeById(DOMNode * root, const XMLCh* id)

    {

        map<const XMLCh*, DOMNode*, ltstr>::iterator cur = iIdToNodeMap.find(id);

        if ( cur == iIdToNodeMap.end() )

        {

            //The node was not found so start traveling the tree

            DOMNode * node = FindNodeByIdFromTree(root,id);

            //We have found the node

            if ( node )

            {

                AddNodeIdToMap(node);

            }

            return node;

        } else

        {

            return cur->second;

        }

    }

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

// NodeIndex::FindNodeByFQName

// Finds the node with fully qualified name

// 

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

// 

DOMNode * NodeIndex::FindNodeByFQName(DOMNode * root, pair<const XMLCh*,const XMLCh* > FQName)

    {

        fqnamemap::iterator cur = iFQNameToNodeMap.find(FQName);

        if ( cur == iFQNameToNodeMap.end() )

        {

            //The node was not found so return NULL

            return NULL;

        } else

        {

            return cur->second;

        }

    }

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

// NodeIndex::FindNodeByIdFromTree

// Search from the tree

// 

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

//

DOMNode * NodeIndex::FindNodeByIdFromTree(DOMNode * root, const XMLCh* id)

    {

        DOMNodeList * childs = root->getChildNodes();

        XMLSize_t childcount = childs->getLength();

        for (unsigned int i = 0; i < childcount; ++i)

        {

            DOMNode* child = childs->item(i);

            const XMLCh* attributeValue = GetAttribute(child,KXMLIdString);

            if ( attributeValue )

            {

                if ( XMLString::equals(id, attributeValue) )

                {

                    //The node was found

                    return child;

                }

            }

        }

        // Not found

        return NULL;

    }

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

// NodeIndex::DumpTables

// 

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

// 

void NodeIndex::DumpTables()

{

/*

	map< const XMLCh *,DOMNode*,ltstr >::iterator it = iIdToNodeMap.begin();

    DEBUG_PRINT("NodeIndex: ")

    DEBUG_PRINT(this)

    DEBUG_PRINT("\n")

    for (; it != iIdToNodeMap.end(); ++it)

    {

        DEBUG_PRINT_XMLCh((*it).first)

        DEBUG_PRINT(" ")

        DEBUG_PRINT((*it).second)

        DEBUG_PRINT("\n")

   }

    fqnamemap::iterator it2 = iFQNameToNodeMap.begin();

#ifndef NO_DBG

    LOG(" ")

    DEBUG_PRINT("NodeIndex: ")

    DEBUG_PRINT(this)

    DEBUG_PRINT("\n")

#endif

    for (; it2 != iFQNameToNodeMap.end(); ++it2)

    {

        DEBUG_PRINT_XMLCh((*it).first.first)

        DEBUG_PRINT(" ")

        DEBUG_PRINT_XMLCh((*it).first.second)

        DEBUG_PRINT("\n")

    }

*/

}

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

// NodeIndex::AddVirtualFunction

// Adds a virtual function to the table vtable

// 

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

// 

void NodeIndex::AddVirtualFunction(const string& vtablename, const string& functionsig, DOMNode * node)

{

	vtableindex_t::iterator it = iVTableIndex.find(vtablename);

	if ( it != iVTableIndex.end() )

	{

		it->second.push_back(pair<string, DOMNode*>(functionsig,node));

	}

	else

	{

		vtable_t tmp_vtable;

		tmp_vtable.push_back(pair<string, DOMNode*>(functionsig,node));		

		iVTableIndex.insert(pair<string,vtable_t >(vtablename,tmp_vtable));

	}

}

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

// NodeIndex::GetVirtualTable

// Gets the virtual table vtable

// 

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

//

const NodeIndex::vtable_t* NodeIndex::GetVirtualTable(const string& vtablename)

{

	vtableindex_t::iterator it = iVTableIndex.find(vtablename);

	if ( it != iVTableIndex.end() )

	{

		return &(it->second);

	}

	return NULL;

}

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

// NodeIndex::AddEmptyVirtualTable

// Inserts empty vtable if one does not already exists. Returns a pointer

// to the vtable.

// 

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

// 

const NodeIndex::vtable_t* NodeIndex::AddEmptyVirtualTable(const string& vtable)

{

	vtable_t tmp_vtable;

	pair<vtableindex_t::iterator,bool> ret = iVTableIndex.insert(pair<string,vtable_t >(vtable,tmp_vtable));

	return &(ret.first->second);

}

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

// NodeIndex::InsertDataMember

// Adds a data member to the given table

// 

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

//

 void NodeIndex::InsertDataMember(const string& parentName, const DataMember& member, dtableindex_t& dataMap)

{

    dtableindex_t::iterator it = dataMap.find(parentName);

    if( it != dataMap.end() )

    {

        it->second.push_back(member);

    }

    else

    {

        it = dataMap.insert(make_pair(parentName, dtable_t())).first;

        it->second.push_back(member);

    }

}

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

// NodeIndex::AddDataMember

// Adds a data member to the member data table.

// 

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

// 

void NodeIndex::AddDataMember(const HANodeIterator& parentNode, const string& parentName, const string& memberName, DOMNode* memberNode, int index, TAccess access,int lineNo)

{

	if( IsAnonymousType(parentNode) )

	{

        InsertDataMember(parentName, DataMember(memberName, memberNode, index, access,lineNo), iAnonymousTable);

    }

    else

    {

        InsertDataMember(parentName, DataMember(memberName, memberNode, index, access,lineNo), iDTableIndex);

    }

}

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

// NodeIndex::GetDataMemberTable

// Gets the data member table

// 

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

// 

const NodeIndex::dtable_t* NodeIndex::GetDataMemberTable(const HANodeIterator& node, const string& nodeName)

{	

	dtableindex_t::iterator it;

	if( IsAnonymousType(node) )

	{

		it = iAnonymousTable.find(nodeName);

		if( it != iAnonymousTable.end() )

		{

			return &(it->second);

		}

	}

	else

	{

		it = iDTableIndex.find(nodeName);

		if( it != iDTableIndex.end() )

		{

		return &(it->second);

		}

    }

    return NULL;

}

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

// NodeIndex::AddEmptyDataMemberTable

// Add empty data table

// 

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

// 

const NodeIndex::dtable_t* NodeIndex::AddEmptyDataMemberTable(const HANodeIterator& node, const string& nodeName)

{

	if( IsAnonymousType(node) )

	{

		return &(iAnonymousTable.insert(make_pair(nodeName, dtable_t()))).first->second;

	}

    return &(iDTableIndex.insert(make_pair(nodeName, dtable_t()))).first->second;

}

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

// ltstr::operator

// Finds the node with id id. Returns NULL if not found

// 

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

// 

bool ltstr::operator()(const XMLCh * s1,const XMLCh * s2) const

  {

    return XMLString::compareString(s1, s2) < 0;

  }

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

// compareFQName::operator

// Finds the node with id id. Returns NULL if not found

// 

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

//

bool compareFQName::operator()(

    const pair<const XMLCh *,const XMLCh *>&  p1,

    const pair<const XMLCh *,const XMLCh *>&  p2) const

  {

    if ( 0 == XMLString::compareString(p1.first,p2.first) )

    {

        return XMLString::compareString(p1.second,p2.second) < 0;

    }

    else

    {

        return XMLString::compareString(p1.first,p2.first) < 0;

    }

  }