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

obconversion.cpp -  Declaration of OBFormat and OBConversion

Copyright (C) 2004 by Chris Morley

Some portions Copyright (C) 2005-2006 by Geoffrey Hutchison

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.

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

// Definition of OBConversion routines

#include <openbabel/babelconfig.h>

#include <openbabel/base.h>

#ifdef _WIN32

  #pragma warning (disable : 4786)

  //using 'this' in base class initializer

  #pragma warning (disable : 4355)

  #ifdef GUI

    #undef DATADIR

    #include "stdafx.h" //(includes<windows.h>

  #endif

#endif

// #define DONT_CATCH_EXCEPTIONS     // This is useful when debugging an exception

#include <iosfwd>

#include <fstream>

#include <sstream>

#include <string>

#include <map>

#include <locale>

#include <limits>

#include <typeinfo>

#include <iterator>

#include <cstdlib>

#include <openbabel/obconversion.h>

//#include <openbabel/mol.h>

#include <openbabel/locale.h>

#ifdef HAVE_LIBZ

#include "zipstream.h"

#endif

#if !HAVE_STRNCASECMP

extern "C" int strncasecmp(const char *s1, const char *s2, size_t n);

#endif

#ifndef BUFF_SIZE

#define BUFF_SIZE 32768

#endif

using namespace std;

//using namespace boost::iostreams;

namespace OpenBabel {

  /** @class OBFormat obconversion.h <openbabel/obconversion.h>

      Two sets of Read and Write functions are specified for each format

      to handle two different requirements.

      The "Convert" interface is for use in file format conversion applications. The

      user interface, a console, a GUI, or another program is kept unaware of the

      details of the chemistry and does not need to \#include mol.h. It is then

      necessary to manipulate only pointers to OBBase in OBConversion and the user

      interface, with all the construction and deletion of OBMol etc objects being

      done in the Format classes or the OB core. The convention  with "Covert"

      interface functions is that chemical objects are made on the heap with new

      in the ReadChemicalObject() functions and and deleted in WriteChemicalObject()

      functions

      The "API" interface is for programatic use of the OB routines in application

      programs where mol.h is \#included. There is generally no creation or

      destruction of objects in ReadMolecule() and WriteMolecule() and no restriction

      on whether the pointers are to the heap or the stack.

  **/

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

