Bond.h
Go to the documentation of this file.
//
// Copyright (C) 2001-2014 Greg Landrum and Rational Discovery LLC
//
// @@ All Rights Reserved @@
// This file is part of the RDKit.
// The contents are covered by the terms of the BSD license
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
#ifndef _RD_BOND_H
#define _RD_BOND_H
// std stuff
#include <iostream>
// Ours
// FIX: grn...
#include <Query/QueryObjects.h>
#include <RDGeneral/types.h>
#include <GraphMol/details.h>
#include <boost/foreach.hpp>
namespace RDKit {
class ROMol;
class RWMol;
class Atom;
typedef boost::shared_ptr<Atom> ATOM_SPTR;
//! class for representing a bond
/*!
<b>Notes:</b>
- many of the methods of Atom require that the Atom be associated
with a molecule (an ROMol).
- each Bond maintains a Dict of \c properties:
- Each \c property is keyed by name and can store an
arbitrary type.
- \c Properties can be marked as \c calculated, in which case
they will be cleared when the \c clearComputedProps() method
is called.
- Because they have no impact upon chemistry, all \c property
operations are \c const, this allows extra flexibility for
clients who need to store extra data on Bond objects.
*/
class Bond {
friend class RWMol;
friend class ROMol;
public:
typedef boost::shared_ptr<Bond> BOND_SPTR;
// FIX: grn...
typedef Queries::Query<int, Bond const *, true> QUERYBOND_QUERY;
//! the type of Bond
typedef enum {
UNSPECIFIED = 0,
SINGLE,
DOUBLE,
TRIPLE,
QUADRUPLE,
QUINTUPLE,
HEXTUPLE,
ONEANDAHALF,
TWOANDAHALF,
THREEANDAHALF,
FOURANDAHALF,
FIVEANDAHALF,
AROMATIC,
IONIC,
HYDROGEN,
THREECENTER,
DATIVEONE, //!< one-electron dative (e.g. from a C in a Cp ring to a metal)
DATIVE, //!< standard two-electron dative
DATIVEL, //!< standard two-electron dative
DATIVER, //!< standard two-electron dative
OTHER,
ZERO //!< Zero-order bond (from
// http://pubs.acs.org/doi/abs/10.1021/ci200488k)
} BondType;
//! the bond's direction (for chirality)
typedef enum {
NONE = 0, //!< no special style
BEGINWEDGE, //!< wedged: narrow at begin
BEGINDASH, //!< dashed: narrow at begin
// FIX: this may not really be adequate
ENDDOWNRIGHT, //!< for cis/trans
ENDUPRIGHT, //!< ditto
EITHERDOUBLE, //!< a "crossed" double bond
UNKNOWN, //!< intentionally unspecified stereochemistry
} BondDir;
//! the nature of the bond's stereochem (for cis/trans)
typedef enum { // stereochemistry of double bonds
STEREONONE = 0, // no special style
STEREOANY, // intentionally unspecified
// -- Put any true specifications about this point so
// that we can do comparisons like if(bond->getStereo()>Bond::STEREOANY)
STEREOZ, // Z double bond
STEREOE, // E double bond
} BondStereo;
Bond();
//! construct with a particular BondType
explicit Bond(BondType bT);
Bond(const Bond &other);
virtual ~Bond();
Bond &operator=(const Bond &other);
//! returns a copy
/*!
<b>Note:</b> the caller is responsible for <tt>delete</tt>ing
the returned pointer.
*/
virtual Bond *copy() const;
//! returns our \c bondType
BondType getBondType() const { return static_cast<BondType>(d_bondType); };
//! sets our \c bondType
void setBondType(BondType bT) { d_bondType = bT; };
//! \brief returns our \c bondType as a double
//! (e.g. SINGLE->1.0, AROMATIC->1.5, etc.)
double getBondTypeAsDouble() const;
//! returns our contribution to the explicit valence of an Atom
/*!
<b>Notes:</b>
- requires an owning molecule
*/
double getValenceContrib(const Atom *at) const;
// \overload
double getValenceContrib(ATOM_SPTR at) const;
//! sets our \c isAromatic flag
void setIsAromatic(bool what) { df_isAromatic = what; };
//! returns the status of our \c isAromatic flag
bool getIsAromatic() const { return df_isAromatic; };
//! sets our \c isConjugated flag
void setIsConjugated(bool what) { df_isConjugated = what; };
//! returns the status of our \c isConjugated flag
bool getIsConjugated() const { return df_isConjugated; };
//! returns a reference to the ROMol that owns this Bond
ROMol &getOwningMol() const { return *dp_mol; };
//! sets our owning molecule
void setOwningMol(ROMol *other);
//! sets our owning molecule
void setOwningMol(ROMol &other) { setOwningMol(&other); };
//! returns our index within the ROMol
/*!
<b>Notes:</b>
- this makes no sense if we do not have an owning molecule
*/
unsigned int getIdx() const { return d_index; };
//! sets our index within the ROMol
/*!
<b>Notes:</b>
- this makes no sense if we do not have an owning molecule
- the index should be <tt>< this->getOwningMol()->getNumBonds()</tt>
*/
void setIdx(unsigned int index) { d_index = index; };
//! returns the index of our begin Atom
/*!
<b>Notes:</b>
- this makes no sense if we do not have an owning molecule
*/
unsigned int getBeginAtomIdx() const { return d_beginAtomIdx; };
//! returns the index of our end Atom
/*!
<b>Notes:</b>
- this makes no sense if we do not have an owning molecule
*/
unsigned int getEndAtomIdx() const { return d_endAtomIdx; };
//! given the index of one Atom, returns the index of the other
/*!
<b>Notes:</b>
- this makes no sense if we do not have an owning molecule
*/
unsigned int getOtherAtomIdx(unsigned int thisIdx) const;
//! sets the index of our begin Atom
/*!
<b>Notes:</b>
- requires an owning molecule
*/
void setBeginAtomIdx(unsigned int what);
//! sets the index of our end Atom
/*!
<b>Notes:</b>
- requires an owning molecule
*/
void setEndAtomIdx(unsigned int what);
//! sets our begin Atom
/*!
<b>Notes:</b>
- requires an owning molecule
*/
void setBeginAtom(Atom *at);
//! \overload
void setBeginAtom(ATOM_SPTR at);
//! sets our end Atom
/*!
<b>Notes:</b>
- requires an owning molecule
*/
void setEndAtom(Atom *at);
//! \overload
void setEndAtom(ATOM_SPTR at);
//! returns a pointer to our begin Atom
/*!
<b>Notes:</b>
- requires an owning molecule
*/
Atom *getBeginAtom() const;
//! returns a pointer to our end Atom
/*!
<b>Notes:</b>
- requires an owning molecule
*/
Atom *getEndAtom() const;
//! returns a pointer to the other Atom
/*!
<b>Notes:</b>
- requires an owning molecule
*/
Atom *getOtherAtom(Atom const *what) const;
// ------------------------------------
// Please see the note in Atom.h for some explanation
// of these methods
// ------------------------------------
// This method can be used to distinguish query bonds from standard bonds
virtual bool hasQuery() const { return false; };
// FIX: the const crap here is all mucked up.
//! NOT CALLABLE
virtual void setQuery(QUERYBOND_QUERY *what);
//! NOT CALLABLE
virtual QUERYBOND_QUERY *getQuery() const;
//! NOT CALLABLE
virtual void expandQuery(
QUERYBOND_QUERY *what,
Queries::CompositeQueryType how = Queries::COMPOSITE_AND,
bool maintainOrder = true);
//! returns whether or not we match the argument
/*!
<b>Notes:</b>
- for Bond objects, "match" means that either one of the Bonds
has \c bondType Bond::UNSPECIFIED or both Bonds have the
same \c bondType.
*/
virtual bool Match(Bond const *what) const;
//! \overload
virtual bool Match(const Bond::BOND_SPTR what) const;
//! sets our direction
void setBondDir(BondDir what) { d_dirTag = what; };
//! returns our direction
BondDir getBondDir() const { return static_cast<BondDir>(d_dirTag); };
//! sets our stereo code
void setStereo(BondStereo what) { d_stereo = what; };
//! returns our stereo code
BondStereo getStereo() const { return static_cast<BondStereo>(d_stereo); };
//! returns the indices of our stereo atoms
const INT_VECT &getStereoAtoms() const {
if (!dp_stereoAtoms) {
const_cast<Bond *>(this)->dp_stereoAtoms = new INT_VECT();
}
return *dp_stereoAtoms;
};
//! \overload
INT_VECT &getStereoAtoms() {
if (!dp_stereoAtoms) dp_stereoAtoms = new INT_VECT();
return *dp_stereoAtoms;
};
// ------------------------------------
// Local Property Dict functionality
// FIX: at some point this stuff should go in a mixin class
// ------------------------------------
//! returns a list with the names of our \c properties
STR_VECT getPropList() const { return dp_props->keys(); }
//! sets a \c property value
/*!
\param key the name under which the \c property should be stored.
If a \c property is already stored under this name, it will be
replaced.
\param val the value to be stored
\param computed (optional) allows the \c property to be flagged
\c computed.
*/
template <typename T>
void setProp(const char *key, T val, bool computed = false) const {
// if(!dp_props) dp_props = new Dict();
std::string what(key);
setProp(what, val, computed);
}
//! \overload
template <typename T>
void setProp(const std::string &key, T val, bool computed = false) const {
// setProp(key.c_str(),val);
if (computed) {
STR_VECT compLst;
getPropIfPresent(detail::computedPropName, compLst);
if (std::find(compLst.begin(), compLst.end(), key) == compLst.end()) {
compLst.push_back(key);
dp_props->setVal(detail::computedPropName, compLst);
}
}
dp_props->setVal(key, val);
}
//! allows retrieval of a particular property value
/*!
\param key the name under which the \c property should be stored.
If a \c property is already stored under this name, it will be
replaced.
\param res a reference to the storage location for the value.
<b>Notes:</b>
- if no \c property with name \c key exists, a KeyErrorException will be
thrown.
- the \c boost::lexical_cast machinery is used to attempt type
conversions.
If this fails, a \c boost::bad_lexical_cast exception will be thrown.
*/
template <typename T>
void getProp(const char *key, T &res) const {
PRECONDITION(dp_props, "getProp called on empty property dict");
dp_props->getVal(key, res);
}
//! \overload
template <typename T>
void getProp(const std::string &key, T &res) const {
PRECONDITION(dp_props, "getProp called on empty property dict");
dp_props->getVal(key, res);
}
//! \Overload
template <typename T>
T getProp(const char *key) const {
return dp_props->getVal<T>(key);
}
//! \overload
template <typename T>
T getProp(const std::string &key) const {
return dp_props->getVal<T>(key);
}
//! returns whether or not we have a \c property with name \c key
//! and assigns the value if we do
template <typename T>
bool getPropIfPresent(const char *key, T &res) const {
return dp_props->getValIfPresent(key, res);
}
//! \overload
template <typename T>
bool getPropIfPresent(const std::string &key, T &res) const {
return dp_props->getValIfPresent(key, res);
}
//! returns whether or not we have a \c property with name \c key
bool hasProp(const char *key) const {
if (!dp_props) return false;
return dp_props->hasVal(key);
};
//! \overload
bool hasProp(const std::string &key) const {
if (!dp_props) return false;
return dp_props->hasVal(key);
};
//! clears the value of a \c property
/*!
<b>Notes:</b>
- if no \c property with name \c key exists, a KeyErrorException
will be thrown.
- if the \c property is marked as \c computed, it will also be removed
from our list of \c computedProperties
*/
void clearProp(const char *key) const {
std::string what(key);
clearProp(what);
};
//! \overload
void clearProp(const std::string &key) const {
STR_VECT compLst;
if (getPropIfPresent(detail::computedPropName, compLst)) {
STR_VECT_I svi = std::find(compLst.begin(), compLst.end(), key);
if (svi != compLst.end()) {
compLst.erase(svi);
dp_props->setVal(detail::computedPropName, compLst);
}
}
dp_props->clearVal(key);
}
//! clears all of our \c computed \c properties
void clearComputedProps() const {
STR_VECT compLst;
if (getPropIfPresent(detail::computedPropName, compLst)) {
BOOST_FOREACH (const std::string &sv, compLst) { dp_props->clearVal(sv); }
compLst.clear();
dp_props->setVal(detail::computedPropName, compLst);
}
}
//! calculates any of our lazy \c properties
/*!
<b>Notes:</b>
- requires an owning molecule
*/
void updatePropertyCache(bool strict = true) { (void)strict; }
protected:
//! sets our owning molecule
// void setOwningMol(ROMol *other);
//! sets our owning molecule
// void setOwningMol(ROMol &other) {setOwningMol(&other);};
bool df_isAromatic;
bool df_isConjugated;
boost::uint8_t d_bondType;
boost::uint8_t d_dirTag;
boost::uint8_t d_stereo;
atomindex_t d_index;
atomindex_t d_beginAtomIdx, d_endAtomIdx;
ROMol *dp_mol;
Dict *dp_props;
INT_VECT *dp_stereoAtoms;
void initBond();
};
};
//! allows Bond objects to be dumped to streams
extern std::ostream &operator<<(std::ostream &target, const RDKit::Bond &b);
#endif
RDKit::Bond::initBond
void initBond()
details.h
RDKit::Bond::setBeginAtomIdx
void setBeginAtomIdx(unsigned int what)
sets the index of our begin Atom
RDKit::Bond::d_stereo
boost::uint8_t d_stereo
Definition: Bond.h:442
RDKit::Bond::STEREONONE
Definition: Bond.h:96
types.h
RDKit::Bond::STEREOE
Definition: Bond.h:101
RDKit::Dict::setVal
void setVal(const std::string &what, T &val)
Sets the value associated with a key.
Definition: Dict.h:169
RDKit::Bond::getStereo
BondStereo getStereo() const
returns our stereo code
Definition: Bond.h:276
RDKit::Bond::copy
virtual Bond * copy() const
returns a copy
RDKit::Bond::getPropList
STR_VECT getPropList() const
returns a list with the names of our properties
Definition: Bond.h:296
RDKit::Bond::getOwningMol
ROMol & getOwningMol() const
returns a reference to the ROMol that owns this Bond
Definition: Bond.h:146
RDKit::Bond::getBondTypeAsDouble
double getBondTypeAsDouble() const
returns our bondType as a double (e.g. SINGLE->1.0, AROMATIC->1.5, etc.)
RDKit::Bond::HYDROGEN
Definition: Bond.h:71
operator<<
std::ostream & operator<<(std::ostream &target, const RDKit::Bond &b)
allows Bond objects to be dumped to streams
RDKit::Bond::getEndAtom
Atom * getEndAtom() const
returns a pointer to our end Atom
Queries::CompositeQueryType
CompositeQueryType
Definition: QueryObjects.h:35
RDKit::RWMol
RWMol is a molecule class that is intended to be edited.
Definition: RWMol.h:30
RDKit::Dict::hasVal
bool hasVal(const char *what) const
Returns whether or not the dictionary contains a particular key.
Definition: Dict.h:48
RDKit::Bond::hasQuery
virtual bool hasQuery() const
Definition: Bond.h:243
RDKit::Bond::hasProp
bool hasProp(const std::string &key) const
Definition: Bond.h:386
RDKit::Bond::df_isAromatic
bool df_isAromatic
sets our owning molecule
Definition: Bond.h:438
RDKit::Bond::clearComputedProps
void clearComputedProps() const
clears all of our computed properties
Definition: Bond.h:417
RDKit::Bond::QUERYBOND_QUERY
Queries::Query< int, Bond const *, true > QUERYBOND_QUERY
Definition: Bond.h:53
RDKit::Bond::OTHER
Definition: Bond.h:77
RDKit::ATOM_SPTR
boost::shared_ptr< Atom > ATOM_SPTR
Definition: Bond.h:26
RDKit::Bond::dp_mol
ROMol * dp_mol
Definition: Bond.h:445
RDKit::Bond::getQuery
virtual QUERYBOND_QUERY * getQuery() const
NOT CALLABLE.
RDKit::Bond::setProp
void setProp(const char *key, T val, bool computed=false) const
sets a property value
Definition: Bond.h:308
RDKit::Bond::BondStereo
BondStereo
the nature of the bond&#39;s stereochem (for cis/trans)
Definition: Bond.h:95
RDKit::Bond::getProp
void getProp(const std::string &key, T &res) const
Definition: Bond.h:351
RDKit::Bond::QUINTUPLE
Definition: Bond.h:62
RDKit::Bond::clearProp
void clearProp(const char *key) const
clears the value of a property
Definition: Bond.h:399
RDKit::Bond::setIsConjugated
void setIsConjugated(bool what)
sets our isConjugated flag
Definition: Bond.h:141
RDKit::Bond::BondType
BondType
the type of Bond
Definition: Bond.h:56
RDKit::Bond::setBondType
void setBondType(BondType bT)
sets our bondType
Definition: Bond.h:121
RDKit::Dict::getValIfPresent
bool getValIfPresent(const std::string &what, T &res) const
Potentially gets the value associated with a particular key returns true on success/false on failure...
Definition: Dict.h:134
RDKit::Bond::IONIC
Definition: Bond.h:70
RDKit::Bond::STEREOZ
Definition: Bond.h:100
RDKit::ROMol
ROMol is a molecule class that is intended to have a fixed topology.
Definition: ROMol.h:102
RDKit::Bond::getPropIfPresent
bool getPropIfPresent(const char *key, T &res) const
Definition: Bond.h:371
RDKit::Bond::UNKNOWN
intentionally unspecified stereochemistry
Definition: Bond.h:91
RDKit::Bond::DATIVER
standard two-electron dative
Definition: Bond.h:76
RDKit::Bond::getBondDir
BondDir getBondDir() const
returns our direction
Definition: Bond.h:271
RDKit::Dict::getVal
void getVal(const std::string &what, T &res) const
Gets the value associated with a particular key.
Definition: Dict.h:84
RDKit::Dict::clearVal
void clearVal(const std::string &what)
Clears the value associated with a particular key, removing the key from the dictionary.
Definition: Dict.h:195
RDKit::Bond::THREEANDAHALF
Definition: Bond.h:66
RDKit::Bond::setIdx
void setIdx(unsigned int index)
sets our index within the ROMol
Definition: Bond.h:165
RDKit::Bond::DOUBLE
Definition: Bond.h:59
RDKit::Bond::setProp
void setProp(const std::string &key, T val, bool computed=false) const
Definition: Bond.h:315
RDKit::Bond::FIVEANDAHALF
Definition: Bond.h:68
RDKit::Bond::getIsAromatic
bool getIsAromatic() const
returns the status of our isAromatic flag
Definition: Bond.h:138
RDKit::Bond::dp_stereoAtoms
INT_VECT * dp_stereoAtoms
Definition: Bond.h:447
RDKit::Bond::expandQuery
virtual void expandQuery(QUERYBOND_QUERY *what, Queries::CompositeQueryType how=Queries::COMPOSITE_AND, bool maintainOrder=true)
NOT CALLABLE.
RDKit::Bond::getIsConjugated
bool getIsConjugated() const
returns the status of our isConjugated flag
Definition: Bond.h:143
RDKit::Bond::TWOANDAHALF
Definition: Bond.h:65
RDKit::Bond::getBeginAtom
Atom * getBeginAtom() const
returns a pointer to our begin Atom
RDKit::INT_VECT
std::vector< int > INT_VECT
Definition: types.h:146
RDKit::Bond::getValenceContrib
double getValenceContrib(const Atom *at) const
returns our contribution to the explicit valence of an Atom
RDKit::Bond::getProp
T getProp(const std::string &key) const
Definition: Bond.h:363
RDKit::Bond::setIsAromatic
void setIsAromatic(bool what)
sets our isAromatic flag
Definition: Bond.h:136
RDKit::Bond::getProp
T getProp(const char *key) const
Definition: Bond.h:358
RDKit::Bond::hasProp
bool hasProp(const char *key) const
returns whether or not we have a property with name key
Definition: Bond.h:381
RDKit::Bond::d_bondType
boost::uint8_t d_bondType
Definition: Bond.h:440
RDKit::Bond::getOtherAtomIdx
unsigned int getOtherAtomIdx(unsigned int thisIdx) const
given the index of one Atom, returns the index of the other
RDKit::Bond::getEndAtomIdx
unsigned int getEndAtomIdx() const
returns the index of our end Atom
Definition: Bond.h:179
RDKit
Includes a bunch of functionality for handling Atom and Bond queries.
Definition: Atom.h:28
RDKit::Bond::ENDUPRIGHT
ditto
Definition: Bond.h:89
RDKit::Dict::keys
STR_VECT keys() const
Returns the set of keys in the dictionary.
Definition: Dict.h:61
RDKit::Bond::updatePropertyCache
void updatePropertyCache(bool strict=true)
calculates any of our lazy properties
Definition: Bond.h:431
detail::computedPropName
const std::string computedPropName
Definition: types.h:25
RDKit::Bond::getStereoAtoms
INT_VECT & getStereoAtoms()
Definition: Bond.h:286
RDKit::Bond::d_index
atomindex_t d_index
Definition: Bond.h:443
RDKit::Bond::setStereo
void setStereo(BondStereo what)
sets our stereo code
Definition: Bond.h:274
RDKit::Bond::DATIVE
standard two-electron dative
Definition: Bond.h:74
RDKit::Bond::QUADRUPLE
Definition: Bond.h:61
RDKit::Bond::HEXTUPLE
Definition: Bond.h:63
RDKit::Bond::df_isConjugated
bool df_isConjugated
Definition: Bond.h:439
RDKit::Bond
class for representing a bond
Definition: Bond.h:46
RDKit::Bond::setOwningMol
void setOwningMol(ROMol *other)
sets our owning molecule
RDKit::Bond::ZERO
Zero-order bond (from.
Definition: Bond.h:78
RDKit::Bond::DATIVEL
standard two-electron dative
Definition: Bond.h:75
RDKit::Bond::setBeginAtom
void setBeginAtom(Atom *at)
sets our begin Atom
RDKit::Bond::BondDir
BondDir
the bond&#39;s direction (for chirality)
Definition: Bond.h:83
RDKit::Bond::d_beginAtomIdx
atomindex_t d_beginAtomIdx
Definition: Bond.h:444
RDKit::Bond::setEndAtomIdx
void setEndAtomIdx(unsigned int what)
sets the index of our end Atom
RDKit::Bond::~Bond
virtual ~Bond()
RDKit::Bond::TRIPLE
Definition: Bond.h:60
RDKit::Bond::getOtherAtom
Atom * getOtherAtom(Atom const *what) const
returns a pointer to the other Atom
RDKit::Bond::getBeginAtomIdx
unsigned int getBeginAtomIdx() const
returns the index of our begin Atom
Definition: Bond.h:172
RDKit::Bond::FOURANDAHALF
Definition: Bond.h:67
RDKit::Bond::setOwningMol
void setOwningMol(ROMol &other)
sets our owning molecule
Definition: Bond.h:150
RDKit::Bond::UNSPECIFIED
Definition: Bond.h:57
RDKit::Bond::AROMATIC
Definition: Bond.h:69
RDKit::Bond::DATIVEONE
one-electron dative (e.g. from a C in a Cp ring to a metal)
Definition: Bond.h:73
RDKit::Bond::d_dirTag
boost::uint8_t d_dirTag
Definition: Bond.h:441
PRECONDITION
#define PRECONDITION(expr, mess)
Definition: Invariant.h:103
RDKit::atomindex_t
boost::uint16_t atomindex_t
Definition: details.h:13
RDKit::Bond::NONE
no special style
Definition: Bond.h:84
RDKit::Bond::BEGINWEDGE
wedged: narrow at begin
Definition: Bond.h:85
RDKit::Bond::EITHERDOUBLE
a "crossed" double bond
Definition: Bond.h:90
RDKit::Bond::getBondType
BondType getBondType() const
returns our bondType
Definition: Bond.h:119
RDKit::Bond::operator=
Bond & operator=(const Bond &other)
RDKit::Bond::BOND_SPTR
boost::shared_ptr< Bond > BOND_SPTR
Definition: Bond.h:51
RDKit::Bond::dp_props
Dict * dp_props
Definition: Bond.h:446
QueryObjects.h
Pulls in all the query types.
RDKit::STR_VECT_I
std::vector< std::string >::iterator STR_VECT_I
Definition: types.h:168
RDKit::Bond::THREECENTER
Definition: Bond.h:72
RDKit::Bond::setEndAtom
void setEndAtom(Atom *at)
sets our end Atom
RDKit::Bond::ONEANDAHALF
Definition: Bond.h:64
RDKit::Bond::getStereoAtoms
const INT_VECT & getStereoAtoms() const
returns the indices of our stereo atoms
Definition: Bond.h:279
RDKit::Bond::Match
virtual bool Match(Bond const *what) const
returns whether or not we match the argument
RDKit::Bond::setBondDir
void setBondDir(BondDir what)
sets our direction
Definition: Bond.h:269
RDKit::Bond::STEREOANY
Definition: Bond.h:97
Queries::Query
Base class for all queries.
Definition: Query.h:45
RDKit::Bond::getProp
void getProp(const char *key, T &res) const
allows retrieval of a particular property value
Definition: Bond.h:345
RDKit::Bond::BEGINDASH
dashed: narrow at begin
Definition: Bond.h:86
Queries::COMPOSITE_AND
Definition: QueryObjects.h:35
RDKit::Bond::getIdx
unsigned int getIdx() const
returns our index within the ROMol
Definition: Bond.h:158
RDKit::Dict
The Dict class can be used to store objects of arbitrary type keyed by strings.
Definition: Dict.h:33
RDKit::Bond::SINGLE
Definition: Bond.h:58
RDKit::Bond::Bond
Bond()
RDKit::Bond::clearProp
void clearProp(const std::string &key) const
Definition: Bond.h:404
RDKit::Atom
The class for representing atoms.
Definition: Atom.h:67
RDKit::Bond::d_endAtomIdx
atomindex_t d_endAtomIdx
Definition: Bond.h:444
RDKit::STR_VECT
std::vector< std::string > STR_VECT
Definition: Dict.h:26
RDKit::Bond::setQuery
virtual void setQuery(QUERYBOND_QUERY *what)
NOT CALLABLE.
RDKit::Bond::getPropIfPresent
bool getPropIfPresent(const std::string &key, T &res) const
Definition: Bond.h:376
RDKit::Bond::ENDDOWNRIGHT
for cis/trans
Definition: Bond.h:88