/* -*- C++ -*- */

#include <iostream>

#include <string>

#include <vector>

#include <list>

#include <map>

#include <lemon/xy.h>

class XmlWriter 

{

  std::ostream& os;

  int level;

protected:

  void indent(int level) {

    os << std::endl;

    for(int i=0;i<level;i++) os << ' ';

  }

  void tag(const std::string &_tag) {

    os << '<' << _tag << '>';

  }

  void etag(const std::string &_tag) {

    os << "</" << _tag << '>';

  }

  void itag(const std::string &_tag) { indent();tag(_tag); }

  void ietag(const std::string &_tag) { indent();etag(_tag); }

  void beginTag(const std::string &_tag) {

    itag(_tag);

    level++;

  }

  void endTag(const std::string &_tag) {

    level--;

    ietag(_tag);

  }

public:

  void indent() 

  {

    if(level>=0) indent(level);

    else level=0;

  }

  ///\e

  ///\e

  ///

  class ContTag

  {

    XmlWriter &ix;

    const std::string _tag;

  public:

  ///\e

  ///\e

  ///

    ContTag(XmlWriter &_ix,const std::string &_t) :

      ix(_ix), _tag(_t)

    {

      ix.tag(_tag);

    }

    ~ContTag() { ix.etag(_tag);}

  };

  class LineTag

  {

    XmlWriter &ix;

    const std::string _tag;

  public:

    ///\e

    ///\e

    ///

    LineTag(XmlWriter &_ix,const std::string &_t) :

      ix(_ix), _tag(_t)

    {

      ix.itag(_tag);

    }

    ~LineTag() { ix.etag(_tag);}

  };

  ///\e

  ///\e

  ///

  class Tag

  {

    XmlWriter &ix;

    const std::string _tag;

  public:

    ///\e

    ///\e

    ///

    Tag(XmlWriter &_ix,const std::string &_t) :

      ix(_ix), _tag(_t)

    {

      ix.beginTag(_tag);

    }

    ~Tag() { 

      ix.endTag(_tag);

    }

  };

  ///\e

  ///\e

  ///

  XmlWriter(std::ostream& _os) : os(_os),level(-1) {}

  ~XmlWriter() { os<< std::endl; }

  XmlWriter &operator()(int v) 

  { 

    if(!(os << v)) throw (std::ios::failure ("data format error"));

    return *this;

  }

  XmlWriter &operator()(const std::string &_tag,int v) 

  { 

    LineTag t(*this,_tag);

    if(!(os << v)) throw (std::ios::failure ("data format error"));

    return *this;

  }

  XmlWriter &operator()(const std::string &_tag,double v) 

  {

    LineTag t(*this,_tag);

    if(os << v) throw (std::ios::failure ("data format error"));

    return *this;

  }

  XmlWriter &operator()(double v) 

  {

    os << v;

    return *this;

  }

  XmlWriter &operator()(const std::string &v)

  {

    for(std::string::const_iterator i=v.begin();i!=v.end();++i)

      switch(*i) {

      case '\\':

	os << "\\\\";

	break;

      case '<':

	os << "\\<";

	break;

      case '&':

	os << "\\&";

	break;

      case '\n':

	os << "\\n";

	break;

      default:

	os<<*i;

	break;

      }

    return *this;

  }

  XmlWriter &operator()(const std::string &_tag,const std::string &v)

  {

    LineTag t(*this,_tag);

    (*this)(v);

    return *this;

  }

  ///\e

  ///\e

  ///

  template<class V>

  XmlWriter &operator()(const std::string &_tag,const V &v)

  {

    Tag t(*this,_tag);

    out(*this,v);

    return *this;

  }

  ///\e

  ///\e

  ///

  template<class V>

  XmlWriter &operator()(const V &v)

  {

    out(*this,v);

    return *this;

  }

};

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

class XmlReader 

{

  std::istream& is;

  std::string next_tag;

  void skipWhiteSpaces()

  {

    char c;

    while (is.get(c) && std::isspace(c,is.getloc()));

    is.unget();

  }

protected:

  ///\e

  ///\e

  ///

  void useTag() {next_tag.clear();}

  void useTag(const std::string &_tag) {

    if(nextTag()==_tag) useTag();

    else throw (std::ios::failure ("data format error"));

  }

public:

  ///\e

  ///\e

  ///

  const std::string &nextTag() 

  {

    if(next_tag.empty()) {

      char c;

      skipWhiteSpaces();

      if(!is.get(c) || c!='<')

	throw (std::ios::failure ("data format error"));

      next_tag.clear();

      while (is.get(c) && c!='>') next_tag.push_back(c);

      if(c!='>')

	throw (std::ios::failure ("data format error"));

    }

    return next_tag;

  }

