/* -*- C++ -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2003-2006

  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Research Group on Combinatorial Optimization, EGRES).

  *

  * Permission to use, modify and distribute this software is granted

  * provided that this copyright notice appears in all copies. For

  * precise terms see the accompanying LICENSE file.

  *

  * This software is provided "AS IS" with no warranty of any kind,

  * express or implied, and with no claim as to its suitability for any

  * purpose.

  *

  */

 #ifndef GLEMON_XML_H

 #define GLEMON_XML_H

 #include <iostream>

 #include <string>

 #include <vector>

 #include <list>

 #include <map>

 #include <lemon/error.h>

 #include <lemon/assert.h>

 #include <lemon/dim2.h>

 namespace lemon {

   class XmlIo 

   {

     bool _writeMode;

   public:

     ///Check if XmlIo is in write mode.

     bool write() { return _writeMode;}

     ///Check if XmlIo is in read mode.

     bool read() { return !_writeMode;}

     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:

     ///Indent the line according to its level.

     ///\warning It can only be used in write mode.

     ///

     void indent()

     {

       if(write())

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

 	else level=0;

       else LEMON_ASSERT(true, "Invalid indentation.");	

     }

     ///Read/write a tag

     ///Read/write a tag.

     ///In write mode it does not start a new line.

     class ContTag

     {

       XmlIo &ix;

       const std::string _tag;

     public:

       ///\e

       ///\e

       ///

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

 	ix(_ix), _tag(_t)

       {

 	if(ix.write()) ix.tag(_tag);

 	else ix.useTag(_tag);

       }

       ~ContTag() { 

 	if(ix.write()) ix.etag(_tag);

 	else if(!std::uncaught_exception()) ix.useTag('/'+_tag);      

       }

     };

     ///Read/write a tag

     ///Read/write a tag.

     ///The whole \<foo\> ... \</foo\> will be placed in a single line.

     class LineTag

     {

       XmlIo &ix;

       const std::string _tag;

     public:

       ///\e

       ///\e

       ///

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

 	ix(_ix), _tag(_t)

       {

 	if(ix.write()) ix.itag(_tag);

 	else ix.useTag(_tag);

       }

       ~LineTag() { 

 	if(ix.write()) ix.etag(_tag);

 	else if(!std::uncaught_exception()) ix.useTag('/'+_tag);

       }

     };

     ///Read/write a tag

     ///Read/write a tag.

     ///

     class Tag

     {

       XmlIo &ix;

       const std::string _tag;

     public:

       ///\e

       ///\e

       ///

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

 	ix(_ix), _tag(_t)

       {

 	if(ix.write()) ix.beginTag(_tag);

 	else ix.useTag(_tag);

       }

       ~Tag() {

 	if(ix.write()) ix.endTag(_tag);

 	else if(!std::uncaught_exception()) ix.useTag('/'+_tag);

       }

     };

   private:

     std::istream& is;

     std::string next_tag;

     int line_number;

     void skipWhiteSpaces()

     {

       if(write()) LEMON_ASSERT(true, "Can't skip whitespaces in write mode.");

       {

 	char c;

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

 	  if(c=='\n') line_number++;

 	is.unget();

       }

     }

   protected:

     /// Use the next tag.

     ///\e

     ///

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

     ///Use the next tag and check if it is equal with \c _tag

     ///\e

     ///

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

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

       else throw FormatError("Unexpected token name","",line_number);

     }

   public:

     ///Return the next tag (if a tag follows on the stream).

     ///\warning It can only be used in read mode.

     ///

     const std::string &nextTag() 

     {

       if(write()) LEMON_ASSERT(true,"Don't use nextTag() in write mode");

       else if(next_tag.empty()) {

 	char c;

 	skipWhiteSpaces();

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

 	  throw FormatError("Bad format","",line_number);

 	next_tag.clear();

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

 	if(c!='>')

 	  throw FormatError("Bad format","",line_number);

       }

       return next_tag;

     }

     /**********************************************************************/

     ///\e

     ///\e

     ///

     XmlIo(std::ostream& _os) : _writeMode(true), os(_os),

 			       level(-1),

 			       is(std::cin) {}

     ///\e

     ///

     XmlIo(std::istream& _is) : _writeMode(false),

 			       os(std::cout), is(_is),

 			       line_number(1) {}

     ~XmlIo() { if(write()) os<< std::endl; }

     XmlIo &operator()(const int &v) 

     { 

       if(write()) os << v;

       else {

 	skipWhiteSpaces();

 	if(!(is >> const_cast<int &>(v))) 

 	  throw FormatError("Not an 'int'","",line_number);

       }

       return *this;

     }

     XmlIo &operator()(const double &v) 

     {

       if(write()) os << v;

       else {

 	skipWhiteSpaces();

 	if(!(is >> const_cast<double &>(v))) 

 	  throw FormatError("Not an 'double'","",line_number);

       }

       return *this;

     }

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

     {

       if(write())

 	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;

 	  }

       else {

 	std::string &w = const_cast<std::string &>(v);

 	w.clear();

 	char c;

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

 	  if(c=='\\')

 	    if(!is.get(c))

 	      throw FormatError("Bad string","",line_number);

 	    else switch(c) {

 	    case 'n':

 	      w.push_back('\n');

 	      break;

 	    default:

 	      w.push_back(c);

 	      break;

 	    }

 	  else {

 	    if(c=='\n') line_number++;

 	    w.push_back(c);

 	  }

 	if(c!='<')

 	  throw FormatError("Unexpected eof","",line_number);

 	is.unget();

       }

       return *this;

     }

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

     { 

       LineTag t(*this,_tag);

       (*this)(v);

       return *this;

     }

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

     {

       LineTag t(*this,_tag);

       (*this)(v);

       return *this;

     }

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

     {

       LineTag t(*this,_tag);

       (*this)(v);

       return *this;

     }

     ///\e

     ///\e

     ///

     template<class V>

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

     {

       Tag t(*this,_tag);

       xml(*this,const_cast<V &>(v));

       return *this;

     }

     ///\e

     ///\e

     ///

     template<class V>

     XmlIo &operator()(const V &v)

     {

       xml(*this,const_cast<V &>(v));

       return *this;

     }

     };

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

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

   ///\e

   ///\relates XmlIo

   ///

   template<class A>

   void xml(XmlIo &x,std::auto_ptr<A> &v)

   {

     if(x.write()) v=new A;

     x(*v);

   }

   ///\e

   ///\relates XmlIo

   ///

   template<class A,class B>

   void xml(XmlIo &x,std::pair<A,B> &v)

   {

     x("first",v.first);

     x("second",v.second);

   }

   ///\e

   ///\relates XmlIo

   ///

   template<class T>

   void xml(XmlIo &x,std::list<T> &v)

   {

     if(x.write())

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

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

     else while(x.nextTag()=="item")

       {

 	v.push_back(T());

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

       }

   }

   ///\e

   ///\relates XmlIo

   ///

   template<class T>

   void xml(XmlIo &x,std::vector<T> &v)

   {

     if(x.write())

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

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

     else while(x.nextTag()=="item")

       {

 	v.push_back(T());

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

       }

   }

   ///\e

   ///\relates XmlIo

   ///

   template<class K,class V>

   void xml(XmlIo &x,std::map<K,V> &v)

   {

     if(x.write()) 

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

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

     else while(x.nextTag()=="item")

       {

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

 	x("item",it);

 	v.insert(it);

       }

   }

   ///\e

   ///\relates XmlIo

   ///

   template<class T>

   void xml(XmlIo &x,lemon::dim2::Point<T> &v)

   {

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

     { XmlIo::ContTag t(x,"y"); x(v.y); }

   }

   ///\e

   ///\relates XmlIo

   ///

   template<class T>

   void xml(XmlIo &x,lemon::dim2::Box<T> &v)

   {

     if(x.write()) {

       if(!v.empty()) {

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

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

       }

     }

     else {

       v.clear();

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

 	lemon::dim2::Point<T> co;

 	x("point",co);

 	v.add(co);

       }

     }

   }

 }

 #endif