obconversion.h

Go to the documentation of this file.

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

Copyright (C) 2004-2009 by Chris Morley

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

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 <cassert>

#include <string>
#include <vector>
#include <map>
#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif

#include <openbabel/oberror.h>
#include <openbabel/format.h>
#include <openbabel/lineend.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

namespace OpenBabel {

 // Needed to preserve deprecated API
 typedef OBPlugin::PluginIterator Formatpos;

 OBERROR extern OBMessageHandler obErrorLog;

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

 OBConversion(std::istream* is=NULL, std::ostream* os=NULL);
 OBConversion(std::string inFilename, std::string outFilename="");
 OBConversion(const OBConversion& o);
 OBConversion& operator=(const OBConversion& rhs);

 virtual ~OBConversion();

 static int RegisterFormat(const char* ID, OBFormat* pFormat, const char* MIME = NULL);
 static OBFormat* FindFormat(const char* ID);
 static OBFormat* FindFormat(const std::string ID);
 static OBFormat* FormatFromExt(const char* filename);
 static OBFormat* FormatFromExt(const char* filename, bool& isgzip);
 static OBFormat* FormatFromExt(const std::string filename);
 static OBFormat* FormatFromExt(const std::string filename, bool& isgzip);
 static OBFormat* FormatFromMIME(const char* MIME);

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



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


 std::istream* GetInStream() const {return pInput;};
 std::ostream* GetOutStream() const {return pOutput;};

 // if false, then will be treated as gzipped stream only if z/zin is set.
 void SetInStream(std::istream* pIn, bool takeOwnership=false);
 void SetOutStream(std::ostream* pOut, bool takeOwnership=false);

 bool SetInAndOutFormats(const char* inID, const char* outID, bool ingzip=false, bool outgzip=false);
 bool SetInAndOutFormats(OBFormat* pIn, OBFormat* pOut, bool ingzip=false, bool outgzip=false);
 bool SetInFormat(const char* inID, bool isgzip=false);
 bool SetInFormat(OBFormat* pIn, bool isgzip=false);
 bool SetOutFormat(const char* outID, bool isgzip=false);
 bool SetOutFormat(OBFormat* pOut, bool isgzip=false);

 OBFormat* GetInFormat() const{return pInFormat;};
 OBFormat* GetOutFormat() const{return pOutFormat;};
 bool GetInGzipped() const{return inFormatGzip;};
 bool GetOutGzipped() const{return outFormatGzip;};
 std::string GetInFilename() const{return InFilename;};
 std::string GetOutFilename() const{return OutFilename;};

 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, ALL };

 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=OUTOPTIONS, 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);

 void CopyOptions(OBConversion* pSourceConv, Option_type typ=ALL);


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


 int AddChemObject(OBBase* pOb);
 OBBase* GetChemObject(); 
 bool IsLast();
 bool IsFirstInput();
 void SetFirstInput(bool b=true);
 int GetOutputIndex() const ;
 void SetOutputIndex(int indx);
 void SetMoreFilesToCome();
 void SetOneObjectOnly(bool b=true);
 void SetLast(bool b){SetOneObjectOnly(b);}
 bool IsLastFile(){ return !MoreFilesToCome;}
 int GetCount()const { return Count; }

 static OBFormat* GetDefaultFormat(){return OBFormat::FindType(NULL);};


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

// OBBase* ReadObject(std::istream* pin=NULL);


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


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

 bool OpenInAndOutFiles(std::string infilepath, std::string outfilepath);

 void ReportNumberConverted(int count, OBFormat* pFormat=NULL);

 int NumInputObjects();


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

 void ClearInStreams();

 protected:

 //helper class for saving stream state
 struct StreamState
 {
 std::ios *pStream; //active stream
 std::vector<std::ios *> ownedStreams; //streams we own the memory to

 StreamState(): pStream(NULL) {}
 ~StreamState()
 {
 assert(ownedStreams.size() == 0); //should be popped
 }

 void pushInput(OBConversion& conv);
 void popInput(OBConversion& conv);

 void pushOutput(OBConversion& conv);
 void popOutput(OBConversion& conv);

 bool isSet() const { return pStream != NULL; }
 };

 bool SetStartAndEnd();
// static FMapType& FormatsMap();///<contains ID and pointer to all OBFormat classes
// static FMapType& FormatsMIMEMap();///<contains MIME and pointer to all OBFormat classes
 typedef std::map<std::string,int> OPAMapType;
 static OPAMapType& OptionParamArray(Option_type typ);
 bool OpenAndSetFormat(bool SetFormat, std::ifstream* is, std::stringstream* ss=NULL);

 std::string InFilename, OutFilename; //OutFileName added v2.4.0

 typedef FilteringInputStream< LineEndingExtractor > LEInStream;

 std::istream *pInput; //input stream, may be filtered
 std::vector<std::istream *> ownedInStreams; //streams we own the memory to

 std::ostream *pOutput; //output stream, may have filters applied
 std::vector<std::ostream *> ownedOutStreams; //streams we own the memory to


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

 //unlike the z and zin options, these are not sticky - setting formats will reset them
 bool inFormatGzip;
 bool outFormatGzip;

 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; 

 };

} //namespace OpenBabel
#endif //OB_CONV_H