  ///\e

  ///\e

  ///

  class Tag

  {

    XmlReader &ix;

    const std::string tag;

  public:

    ///\e

    ///\e

    ///

    Tag(XmlReader &_ix,const std::string &_tag) :

      ix(_ix), tag(_tag)

    {

      ix.useTag(_tag);

    }

    ~Tag() {

      if(!std::uncaught_exception()) 

	ix.useTag('/'+tag);

    }

  };

  ///\e

  ///\e

  ///

  XmlReader(std::istream& _is) : is(_is) {}

  int operator()(const std::string &tag,int &v)

  { 

    Tag t(*this,tag);

    if(!(is >> v)) throw (std::ios::failure ("data format error"));

    return v;

  }

  double operator()(const std::string &tag,double &v) 

  {

    Tag t(*this,tag);

    if(!(is >> v)) throw (std::ios::failure ("data format error"));

    return v;

  }

  std::string &operator()(const std::string &tag,std::string &v)

  {

    Tag t(*this,tag);

    v.clear();

    char c;

    while (is.get(c) && c!='<')

      if(c=='\\')

	if(!is.get(c)) throw (std::ios::failure ("data format error"));

	else switch(c) {

	case 'n':

	  v.push_back('\n');

	  break;

	default:

	  v.push_back(c);

	  break;

	}

      else v.push_back(c);

    if(c!='<')

	throw (std::ios::failure ("data format error"));

    is.unget();

    return v;

  }

  ///\e

  ///\e

  ///

  template<class V>

  V &operator()(const std::string &tag,V &v)

  {

    Tag t(*this,tag);

    in(*this,v);

    return v;

  }

  ///\e

  ///\e

  ///

  template<class V>

  V &operator()(V &v)

  {

    in(*this,v);

    return v;

  }

  ///\e

  ///\e

  ///

  template<class V>

  V load(const std::string &tag)

  {

    Tag t(*this,tag);

    V v;

    (*this)(tag,v);

    return v;

  }

};

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

template<class A,class B>

void out(XmlWriter &i,const std::pair<A,B> &v)

{

  i("first",v.first);

  i("second",v.second);

}

template<class A,class B>

void in(XmlReader &i,std::pair<A,B> &v)

{

  i("first",v.first);

  i("second",v.second);

}

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

template<class T>

void out(XmlWriter &i,const std::list<T> &v)

{

  for(typename std::list<T>::const_iterator it=v.begin();

      it!=v.end();++it) i("item",*it);

}

template<class T>

void in(XmlReader &i,std::list<T> &v)

{

  while(i.nextTag()=="item")

    {

      v.push_back(T());

      i("item",v.back());

    }

}

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

template<class T>

void out(XmlWriter &i,const std::vector<T> &v)

{

  for(typename std::vector<T>::const_iterator it=v.begin();

      it!=v.end();++it) i("item",*it);

}

template<class T>

void in(XmlReader &i,std::vector<T> &v)

{

  while(i.nextTag()=="item")

    {

      v.push_back(T());

      i("item",v.back());      

    }

}

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

template<class K,class V>

void out(XmlWriter &i,const std::map<K,V> &v)

{

  for(typename std::map<K,V>::const_iterator it=v.begin();

      it!=v.end();++it) i("item",*it);

}

template<class K,class V>

void in(XmlReader &i,std::map<K,V> &v)

{

  while(i.nextTag()=="item")

    {

      typename std::map<K,V>::value_type it;

      i("item",it);

      v.insert(it);

    }

}

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

template<class T>

void out(XmlWriter &i,const lemon::xy<T> &v)

{

//   i("x",v.x);

//   i("y",v.y);

  { XmlWriter::LineTag t(i,"x"); i(v.x); }

  { XmlWriter::ContTag t(i,"y"); i(v.y); }

}

template<class T>

void in(XmlReader &i,lemon::xy<T> &v)

{

  i("x",v.x);

  i("y",v.y);

}

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

template<class T>

void out(XmlWriter &i,const lemon::BoundingBox<T> &v)

{

  if(!v.empty()) {

    i("point",v.bottomLeft());

    if(v.bottomLeft()!=v.topRight()) i("point",v.topRight());

  }

}

template<class T>

void in(XmlReader &i,lemon::BoundingBox<T> &v)

{

  v.clear();

  while(i.nextTag()=="point") {

    lemon::xy<T> co;

    i("point",co);

    v+=co;

  }

}