  /** @class OBConversion obconversion.h <openbabel/obconversion.h>

      OBConversion maintains a list of the available formats,

      provides information on them, and controls the conversion process.

      A conversion is carried out by the calling routine, usually in a

      user interface or an application program, making an instance of

      OBConversion. It is loaded with the in and out formats, any options

      and (usually) the default streams for input and output. Then either

      the Convert() function is called, which allows a single input file

      to be converted, or the extended functionality of FullConvert()

      is used. This allows multiple input and output files, allowing:

      - aggregation      - the contents of many input files converted

      and sent to one output file;

      - splitting        - the molecules from one input file sent to

      separate output files;

      - batch conversion - each input file converted to an output file.

      These procedures constitute the "Convert" interface. OBConversion

      and the user interface or application program do not need to be

      aware of any other part of OpenBabel - mol.h is not \#included. This

      allows any chemical object derived from OBBase to be converted;

      the type of object is decided by the input format class.

      However,currently, almost all the conversions are for molecules of

      class OBMol.

      ///

      OBConversion can also be used with an "API" interface

      called from programs which manipulate chemical objects. Input/output is

      done with the Read() and Write() functions which work with any

      chemical object, but need to have its type specified. (The

      ReadMolecule() and WriteMolecule() functions of the format classes

      can also be used directly.)

      Example code using OBConversion

      <b>To read in a molecule, manipulate it and write it out.</b>

      Set up an istream and an ostream, to and from files or elsewhere.

      (cin and cout are used in the example). Specify the file formats.

      @code

      OBConversion conv(&cin,&cout);

      if(conv.SetInAndOutFormats("SMI","MOL"))

      {

         OBMol mol;

         if(conv.Read(&mol))

            // ...manipulate molecule

         conv->Write(&mol);

      }

      @endcode

      A two stage construction is used to allow error handling

      if the format ID is not recognized. This is necessary now that the

      formats are dynamic and errors are not caught at compile time.

      OBConversion::Read() uses a pointer to OBBase, so that, in addition

      to OBMol, other kinds of objects, such as reactions, can also be handled

      if the format routines are written appropriately.

      <b>To make a molecule from a SMILES string.</b>

      @code

      std::string SmilesString;

      OBMol mol;

      stringstream ss(SmilesString)

      OBConversion conv(&ss);

      if(conv.SetInFormat("smi") && conv.Read(&mol))

         // ...

      @endcode

      An alternative way is more convenient if using bindings from another language:

      @code

      std::string SmilesString;

      OBMol mol;

      OBConversion conv;

      if(conv.SetInFormat("smi") && conv.ReadString(&mol, SmilesString))

         // ...

      @endcode

      <b>To do a file conversion without manipulating the molecule.</b>

      @code

      #include <openbabel/obconversion.h> //mol.h is not needed

      ...set up an istream is and an ostream os

      OBConversion conv(&is,&os);

      if(conv.SetInAndOutFormats("SMI","MOL"))

      {

         conv.AddOption("h",OBConversion::GENOPTIONS); //Optional; (h adds expicit hydrogens)

         conv.Convert();

      }

      @endcode

      <b>To read a multi-molecule file if using bindings from another language</b>

      The first molecule should be read using ReadFile, and subsequent molecules using Read,

      as follows:

      @code

      #include <openbabel/obconversion.h> //mol.h is not needed

      OBConversion conv;

      OBMol mol;

      bool success = conv.SetInFormat("sdf");

      if(success)

      {

         bool notatend = conv.ReadFile(&mol, "myfile.sdf");

         // Do something with mol

   while(notatend)

   {

             notatend = conv.Read(&mol);

       // Do something with mol

   }

      }

      @endcode

      <b>To add automatic format conversion to an existing program.</b>

      The existing program inputs from the file identified by the

      const char* filename into the istream is. The file is assumed to have

      a format ORIG, but other formats, identified by their file extensions,

      can now be used.

      @code

      ifstream ifs(filename); //Original code

      OBConversion conv;

      OBFormat* inFormat = conv.FormatFromExt(filename);

      OBFormat* outFormat = conv.GetFormat("ORIG");

      istream* pIn = &ifs;

      stringstream newstream;

      if(inFormat && outFormat)

      {

         conv.SetInAndOutFormats(inFormat,outFormat);

         conv.Convert(pIn,&newstream);

         pIn=&newstream;

      }

      //else error; new features not available; fallback to original functionality

      ...Carry on with original code using pIn

      @endcode

  */

//  OBFormat* OBConversion::pDefaultFormat=NULL;

  OBConversion::OBConversion(istream* is, ostream* os) :

    pInput(nullptr), pOutput(nullptr),

    pInFormat(nullptr),pOutFormat(nullptr), Index(0), StartNumber(1),

    EndNumber(0), Count(-1), m_IsFirstInput(true), m_IsLast(true),

    MoreFilesToCome(false), OneObjectOnly(false), ReadyToInput(false), SkippedMolecules(false),

    inFormatGzip(false), outFormatGzip(false),

    pOb1(nullptr), wInpos(0), wInlen(0), pAuxConv(nullptr)

  {

    SetInStream(is);

    SetOutStream(os);

    //These options take a parameter

    RegisterOptionParam("f", nullptr, 1,GENOPTIONS);

    RegisterOptionParam("l", nullptr, 1,GENOPTIONS);

  }

  /// Convenience constructor.  Sets up streams from specified files.

  /// If format can not be determined from filename, a stream is not opened.

  OBConversion::OBConversion(string infile, string outfile):

        pInput(nullptr), pOutput(nullptr),

        pInFormat(nullptr), pOutFormat(nullptr), Index(0), StartNumber(1),

        EndNumber(0), Count(-1), m_IsFirstInput(true), m_IsLast(true),

        MoreFilesToCome(false), OneObjectOnly(false), ReadyToInput(false), SkippedMolecules(false),

        inFormatGzip(false), outFormatGzip(false),

