xml.h

Go to the documentation of this file.

/**********************************************************************
xml.h Declaration of XMLConversion,
declaration and definition of XMLBaseFormat and XMLMoleculeFormat
Copyright (C) 2005-2006 by Chris Morley

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
***********************************************************************/

#ifndef OB_XML_H
#define OB_XML_H

#include <typeinfo>

#include <openbabel/obconversion.h>
#include <openbabel/obmolecformat.h>
#include <openbabel/mol.h>

#include <libxml/xmlreader.h>
#include <libxml/xmlwriter.h>
#include <typeinfo>

namespace OpenBabel
{


 //forward declaration
 class XMLBaseFormat;

 //******************************************************
 class XMLConversion : public OBConversion
 {
 public:
 XMLConversion(OBConversion* pConv);

 ~XMLConversion();

 bool SetupReader();
 bool SetupWriter();

 bool ReadXML(XMLBaseFormat* pFormat, OBBase* pOb);

 int SkipXML(const char* ctag);

 typedef std::map<std::string, XMLBaseFormat*> NsMapType;

 static NsMapType& Namespaces()
 {
 static NsMapType ns;
 return ns;

 //static NsMapType* nsm = NULL;
 //if (!nsm)
 // nsm = new NsMapType;
 //return *nsm;
 };

 static void RegisterXMLFormat(XMLBaseFormat* pFormat,
 bool IsDefault=false, const char* uri=NULL);

 static XMLConversion* GetDerived(OBConversion* pConv, bool ForReading=true);

 bool IsLast()
 { return _pConv->IsLast(); }
 int GetOutputIndex()
 { return _pConv->GetOutputIndex(); }


 xmlTextReaderPtr GetReader() const
 { return _reader; };

 xmlTextWriterPtr GetWriter() const
 { return _writer; };

 void OutputToStream()
 {
 xmlOutputBufferFlush(_buf);
 }

 static XMLBaseFormat* GetDefaultXMLClass() //TODO make dependent on object type
 { return _pDefault;};

 void LookForNamespace()
 { _LookingForNamespace = true; };

 static int ReadStream(void * context, char * buffer, int len);
 static int WriteStream(void * context, const char * buffer, int len);
 //static int CloseStream(void* context);

 std::string GetAttribute(const char* attrname);

 std::string GetContent();

 bool GetContentInt(int& value);

 bool GetContentDouble(double& value);

 private:
 static XMLBaseFormat* _pDefault;
 OBConversion* _pConv;
 std::streampos _requestedpos, _lastpos;
 xmlTextReaderPtr _reader;
 xmlTextWriterPtr _writer;
 xmlOutputBufferPtr _buf;
 // xmlBufferPtr _buf;
 bool _LookingForNamespace;
 public:
 bool _SkipNextRead;
 };

 //*************************************************
 class XMLBaseFormat : public OBFormat
 {
 protected:
 XMLConversion* _pxmlConv;

 //formating for output
 std::string _prefix;
 int baseindent, ind;
 std::string nsdecl;
 int _embedlevel;

 public:
 ~XMLBaseFormat(){}
 virtual const char* NamespaceURI()const=0;
 virtual bool DoElement(const std::string& ElName){return false;};
 virtual bool EndElement(const std::string& ElName){return false;};
 virtual const char* EndTag(){return ">";};

 protected:
 xmlTextReaderPtr reader() const
 {
 return _pxmlConv->GetReader();
 }

 xmlTextWriterPtr writer() const
 {
 return _pxmlConv->GetWriter();
 }

 void OutputToStream()
 {
 _pxmlConv->OutputToStream();
 }

 virtual int SkipObjects(int n, OBConversion* pConv)
 {
 //don't implement on base class
 if(*EndTag()=='>')
 return 0;

 //Set up XMLConversion class with reader
 _pxmlConv = XMLConversion::GetDerived(pConv,true);
 if(!_pxmlConv)
 return -1;

 //always find the end of at least 1 object
 if(n==0)++n;

 //Skip n objects, returning -1 if not successful
 int i;
 for(i=0; i<n; ++i)
 if(_pxmlConv->SkipXML(EndTag())!=1)
 return -1;

 return 1;
 }

 };

 //*************************************************
 class XMLMoleculeFormat : public XMLBaseFormat
 {
 protected:
 OBMol* _pmol;

 public:
 ~XMLMoleculeFormat(){}
 virtual bool ReadChemObject(OBConversion* pConv)
 {
 return OBMoleculeFormat::ReadChemObjectImpl(pConv, this);
 };

 virtual bool WriteChemObject(OBConversion* pConv)
 {
 return OBMoleculeFormat::WriteChemObjectImpl(pConv, this);
 };

 virtual bool ReadMolecule(OBBase* pOb, OBConversion* pConv)
 {
 _pmol = dynamic_cast<OBMol*>(pOb);
 if(!_pmol)
 return false;
 _pxmlConv = XMLConversion::GetDerived(pConv,true);
 if(!_pxmlConv)
 return false;
 _embedlevel = -1;
 return _pxmlConv->ReadXML(this,pOb);
 };

 const std::type_info& GetType()
 {
 return typeid(OBMol*);
 };

 };


}//namespace


#endif