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