        pOb1(nullptr), wInpos(0), wInlen(0), pAuxConv(nullptr)

  {

    //These options take a parameter

    RegisterOptionParam("f", nullptr, 1,GENOPTIONS);

    RegisterOptionParam("l", nullptr, 1,GENOPTIONS);

    OpenInAndOutFiles(infile, outfile);

  }

  /////////////////////////////////////////////////

  OBConversion::OBConversion(const OBConversion& o)

  {

    *this = o;

  }

  OBConversion& OBConversion::operator=(const OBConversion& o)

  {

    //the original obconversion retains ownership of any allocated streams

    //this means if the original gets destroyed, bad things may happen

    //by doing this first, format isn't initialized, so we add no additional filters

    pInFormat = nullptr;

    inFormatGzip = false;

    pOutFormat = nullptr;

    outFormatGzip = false;

    SetInStream(o.pInput, false);

    SetOutStream(o.pOutput, false);

    Index          = o.Index;

    Count          = o.Count;

    StartNumber    = o.StartNumber;

    EndNumber      = o.EndNumber;

    pInFormat      = o.pInFormat;

    inFormatGzip   = o.inFormatGzip;

    pOutFormat     = o.pOutFormat;

    outFormatGzip  = o.outFormatGzip;

    OptionsArray[0]= o.OptionsArray[0];

    OptionsArray[1]= o.OptionsArray[1];

    OptionsArray[2]= o.OptionsArray[2];

    InFilename     = o.InFilename;

    rInpos         = o.rInpos;

    wInpos         = o.wInpos;

    rInlen         = o.rInlen;

    wInlen         = o.wInlen;

    m_IsLast       = o.m_IsLast;

    MoreFilesToCome= o.MoreFilesToCome;

    OneObjectOnly  = o.OneObjectOnly;

    pOb1           = o.pOb1;

    ReadyToInput   = o.ReadyToInput;

    m_IsFirstInput = o.m_IsFirstInput;

    SkippedMolecules = o.SkippedMolecules;

    pAuxConv       = o.pAuxConv;

     return *this;

  }

  ///////////////////////////////////////////////

  OBConversion::~OBConversion()

  {

    if(pAuxConv!=this)

      delete pAuxConv;

    // Free any remaining streams from convenience functions

    SetInStream(nullptr);

    SetOutStream(nullptr);

  }

  //////////////////////////////////////////////////////

  /// Class information on formats is collected by making an instance of the class

  /// derived from OBFormat(only one is usually required). RegisterFormat() is called

  /// from its constructor.

  ///

  /// If the compiled format is stored separately, like in a DLL or shared library,

  /// the initialization code makes an instance of the imported OBFormat class.

  int OBConversion::RegisterFormat(const char* ID, OBFormat* pFormat, const char* MIME)

  {

    return pFormat->RegisterFormat(ID, MIME);

  }

  /// Set input stream, removing/deallocating previous stream if necessary.

  /// If takeOwnership is true, takes responsibility for freeing pIn

  void OBConversion::SetInStream(std::istream* pIn, bool takeOwnership)

  {

      //clear and deallocate any existing streams

      for(unsigned i = 0, n = ownedInStreams.size(); i < n; i++)

      {

        delete ownedInStreams[i];

      }

      ownedInStreams.clear();

      pInput = nullptr;

      if (pIn)

      {

          if(takeOwnership)

              ownedInStreams.push_back(pIn);

          pInput = pIn; //simplest case

  #ifdef HAVE_LIBZ

          if(IsOption("zin", GENOPTIONS) || inFormatGzip)

          {

            zlib_stream::zip_istream *zIn = new zlib_stream::zip_istream(*pInput);

            ownedInStreams.push_back(zIn);

            pInput = zIn;

          }

  #endif

          //always transform newlines if input isn't binary/xml

          if(pInFormat && !(pInFormat->Flags() & (READBINARY | READXML)) &&

              pIn != &std::cin) //avoid filtering stdin as well

          {

            LEInStream *leIn = new LEInStream(*pInput);

            ownedInStreams.push_back(leIn);

            pInput = leIn;

          }

      }

  }

