include/realroot/xml.hpp

Go to the documentation of this file.

/*********************************************************************
*    This file is part of the source code of SYNAPS library.         *
*    Author(s): B. Mourrain, GALAAD, INRIA                           *
**********************************************************************/
#ifndef realroot_xml_hpp_
#define realroot_xml_hpp_
#include <string.h>
#include <string>
//--------------------------------------------------------------------
namespace mmx {

//--------------------------------------------------------------------
namespace xml {
  template<class ISTREAM>
  bool skip(ISTREAM& is, const char* s) 
  {
    char c=(*s); const char* t=s;
    unsigned n= strlen(s),i=0;    
    while(c != EOF)
      {
        for(i=0; i<n && (c !=EOF) && (c=is.get()) == (*t); i++,t++);
        if(i==n) 
          return true;
        else 
          t=s;
      }
    return false;
  }

  template<class OSTREAM, typename X>
  OSTREAM& print(OSTREAM& os, const X& x, const char *tag)
  {
    os<<"<"<<tag<<">"<<x<<"</"<<tag<<">";
    return os;
  }


  #define begin_polynomial "<polynomial>"
  #define end_polynomial "</polynomial>"

 
  template<class ISTREAM>
  std::string read_tag(ISTREAM& is, const char* tag)
  {
    if(skip(is,tag))
      {
        std::string s; char c;
        while((c=is.get()) != EOF && c != '<') 
          {
            if(c != '\n') s+=c;
          }
        //      s+='\0';
        return s;
      }
    else
      {
        return std::string("");
      }
  }
  template<class ISTREAM, typename T>
  bool read_pol(ISTREAM& is, T& p)
  {
    if(skip(is,begin_polynomial))
      {
        ::std::string s; char c;
        while((c=is.get()) != EOF && c != '<') 
          {
            if(c != ' ' && c != '\n') s+=c;
          }
        s+='\0';
        //PRINT_DEBUG(s.data());
        p = T(s.data());
        return true;
      }
    else 
      {
        p=T(0); return false;
      }
  }

  template<class ISTREAM, typename T, class VAR>
  bool read_pol(ISTREAM& is, T& p, const VAR& V)
  {
    if(skip(is,begin_polynomial))
      {
        std::string s; char c;
        while((c=is.get()) != EOF && c != '<') 
          {
            if(c != ' ' && c != '\n') s+=c;
          }
        s+='\0';
        p = T(s.data(),V);
        return true;
      }
    else 
      {
        p=T(0); return false;
      }
  }
}

//--------------------------------------------------------------------
template<typename C,typename R> struct upoldse;
//--------------------------------------------------------------------
namespace xml 
{
  //  using namespace SYNAPS;

  template<class ISTREAM, typename T>
  bool read_upol(ISTREAM& is, T& p)
  {
    if(skip(is,begin_polynomial))
      {
        std::string s; char c;
        while((c=is.get()) != EOF && c != '<') 
          {
            if(c != ' ' && c != '\n') s+=c;
          }
        s+='\0';
        p = T(s.data());
        return true;
      }
    else 
      {
        p=T(0); return false;
      }
  }

  template<class ISTREAM, typename C,typename R>
  bool read(ISTREAM& is, upoldse<C,R>& p)
  {
    return read_upol(is,p);
  }

  template<class OSTREAM, typename C,typename R>
  OSTREAM& print(OSTREAM& os, const upoldse<C,R>& p)
  {
    xml::print(os,p,"polynomial");
    return os;
  }

}
//----------------------------------------------------------------------
} //namespace mmx
//----------------------------------------------------------------------
#endif //realroot_xml_hpp_

---