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;

  typedef OBBond OBEdgeBase;

  //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_TORUP_BOND     (1<<5)

#define OB_TORDOWN_BOND   (1<<6)

#define OB_KSINGLE_BOND   (1<<7)

#define OB_KDOUBLE_BOND   (1<<8)

#define OB_KTRIPLE_BOND   (1<<9)

#define OB_CLOSURE_BOND   (1<<10)
  // 11-16 currently unused

#define OB_WEDGE_OR_HASH_BOND     (1<<11)
#define OB_CIS_OR_TRANS_BOND     (1<<12)

  //class OBBondPrivate;
  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 SetBO(int order);
      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 SetKSingle();
      void SetKDouble();
      void SetKTriple();
      void SetAromatic()    { SetFlag(OB_AROMATIC_BOND); }
      void SetWedge() { SetFlag(Wedge); }
      void SetHash() { SetFlag(Hash); }
      void SetWedgeOrHash() { SetFlag(WedgeOrHash); }
      void SetUp()          { SetFlag(OB_TORUP_BOND); UnsetFlag(OB_TORDOWN_BOND); }
      void SetDown()        { SetFlag(OB_TORDOWN_BOND); UnsetFlag(OB_TORUP_BOND);   }
      void SetInRing(bool set=true) { if(set)SetFlag(OB_RING_BOND); else UnsetFlag(OB_RING_BOND);}

      void SetClosure()     { SetFlag(OB_CLOSURE_BOND);  }
      void UnsetHash()      { UnsetFlag(OB_HASH_BOND);    }
      void UnsetWedge()     { UnsetFlag(OB_WEDGE_BOND);   }
      void UnsetUp()        { UnsetFlag(OB_TORUP_BOND);   }
      void UnsetDown()      { UnsetFlag(OB_TORDOWN_BOND); }
      void UnsetAromatic()  { UnsetFlag(OB_AROMATIC_BOND);}
      void UnsetKekule()
        {
          _flags &= (~(OB_KSINGLE_BOND|OB_KDOUBLE_BOND|OB_KTRIPLE_BOND));
        }



      unsigned int     GetIdx()           const { return(_idx);  }
      unsigned long GetId()           const { return _id; }

      unsigned int     GetBO()            const { return(_order); }
      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 IsAmide();
      bool IsPrimaryAmide();
      bool IsSecondaryAmide();
      bool IsTertiaryAmide();
      bool IsEster();
      bool IsCarbonyl();
      bool IsSingle();
      bool IsDouble();
      bool IsTriple();
      bool IsKSingle();
      bool IsKDouble();
      bool IsKTriple();
      bool IsClosure();
      bool IsUp()    {    return(HasFlag(OB_TORUP_BOND));    }
      bool IsDown()  {    return(HasFlag(OB_TORDOWN_BOND));  }
      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