inmost_xml.h

#ifndef INMOST_XML_INCLUDED
#define INMOST_XML_INCLUDED
 
#include "inmost.h"
 
namespace INMOST
{  
  std::string CharToHex(char c);
#if defined(USE_MESH)
  std::string ReferenceToString(INMOST::HandleType h, int pos);
#endif
#if defined(USE_AUTODIFF)
  std::string VariableToString(INMOST::variable v, bool noder=false);
#endif
  
    
 
  class XMLReader
  {
    class Interpreter
    {
      bool error_state;
      std::vector<std::string> Expand(const std::string & input) const;
      std::vector<std::string> MakePolish(const std::vector<std::string> & input);
      void Print(const std::vector<std::string> & polish) const;
      double Run(const std::vector<std::string> & polish);
    public:
      Interpreter();
      Interpreter(const Interpreter & b);
      Interpreter & operator = (Interpreter const & b);
      double Evaluate(const std::string & str);
      bool isError();
      void ClearError();
    };
    Interpreter intrp;
    struct Stream
    {
      std::string src;
      std::istream * s;
      int linebreak, linechar;
      int hadlinebreak, hadlinechar;
    };
    std::vector<Stream> inp;
    int verbose;
    enum State
    {
      Intro, //read tag or read tag contents
      WaitTag, //wait tag name or comment
      ReadTag, //reading in tag name
      ReadCommentExclamation, //skipping comments
      ReadCommentQuestion, //skipping comments
      WaitAttribute, //reading attribute name
      ReadAttribute,
      WaitAttributeValue, //read attribute value
      ReadAttributeValue,
      ReadAttributeValueQuote,
      EndTag, //tag ended read closing
      WaitCloseTag,
      ReadCloseTagSlash,
      ReadCloseTagName,
 
      WaitContentsOpen,
      WaitContents,
      ReadContents, //parse a word
      ReadContentsVector, // {0,1,2,3}
      ReadContentsQuotes, // "hello world"
      ReadContentsMultiplier, // 123*5
      ReadContentsMultiplierSkopes, // 123*(SetSize/2)
      EndContents,
      ReadVector,
 
      EndOfFile, // end of file reached
      Failure //unexpected error
    } _state;
    Stream & get_Stream();
    const Stream & get_Stream() const;
    std::istream & get_iStream();
    const std::istream & get_iStream() const;
    //should not share the reference to the stream with another reader
    XMLReader(const XMLReader & other);
    XMLReader & operator =(XMLReader & other);
    char GetChar();
    //return one character back to the stream
    void RetChar();
    void SkipComments(State RetState);
    std::string StateName(State s) const;
  public:
    void SetVerbosity(int verbosity) {verbose =  verbosity;}
    void Report(const char * fmt, ...) const;
    XMLReader(std::string sourcename, std::istream & input);
    void PushStream(std::string file);
    void PopStream();
    //wait for '<' on input,
    //returns true and changes state to WaitTag if '<' encountered,
    //otherwise returns false
    bool ExpectOpenTag();
    //read in <TagName returns TagName
    std::string ReadOpenTag();
    //read > or /> skipping for attributes
    int ReadCloseTag();
    bool isTagFinish() const;
    //read </TagName> or fail
    bool ReadFinishTag(std::string TagName);
    //read next attribute name, check isTagEnded
    std::string AttributeName();
    //read value of the attribute after reading it's name
    std::string AttributeValue();
    // > or /> was reached, should close ReadCloseTag
    // to finalize
    bool isTagEnded() const;
    //read in <![CDATA[
    //Quick and dirty, rewrite with states!
    bool ReadOpenContents();
    //get next full word inside contents
    std::string GetContentsWord();
    //read ]]>
    bool ReadCloseContents();
    //]]> was reached, should call ReadCloseContents
    //to finalize
    bool isContentsEnded() const;
    bool isFailure() const;
    bool isEof() const;
    
#if defined(USE_MESH)
    INMOST::ElementType atoes(const char * _str);
    INMOST::ElementType atoe(const char * _str);
    std::pair<INMOST::ElementType,int> atoh(const char * _str);
    std::pair<std::string,std::pair<INMOST::ElementType,int> > atorh(const char * _str);
#endif
#if defined(USE_AUTODIFF)
    INMOST::variable atov(const char * _str);
#endif
    int EvaluateExpression(std::string expression);
    int ConvertMultiplier(std::string expression, int SetSize);
    void SplitValueMultiplier(std::string expression, std::string & value, std::string & multiplier);
    bool ParseBool(std::string word);
    void ParseCommaSeparated(std::string word, std::vector<std::string> & parsed, char symbol = ',');
#if defined(USE_MESH)
    void ParseReal(std::string word, std::vector<INMOST::Storage::real> & Vector, int & Repeat, int SetSize);
#if defined(USE_AUTODIFF)
    void ParseVariable(std::string word, std::vector<INMOST::Storage::var> & Vector, int & Repeat, int SetSize);
#endif
    void ParseInteger(std::string word, std::vector<INMOST::Storage::integer> & Vector, int & Repeat, int SetSize);
#endif
    void ParseBulk(std::string word, std::string & Vector, int & Repeat, int SetSize);
#if defined(USE_MESH)
    void ParseReference(std::string word, std::vector<std::pair<INMOST::ElementType,int> > & Vector, int & Repeat, int SetSize);
    void ParseRemoteReference(std::string word, std::vector< std::pair<std::string,std::pair<INMOST::ElementType,int> > > & Vector, int & Repeat, int SetSize);
#endif
    
