---

ocXML.h

#include <string>
#include <iomanip>
#include <algorithm>
#include <map>
#include <vector>
#include <stack>
#include <fstream>
#include "ocString.h"

#ifndef OC_XML_H
#define OC_XML_H

using namespace std;

// define a base function object to be used by the parser
class parseFobject
{
public:
  // ctor
  parseFobject()
  {;}
  // the function operator itself
  virtual void operator () ( ocString & in )
  {;}// default base method does nothing
};

// define the base parser
class ocGenericParser
{
protected:
  istream * iStream;
  ocString  input;
  parseFobject * pCurrentFunction;
public:
  ocGenericParser( istream * in ):iStream(in),pCurrentFunction(NULL)
  {
    ;
  }
  ocGenericParser( string & in ):iStream(NULL),pCurrentFunction(NULL)
  {
    input = in;
  }
  virtual ~ocGenericParser()
  {;}
  bool parse( void )
  {
    // the object will be entered with 1 of 2 constructors
    bool bGood=true;
    do
    {
      // IS a function, input to parse, input is not finished parsing
      while( pCurrentFunction && input.length() && !input.endOfParse() )
      {
        curFunc()(input);
      }
      if(iStream)
      {
        iStream->clear();
        getline(*iStream,input);
        input.parseInit();
        bGood = iStream->good();
      }
    } while( pCurrentFunction && iStream && !iStream->eof() );
    return bGood;
  }
  parseFobject & curFunc(void)
  {
    return *pCurrentFunction;
  }
  virtual void callback( void )
  {
    ;
  }
};

// Define a derived function object to overload
class baseFunc: public parseFobject
{
protected:
  ocGenericParser & rParser; // reference to parser
public:
  // ctor
  baseFunc(ocGenericParser & irParser):parseFobject(),rParser(irParser){;}
  // v dtor
  virtual ~baseFunc(){;}
};

/*
  Abstraction of a (flat) xml node
*/
typedef class map<string,string> node_attr;
class xmlNode
{
public:
  string name;
  string data;
  node_attr attr;
  bool monopole;
  xmlNode()
  :name(""),data(""),attr(),monopole(false)
  {;}
  xmlNode(const xmlNode & in)
  :name(in.name),data(in.data),attr(in.attr),monopole(in.monopole)
  {;}
  xmlNode & operator = (const xmlNode & in)
  {
    name=in.name;
    data=in.data;
    attr=in.attr;
    monopole=in.monopole;
    return *this;
  }
  string emit( void )
  {
    string ret = "<";
    ret += name;
    if( attr.size() )
    {      
      node_attr::iterator it;
      for( it = attr.begin(); it != attr.end(); ++it )
      {
        ret += " ";
        ret += it->first;
        ret += "='";
        ret += it->second;
        ret += "'";
      }      
    }
    if( monopole )
    {
      ret += "/>";
    }
    else
    {
      ret += ">";
      ret += data;
      ret += "</";
      ret += name;
      ret += ">";
    }
    return ret;
  }
};

/*
  This particular implementaion flattens the tree into a multimap.
*/
typedef class vector<xmlNode> node_vector;
typedef class multimap<string,size_t> node_map;
typedef class stack<size_t> node_stack;
struct stateMachine
{
  node_vector nodes;
  node_stack nodestack;
  node_map   nodemap;
  xmlNode & topNode( void )
  {
    return nodes[nodestack.top()];
  }
};

// start with the XML operators
class findStart: public baseFunc
{
public:
  ocString data;
  bool foundStart;
  findStart(ocGenericParser & irParser):baseFunc(irParser)
  {
    foundStart = false;
  }
  void operator () ( ocString & in )
  {
    data += in.parse("<");
    foundStart = (in.lastPos() > 0);
    if( foundStart )
    {
      rParser.callback();
      data = "";
    }
  }
};


class findEnd: public baseFunc
{
public:
  ocString data;
  bool foundEnd;

  findEnd(ocGenericParser & irParser):baseFunc(irParser)
  {
    foundEnd = false;
  }

  void operator () ( ocString & in )
  {
    data += in.parse(">");
    foundEnd = (in.lastPos() > 0);
    if( foundEnd )
    {
      rParser.callback();
      data = "";
    }
  }
};
/*
  Escape these values:
  int [34]  hex [22] = ["] = &#x22;
  int [37]  hex [25] = [%] = &#x25;
  int [38]  hex [26] = [&] = &#x26;
  int [39]  hex [27] = ['] = &#x27;
  int [43]  hex [2b] = [+] = &#x2b;
  int [60]  hex [3c] = [<] = &#x3c;
  int [62]  hex [3e] = [>] = &#x3e;

  in hex the escape would be &#xNN;
  The values will be unescaped by the xml parser.
  see W3C XML spec section 4.1 Character and Entity References
*/
string xmlEscape( string in )
{
  ocString temp ( in );
  return temp.replaceAll( "\"", "&#x22;" )
             .replaceAll( "%", "&#x25;" )
             .replaceAll( "&", "&#x26;" )
             .replaceAll( "'", "&#x27;" )
             .replaceAll( "+", "&#x2b;" )
             .replaceAll( "<", "&#x3c;" )
             .replaceAll( ">", "&#x3e;" );
}
string xmlUnescape( string in )
{
  ocString temp ( in );
  return temp.replaceAll(  "&#x22;", "\"")
             .replaceAll(  "&#x25;", "%" )
             .replaceAll(  "&#x26;", "&" )
             .replaceAll(  "&#x27;", "'" )
             .replaceAll(  "&#x2b;", "+" )
             .replaceAll(  "&#x3c;", "<" )
             .replaceAll(  "&#x3e;", ">" );
}