  /// Set output stream, removing/deallocating previous stream if necessary.

  /// If takeOwnership is true, takes responsibility for freeing pOut

  /// Be aware that if the output stream is gzipped format, then this outstream

  /// either needs to be replaced (e.g., SetOutStream(NULL)) or the OBConversion

  /// destroyed before the underlying outputstream is deallocated.

  void OBConversion::SetOutStream(std::ostream* pOut, bool takeOwnership)

  {

    //clear and deallocate any existing streams

    for (unsigned i = 0, n = ownedOutStreams.size(); i < n; i++)

    {

      delete ownedOutStreams[i];

    }

    ownedOutStreams.clear();

    pOutput = nullptr;

    if (pOut)

    {

      if (takeOwnership)

        ownedOutStreams.push_back(pOut);

      pOutput = pOut;

#ifdef HAVE_LIBZ

      if (IsOption("z", GENOPTIONS) || outFormatGzip)

      {

        zlib_stream::zip_ostream *zOut = new zlib_stream::zip_ostream(*pOutput, true);

        //we need to delete the zstream _before_ the underlying stream so it can add the footer

        ownedOutStreams.insert(ownedOutStreams.begin(),zOut);

        pOutput = zOut;

      }

#endif

    }

  }

//////////////////////////////////////////////////////

  /// Sets the formats from their ids, e g CML.

  /// If inID is NULL, the input format is left unchanged. Similarly for outID

  /// Returns true if both formats have been successfully set at sometime

  bool OBConversion::SetInAndOutFormats(const char* inID, const char* outID, bool inzip, bool outzip)

  {

    return SetInFormat(inID, inzip) && SetOutFormat(outID, outzip);

  }

  //////////////////////////////////////////////////////

  bool OBConversion::SetInAndOutFormats(OBFormat* pIn, OBFormat* pOut, bool inzip, bool outzip)

  {

    return SetInFormat(pIn, inzip) && SetOutFormat(pOut, outzip);

  }

  //////////////////////////////////////////////////////

  bool OBConversion::SetInFormat(OBFormat* pIn, bool gzip)

  {

    inFormatGzip = gzip;

    if (pIn == nullptr)

      return true;

    pInFormat=pIn;

    return !(pInFormat->Flags() & NOTREADABLE);

  }

  //////////////////////////////////////////////////////

  bool OBConversion::SetOutFormat(OBFormat* pOut, bool gzip)

  {

    outFormatGzip = gzip;

    pOutFormat=pOut;

    return pOut && !(pOutFormat->Flags() & NOTWRITABLE);

  }

  //////////////////////////////////////////////////////

  bool OBConversion::SetInFormat(const char* inID, bool gzip)

  {

    inFormatGzip = gzip;

    if(inID)

      pInFormat = FindFormat(inID);

    return pInFormat && !(pInFormat->Flags() & NOTREADABLE);

  }

  //////////////////////////////////////////////////////

  bool OBConversion::SetOutFormat(const char* outID, bool gzip)

  {

    outFormatGzip = gzip;

    if(outID)

      pOutFormat= FindFormat(outID);

    return pOutFormat && !(pOutFormat->Flags() & NOTWRITABLE);

  }

  //////////////////////////////////////////////////////

  /// Convert molecules from is into os.  If either is null, uses existing streams.

  /// If streams are specified, they do _not_ replace any existing streams.

  int OBConversion::Convert(istream* is, ostream* os)

  {

    StreamState savedIn, savedOut;

    if (is)

    {

#ifdef HAVE_LIBZ

      if(!inFormatGzip && pInFormat && zlib_stream::isGZip(*is))

      {

        inFormatGzip = true;

      }

#endif

      savedIn.pushInput(*this);

      SetInStream(is, false);

    }

    if (os)

    {

      savedOut.pushOutput(*this);

      SetOutStream(os, false);

    }

    int count = Convert();

    if(savedIn.isSet()) savedIn.popInput(*this);

    if(savedOut.isSet()) savedOut.popOutput(*this);

    return count;

  }

  ////////////////////////////////////////////////////

  /// Actions the "convert" interface.

