obconversion.h

Go to the documentation of this file.

/**********************************************************************
obconversion.h - Handle file conversions. Declaration of OBFormat, OBConversion

Copyright (C) 2004-2005 by Chris Morley

This file is part of the Open Babel project.
For more information, see <http://openbabel.sourceforge.net/>

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_CONV_H
#define OB_CONV_H

#include <openbabel/babelconfig.h>

#include <iostream>
#include <fstream>
#include <sstream>

#include <string>
#include <vector>
#include <map>

#include <openbabel/dlhandler.h>
#include <openbabel/oberror.h>

// These macros are used in DLL builds. If they have not
// been set in babelconfig.h, define them as nothing.
#ifndef OBCONV
        #define OBCONV
#endif
#ifndef OBDLL
        #define OBDLL
#endif

//using namespace std;
namespace OpenBabel {


  class OBBase;
  class OBConversion;
  OBERROR extern  OBMessageHandler obErrorLog;

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

  // class introduction in obconversion.cpp
  class OBCONV OBFormat
    {
    public:

      virtual bool ReadMolecule(OBBase* /*pOb*/, OBConversion* /*pConv*/)
        { std::cerr << "Not a valid input format"; return false;}


      virtual bool ReadChemObject(OBConversion* /*pConv*/)
        { std::cerr << "Not a valid input format"; return false;}


      virtual bool WriteMolecule(OBBase* /*pOb*/, OBConversion* /*pConv*/)
        { std::cerr << "Not a valid output format"; return false;}


      virtual bool WriteChemObject(OBConversion* /*pConv*/)
        { std::cerr << "Not a valid output format"; return false;}


      virtual const char* Description()=0;
        

      virtual const char* TargetClassDescription();


      virtual const std::type_info& GetType();
        
      virtual const char* SpecificationURL() { return ""; }

      virtual const char* GetMIMEType() { return ""; }

   
      virtual unsigned int Flags() { return 0;}; 


      virtual int SkipObjects(int /*n*/, OBConversion* /*pConv*/)
        {
          return 0; //shows not implemented in the format class
        };


      virtual OBFormat* MakeNewInstance()
        {
          return NULL; //shows not implemented in the format class
        }

      virtual ~OBFormat(){};
    };

  //*************************************************
        struct CharPtrLess : public std::binary_function<const char*,const char*, bool>
        {
                bool operator()(const char* p1,const char* p2) const
                { return strcasecmp(p1,p2)<0; }
        };

        typedef std::map<const char*,OBFormat*,CharPtrLess > FMapType;
        typedef FMapType::iterator Formatpos;

  //*************************************************
  // Class introduction in obconversion.cpp
  class OBCONV OBConversion
    {
    public:

      OBConversion(std::istream* is=NULL, std::ostream* os=NULL);
      OBConversion(const OBConversion& o);
      virtual     ~OBConversion(); 



      static int                                RegisterFormat(const char* ID, OBFormat* pFormat, const char* MIME = NULL);
      static OBFormat*  FindFormat(const char* ID);
      static OBFormat*  FormatFromExt(const char* filename);
      static OBFormat*        FormatFromMIME(const char* MIME);

      static bool               GetNextFormat(Formatpos& itr, const char*& str,OBFormat*& pFormat);
                

      static const char* Description(); //generic conversion options


      std::istream* GetInStream() const {return pInStream;};
      std::ostream* GetOutStream() const {return pOutStream;};
      void          SetInStream(std::istream* pIn)
        { 
          if (pInStream && NeedToFreeInStream) {
            delete pInStream; NeedToFreeInStream = false;
          }
          pInStream=pIn;
          CheckedForGzip = false; // haven't tried to gzip decode this stream
        };
      void          SetOutStream(std::ostream* pOut)
        {
          if (pOutStream && NeedToFreeOutStream) {
            delete pOutStream; NeedToFreeOutStream = false;
          }
          pOutStream=pOut;
        };
      bool        SetInAndOutFormats(const char* inID, const char* outID);
      bool        SetInAndOutFormats(OBFormat* pIn, OBFormat* pOut);
      bool            SetInFormat(const char* inID);
      bool            SetInFormat(OBFormat* pIn);
      bool            SetOutFormat(const char* outID);
      bool            SetOutFormat(OBFormat* pOut);

      OBFormat*   GetInFormat() const{return pInFormat;};
      OBFormat*   GetOutFormat() const{return pOutFormat;};
      std::string GetInFilename() const{return InFilename;};
        
      std::streampos GetInPos()const{return wInpos;}; 

      size_t GetInLen()const{return wInlen;}; 

      const char* GetTitle() const;

      OBConversion* GetAuxConv() const {return pAuxConv;};
      void          SetAuxConv(OBConversion* pConv) {pAuxConv=pConv;};



      enum Option_type { INOPTIONS, OUTOPTIONS, GENOPTIONS };

      const char* IsOption(const char* opt,Option_type opttyp=OUTOPTIONS);
        
      const std::map<std::string,std::string>* GetOptions(Option_type opttyp)
        { return &OptionsArray[opttyp];};

      void AddOption(const char* opt, Option_type opttyp, const char* txt=NULL);
        
      bool RemoveOption(const char* opt, Option_type optype);

      void SetOptions(const char* options, Option_type opttyp);

      static void RegisterOptionParam(std::string name, OBFormat* pFormat,
                                      int numberParams=0, Option_type typ=OUTOPTIONS);

      static int GetOptionParams(std::string name, Option_type typ);


      // @brief Set and return the list of supported input format
      std::vector<std::string> GetSupportedInputFormat();
      // @brief Set and return the list of supported output format
      std::vector<std::string> GetSupportedOutputFormat();



      int         Convert(std::istream* is, std::ostream* os);

      int         Convert();

      int                                       FullConvert(std::vector<std::string>& FileList,
                              std::string& OutputFileName, std::vector<std::string>& OutputFileList);


      bool                              AddChemObject(OBBase* pOb);
      OBBase*                   GetChemObject(); 
      bool                              IsLast();
      bool                              IsFirstInput();
      int         GetOutputIndex() const ;
      void                              SetOutputIndex(int indx);
      void                              SetMoreFilesToCome();
      void                              SetOneObjectOnly(bool b=true);
      void        SetLast(bool b){SetOneObjectOnly(b);}




      static OBFormat* GetDefaultFormat(){return pDefaultFormat;};

        
      bool                              Write(OBBase* pOb, std::ostream* pout=NULL);

        
      std::string                     WriteString(OBBase* pOb, bool trimWhitespace = false);

        
      bool                            WriteFile(OBBase* pOb, std::string filePath);

      void CloseOutFile();

        
      bool      Read(OBBase* pOb, std::istream* pin=NULL);

        
      bool      ReadString(OBBase* pOb, std::string input);

        
      bool      ReadFile(OBBase* pOb, std::string filePath);

protected:
      static std::string BatchFileName(std::string& BaseName, std::string& InFile);
      static std::string IncrementedFileName(std::string& BaseName, const int Count);
      static bool CheckForUnintendedBatch(const std::string& infile, const std::string& outfile);


    protected:
      bool             SetStartAndEnd();
      static FMapType& FormatsMap();
      static FMapType& FormatsMIMEMap();
      typedef std::map<std::string,int> OPAMapType;
      static OPAMapType& OptionParamArray(Option_type typ);
      static int       LoadFormatFiles();
      bool             OpenAndSetFormat(bool SetFormat, std::ifstream* is);

      std::string         InFilename;
      std::istream*     pInStream;
      std::ostream*     pOutStream;
      static OBFormat*  pDefaultFormat;
      OBFormat*           pInFormat;
      OBFormat*   pOutFormat;

      std::map<std::string,std::string> OptionsArray[3];

      int                 Index;
      unsigned int        StartNumber;
      unsigned int        EndNumber;
      int                 Count;
      bool                      m_IsFirstInput;
      bool                m_IsLast;
      bool                MoreFilesToCome;
      bool                OneObjectOnly;
      bool                ReadyToInput;
      bool      CheckedForGzip;      
      bool      NeedToFreeInStream;
      bool      NeedToFreeOutStream;

      static int FormatFilesLoaded;
      OBBase*             pOb1;
      std::streampos wInpos; 
      std::streampos rInpos; 
      size_t wInlen; 
      size_t rInlen; 
        
      OBConversion* pAuxConv;

      std::vector<std::string> SupportedInputFormat; 
      std::vector<std::string> SupportedOutputFormat; 

    };

#define NOTREADABLE     0x01
#define READONEONLY     0x02
#define READBINARY      0x04
#define ZEROATOMSOK     0x08
#define NOTWRITABLE     0x10
#define WRITEONEONLY    0x20
#define WRITEBINARY     0x40
#define READXML         0x80
#define DEFAULTFORMAT   0x4000

} //namespace OpenBabel
#endif //OB_CONV_H


 

---

This file is part of the documentation for Open Babel, version 2.1.0.

Documentation copyright © 1998-2007, the Open Babel Developers.
Open Babel is hosted by:
Generated on Tue Apr 24 18:08:05 2007 by  1.5.2.