// Now make the special xml flavor of the parser
class xmlParser : public ocGenericParser
{
private:
  // function objects
  findStart    start;
  findEnd      end;  
  node_vector::iterator xnode_it;
  
  void startCallback(void)
  {
    size_t len = start.data.length();
    if( len && !states.nodestack.empty() )
    {
      // Add data to the last known top node
      xmlNode & rNode =  states.topNode();
      rNode.data += xmlUnescape(start.data);
    }
    pCurrentFunction = &end;
  }
  void endCallback(void)
  {
    ocString parseableData = end.data;
    size_t len = end.data.length();
    if( len == 0 ) return;

    // see if this is the end ex: </tag>
    bool isEndTag = end.data[0] == '/';
    // see if this is a monopole ex: <tag/>
    bool isMonoTag = end.data[len-1] == '/';
    if( isMonoTag )
    {
      len--;
      parseableData.resize(len);
    }
    if( !isEndTag || isMonoTag )
    {
      // This is the beginning container tag, or a monotag
      // EX: [name attr1='x' attr2="y z" ...]
      //   so parse the name and attributes:
      xmlNode node;
      // Get the name
      node.name = parseableData.tokenParse( " \t\n\r" );
      if( isMonoTag ) node.monopole = true;
      // Get the attributes (if any)
      do
      {
        // EX: [attr1='x' attr2="y z" ...]
        string attrCandidate = parseableData.parse( "=" );
        // for attributes after the first attribute, there will be a space...
        while( attrCandidate.size() && (
               attrCandidate[0] == ' ' ||
               attrCandidate[0] == '\n' || 
               attrCandidate[0] == '\t' ) ) attrCandidate.erase(0,1);
        if(attrCandidate.length())
        {
          string attrName = attrCandidate;
          // EX: ['x' attr2="y z" ...]
          // build token on valid chars ' or "
          char pTok[2];
          pTok[0] = parseableData.remainder()[0];
          pTok[1] = '\0';
          parseableData.parse( pTok ); // strip the first quote
          string attrValue = parseableData.parse( pTok ); // get the value
          // EX: [ attr2="y z" ...] NOTE THE SPACE
          if( attrName.length() && attrValue.length() )
          {
            node.attr.insert(make_pair(attrName,xmlUnescape(attrValue)));
          }
        }
      } while(!parseableData.endOfParse());
      // add the node
      addNode(node);
            
      if( !isMonoTag )
      {
        // Push the last item on the stack
        //   so data can be added to the parent
        //   node in a nested doc.
        size_t nTop = states.nodes.size()-1;
        states.nodestack.push(nTop);
      }
    } // End if start of container
    if(isEndTag)
    {
      // This contained item is finished so
      //   pop the last item off the stack
      states.nodestack.pop();
    }
    pCurrentFunction = &start;
  }
public:
  // state machine
  stateMachine states;

  xmlParser( istream * in ):ocGenericParser(in),start(*this),end(*this)
  {
    pCurrentFunction = &start;
  }
  xmlParser(string & in):ocGenericParser(in),start(*this),end(*this)
  {
    pCurrentFunction = &start;
  }
  virtual ~xmlParser(){;}

  virtual void callback( void )
  {
    if( pCurrentFunction == &start )
    {
      startCallback();
    }
    else if(pCurrentFunction == &end)
    {
      endCallback();
    }
  }
  // Return the node list
  node_vector & nodeList( void )
  {
    return states.nodes;
  }
  // Add a new node, outside of the parse
  void addNode( xmlNode &node )
  {
    states.nodes.push_back(node);
    states.nodemap.insert(make_pair(node.name,states.nodes.size()-1));
  }
  
  // Re-emit as XML
  string emit( void )
  {
    string ret;
    for(int i=0;i<states.nodes.size();i++)
    {
      ret += states.nodes[i].emit();
    }
    return ret;
  }
  
  
  // Find the first instance of a node that has an attribute 'name' having 'value'
  node_vector::iterator & findFirstNodeByAttribute( string name, string value )
  {
    xnode_it = states.nodes.begin();    
    for( ;xnode_it!=states.nodes.end();++xnode_it)
    {
      node_attr::iterator it = (*xnode_it).attr.find(name);
      if( it != (*xnode_it).attr.end() )
      {
        if( it->second == value ) 
        {             
          break;
        }  
      }    
    }
    return xnode_it;
  } 
};

/*
Usage example:
int main( int argc, char * argv[] )
{

  xmlParser parser( &cin );
  parser.parse();
  node_vector & xnodes = parser.nodeList();
  int i;

  for(i=0;i<xnodes.size();i++)
  {
    xmlNode & node = xnodes[i];
    cout << "Node: " << node.name << endl
         << " contains: " << node.data << endl;
    cout << "node attributes" << endl << "=================" << endl;
    node_attr::iterator x;
    for( x=node.attr.begin(); x!=node.attr.end(); ++x)
    {
      cout << x->first << " = " << x->second << endl;
    }
    cout << "=================" << endl;
  }
  return 0;
}

*/
#endif

---