  /// Calls the OBFormat class's ReadMolecule() which

  ///  - makes a new chemical object of its chosen type (e.g. OBMol)

  ///  - reads an object from the input file

  ///  - subjects the chemical object to 'transformations' as specified by the Options

  ///  - calls AddChemObject to add it to a buffer. The previous object is first output

  ///    via the output Format's WriteMolecule(). During the output process calling

  /// IsFirst() and GetIndex() (the number of objects including the current one already output.

  /// allows more control, for instance writing \<cml\> and \</cml\> tags for multiple molecule outputs only.

  ///

  /// AddChemObject does not save the object passed to it if it is NULL (as a result of a DoTransformation())

  /// or if the number of the object is outside the range defined by

  /// StartNumber and EndNumber.This means the start and end counts apply to all chemical objects

  /// found whether or not they are output.

  ///

  /// If ReadMolecule returns false the input conversion loop is exited.

  ///

  int OBConversion::Convert()

  {

    if (pInput == nullptr)

      {

        obErrorLog.ThrowError(__FUNCTION__, "input or output stream not set", obError);

        return 0;

      }

    if(!pInFormat) return 0;

    Count=0;//number objects processed

    if(!SetStartAndEnd())

      return 0;

    ReadyToInput=true;

    m_IsLast=false;

    pOb1=nullptr;

    wInlen=0;

    if(pInFormat->Flags() & READONEONLY)

      OneObjectOnly=true;

    //Input loop

    while(ReadyToInput && pInput->good()) //Possible to omit? && pInStream->peek() != EOF

      {

        if(pInput==&cin)

          {

            if(pInput->peek()==-1) //Cntl Z Was \n but interfered with piping

            {

              if (!IsOption("separate", OBConversion::GENOPTIONS))

                break;

              pInput->clear();

            }

          }

        else

          rInpos = pInput->tellg();

        bool ret=false;

#ifndef DONT_CATCH_EXCEPTIONS

       try

#endif

          {

            ret = pInFormat->ReadChemObject(this);

/*            if (ret && IsOption("readconformers", GENOPTIONS)) {

              std::streampos pos = pInStream->tellg();

              OBMol nextMol;

              OBConversion conv;

              conv.SetOutFormat("smi");

              std::string ref_smiles = conv.WriteString(pOb1);

              while (pInStream->good()) {

                if (!pInFormat->ReadMolecule(&nextMol, this))

                  break;

                std::string smiles = conv.WriteString(&nextMol);

                if (smiles == ref_smiles) {

                  OBMol *pmol = dynamic_cast<OBMol*>(pOb1);

                  if (!pmol)

                    break;

                  unsigned int numCoords = nextMol.NumAtoms() * 3;

                  double *coords = nextMol.GetCoordinates();

                  double *conformer = new double [numCoords];

                  for (unsigned int i = 0; i < numCoords; ++i)

                    conformer[i] = coords[i];

                  pmol->AddConformer(conformer);

                  pos = pInStream->tellg();

                } else {

                  break;

                }

              }

              pInStream->seekg(pos, std::ios::beg);

            }

*/

            SetFirstInput(false);

          }

#ifndef DONT_CATCH_EXCEPTIONS

        catch(...)

          {

            if(!IsOption("e", GENOPTIONS) && !OneObjectOnly)

            {

              obErrorLog.ThrowError(__FUNCTION__, "Convert failed with an exception" , obError);

              return Index; // the number we've actually output so far

            }

          }

#endif

        if(!ret)

          {

            //error or termination request: terminate unless

            // -e option requested and successfully can skip past current object

            if(!IsOption("e", GENOPTIONS) || pInFormat->SkipObjects(0,this)!=1)

              break;

          }

        if(OneObjectOnly)

          break;

        // Objects supplied to AddChemObject() which may output them after a delay

        //ReadyToInput may be made false in AddChemObject()

        // by WriteMolecule() returning false  or by Count==EndNumber

      }

    //Output last object

    m_IsLast= !MoreFilesToCome;

    //Output is always occurs at the end with the --OutputAtEnd option

    bool oae = IsOption("OutputAtEnd", GENOPTIONS) != nullptr;

    if(pOutFormat && (!oae || m_IsLast))

      if((oae || pOb1) && !pOutFormat->WriteChemObject(this))

        Index--;

    //Put AddChemObject() into non-queue mode

    Count= -1;

    EndNumber=StartNumber=0; pOb1=nullptr; //leave tidy

    MoreFilesToCome=false;

    OneObjectOnly=false;

    return Index; //The number actually output

  }

