data.h

Go to the documentation of this file.

/**********************************************************************
data.h - Global data and resource file parsers.

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 by Geoffrey R. 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.
***********************************************************************/

#ifndef OB_DATA_H
#define OB_DATA_H

#include <openbabel/babelconfig.h>

#include <stdio.h>
#include <cstring>
#include <fstream>
#include <vector>
#include <string>
#include <cstring>

namespace OpenBabel
{

  class OBAtom;
  class OBMol;

  class OBAPI OBGlobalDataBase
    {
    protected:
      bool         _init;               
      const char  *_dataptr;
      std::string  _filename;
      std::string  _dir;                
      std::string  _subdir;     
      std::string  _envvar;     

    public:
      OBGlobalDataBase(): _init(false), _dataptr(NULL) { }
      virtual ~OBGlobalDataBase()                  {}
      void  Init();
      virtual size_t GetSize()                 { return 0;}
      void  SetReadDirectory(char *dir)            { _dir = dir;    }
      void  SetEnvironmentVariable(char *var)      { _envvar = var; }
      virtual void ParseLine(const char*)          {}
    };

  class OBAPI OBAtomHOF
  {
  private:
      std::string _element,_method,_desc,_unit;
    double _T,_value;
    int _charge;
    int _multiplicity;

  public:
    OBAtomHOF(std::string element,int charge,
              std::string method,std::string desc,
              double T,double value,int multiplicity,
              std::string unit)
      {
        _element      = element;
        _charge       = charge;
        _method       = method;
        _desc         = desc;
        _T            = T;
        _value        = value;
        _multiplicity = multiplicity;
        _unit         = unit;
      }

    ~OBAtomHOF() {}
    std::string Element() { return _element; }
    int Charge()          { return _charge; }
    std::string Method()  { return _method; }
    std::string Desc()    { return _desc; }
    double T()            { return _T; }
    double Value()        { return _value; }
    int Multiplicity()    { return _multiplicity; }
    std::string Unit()    { return _unit; }
  };

  class OBAPI OBAtomicHeatOfFormationTable : public OBGlobalDataBase
  {
    std::vector<OBAtomHOF> _atomhof;

    public:
      OBAtomicHeatOfFormationTable(void);
      ~OBAtomicHeatOfFormationTable() {}

      size_t GetSize() { return _atomhof.size(); }

      void      ParseLine(const char*);
      int       GetHeatOfFormation(std::string elem, 
                               int charge,
                               std::string method,
                               double T, double *dhof0,
                               double *dhofT,double *S0T);
    };

  // class introduction in data.cpp
  class OBAPI OBTypeTable : public OBGlobalDataBase
    {
      int             _linecount;
      unsigned int    _ncols,_nrows;
      int             _from,_to;
      std::vector<std::string> _colnames;
      std::vector<std::vector<std::string> > _table;

    public:

      OBTypeTable(void);
      ~OBTypeTable() {}

      void ParseLine(const char*);

      size_t GetSize() { return _table.size(); }

      bool SetFromType(const char*);
      bool SetToType(const char*);
      bool Translate(char *to, const char *from); // to, from
      bool Translate(std::string &to, const std::string &from); // to, from
      std::string Translate(const std::string &from);

      std::string GetFromType();
      std::string GetToType();
    };

  EXTERN  OBTypeTable      ttab;

  class OBAPI OBResidueData : public OBGlobalDataBase
    {
      int                                               _resnum;
      std::vector<std::string>                          _resname;
      std::vector<std::vector<std::string> >            _resatoms;
      std::vector<std::vector<std::pair<std::string,int> > > _resbonds;

      //variables used only temporarily for parsing resdata.txt
      std::vector<std::string>                          _vatmtmp;
      std::vector<std::pair<std::string,int> >          _vtmp;
    public:

      OBResidueData();
      void ParseLine(const char*);

      size_t GetSize() { return _resname.size(); }

      bool SetResName(const std::string &);
      int  LookupBO(const std::string &);
      int  LookupBO(const std::string &, const std::string&);
      bool LookupType(const std::string &,std::string&,int&);
      bool AssignBonds(OBMol &);
    };

  EXTERN  OBResidueData    resdat;


} // end namespace OpenBabel
  
#endif //DATA_H