ASMXMLParser.hpp

Go to the documentation of this file.

#ifndef HCEXML_PARSER_HPP
#define HCEXML_PARSER_HPP

#include <Poco/JSON/Object.h>
#include <Poco/SAX/SAXParser.h>
#include <Poco/SAX/ContentHandler.h>
#include <Poco/SAX/LexicalHandler.h>
#include <Poco/SAX/Attributes.h>
#include <Poco/SAX/Locator.h>
#include <Poco/Exception.h>
#include <iostream>
#include <stack>

#include "XMLEmptyNameException.hpp"

using Poco::XML::SAXParser;
using Poco::XML::XMLReader;
using Poco::XML::XMLString;
using Poco::XML::XMLChar;
using Poco::XML::ContentHandler;
using Poco::XML::LexicalHandler;
using Poco::XML::Attributes;
using Poco::XML::Locator;

using namespace HCE::exception;

namespace HCE
{
  namespace utils
  {
    class HCEXMLParser: public ContentHandler, public LexicalHandler
    {
    protected:
      std::stack<Poco::JSON::Object::Ptr> objStack;
      std::stack<XMLString> attrNamesStack;
      std::string tagVal;
      Poco::JSON::Object::Ptr rootObject;
      std::vector<XMLString> attrTagNames;
    public:
      HCEXMLParser():_pLocator(0)
      {
        tagVal = "";
        rootObject = NULL;
      }
      
      void addAttrTag(std::string tagName)
      {
        attrTagNames.push_back(tagName);
      }
      
      // ContentHandler
      void setDocumentLocator(const Locator* loc)
      {
        _pLocator = loc;
      }
      
      void startDocument()
      {
      }
      
      void endDocument()
      {
      }
      
      void startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
      {
        objStack.push(new Poco::JSON::Object());
        attrNamesStack.push(localName);
        tagVal = "";
        if(attributes.getLength() > 0)
        {
          for(unsigned int i = 0; i < attrTagNames.size(); i++)
          {
            if(!attributes.getValue(attrTagNames[i]).empty())
            {
              attrNamesStack.top() = attributes.getValue(attrTagNames[i]);
              break;
            }
          }
          bool isFind = false;
          Poco::JSON::Object::Ptr localObjPtr = Poco::JSON::Object::Ptr(new Poco::JSON::Object());
          Poco::JSON::Object::Ptr localObjPtrParent = objStack.top();
          for(unsigned int i = 0; i < static_cast<unsigned int>(attributes.getLength()) ; i++)
          {
            isFind = false;
            for(unsigned int j = 0; j < attrTagNames.size(); j++)
            {
              if(attributes.getLocalName(i).compare(attrTagNames[j]) == 0)
              {
                isFind = true;
                break;
              }
            }
            if(!isFind)
            {
              tagVal = attributes.getValue(i);
              insertAtEndElement(attributes.getLocalName(i), localObjPtr, localObjPtrParent);
            }
          }
          tagVal = "";
        }
      }
      
      void insertAtEndElement(const XMLString& localName, Poco::JSON::Object::Ptr localObjPtr, Poco::JSON::Object::Ptr localObjPtrParent)
      {
        const XMLString &tagAttrName = ((attrNamesStack.empty() || attrNamesStack.top().empty()) ? localName : attrNamesStack.top());
        if(tagAttrName.empty())
        {
          throw XMLEmptyNameException("Empty Tag Name");
        }
        else if(tagAttrName != localName)
        {
          throw XMLEmptyNameException("Wrong Close Tag Name");
        }
        Poco::Dynamic::Var localVar;
        if(localObjPtr->size() > 0)
        {
          localVar = localObjPtr;
        }
        else
        {
          localVar = tagVal;
        }
        if(!localObjPtrParent->has(tagAttrName))
        {
          localObjPtrParent->set(tagAttrName, localVar);
        }
        else if(localObjPtrParent->isArray(tagAttrName))
        {
          Poco::JSON::Array::Ptr localArray = localObjPtrParent->getArray(tagAttrName);
          if(!localArray.isNull())
          {
            localArray->add(localVar);
          }
        }
        else
        {
          Poco::JSON::Array::Ptr localArray = Poco::JSON::Array::Ptr(new Poco::JSON::Array());
          localArray->add(localObjPtrParent->get(tagAttrName));
          localArray->add(localVar);
          localObjPtrParent->remove(tagAttrName);
          localObjPtrParent->set(tagAttrName, localArray);
        }
      }
      
      void endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname)
      {
        Poco::JSON::Object::Ptr localObjPtr;
        if(!objStack.empty())
        {
          localObjPtr = objStack.top();
          objStack.pop();
          if(objStack.size() > 0)
          {
            Poco::JSON::Object::Ptr localObjPtrParent = objStack.top();
            if(!localObjPtr.isNull() && !localObjPtrParent.isNull())
            {
              insertAtEndElement(localName, localObjPtr, localObjPtrParent);
            }
          }
          else
          {
            rootObject = localObjPtr;
          }
          attrNamesStack.pop();
          tagVal = "";
        }
      }
      
      void characters(const XMLChar ch[], int start, int length)
      {
        tagVal.append(ch + start, length);
      }
      
      void ignorableWhitespace(const XMLChar ch[], int start, int length)
      { 
      }
      
      void processingInstruction(const XMLString& target, const XMLString& data)
      {
      }
      
      void startPrefixMapping(const XMLString& prefix, const XMLString& uri)
      {
      }
      
      void endPrefixMapping(const XMLString& prefix)
      {
      }
      
      void skippedEntity(const XMLString& name)
      {
      }
      
      // LexicalHandler
      void startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId)
      {
      }
      
      void endDTD()
      {
      }
      
      void startEntity(const XMLString& name)
      {
      }
      
      void endEntity(const XMLString& name)
      {
      }
      
      void startCDATA()
      {
      }
      
      void endCDATA()
      {
      }
      
      void comment(const XMLChar ch[], int start, int length)
      {
      }
      
      Poco::JSON::Object::Ptr getObject()
      {
        return rootObject;
      }
      
    private:
      const Locator* _pLocator;
    };
  }
}

#endif