  //////////////////////////////////////////////////////

  bool OBConversion::SetStartAndEnd()

  {

    unsigned int TempStartNumber=0;

    const char* p = IsOption("f",GENOPTIONS);

    if(p)

      {

        StartNumber=atoi(p);

        if(StartNumber>1)

          {

            TempStartNumber=StartNumber;

            //Try to skip objects now

            int ret = pInFormat->SkipObjects(StartNumber-1,this);

            if(ret==-1) //error

              return false;

            if(ret==1) //success:objects skipped

              {

                Count = StartNumber-1;

                StartNumber=0;

              }

          }

      }

    p = IsOption("l",GENOPTIONS);

    if(p)

      {

        EndNumber=atoi(p);

        if(TempStartNumber && EndNumber<TempStartNumber)

          EndNumber=TempStartNumber;

      }

    return true;

  }

  //////////////////////////////////////////////////////

  /// Retrieves an object stored by AddChemObject() during output

  OBBase* OBConversion::GetChemObject()

  {

    Index++;

    return pOb1;

  }

  //////////////////////////////////////////////////////

  /// Called by ReadMolecule() to deliver an object it has read from an input stream.

  /// Used in two modes:

  ///  - When Count is negative it is left negative and the routine is just a store

  ///    for an OBBase object.  The negative value returned tells the calling

  ///    routine that no more objects are required.

  ///  - When count is >=0, probably set by Convert(), it acts as a queue of 2:

  ///    writing the currently stored value before accepting the supplied one. This delay

  ///    allows output routines to respond differently when the written object is the last.

  ///    Count is incremented with each call, even if pOb=NULL.

  ///    Objects are not added to the queue if the count is outside the range

  ///    StartNumber to EndNumber. There is no upper limit if EndNumber is zero.

  ///    The return value is Count ((>0) or 0 if WriteChemObject returned false.

  int OBConversion::AddChemObject(OBBase* pOb)

  {

    if(Count<0)

      {

        pOb1=pOb;

        return Count; // <0

      }

    Count++;

    if(Count>=(int)StartNumber)//keeps reading objects but does nothing with them

      {

        if(Count==(int)EndNumber)

          ReadyToInput=false; //stops any more objects being read

        rInlen = pInput ? pInput->tellg() - rInpos : 0;

         // - (pLineEndBuf ? pLineEndBuf->getCorrection() : 0); //correction for CRLF

        if(pOb)

          {

            if(pOb1 && pOutFormat) //see if there is an object ready to be output

              {

                //Output object

                if (!pOutFormat->WriteChemObject(this))

                  {

                    //faultly write, so finish

                    --Index;

                    //ReadyToInput=false;

                    pOb1 = nullptr;

                    // The newly-read object never gets stored on this

                    // abort path; delete it so it does not leak.

                    delete pOb;

                    return 0;

                  }

                //Stop after writing with single object output files

                if(pOutFormat->Flags() & WRITEONEONLY)

                  {

                    // if there are more molecules to output, send a warning

                    stringstream errorMsg;

                    errorMsg << "WARNING: You are attempting to convert a file"

                             << " with multiple molecule entries into a format"

                             << " which can only store one molecule. The current"

                             << " output will only contain the first molecule.\n\n";

                    errorMsg << "To convert this input into multiple separate"

                             << " output files, with one molecule per file, try:\n"

                             << "obabel [input] [output] -m\n\n";

                    errorMsg << "To pick one particular molecule"

                             << " (e.g., molecule 4), try:\n"

                             << "obabel -f 4 -l 4 [input] [output]" << endl;

                    obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning);

                    ReadyToInput = false;

                    pOb1 = nullptr;

                    // Surplus newly-read object; never stored, must free.

                    delete pOb;

                    return Count; // >0

                  }

              }

            pOb1=pOb;

            wInpos = rInpos; //Save the position in the input file to be accessed when writing it

            wInlen = rInlen;

          }

      }

