Hi all,
I had downloaded the Xerces C++ DOMLibrary and had also prepared a
parser which reads a file which is similar to our Menu.
Now in the similarway iam trying to prepare a parser for one more
Schema which is as follows:
<ConfigurationFile Name="EventConfiguration"
Id="ID_EVENTCONFIGURATION">
<Events Name="MouseEvents" Id="ID_MOUSEEVENTS">
<Event Name="LCDOWN" Id="ID_LCDOWN">
<Mode Name="Select" Id="ID_SELECT">
<Command>LCDOWN Selected</Command>
</Mode>
</Event>
<Event Name="LCUP" Id="ID_LCUP">
<Mode Name="Move" Id="ID_MOVE">
<Command>LCUP Moved</Command>
</Mode>
</Event>
<Event Name="LDCUP" Id="ID_LDCUP">
<Mode Name="Add" Id="ID_ADD">
<Command>LDCUP Added</Command>
</Mode>
</Event>
</Events>
<Events Name="KeyBoardEvents" Id="ID_KEYBOARDEVENTS">
<Event Name="ENTER" Id="ID_ENTER">
<Mode Name="Select" Id="ID_SELECT">
<Command>Selected ENTER</Command>
</Mode>
</Event>
<Event Name="Delete" Id="ID_DELETE">
<Mode Name="Select" Id="ID_SELECT">
<Command>Selected Delete</Command>
</Mode>
</Event>
<Event Name="Back" Id="ID_BACK">
<Mode Name="Select" Id="ID_SELECT">
<Command>Selected Back</Command>
</Mode>
</Event>
</Events>
</ConfigurationFile>
For the above schema iam writing a parser but when i come to the MODE
tag,if i try to check the condition pDOMNode->getNodeType();
it returns a value 3 even it is an element Node.
if i donot check the condition it gives me a #text value followed by
the correct value int he nxt iteration.
Can any one suggest me whay is this happening?
U can see the whole code and class which i had written.
main.cpp
#include "XMLFileParser.h"
#include <iostream>
using namespace std;
void main()
{
XMLFileParser fileParser;
bool bIsParsed = false;
bIsParsed = fileParser.OpenXMLDocument("Event.xml");
if (bIsParsed)
{
std::cout<<"Successfully read the XML Document";
}
else
{
std::cout<<"Error reading the XML Document";
}
getchar();
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
XMLFileParser.cpp
#include "XMLFileParser.h"
XMLFileParser::XMLFileParser()
{
m_pDOMParser = 0;
m_pXMLDocument = 0;
m_pToolBarData = 0;
m_pMenuParentData = 0;
m_pMouseEventData = 0;
m_pKeyBoardEventData = 0;
}
XMLFileParser::~XMLFileParser()
{
// Delete the m_pDOMParser itself.
if (m_pDOMParser != 0)
{
m_pDOMParser->release();
}
// Call the termination method
XMLPlatformUtils::Terminate();
}
int XMLFileParser::Initialize()
{
bool bReturn = false;
DOMImplementation* pDOMImpl = 0;
char localeStr[64] = {0};
memset(localeStr, 0, sizeof localeStr);
XMLPlatformUtils::Initialize(localeStr);
pDOMImpl = DOMImplementationRegistry::getDOMImplementation(NU LL);
if (pDOMImpl != 0)
{
m_pDOMParser =
((DOMImplementationLS*)pDOMImpl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHR ONOUS,
0);
if (m_pDOMParser != 0)
{
// Instantiate the DOM m_pDOMParser.
m_pDOMParser->setFeature(XMLUni::fgDOMNamespaces, true);
m_pDOMParser->setFeature(XMLUni::fgXercesSchema, true);
m_pDOMParser->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
m_pDOMParser->setFeature(XMLUni::fgDOMValidateIfSchema, true);
m_pDOMParser->setFeature(XMLUni::fgDOMValidation, true);
m_pDOMParser->setFeature(XMLUni::fgDOMDatatypeNormalization, true);
bReturn = true;
}
}
return bReturn;
}
void XMLFileParser::ReadConfigurationFile(const DOMNode *pDOMNode)
{
char *strTag = 0;
short count = pDOMNode->getNodeType();
cout<<count;
if ((pDOMNode) &&(pDOMNode->getNodeType() == DOMNode::ELEMENT_NODE) &&
(pDOMNode->hasChildNodes()))
{
//get the tag Name
strTag = XMLString::transcode(pDOMNode->getNodeName());
//std::cout<<strTag<<endl;
if (strcmpi(strTag, "ConfigurationFile") == 0)
{
XMLString::release(&strTag);
vector<ATTRIBUTE> vecConfigurationAttr;
GetNodeAttributes(pDOMNode, vecConfigurationAttr);
cout<<"vecConfigurationAttrsize ="<<vecConfigurationAttr.size();
for(unsigned int i=0;i<vecConfigurationAttr.size();i++)
{
cout<<vecConfigurationAttr[i].strVal.c_str()<<endl;
}
if (vecConfigurationAttr.size() > 0)
{
if (vecConfigurationAttr[0].strVal.compare("ToolBarsandMenu") == 0)
{
//GetToolBarsandMenuElements(pDOMNode);
}
else if
(vecConfigurationAttr[1].strVal.compare("EventConfiguration") == 0)
{
cout<<vecConfigurationAttr[1].strVal.c_str()<<endl;
GetEventConfigurationElements(pDOMNode);
}
}
//cout<<vecConfigurationAttr[1].strVal<<endl;
}
}
}
void XMLFileParser::GetEventConfigurationElements(const DOMNode
*pDOMNode)
{
char *strTag = 0;
MAPEVENT* pMapEvent = 0;
//vector<ATTRIBUTE> vecEventsAttr;
short count = pDOMNode->getNodeType();
cout<<count;
if ((pDOMNode) &&(pDOMNode->getNodeType() == DOMNode::ELEMENT_NODE) &&
(pDOMNode->hasChildNodes()))
{
for(DOMNode *pChildNode = pDOMNode->getFirstChild(); pChildNode != 0;
pChildNode = pChildNode->getNextSibling())
{
short count = pDOMNode->getNodeType();
cout<<count;
if ((pChildNode) &&(pChildNode->getNodeType() ==
DOMNode::ELEMENT_NODE) && (pChildNode->hasChildNodes()))
{
strTag = XMLString::transcode(pChildNode->getNodeName());
vector<ATTRIBUTE> vecEventsAttr;
GetNodeAttributes(pChildNode, vecEventsAttr);
cout<<vecEventsAttr[1].strVal.c_str()<<endl;
if(strcmpi(strTag, "Events") == 0)
{
if (vecEventsAttr[1].strVal.compare("MouseEvents") == 0)
{
m_pMouseEventData = new MAPEVENT();
pMapEvent = m_pMouseEventData;
}
else if (vecEventsAttr[1].strVal.compare("KeyBoardEvents") == 0)
{
m_pKeyBoardEventData = new MAPEVENT();
pMapEvent = m_pKeyBoardEventData;
}
GetEventElements(pChildNode, pMapEvent);
}
}
}
}
}
void XMLFileParser::GetEventElements(const DOMNode *pDOMNode,
MAPEVENT*& pMapEvent)
{
char *strTag = 0;
if ((pDOMNode) && (pDOMNode->getNodeType() == DOMNode::ELEMENT_NODE)
&& (pDOMNode->hasChildNodes()))
{
short count = pDOMNode->getNodeType();
cout<<count;
for (DOMNode *pChildNode = pDOMNode->getFirstChild(); pChildNode !=
0; pChildNode = pChildNode->getNextSibling())
{
MAPEVENT mapMouseEvent,mapKeyBoardEvent;
short count = pDOMNode->getNodeType();
cout<<count;
if ((pChildNode) && (pChildNode->getNodeType() ==
DOMNode::ELEMENT_NODE) && (pChildNode->hasChildNodes()))
{
strTag = XMLString::transcode(pChildNode->getNodeName());
short count = pChildNode->getNodeType();
cout<<count;
if (strcmpi(strTag, "Event") == 0)
{
MAPMODE* pMapMode = new MAPMODE;
vector<ATTRIBUTE> vecEventAttr;
GetNodeAttributes(pChildNode, vecEventAttr);
cout<<vecEventAttr[0].strVal.c_str()<<endl;
(*pMapEvent)[vecEventAttr[0].strVal] = pMapMode;
DOMNode *pGrandChildNode = pChildNode->getFirstChild();
strTag = XMLString::transcode(pGrandChildNode->getNodeName());
short count = pGrandChildNode->getNodeType();
cout<<count;
GetModeElements(pGrandChildNode, pMapMode);
}
}
}
}
}
void XMLFileParser::GetModeElements(const DOMNode *pDOMNode, MAPMODE*&
pMapTempMode)
{
char *strTag = 0;
short count = pDOMNode->getNodeType();
cout<<count;
if ((pDOMNode) &&(pDOMNode->getNodeType() == DOMNode::TEXT_NODE) &&
(pDOMNode->hasChildNodes()))
{
strTag = XMLString::transcode(pDOMNode->getNodeName());
//cout<<strTag<<endl;
if (strcmpi(strTag, "Mode") == 0)
{
vector<ATTRIBUTE> vecModeAttr;
GetNodeAttributes(pDOMNode, vecModeAttr);
DOMNode *pChildNode = pDOMNode->getFirstChild();
if ((pChildNode) && (pChildNode->getNodeType() ==
DOMNode::ELEMENT_NODE))
{
strTag = XMLString::transcode(pChildNode->getNodeName());
cout<<strTag<<endl;
if (strcmpi(strTag, "Command") == 0)
{
vector<ATTRIBUTE> vecCommandAttr;
GetNodeAttributes(pChildNode, vecCommandAttr);
cout<<vecModeAttr[1].strVal.c_str()<<endl;
cout<<vecCommandAttr[1].strVal.c_str()<<endl;
(*pMapTempMode)[vecModeAttr[1].strVal.c_str()] =
vecCommandAttr[1].strVal.c_str();
}
}
}
pDOMNode = pDOMNode->getNextSibling();
GetModeElements(pDOMNode, pMapTempMode);
}
}
//Retrieves all the Attributes for a ParticularNode
void XMLFileParser::GetNodeAttributes(const DOMNode *pDOMNode,
std::vector<ATTRIBUTE>& vecAttr)
{
if(pDOMNode->hasAttributes()) //Check whether that node has
attributes or not
{
ATTRIBUTE Attr;
DOMAttr* pAttributeNode = 0;
// Retrieve all the attributes of the node
DOMNamedNodeMap *pAttributes = pDOMNode->getAttributes();
for(unsigned int i = 0; i < pAttributes->getLength(); i++)
{
pAttributeNode = (DOMAttr*) pAttributes->item(i);
// Retrieve the attribute name
Attr.strName.assign(XMLString::transcode(pAttribut eNode->getName()));
// Retrieve the attribute type
Attr.strVal.assign(XMLString::transcode(pAttribute Node->getValue()));
vecAttr.push_back(Attr); //Push all the attributes in a vector
}
}
}
/*void XMLFileParser::DisplayEventData(EVENTDATA pEventData)
{
if(pEventData !=0)
{
pEventData::iterator p;
for(itm = mapMouseEvent.begin();itm != mapMouseEvent.end();itm++)
{
cout<<itm->first;
for(p =(itm->second).begin();p !=(itm->second).end();itm++)
{
cout<<p->first<<endl<<p->second;
}
}
}
}*/
bool XMLFileParser::OpenXMLDocument(const char* strFileName)
{
bool bReturn = true;
// reset document pool
try
{
if (Initialize())
{
m_pDOMParser->resetDocumentPool();
m_pXMLDocument = m_pDOMParser->parseURI(strFileName);
// Extract the DOM tree, get the list of all the elements
if (m_pXMLDocument)
{
ReadConfigurationFile((DOMNode*)m_pXMLDocument->getDocumentElement());
//DisplayMenuData(m_pMenuParentData);
//DisplayToolbarsData(m_pToolBarData);
//DisplayEventData(m_pMouseEventData);
//DisplayEventData(m_pKeyBoardEventData);
bReturn = true;
}
}
else
{
bReturn = false;
}
}
catch (...)
{
bReturn = false;
}
return bReturn;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
XMLFileParser.h
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/parsers/AbstractDOMParser.hpp>
#include <xercesc/dom/DOMImplementation.hpp>
#include <xercesc/dom/DOMImplementationLS.hpp>
#include <xercesc/dom/DOMImplementationRegistry.hpp>
#include <xercesc/dom/DOMBuilder.hpp>
#include <xercesc/dom/DOMException.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMNodeList.hpp>
#include <xercesc/dom/DOMError.hpp>
#include <xercesc/dom/DOMLocator.hpp>
#include <xercesc/dom/DOMNamedNodeMap.hpp>
#include <xercesc/dom/DOMAttr.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/util/XMLString.hpp>
#if defined(XERCES_NEW_IOSTREAMS)
#include <iostream>
#else
#include <iostream.h>
#endif
XERCES_CPP_NAMESPACE_USE
#include <vector>
#include <string>
#include <map>
using namespace std;
typedef struct
{
string strName;
string strVal;
} ATTRIBUTE;
typedef struct
{
string strDisplayName;
string strId;
string strType;
} ATTRIBUTEDATA;
typedef struct MENUDATA
{
ATTRIBUTEDATA structAttribData;
vector<MENUDATA*> vecMenuData;
} MENUDATA;
typedef struct
{
std::vector<ATTRIBUTEDATA*> vecDrawingToolBar;
std::vector<ATTRIBUTEDATA*> vecTextToolBar;
std::vector<ATTRIBUTEDATA*> vecRunTimeOptionsToolBar;
std::vector<ATTRIBUTEDATA*> vecFileControlToolBar;
std::vector<ATTRIBUTEDATA*> vecNodeStyleToolBar;
std::vector<ATTRIBUTEDATA*> vecAlignmentToolBar;
std::vector<ATTRIBUTEDATA*> vecStandardToolBar;
} TOOLBARDATA;
typedef map<string, string> MAPMODE;
typedef map<string, MAPMODE*> MAPEVENT;
class XMLFileParser
{
private:
MAPEVENT* m_pMouseEventData;
MAPEVENT* m_pKeyBoardEventData;
TOOLBARDATA* m_pToolBarData;
MENUDATA* m_pMenuParentData;
DOMBuilder* m_pDOMParser;
XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *m_pXMLDocument;
int Initialize();
void ReadConfigurationFile(const DOMNode *pDOMNode);
//void GetToolBarsandMenuElements(const DOMNode *pDOMNode);
void GetEventConfigurationElements(const DOMNode *pDOMNode);
void GetEventElements(const DOMNode *pDOMNode, MAPEVENT*&);
void GetModeElements(const DOMNode *pDOMNode, MAPMODE*&);
void GetCommandElements(const DOMNode *pDOMNode,
std::vector<ATTRIBUTE>& vecTempCommandAttr); /*void
GetToolBarElements(const DOMNode *pDOMNode,
vector<ATTRIBUTEDATA*>& vecToolbarElements);
ATTRIBUTEDATA* GetToolElements(const DOMNode *pDOMNode);
void GetMenuElements(const DOMNode *pDOMNode, MENUDATA*
pMenuParentData,
MENUDATA* pMenuChildData);*/
void GetNodeAttributes(const DOMNode *pDOMNode,
std::vector<ATTRIBUTE>& vecAttr);
void GetTempElements(const DOMNode *pDOMNode, MAPMODE*&);
/*void GetToolBars(const DOMNode *pDOMNode);
bool CheckNode(const DOMNode *pDOMNode);
void DisplayMenuData(MENUDATA* pMenuData);
void DisplayToolbarsData(TOOLBARDATA* pToolbarData);
void DisplayEventData();
*/
public:
XMLFileParser();
~XMLFileParser();
bool OpenXMLDocument(const char* strFileName);
};
Thanking u in Advance.
Hepsiba Sushma