bond.h

Go to the documentation of this file.

/**********************************************************************
bond.h - Handle OBBond class.

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2006 by Geoffrey R. Hutchison
Some portions Copyright (C) 2003 by Michael Banck
Some portions Copyright (C) 2008 by Tim Vandermeersch

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_BOND_H
#define OB_BOND_H

#include <openbabel/babelconfig.h>

#ifndef EXTERN
#  define EXTERN extern
#endif

#include <openbabel/base.h>
#include <openbabel/atom.h>

namespace OpenBabel
{
  class OBAtom;
  class OBRing;

  //BOND Property Macros (flags)
#define OB_AROMATIC_BOND  (1<<1)
#define OB_WEDGE_BOND     (1<<2)
#define OB_HASH_BOND      (1<<3)
#define OB_RING_BOND      (1<<4)
#define OB_CLOSURE_BOND   (1<<10)
  // 11-16 currently unused
#define OB_WEDGE_OR_HASH_BOND     (1<<11)

#define SET_OR_UNSET_FLAG(X) \
  if (value) SetFlag(X); \
  else     UnsetFlag(X);


  class OBAPI OBBond: public OBBase
  {
    protected:
      unsigned int                _idx;   
      OBMol                      *_parent;
      OBAtom                     *_bgn;   
      OBAtom                     *_end;   
      char                        _order; 
      unsigned short int          _flags; 
      unsigned long                 _id;        
      //OBBondPrivate * const d;

      bool HasFlag(int flag) const { return ((_flags & flag) != 0); }
      void SetFlag(int flag) { _flags |= flag; }
      void UnsetFlag(int flag) { _flags &= (~(flag)); }

    public:
      enum Flag {
        Aromatic = (1<<1), 
        Ring     = (1<<4), 
        Closure  = (1<<10) 
      };
      enum StereoFlag {
        Wedge       = (1<<2),  
        Hash        = (1<<3),  
        WedgeOrHash = (1<<11), 
        CisOrTrans  = (1<<12)  
      };

      bool Visit;

      OBBond();
      virtual ~OBBond();



      void SetIdx(int idx)        {          _idx = idx;        }
      void SetId(unsigned long id) { _id = id; }
      void SetBondOrder(int order);
      void SetBegin(OBAtom *begin){          _bgn = begin;      }
      void SetEnd(OBAtom *end)    {          _end = end;        }
      void SetParent(OBMol *ptr)  {        _parent= ptr;        }
      void SetLength(OBAtom *fixed,double length);
      void SetLength(double length);
      void Set(int index, OBAtom* begin,OBAtom* end,int order,int flags);
      void SetAromatic(bool value=true)    { SET_OR_UNSET_FLAG(OB_AROMATIC_BOND); }
      void SetWedge(bool value=true) { SET_OR_UNSET_FLAG(Wedge); }
      void SetHash(bool value=true) { SET_OR_UNSET_FLAG(Hash); }
      void SetWedgeOrHash(bool value=true) { SET_OR_UNSET_FLAG(WedgeOrHash); }
      void SetInRing(bool value=true) { SET_OR_UNSET_FLAG(OB_RING_BOND); }

      void SetClosure(bool value=true)     { SET_OR_UNSET_FLAG(OB_CLOSURE_BOND); }


      unsigned int     GetIdx()           const { return(_idx);  }
      unsigned long GetId()           const { return _id; }
      unsigned int     GetBondOrder()     const { return(_order); }
      unsigned int     GetFlags()         const { return(_flags);      }
      unsigned int     GetBeginAtomIdx()  const
        { return (_bgn ? _bgn->GetIdx() : 0); }
      unsigned int     GetEndAtomIdx()    const
        { return (_end ? _end->GetIdx() : 0); }
      OBAtom *GetBeginAtom()    { return(_bgn);    }
      const OBAtom *GetBeginAtom() const
        { return(_bgn);    }
      OBAtom *GetEndAtom()      { return(_end);    }
      const OBAtom *GetEndAtom() const
        { return(_end);    }

      OBAtom *GetNbrAtom(OBAtom *ptr)
        {
          return((ptr != _bgn)? _bgn : _end);
        }
      OBMol  *GetParent()                 {return(_parent);}

      double  GetEquibLength() const;
      double  GetLength() const;

      unsigned int     GetNbrAtomIdx(OBAtom *ptr)
        {
          if (ptr!=_bgn)
            return (_bgn ? _bgn->GetIdx() : 0);
          else
            return (_end ? _end->GetIdx() : 0);
        }
      OBRing* FindSmallestRing() const;


      bool IsAromatic() const;
      bool IsInRing() const;

      bool IsRotor(bool includeRingBonds=false);
      bool IsAmide();
      bool IsPrimaryAmide();
      bool IsSecondaryAmide();
      bool IsTertiaryAmide();
      bool IsEster();
      bool IsCarbonyl();
      bool IsClosure();
      bool IsWedge() {    return(HasFlag(OB_WEDGE_BOND));    }
      bool IsHash()  {    return(HasFlag(OB_HASH_BOND));     }
      bool IsWedgeOrHash() const { return(HasFlag(WedgeOrHash)); }
      bool IsCisOrTrans() const { return(HasFlag(CisOrTrans)); }

      bool IsDoubleBondGeometry();

    }; // class OBBond

  typedef std::vector<OBBond*>::iterator OBBondIterator;

}// namespace OpenBabel

#endif   // OB_BOND_H