    return Count; // >0

  }

  //////////////////////////////////////////////////////

  ///Returns the number of objects which have been output or are currently being output.

  ///The outputindex is incremented when an object for output is fetched by GetChemObject().

  ///So the function will return 1 if called from WriteMolecule() during output of the first object.

  int OBConversion::GetOutputIndex() const

  {

    //The number of objects actually written already from this instance of OBConversion

    return Index;

  }

  void OBConversion::SetOutputIndex(int indx)

  {

    Index=indx;

  }

  //////////////////////////////////////////////////////

  OBFormat* OBConversion::FindFormat(const char* ID)

  {

    return OBFormat::FindType(ID);

  }

  OBFormat* OBConversion::FindFormat(const std::string ID)

  {

    return OBFormat::FindType(ID.c_str());

  }

  //////////////////////////////////////////////////

  const char* OBConversion::GetTitle() const

  {

    return(InFilename.c_str());

  }

  void OBConversion::SetMoreFilesToCome()

  {

    MoreFilesToCome=true;

  }

  void OBConversion::SetOneObjectOnly(bool b)

  {

    OneObjectOnly=b;

    m_IsLast=b;

  }

  /////////////////////////////////////////////////////////

  OBFormat* OBConversion::FormatFromExt(const char* filename, bool& isgzip)

  {

    string file = filename;

    string::size_type extPos = file.rfind('.');

    isgzip = false;

    if(extPos!=string::npos // period found

       && (file.substr(extPos + 1, file.size())).find("/")==string::npos) // and period is after the last "/"

      {

        // only do this if we actually can read .gz files

        if (file.substr(extPos) == ".gz")

           {

            isgzip = true;

            file.erase(extPos);

            extPos = file.rfind('.');

            if (extPos!=string::npos)

            {

              return FindFormat( (file.substr(extPos + 1, file.size())).c_str() );

            }

          }

        else

          return FindFormat( (file.substr(extPos + 1, file.size())).c_str() );

      }

    // Check the filename if no extension (e.g. VASP does not use extensions):

    extPos = file.rfind('/');

    if(extPos!=string::npos) {

      return FindFormat( (file.substr(extPos + 1, file.size())).c_str() );

    }

    // If we are just passed the filename with no path, this should catch it:

    return FindFormat( file.c_str() ); //if no format found

  }

  OBFormat* OBConversion::FormatFromExt(const char* filename)

  {

    bool isgzip;

    return FormatFromExt(filename, isgzip);

  }

  OBFormat* OBConversion::FormatFromExt(const std::string filename)

  {

    bool gzip;

    return FormatFromExt(filename.c_str(), gzip);

  }

  OBFormat* OBConversion::FormatFromExt(const std::string filename, bool& isgzip)

  {

    return FormatFromExt(filename.c_str(), isgzip);

  }

  OBFormat* OBConversion::FormatFromMIME(const char* MIME)

  {

    return OBFormat::FormatFromMIME(MIME);

  }

  bool  OBConversion::Read(OBBase* pOb, std::istream* pin)

  {

    if(pin) {

      //for backwards compatibility, attempt to detect a gzip file

#ifdef HAVE_LIBZ

    if(!inFormatGzip && pInFormat && zlib_stream::isGZip(*pin))

      {

        inFormatGzip = true;

      }

#endif

      SetInStream(pin, false);

    }

    if(!pInFormat || !pInput) return false;

    //mysterious line to ensure backwards compatibility

    //previously, even an open istream would have the gzip check applied

    //this meant that a stream at the eof position would end up in an error state

    //code has come to depend on this behavior

    if(pInput->eof()) pInput->get();

    // Set the locale for number parsing to avoid locale issues: PR#1785463

    obLocale.SetLocale();

    // Also set the C++ stream locale

    locale originalLocale = pInput->getloc(); // save the original

    locale cNumericLocale(originalLocale, "C", locale::numeric);

    pInput->imbue(cNumericLocale);

    // skip molecules if -f or -l option is set

    if (!SkippedMolecules) {

        Count = 0; // make sure it's 0

        if(!SetStartAndEnd()) {

           return false;

        }

        SkippedMolecules = true;

    }

    // catch last molecule acording to -l

    Count++;

    bool success = false;

    if (EndNumber==0 || (unsigned)Count<=EndNumber) {

        success = pInFormat->ReadMolecule(pOb, this);

    }

    // return the C locale to the original one

    obLocale.RestoreLocale();

    // Restore the original C++ locale as well

    pInput->imbue(originalLocale);

    // If we failed to read, plus the stream is over, then check if this is a stream from ReadFile

    if (!success && !pInput->good() && ownedInStreams.size() > 0) {

      ifstream *inFstream = dynamic_cast<ifstream*>(ownedInStreams[0]);

      if (inFstream != nullptr)

        inFstream->close(); // We will free the stream later, but close the file now

    }

    return success;

  }

  //////////////////////////////////////////////////

  /// Writes the object pOb but does not delete it afterwards.

  /// The output stream is lastingly changed if pos is not NULL

  /// Returns true if successful.

  bool OBConversion::Write(OBBase* pOb, ostream* pos)

  {

    if(pos) SetOutStream(pos, false);

    if(!pOutFormat || !pOutput) return false;

    // Set the locale for number parsing to avoid locale issues: PR#1785463

    obLocale.SetLocale();

    // Also set the C++ stream locale

    locale originalLocale = pOutput->getloc(); // save the original

    locale cNumericLocale(originalLocale, "C", locale::numeric);

    pOutput->imbue(cNumericLocale);

    // Increment the output counter.

    // This is done *before* the WriteMolecule because some of

    // the format plugins initialized when GetOutputIndex() == 1.

    // This matches the original Convert(), which increments

    // the count for GetChemObject() before the write.

    Index++;

    // The actual work is done here

    bool success = pOutFormat->WriteMolecule(pOb,this);

    // return the C locale to the original one

    obLocale.RestoreLocale();

    // Restore the C++ stream locale too

    pOutput->imbue(originalLocale);

    return success;

  }

  //save the current input state to this streamstate and clear conv

  void OBConversion::StreamState::pushInput(OBConversion& conv)

  {

    assert(ownedStreams.size() == 0); //should be empty

    pStream = conv.pInput;

    std::copy(conv.ownedInStreams.begin(), conv.ownedInStreams.end(), std::back_inserter(ownedStreams));

    conv.pInput = nullptr;

    conv.ownedInStreams.clear();

  }

  //restore state, blowing away whatever is in conv

  void OBConversion::StreamState::popInput(OBConversion& conv)

  {

    conv.SetInStream(nullptr);

    conv.pInput =  dynamic_cast<std::istream*>(pStream);

    assert(conv.ownedInStreams.size() == 0); //should be empty

    for(unsigned i = 0, n = conv.ownedInStreams.size(); i < n; i++)

    {

      std::istream *s = dynamic_cast<std::istream*>(conv.ownedInStreams[i]);

      assert(s);

      conv.ownedInStreams.push_back(s);

    }

    pStream = nullptr;

    ownedStreams.clear();

  }

  //save the current output state to this streamstate and clear conv

  void OBConversion::StreamState::pushOutput(OBConversion& conv)

  {

    assert(ownedStreams.size() == 0); //should be empty

    pStream = conv.pOutput;

    std::copy(conv.ownedOutStreams.begin(), conv.ownedOutStreams.end(), std::back_inserter(ownedStreams));

    conv.pOutput = nullptr;

    conv.ownedOutStreams.clear();

  }

  //restore state, blowing away whatever is in conv

  void OBConversion::StreamState::popOutput(OBConversion& conv)

  {

    conv.SetOutStream(nullptr);

    conv.pOutput =  dynamic_cast<std::ostream*>(pStream);

    assert(conv.ownedOutStreams.size() == 0); //should be empty

    for(unsigned i = 0, n = conv.ownedOutStreams.size(); i < n; i++)

    {