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 "babelconfig.h"

#if HAVE_IOSTREAM
#include <iostream>
#elif HAVE_IOSTREAM_H
#include <iostream.h>
#endif
#if HAVE_FSTREAM
#include <fstream>
#elif HAVE_FSTREAM_H
#include <fstream.h>
#endif

#if HAVE_SSTREAM
        #include <sstream>
#elif
        #include <sstream.h>
#endif

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

#include "dlhandler.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;
//*************************************************


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 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){pInStream=pIn;};
        void          SetOutStream(std::ostream* pOut){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);



        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);


        int                                     AddChemObject(OBBase* pOb);
        OBBase*                 GetChemObject(); 
        bool                            IsLast();
        bool                            IsFirstInput();
        int         GetOutputIndex() const ;
        void                            SetOutputIndex(int indx);
        void                            SetMoreFilesToCome();
        void                            SetOneObjectOnly();




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

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

        
        std::string                     WriteString(OBBase* pOb);

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

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

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

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


        static std::string BatchFileName(std::string& BaseName, std::string& InFile);
        static std::string IncrementedFileName(std::string& BaseName, const int Count);

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_IsLast;
        bool              MoreFilesToCome;
        bool              OneObjectOnly;
        bool              ReadyToInput;
        bool              CheckedForGzip; 
        static int FormatFilesLoaded;
        OBBase*           pOb1;
        std::streampos wInpos; 
        std::streampos rInpos; 
        size_t wInlen; 
        size_t rInlen; 
        
        OBConversion* pAuxConv;
};

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

} //namespace OpenBabel
#endif //OB_CONV_H


 

---

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

Documentation copyright © 1998-2005, the Open Babel Developers.
Open Babel is hosted by:
Generated on Thu Nov 30 20:18:01 2006 by  1.5.1.