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-2005 by Geoffrey R. Hutchison
 
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_DATA_H
#define OB_DATA_H

#include "babelconfig.h"

#include <stdio.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

#include <vector>
#include <string>

namespace OpenBabel
{

class OBElement;
class OBAtom;
class OBElementTable;

class OBMol;
class OBBitVec;

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 = (char*)NULL;
    }
    virtual ~OBGlobalDataBase()                  {}
    void  Init();
    virtual unsigned int GetSize()                 { return 0;}
    void  SetReadDirectory(char *dir)            { _dir = dir;    }
    void  SetEnvironmentVariable(char *var)      { _envvar = var; }
    virtual void ParseLine(const char*)          {}
};

class OBAPI OBElement
{
    int _num;
    char _symbol[3];
    std::string _name;
    double _Rcov,_Rvdw,_mass,_elNeg,_ionize,_elAffinity;
    double _red, _green, _blue;
    int _maxbonds;
public:
    OBElement()    {}
    OBElement(int num, const char *sym, double rcov, double rvdw,
              int maxbo, double mass, double elNeg, double ionize,
              double elAffin, double red, double green, double blue,
              std::string name) :
      _num(num), _name(name), _Rcov(rcov), _Rvdw(rvdw), _mass(mass), 
      _elNeg(elNeg), _ionize(ionize), _elAffinity(elAffin), 
      _red(red), _green(green), _blue(blue),
      _maxbonds(maxbo)
    {
      strncpy(_symbol, sym, 3);
    }

    int GetAtomicNum()         {       return(_num);    }
    char *GetSymbol()          {       return(_symbol); }
    double GetCovalentRad()    {       return(_Rcov);   }
    double GetVdwRad()         {       return(_Rvdw);   }
    double GetMass()           {       return(_mass);   }
    int GetMaxBonds()          {       return(_maxbonds);}
    double GetElectroNeg()     {       return(_elNeg);  }
    double GetIonization()     {       return(_ionize);  }
    double GetElectronAffinity(){      return(_elAffinity);  }
    std::string GetName()      {       return(_name);    }
    double GetRed()            {       return(_red);     }
    double GetGreen()          {       return(_green);   }
    double GetBlue()           {       return(_blue);    }
};

// class introduction in data.cpp
class OBAPI OBElementTable : public OBGlobalDataBase
{
    std::vector<OBElement*> _element;

public:

    OBElementTable(void);
    ~OBElementTable();

    void  ParseLine(const char*);

    unsigned int                GetNumberOfElements();
    unsigned int GetSize() { return GetNumberOfElements(); }

    int   GetAtomicNum(const char *);
    int   GetAtomicNum(const char *, int &iso);
    char *GetSymbol(int);
    double GetVdwRad(int);
    double GetCovalentRad(int);
    double GetMass(int);
    double CorrectedBondRad(int,int = 3); // atomic #, hybridization
    double CorrectedVdwRad(int,int = 3); // atomic #, hybridization
    int GetMaxBonds(int);
    double GetElectroNeg(int);
    double GetIonization(int);
    double GetElectronAffinity(int);
    std::vector<double> GetRGB(int);
    std::string GetName(int);
};

// class introduction in data.cpp
class OBAPI OBIsotopeTable : public OBGlobalDataBase
{
    std::vector<std::vector<std::pair <unsigned int, double> > > _isotopes;

public:

    OBIsotopeTable(void);
    ~OBIsotopeTable()    {}

    unsigned int GetSize() { return _isotopes.size(); }

    void        ParseLine(const char*);
    double      GetExactMass(const unsigned int atomicNum,
                             const unsigned int isotope = 0);
};

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

    unsigned int 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 GetFromType();
    std::string GetToType();
};

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

    unsigned int 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 &,OBBitVec &);
};

// Used by other code for reading files
#ifdef WIN32
#define FILE_SEP_CHAR "\\"
#else
#define FILE_SEP_CHAR "/"
#endif

} // end namespace OpenBabel

#endif //DATA_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:00 2006 by  1.5.1.