base.h

Go to the documentation of this file.

/**********************************************************************
base.h - Base class for OpenBabel objects

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_BASE_H
#define OB_BASE_H

#include <openbabel/babelconfig.h>

#include <vector>
#include <map>
#include <string>
#include <iostream>
#include <openbabel/tokenst.h>

#ifdef UNUSED
#elif (__GNUC__ == 4)
# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
#elif defined(__LCLINT__)
# define UNUSED(x) /*@unused@*/ x
#else
# define UNUSED(x) x
#endif

namespace OpenBabel
{

  //Forward declaration of the base class for OBMol OBReaction, OBAtom, etc.
  //Declaration later in this file.
class OBBase;
class OBConversion; //used only as pointer

  OBAPI std::string OBReleaseVersion();

  namespace OBGenericDataType
  {
    enum
    {
      UndefinedData =      0,

      PairData      =      1,

      EnergyData    =      2,

      CommentData   =      3,

      ConformerData =      4,

      ExternalBondData =   5,

      RotamerList =        6,

      VirtualBondData =    7,

      RingData =           8,

      TorsionData =        9,

      AngleData =         10,

      SerialNums =        11,

      UnitCell =          12,

      SpinData =          13,

      ChargeData =        14,

      SymmetryData =      15,

      // 16 - Value unused, formerly ChiralData

      OccupationData =    17,

      DensityData =       18,

      ElectronicData =    19,

      VibrationData =     20,

      RotationData =      21,

      NuclearData =       22,

      SetData =           23,

      GridData =          24,

      VectorData =        25,

      MatrixData =        26,

      StereoData =        27,

      DOSData =           28,

      ElectronicTransitionData = 29,

      // space for up to 2^14 more entries...

      CustomData0 = 16384,
      CustomData1 = 16385,
      CustomData2 = 16386,
      CustomData3 = 16387,
      CustomData4 = 16388,
      CustomData5 = 16389,
      CustomData6 = 16390,
      CustomData7 = 16391,
      CustomData8 = 16392,
      CustomData9 = 16393,
      CustomData10 = 16394,
      CustomData11 = 16395,
      CustomData12 = 16396,
      CustomData13 = 16397,
      CustomData14 = 16398,
      CustomData15 = 16399
    };
  } // end namespace
  enum DataOrigin {
    any,                 
    fileformatInput,     
    userInput,           
    perceived,           
    external,            
    local                
  };

  // Class introduction in generic.cpp
  // This base class declaration  has no dependence on mol.h
  class OBAPI OBGenericData
  {
  protected:
    std::string  _attr;  
    unsigned int _type;  
    DataOrigin   _source;
  public:
    OBGenericData(const std::string attr = "undefined",
                  const unsigned int type =  OBGenericDataType::UndefinedData,
                  const DataOrigin source = any);
    //Use default copy constructor and assignment operators
    //OBGenericData(const OBGenericData&);

    /* Virtual constructors added. see
       http://www.parashift.com/c++-faq-lite/abcs.html#faq-22.5
       to allow copying given only a base class OBGenericData pointer.
       It may be necessary to cast the return pointer to the derived class
       type, since we are doing without Covariant Return Types
       http://www.parashift.com/c++-faq-lite/virtual-functions.html#faq-20.8

       A derived class may return NULL if copying is inappropriate */
    virtual OBGenericData* Clone(OBBase* /*parent*/) const
    { return NULL; }
    virtual ~OBGenericData()    {}
    //Use default copy constructor and assignment operators
    //OBGenericData& operator=(const OBGenericData &src);

    void                      SetAttribute(const std::string &v)
    {        _attr = v;        }
    void SetOrigin(const DataOrigin s) { _source = s; }
    virtual const std::string &GetAttribute()  const
    {        return(_attr);    }
    unsigned int                GetDataType()    const
    {        return(_type);    }
    virtual const std::string &GetValue()  const
    {                   return _attr; }
    virtual DataOrigin GetOrigin() const
    {     return _source; }
  };

  typedef std::vector<OBGenericData*>::iterator OBDataIterator;

  // introduction in base.cpp
  class OBAPI OBBase
    {
    public:
      virtual ~OBBase()
        {
          if (!_vdata.empty())
            {
              std::vector<OBGenericData*>::iterator m;
              for (m = _vdata.begin();m != _vdata.end();m++)
                delete *m;
              _vdata.clear();
            }
        }

      virtual bool Clear();

      virtual OBBase* DoTransformations(const std::map<std::string,std::string>* /*pOptions*/,
                                        OBConversion* /*pConv*/)
        {
          return this;
        }

      static const char* ClassDescription()
        {
          return "";
        }

      template< class T >
      T* CastAndClear(bool clear=true)
        {
          T* pOb = dynamic_cast<T*>(this);
          if(pOb && clear)// Clear only if this is of target class
            Clear();
          return pOb;
        }

      //Currently no title data member in base class.
      virtual const char  *GetTitle(bool UNUSED(replaceNewlines) = true) const { return "";}
      virtual void  SetTitle(const char *) {}


      bool                              HasData(const std::string &);
      bool                              HasData(const char *);
      bool                              HasData(const unsigned int type);
      void                              DeleteData(unsigned int type);
      void                              DeleteData(OBGenericData*);
      void                              DeleteData(std::vector<OBGenericData*>&);
      bool                              DeleteData(const std::string& s);
      void                              SetData(OBGenericData *d)
        {
          if(d) _vdata.push_back(d);
        }
      void                              CloneData(OBGenericData *d);
      size_t                      DataSize() const
        { return(_vdata.size()); }
      OBGenericData                    *GetData(const unsigned int type);
      OBGenericData                    *GetData(const std::string&);
      OBGenericData                    *GetData(const char *);
      std::vector<OBGenericData*>       GetAllData(const unsigned int type);
      std::vector<OBGenericData*>      &GetData() { return(_vdata); }
      std::vector<OBGenericData*>      GetData(DataOrigin source);
      OBDataIterator  BeginData()
        { return(_vdata.begin());        }
      OBDataIterator  EndData()
        { return(_vdata.end());          }
    protected:
      std::vector<OBGenericData*> _vdata; 

    };

} //namespace OpenBabel

#endif // OB_BASE_H