    struct XMLAttrib
    {
      std::string name; //< Name of the attribute.
      std::string value; //< Value of the attribute.
    };
 
    struct XMLTag
    {
      std::string name; //<Name of the XML tag.
      std::vector<XMLAttrib> attributes; //<List of attributes.
      int finish; //<Whether to close the tag.
 
 
      bool RawData() const {return finish == 5;}
      bool BlockData() const {return finish == 4;}
      bool Failure() const {return finish == 0;}
      bool Process() const {return finish == 1;}
      bool Stub() const {return finish == 2;}
      bool Finalize() const {return finish == 3;}
      const XMLAttrib & GetAttrib(int n) const {return attributes[n];}
      XMLAttrib & GetAttrib(int n) {return attributes[n];}
      int NumAttrib() const {return (int)attributes.size();}
      std::string GetName() const {return name;}
    };
 
    XMLTag OpenTag();
    bool CloseTag(XMLTag & tag);
 
    struct XMLTree
    {
        XMLTag tag; //< tag information, such as name and attributes.
        std::vector<XMLTree> children; //< Children inside XML tag.
        std::string contents; //< Text inside of the tag.
 
        int FindChild(std::string name, int offset = -1) const;
        int FindAttrib(std::string name, int offset = -1) const;
        const XMLTree & GetChild(int n) const {return children[n];}
        const XMLTree * GetChild(std::string name) const;
        const XMLTree * GetChildWithAttrib(std::string name, std::string value) const;
        int NumChildren() const {return (int)children.size();}
        const XMLAttrib & GetAttrib(int n) const {return tag.GetAttrib(n);}
        const std::string & GetAttrib(std::string name) const;
        int NumAttrib() const {return tag.NumAttrib();}
        std::string GetName() const {return tag.GetName();}
        const std::string & GetContents() const {return contents;}
    };
 
 
private:
    std::string ReadUntil(std::string stop);
    int ReadXMLSub(XMLTree & root);
public:
    XMLTree ReadXML();
  };
 
  void WriteXML(const XMLReader::XMLTree & t, std::ostream & output, int offset = 0);
 
    typedef std::vector<XMLReader::XMLTree>::iterator xml_reader_tree_iterator_t;
    typedef std::vector<XMLReader::XMLAttrib>::iterator xml_reader_attrib_iterator_t;
}
 
 
#endif //INMOST_XML_INCLUDED