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
 
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_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;

  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

  // class introduction in bond.cpp
 class OBAPI OBBond: public OBBase
    {
    protected:
      unsigned int                _idx;   
      OBMol                      *_parent;
      OBAtom                     *_bgn;   
      OBAtom                     *_end;   

      char                        _order; 
      unsigned short int          _flags; 

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

    public:

      bool Visit;

      OBBond();
      virtual ~OBBond();




      void SetIdx(int idx)        {          _idx = idx;        }

      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 Set(int index, OBAtom* begin,OBAtom* end,int order,int flags);
      void SetKSingle();
      void SetKDouble();
      void SetKTriple();
      void SetAromatic()    { SetFlag(OB_AROMATIC_BOND); }
      void SetHash()        { SetFlag(OB_HASH_BOND);     }
      void SetWedge()       { SetFlag(OB_WEDGE_BOND);    }
      void SetUp()          { SetFlag(OB_TORUP_BOND); UnsetFlag(OB_TORDOWN_BOND); }
      void SetDown()        { SetFlag(OB_TORDOWN_BOND); UnsetFlag(OB_TORUP_BOND);   }
      void SetInRing()      { SetFlag(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 int     GetBO()            const { return(_order); }
      unsigned int     GetBondOrder()     const { return(_order); }
      unsigned int     GetFlags()         const { return(_flags);      }
      unsigned int     GetBeginAtomIdx()  const { return(_bgn->GetIdx()); }
      unsigned int     GetEndAtomIdx()    const { return(_end->GetIdx()); }
      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();
      double  GetLength();

      unsigned int     GetNbrAtomIdx(OBAtom *ptr)
        {
          return((ptr!=_bgn)?_bgn->GetIdx():_end->GetIdx());
        }





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

      bool IsRotor();
      bool IsAmide();
      bool IsPrimaryAmide();
      bool IsSecondaryAmide();
      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 IsDoubleBondGeometry();

    }; // class OBBond

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

}// namespace OpenBabel

#endif   // OB_BOND_H

---

This file is part of the documentation for Open Babel, version 2.1.0.

Documentation copyright © 1998-2007, the Open Babel Developers.
Open Babel is hosted by:
Generated on Tue Apr 24 18:08:04 2007 by  1.5.2.