Subversion Repositories gelsvn

#include <fstream>

#include <string>

#include <sstream>

#include <cstring>

#include <algorithm>

#include <list>

#include "XmlParser.h"

#include "string_utils.h"

using namespace std;

namespace Util

{

  /////////////////////////////////////////////////////////////////

  // String handling

  /////////////////////////////////////////////////////////////////

  void parse_attribs(const string& s, map<string, string>& result)

  {

    string name1, name2;

    list<string> atts;

    trim_split(s, atts, "=");

    if(atts.empty())

      return;

    get_last(atts.front(), name1);

    list<string>::iterator i = atts.begin();

    list<string>::iterator end = atts.end();

    if(i == --end)

      return;

    for(++i; i != end; ++i)

    { 

      get_last(*i, name2);

      result[trim(name1)] = trim(*i, " \"");

      name1 = name2;

    }

    result[trim(name1)] = trim(*end, " \"");

  }

  /////////////////////////////////////////////////////////////////

  // File handling

  /////////////////////////////////////////////////////////////////

  ifstream& seek_string(ifstream& in, const string& s, const size_t bufsize = 100)

  {

    const int bsize = static_cast<int>(max(s.size(), bufsize));

    const int n = static_cast<int>(s.size());

    char* buf = new char[bsize + 1];

    char s0 = s[0];

    in.get(buf, bsize, s0);

    in.clear();

    in.read(buf, n);

    buf[n] = '\0'; 

    while(in && strcmp(s.c_str(), buf) != 0)

    {

      in.get(buf, bsize, s0);

      in.clear();

      in.read(buf, n);

      buf[n] = '\0'; 

    }

    delete [] buf;

    return in;

  }

  ifstream& read_until(ifstream& in, string& s_in, const string s, const size_t bufsize = 500)

  {

    const int bsize = static_cast<int>(max(s.size(), bufsize));

    const int n = static_cast<int>(s.size());

    char* buf = new char[bsize + 1];

    char s0 = s[0];

    ostringstream ostr;

    in.get(buf, bsize, s0);

    ostr << buf;

    in.clear();

    in.read(buf, n);

    buf[n] = '\0'; 

    while(in && strcmp(s.c_str(), buf) != 0)

    {

      ostr << buf;

      in.get(buf, bsize, s0);

      ostr << buf;

      in.clear();

      in.read(buf, n);

      buf[n] = '\0'; 

    }

    s_in = ostr.str();

    delete [] buf;

    return in;

  }

  ifstream& operator>>(ifstream& in, XmlHead& fhead)

  {

    seek_string(in, "<?xml");

    string head;

    read_until(in, head, "?>");

    fhead.is_xml = in.good();

    parse_attribs(head, fhead.atts);

    return in;

  }

  ifstream& operator>>(ifstream& in, XmlElement& elem)

  {

    seek_string(in, "<");

    string head;

    read_until(in, head, ">");

    if(head.empty() || head[0] == '!') return in;

    if(head[0] == '/')

    {

      if(elem.parent && elem.parent->name == head.substr(1))

        in.setstate(ios_base::eofbit);

      else

        elem.name = "";

      return in;

    }

    bool has_body = true;

    if(head[head.size() - 1] == '/')

    {

      has_body = false;

      head.erase(head.size() - 1);

    }

    get_first(head, elem.name);

    elem.name = trim(elem.name);

    parse_attribs(head, elem.atts);

    if(has_body)

    {

      delete elem.body;

      elem.body = new XmlBody(elem.doc);

      elem.body->element.parent = &elem;

      read_until(in, elem.body->text, "<");

      in.putback('<');

    }

    return in;

  }

  ifstream& operator>>(ifstream& in, XmlBody& body)

  {

    read_until(in, body.text, "<");

    in.putback('<');

    return in;

  }

  /////////////////////////////////////////////////////////////////

  // Methods

  /////////////////////////////////////////////////////////////////

  XmlElement::~XmlElement()

  {

    delete body;

  }

  void XmlBody::process_element()

  {

    if(!doc) return;

    if((doc->infile >> element) && !doc->infile.eof())

    {

      XmlElementHandler h = doc->handlers[element.name];

      if(h) 

        h(element);

      else 

        element.process_elements();

    }

  }

  void XmlElement::process_elements()

  {

    if(!doc) return;

    if(!body) return; 

    while(!doc->infile.eof() && (doc->infile >> body->element))

    {

      XmlElementHandler h = doc->handlers[body->element.name];

      if(h) 

        h(body->element);

      else 

        body->element.process_elements();

    }

    doc->infile.clear();

  }

  XmlDoc::XmlDoc(const char *filename)

    : body(0), infile(filename)

  {

    if(!infile)

    {

       cerr << "cannot open input file" << filename << endl;

       return;

    }

    if(infile >> head)

      infile >> body;

    else

      cerr << filename << " is not a valid xml-file" << endl;

    body.doc = this;

    body.element.doc = this;

  }

  void XmlDoc::process_elements()

  {

    while((infile >> body.element) && !infile.eof())

    {

      XmlElementHandler h = handlers[body.element.name];

      if(h) 

        h(body.element);

      else 

        body.element.process_elements();

    }

    infile.clear();

  }

  /////////////////////////////////////////////////////////////////

  // Output handling

  /////////////////////////////////////////////////////////////////

  ostream& operator<<(ostream& out, const pair<string, string>& attrib)

  {

    return out << attrib.first << "=\"" << attrib.second << "\"";

  }

  ostream& operator<<(ostream& out, const XmlHead& head)

  {

    out << "<?xml";

    for(map<string, string>::const_iterator i = head.atts.begin(); i != head.atts.end(); ++i)

      out << " " << *i;

    out << "?>";

    return out;

  }

}