RDKit
Open-source cheminformatics and machine learning.
QueryOps.h
Go to the documentation of this file.
1 //
2 // Copyright (C) 2003-2017 Greg Landrum and Rational Discovery LLC
3 //
4 // @@ All Rights Reserved @@
5 // This file is part of the RDKit.
6 // The contents are covered by the terms of the BSD license
7 // which is included in the file license.txt, found at the root
8 // of the RDKit source tree.
9 //
10 
11 //! \file QueryOps.h
12 /*!
13  \brief Includes a bunch of functionality for handling Atom and Bond queries.
14 */
15 #include <RDGeneral/export.h>
16 #ifndef _RD_QUERY_OPS_H
17 #define _RD_QUERY_OPS_H
18 
19 #include <GraphMol/RDKitBase.h>
20 #include <Query/QueryObjects.h>
21 #include <Query/Query.h>
22 #include <DataStructs/BitVects.h>
23 #include <DataStructs/BitOps.h>
24 
25 #ifdef RDK_THREADSAFE_SSS
26 #include <mutex>
27 #endif
28 
29 namespace RDKit {
32 
35 
38 
41 
44 
47 
52 
55 
58 
61 
64 
67 
68 // -------------------------------------------------
69 // common atom queries
70 
71 static inline int queryAtomAromatic(Atom const *at) {
72  return at->getIsAromatic();
73 };
74 static inline int queryAtomAliphatic(Atom const *at) {
75  return !(at->getIsAromatic());
76 };
77 static inline int queryAtomExplicitDegree(Atom const *at) {
78  return at->getDegree();
79 };
80 static inline int queryAtomTotalDegree(Atom const *at) {
81  return at->getTotalDegree();
82 };
83 static inline int queryAtomNonHydrogenDegree(Atom const *at) {
84  return at->getTotalDegree() - at->getTotalNumHs(true);
85 }
86 static inline int queryAtomHeavyAtomDegree(Atom const *at) {
87  int heavyDegree = 0;
88  ROMol::ADJ_ITER nbrIdx, endNbrs;
89  boost::tie(nbrIdx, endNbrs) = at->getOwningMol().getAtomNeighbors(at);
90  while (nbrIdx != endNbrs) {
91  const Atom *nbr = at->getOwningMol()[*nbrIdx];
92  if (nbr->getAtomicNum() > 1) {
93  heavyDegree++;
94  }
95  ++nbrIdx;
96  }
97 
98  return heavyDegree;
99 };
100 static inline int queryAtomHCount(Atom const *at) {
101  return at->getTotalNumHs(true);
102 };
103 static inline int queryAtomImplicitHCount(Atom const *at) {
104  return at->getTotalNumHs(false);
105 };
106 static inline int queryAtomHasImplicitH(Atom const *at) {
107  return int(at->getTotalNumHs(false) > 0);
108 };
109 static inline int queryAtomImplicitValence(Atom const *at) {
110  return at->getImplicitValence();
111 };
112 static inline int queryAtomExplicitValence(Atom const *at) {
113  return at->getExplicitValence() - at->getNumExplicitHs();
114 };
115 static inline int queryAtomTotalValence(Atom const *at) {
116  return at->getExplicitValence() + at->getImplicitValence();
117 };
118 static inline int queryAtomUnsaturated(Atom const *at) {
119  return static_cast<int>(at->getDegree()) < at->getExplicitValence();
120 };
121 static inline int queryAtomNum(Atom const *at) { return at->getAtomicNum(); };
122 static inline int makeAtomType(int atomic_num, bool aromatic) {
123  return atomic_num + 1000 * static_cast<int>(aromatic);
124 }
125 static inline void parseAtomType(int val, int &atomic_num, bool &aromatic) {
126  if (val > 1000) {
127  aromatic = true;
128  atomic_num = val - 1000;
129  } else {
130  aromatic = false;
131  atomic_num = val;
132  }
133 }
134 static inline bool getAtomTypeIsAromatic(int val) {
135  if (val > 1000) return true;
136  return false;
137 }
138 static inline int getAtomTypeAtomicNum(int val) {
139  if (val > 1000) return val - 1000;
140  return val;
141 }
142 
143 static inline int queryAtomType(Atom const *at) {
144  return makeAtomType(at->getAtomicNum(), at->getIsAromatic());
145 };
147 static inline int queryAtomMass(Atom const *at) {
148  return static_cast<int>(round(massIntegerConversionFactor * at->getMass()));
149 };
150 static inline int queryAtomIsotope(Atom const *at) {
151  return static_cast<int>(at->getIsotope());
152 };
153 static inline int queryAtomFormalCharge(Atom const *at) {
154  return static_cast<int>(at->getFormalCharge());
155 };
156 static inline int queryAtomHybridization(Atom const *at) {
157  return at->getHybridization();
158 };
159 static inline int queryAtomNumRadicalElectrons(Atom const *at) {
160  return at->getNumRadicalElectrons();
161 };
162 static inline int queryAtomHasChiralTag(Atom const *at) {
163  return at->getChiralTag() != Atom::CHI_UNSPECIFIED;
164 };
165 static inline int queryAtomMissingChiralTag(Atom const *at) {
166  return at->getChiralTag() == Atom::CHI_UNSPECIFIED &&
168 };
169 
170 static inline int queryAtomHasHeteroatomNbrs(Atom const *at) {
171  ROMol::ADJ_ITER nbrIdx, endNbrs;
172  boost::tie(nbrIdx, endNbrs) = at->getOwningMol().getAtomNeighbors(at);
173  while (nbrIdx != endNbrs) {
174  const Atom *nbr = at->getOwningMol()[*nbrIdx];
175  if (nbr->getAtomicNum() != 6 && nbr->getAtomicNum() != 1) {
176  return 1;
177  }
178  ++nbrIdx;
179  }
180  return 0;
181 };
182 
183 static inline int queryAtomNumHeteroatomNbrs(Atom const *at) {
184  int res = 0;
185  ROMol::ADJ_ITER nbrIdx, endNbrs;
186  boost::tie(nbrIdx, endNbrs) = at->getOwningMol().getAtomNeighbors(at);
187  while (nbrIdx != endNbrs) {
188  const Atom *nbr = at->getOwningMol()[*nbrIdx];
189  if (nbr->getAtomicNum() != 6 && nbr->getAtomicNum() != 1) {
190  ++res;
191  }
192  ++nbrIdx;
193  }
194  return res;
195 };
196 
197 static inline int queryAtomHasAliphaticHeteroatomNbrs(Atom const *at) {
198  ROMol::ADJ_ITER nbrIdx, endNbrs;
199  boost::tie(nbrIdx, endNbrs) = at->getOwningMol().getAtomNeighbors(at);
200  while (nbrIdx != endNbrs) {
201  const Atom *nbr = at->getOwningMol()[*nbrIdx];
202  if ((!nbr->getIsAromatic()) && nbr->getAtomicNum() != 6 &&
203  nbr->getAtomicNum() != 1) {
204  return 1;
205  }
206  ++nbrIdx;
207  }
208  return 0;
209 };
210 
211 static inline int queryAtomNumAliphaticHeteroatomNbrs(Atom const *at) {
212  int res = 0;
213  ROMol::ADJ_ITER nbrIdx, endNbrs;
214  boost::tie(nbrIdx, endNbrs) = at->getOwningMol().getAtomNeighbors(at);
215  while (nbrIdx != endNbrs) {
216  const Atom *nbr = at->getOwningMol()[*nbrIdx];
217  if ((!nbr->getIsAromatic()) && nbr->getAtomicNum() != 6 &&
218  nbr->getAtomicNum() != 1) {
219  ++res;
220  }
221  ++nbrIdx;
222  }
223  return res;
224 };
225 
226 RDKIT_GRAPHMOL_EXPORT unsigned int queryAtomBondProduct(Atom const *at);
227 RDKIT_GRAPHMOL_EXPORT unsigned int queryAtomAllBondProduct(Atom const *at);
228 
229 // -------------------------------------------------
230 // common bond queries
231 
232 static inline int queryBondOrder(Bond const *bond) {
233  return static_cast<int>(bond->getBondType());
234 };
235 static inline int queryBondIsSingleOrAromatic(Bond const *bond) {
236  return static_cast<int>(bond->getBondType() == Bond::SINGLE ||
237  bond->getBondType() == Bond::AROMATIC);
238 };
239 static inline int queryBondDir(Bond const *bond) {
240  return static_cast<int>(bond->getBondDir());
241 };
242 static inline int queryIsBondInNRings(Bond const *at) {
243  return at->getOwningMol().getRingInfo()->numBondRings(at->getIdx());
244 };
245 static inline int queryBondHasStereo(Bond const *bnd) {
246  return bnd->getStereo() > Bond::STEREONONE;
247 };
248 
249 // -------------------------------------------------
250 // ring queries
251 
252 static inline int queryIsAtomInNRings(Atom const *at) {
253  return at->getOwningMol().getRingInfo()->numAtomRings(at->getIdx());
254 };
255 static inline int queryIsAtomInRing(Atom const *at) {
256  return at->getOwningMol().getRingInfo()->numAtomRings(at->getIdx()) != 0;
257 };
258 static inline int queryAtomHasRingBond(Atom const *at) {
259  ROMol::OBOND_ITER_PAIR atomBonds = at->getOwningMol().getAtomBonds(at);
260  while (atomBonds.first != atomBonds.second) {
261  unsigned int bondIdx =
262  at->getOwningMol().getTopology()[*atomBonds.first]->getIdx();
263  if (at->getOwningMol().getRingInfo()->numBondRings(bondIdx)) {
264  return 1;
265  }
266  ++atomBonds.first;
267  }
268  return 0;
269 };
270 static inline int queryIsBondInRing(Bond const *bond) {
271  return bond->getOwningMol().getRingInfo()->numBondRings(bond->getIdx()) != 0;
272 };
273 static inline int queryAtomMinRingSize(Atom const *at) {
274  return at->getOwningMol().getRingInfo()->minAtomRingSize(at->getIdx());
275 };
276 static inline int queryBondMinRingSize(Bond const *bond) {
277  return bond->getOwningMol().getRingInfo()->minBondRingSize(bond->getIdx());
278 };
279 
280 static inline int queryAtomRingBondCount(Atom const *at) {
281  // EFF: cache this result
282  int res = 0;
283  ROMol::OBOND_ITER_PAIR atomBonds = at->getOwningMol().getAtomBonds(at);
284  while (atomBonds.first != atomBonds.second) {
285  unsigned int bondIdx =
286  at->getOwningMol().getTopology()[*atomBonds.first]->getIdx();
287  if (at->getOwningMol().getRingInfo()->numBondRings(bondIdx)) {
288  res++;
289  }
290  ++atomBonds.first;
291  }
292  return res;
293 }
294 
295 template <int tgt>
297  if (at->getOwningMol().getRingInfo()->isAtomInRingOfSize(at->getIdx(), tgt)) {
298  return tgt;
299  } else {
300  return 0;
301  }
302 };
303 template <int tgt>
304 int queryBondIsInRingOfSize(Bond const *bond) {
305  if (bond->getOwningMol().getRingInfo()->isBondInRingOfSize(bond->getIdx(),
306  tgt)) {
307  return tgt;
308  } else {
309  return 0;
310  }
311 };
312 
313 template <class T>
314 T *makeAtomSimpleQuery(int what, int func(Atom const *),
315  const std::string &description = "Atom Simple") {
316  T *res = new T;
317  res->setVal(what);
318  res->setDataFunc(func);
319  res->setDescription(description);
320  return res;
321 }
322 
323 static inline ATOM_RANGE_QUERY *makeAtomRangeQuery(
324  int lower, int upper, bool lowerOpen, bool upperOpen,
325  int func(Atom const *), const std::string &description = "Atom Range") {
326  ATOM_RANGE_QUERY *res = new ATOM_RANGE_QUERY(lower, upper);
327  res->setDataFunc(func);
328  res->setDescription(description);
329  res->setEndsOpen(lowerOpen, upperOpen);
330  return res;
331 }
332 
333 //! returns a Query for matching atomic number
334 template <class T>
335 T *makeAtomNumQuery(int what, const std::string &descr) {
336  return makeAtomSimpleQuery<T>(what, queryAtomNum, descr);
337 }
338 //! \overload
339 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomNumQuery(int what);
340 
341 //! returns a Query for matching atomic number and aromaticity
342 template <class T>
343 T *makeAtomTypeQuery(int num, int aromatic, const std::string &descr) {
344  return makeAtomSimpleQuery<T>(makeAtomType(num, aromatic), queryAtomType,
345  descr);
346 }
347 //! \overload
348 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomTypeQuery(int num,
349  int aromatic);
350 
351 //! returns a Query for matching implicit valence
352 template <class T>
353 T *makeAtomImplicitValenceQuery(int what, const std::string &descr) {
354  return makeAtomSimpleQuery<T>(what, queryAtomImplicitValence, descr);
355 }
356 //! \overload
357 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomImplicitValenceQuery(int what);
358 
359 //! returns a Query for matching explicit valence
360 template <class T>
361 T *makeAtomExplicitValenceQuery(int what, const std::string &descr) {
362  return makeAtomSimpleQuery<T>(what, queryAtomExplicitValence, descr);
363 }
364 //! \overload
365 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomExplicitValenceQuery(int what);
366 
367 //! returns a Query for matching total valence
368 template <class T>
369 T *makeAtomTotalValenceQuery(int what, const std::string &descr) {
370  return makeAtomSimpleQuery<T>(what, queryAtomTotalValence, descr);
371 }
372 //! \overload
373 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomTotalValenceQuery(int what);
374 
375 //! returns a Query for matching explicit degree
376 template <class T>
377 T *makeAtomExplicitDegreeQuery(int what, const std::string &descr) {
378  return makeAtomSimpleQuery<T>(what, queryAtomExplicitDegree, descr);
379 }
380 //! \overload
381 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomExplicitDegreeQuery(int what);
382 
383 //! returns a Query for matching atomic degree
384 template <class T>
385 T *makeAtomTotalDegreeQuery(int what, const std::string &descr) {
386  return makeAtomSimpleQuery<T>(what, queryAtomTotalDegree, descr);
387 }
388 //! \overload
389 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomTotalDegreeQuery(int what);
390 
391 //! returns a Query for matching heavy atom degree
392 template <class T>
393 T *makeAtomHeavyAtomDegreeQuery(int what, const std::string &descr) {
394  return makeAtomSimpleQuery<T>(what, queryAtomHeavyAtomDegree, descr);
395 }
396 //! \overload
397 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomHeavyAtomDegreeQuery(int what);
398 
399 //! returns a Query for matching hydrogen count
400 template <class T>
401 T *makeAtomHCountQuery(int what, const std::string &descr) {
402  return makeAtomSimpleQuery<T>(what, queryAtomHCount, descr);
403 }
404 //! \overload
405 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomHCountQuery(int what);
406 
407 //! returns a Query for matching ring atoms
408 template <class T>
409 T *makeAtomHasImplicitHQuery(const std::string &descr) {
410  return makeAtomSimpleQuery<T>(true, queryAtomHasImplicitH, descr);
411 }
412 //! \overload
414 
415 //! returns a Query for matching implicit hydrogen count
416 template <class T>
417 T *makeAtomImplicitHCountQuery(int what, const std::string &descr) {
418  return makeAtomSimpleQuery<T>(what, queryAtomImplicitHCount, descr);
419 }
420 //! \overload
421 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomImplicitHCountQuery(int what);
422 
423 //! returns a Query for matching the \c isAromatic flag
424 template <class T>
425 T *makeAtomAromaticQuery(const std::string &descr) {
426  return makeAtomSimpleQuery<T>(true, queryAtomAromatic, descr);
427 }
428 //! \overload
429 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomAromaticQuery();
430 
431 //! returns a Query for matching aliphatic atoms
432 template <class T>
433 T *makeAtomAliphaticQuery(const std::string &descr) {
434  return makeAtomSimpleQuery<T>(true, queryAtomAliphatic, descr);
435 }
436 //! \overload
437 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomAliphaticQuery();
438 
439 //! returns a Query for matching atoms with a particular mass
440 template <class T>
441 T *makeAtomMassQuery(int what, const std::string &descr) {
442  return makeAtomSimpleQuery<T>(massIntegerConversionFactor * what,
443  queryAtomMass, descr);
444 }
445 //! \overload
446 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomMassQuery(int what);
447 
448 //! returns a Query for matching atoms with a particular isotope
449 template <class T>
450 T *makeAtomIsotopeQuery(int what, const std::string &descr) {
451  return makeAtomSimpleQuery<T>(what, queryAtomIsotope, descr);
452 }
453 //! \overload
454 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomIsotopeQuery(int what);
455 
456 //! returns a Query for matching formal charge
457 template <class T>
458 T *makeAtomFormalChargeQuery(int what, const std::string &descr) {
459  return makeAtomSimpleQuery<T>(what, queryAtomFormalCharge, descr);
460 }
461 //! \overload
462 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomFormalChargeQuery(int what);
463 
464 //! returns a Query for matching hybridization
465 template <class T>
466 T *makeAtomHybridizationQuery(int what, const std::string &descr) {
467  return makeAtomSimpleQuery<T>(what, queryAtomHybridization, descr);
468 }
469 //! \overload
470 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomHybridizationQuery(int what);
471 
472 //! returns a Query for matching the number of radical electrons
473 template <class T>
474 T *makeAtomNumRadicalElectronsQuery(int what, const std::string &descr) {
475  return makeAtomSimpleQuery<T>(what, queryAtomNumRadicalElectrons, descr);
476 }
477 //! \overload
479  int what);
480 
481 //! returns a Query for matching whether or not chirality has been set on the
482 //! atom
483 template <class T>
484 T *makeAtomHasChiralTagQuery(const std::string &descr) {
485  return makeAtomSimpleQuery<T>(true, queryAtomHasChiralTag, descr);
486 }
487 //! \overloadquery
489 
490 //! returns a Query for matching whether or not a potentially chiral atom is
491 //! missing a chiral tag
492 template <class T>
493 T *makeAtomMissingChiralTagQuery(const std::string &descr) {
494  return makeAtomSimpleQuery<T>(true, queryAtomMissingChiralTag, descr);
495 }
496 //! \overloadquery
498 
499 //! returns a Query for matching atoms with unsaturation:
500 template <class T>
501 T *makeAtomUnsaturatedQuery(const std::string &descr) {
502  return makeAtomSimpleQuery<T>(true, queryAtomUnsaturated, descr);
503 }
504 //! \overload
506 
507 //! returns a Query for matching ring atoms
508 template <class T>
509 T *makeAtomInRingQuery(const std::string &descr) {
510  return makeAtomSimpleQuery<T>(true, queryIsAtomInRing, descr);
511 }
512 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomInRingQuery();
513 //! \overload
514 
515 //! returns a Query for matching atoms in a particular number of rings
516 template <class T>
517 T *makeAtomInNRingsQuery(int what, const std::string &descr) {
518  return makeAtomSimpleQuery<T>(what, queryIsAtomInNRings, descr);
519 }
520 //! \overload
521 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomInNRingsQuery(int what);
522 
523 //! returns a Query for matching atoms in rings of a particular size
524 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomInRingOfSizeQuery(int tgt);
525 
526 //! returns a Query for matching an atom's minimum ring size
527 template <class T>
528 T *makeAtomMinRingSizeQuery(int tgt, const std::string &descr) {
529  return makeAtomSimpleQuery<T>(tgt, queryAtomMinRingSize, descr);
530 }
531 //! \overload
532 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomMinRingSizeQuery(int tgt);
533 
534 //! returns a Query for matching atoms with a particular number of ring bonds
535 template <class T>
536 T *makeAtomRingBondCountQuery(int what, const std::string &descr) {
537  return makeAtomSimpleQuery<T>(what, queryAtomRingBondCount, descr);
538 }
539 //! \overload
540 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAtomRingBondCountQuery(int what);
541 
542 //! returns a Query for matching generic A atoms (heavy atoms)
543 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAAtomQuery();
544 //! returns a Query for matching generic AH atoms (any atom)
545 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeAHAtomQuery();
546 //! returns a Query for matching generic Q atoms (heteroatoms)
547 RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY *makeQAtomQuery();
548 //! returns a Query for matching generic QH atoms (heteroatom or H)
549 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *makeQHAtomQuery();
550 //! returns a Query for matching generic X atoms (halogens)
551 RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY *makeXAtomQuery();
552 //! returns a Query for matching generic XH atoms (halogen or H)
553 RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY *makeXHAtomQuery();
554 //! returns a Query for matching generic M atoms (metals)
555 RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY *makeMAtomQuery();
556 //! returns a Query for matching generic MH atoms (metals or H)
557 RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY *makeMHAtomQuery();
558 
559 //! returns a Query for matching atoms that have ring bonds
560 template <class T>
561 T *makeAtomHasRingBondQuery(const std::string &descr) {
562  return makeAtomSimpleQuery<T>(1, queryAtomHasRingBond, descr);
563 }
564 //! \overload
566 
567 //! returns a Query for matching the number of heteroatom neighbors
568 template <class T>
569 T *makeAtomNumHeteroatomNbrsQuery(int what, const std::string &descr) {
570  return makeAtomSimpleQuery<T>(what, queryAtomNumHeteroatomNbrs, descr);
571 }
572 //! \overload
574  int what);
575 
576 //! returns a Query for matching atoms that have heteroatom neighbors
577 template <class T>
578 T *makeAtomHasHeteroatomNbrsQuery(const std::string &descr) {
579  return makeAtomSimpleQuery<T>(1, queryAtomHasHeteroatomNbrs, descr);
580 }
581 //! \overload
583 
584 //! returns a Query for matching the number of aliphatic heteroatom neighbors
585 template <class T>
586 T *makeAtomNumAliphaticHeteroatomNbrsQuery(int what, const std::string &descr) {
587  return makeAtomSimpleQuery<T>(what, queryAtomNumAliphaticHeteroatomNbrs,
588  descr);
589 }
590 //! \overload
591 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *
593 
594 //! returns a Query for matching atoms that have heteroatom neighbors
595 template <class T>
596 T *makeAtomHasAliphaticHeteroatomNbrsQuery(const std::string &descr) {
597  return makeAtomSimpleQuery<T>(1, queryAtomHasAliphaticHeteroatomNbrs, descr);
598 }
599 //! \overload
600 RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY *
602 
603 //! returns a Query for matching bond orders
605  Bond::BondType what);
606 //! returns a Query for unspecified SMARTS bonds
608 //! returns a Query for matching bond directions
610  Bond::BondDir what);
611 //! returns a Query for matching bonds with stereo set
612 RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY *makeBondHasStereoQuery();
613 //! returns a Query for matching ring bonds
614 RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY *makeBondIsInRingQuery();
615 //! returns a Query for matching bonds in rings of a particular size
616 RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY *makeBondInRingOfSizeQuery(int what);
617 //! returns a Query for matching a bond's minimum ring size
618 RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY *makeBondMinRingSizeQuery(int what);
619 //! returns a Query for matching bonds in a particular number of rings
620 RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY *makeBondInNRingsQuery(int tgt);
621 
622 //! returns a Query for matching any bond
623 RDKIT_GRAPHMOL_EXPORT BOND_NULL_QUERY *makeBondNullQuery();
624 //! returns a Query for matching any atom
625 RDKIT_GRAPHMOL_EXPORT ATOM_NULL_QUERY *makeAtomNullQuery();
626 
627 static inline int queryAtomRingMembership(Atom const *at) {
628  return static_cast<int>(
629  at->getOwningMol().getRingInfo()->numAtomRings(at->getIdx()));
630 }
631 // I'm pretty sure that this typedef shouldn't be necessary,
632 // but VC++ generates a warning about const Atom const * in
633 // the definition of Match, then complains about an override
634 // that differs only by const/volatile (c4301), then generates
635 // incorrect code if we don't do this... so let's do it.
636 typedef Atom const *ConstAtomPtr;
637 
639  : public Queries::EqualityQuery<int, ConstAtomPtr, true> {
640  public:
641  AtomRingQuery() : Queries::EqualityQuery<int, ConstAtomPtr, true>(-1) {
642  // default is to just do a number of rings query:
643  this->setDescription("AtomInNRings");
644  this->setDataFunc(queryAtomRingMembership);
645  };
646  explicit AtomRingQuery(int v)
647  : Queries::EqualityQuery<int, ConstAtomPtr, true>(v) {
648  // default is to just do a number of rings query:
649  this->setDescription("AtomInNRings");
650  this->setDataFunc(queryAtomRingMembership);
651  };
652 
653  virtual bool Match(const ConstAtomPtr what) const {
654  int v = this->TypeConvert(what, Queries::Int2Type<true>());
655  bool res;
656  if (this->d_val < 0) {
657  res = v != 0;
658  } else {
659  res = !Queries::queryCmp(v, this->d_val, this->d_tol);
660  }
661  if (this->getNegation()) {
662  res = !res;
663  }
664  return res;
665  }
666 
667  //! returns a copy of this query
669  AtomRingQuery *res = new AtomRingQuery(this->d_val);
670  res->setNegation(getNegation());
671  res->setTol(this->getTol());
672  res->d_description = this->d_description;
673  res->d_dataFunc = this->d_dataFunc;
674  return res;
675  }
676 };
677 
678 //! allows use of recursive structure queries (e.g. recursive SMARTS)
680  : public Queries::SetQuery<int, Atom const *, true> {
681  public:
683  : Queries::SetQuery<int, Atom const *, true>(), d_serialNumber(0) {
684  setDataFunc(getAtIdx);
685  setDescription("RecursiveStructure");
686  };
687  //! initialize from an ROMol pointer
688  /*!
689  <b>Notes</b>
690  - this takes over ownership of the pointer
691  */
692  RecursiveStructureQuery(ROMol const *query, unsigned int serialNumber = 0)
693  : Queries::SetQuery<int, Atom const *, true>(),
694  d_serialNumber(serialNumber) {
695  setQueryMol(query);
696  setDataFunc(getAtIdx);
697  setDescription("RecursiveStructure");
698  };
699  //! returns the index of an atom
700  static inline int getAtIdx(Atom const *at) {
701  PRECONDITION(at, "bad atom argument");
702  return at->getIdx();
703  };
704 
705  //! sets the molecule we'll use recursively
706  /*!
707  <b>Notes</b>
708  - this takes over ownership of the pointer
709  */
710  void setQueryMol(ROMol const *query) { dp_queryMol.reset(query); }
711  //! returns a pointer to our query molecule
712  ROMol const *getQueryMol() const { return dp_queryMol.get(); };
713 
714  //! returns a copy of this query
717  res->dp_queryMol.reset(new ROMol(*dp_queryMol, true));
718 
719  std::set<int>::const_iterator i;
720  for (i = d_set.begin(); i != d_set.end(); i++) {
721  res->insert(*i);
722  }
723  res->setNegation(getNegation());
724  res->d_description = d_description;
725  res->d_serialNumber = d_serialNumber;
726  return res;
727  }
728  unsigned int getSerialNumber() const { return d_serialNumber; };
729 
730 #ifdef RDK_THREADSAFE_SSS
731  std::mutex d_mutex;
732 #endif
733  private:
734  boost::shared_ptr<const ROMol> dp_queryMol;
735  unsigned int d_serialNumber;
736 };
737 
738 template <typename T>
739 int nullDataFun(T) {
740  return 1;
741 }
742 template <typename T>
743 bool nullQueryFun(T) {
744  return true;
745 }
746 
747 typedef Bond const *ConstBondPtr;
748 
749 // ! Query whether an atom has a property
750 template <class TargetPtr>
751 class HasPropQuery : public Queries::EqualityQuery<int, TargetPtr, true> {
752  std::string propname;
753 
754  public:
755  HasPropQuery() : Queries::EqualityQuery<int, TargetPtr, true>(), propname() {
756  // default is to just do a number of rings query:
757  this->setDescription("AtomHasProp");
758  this->setDataFunc(0);
759  };
760  explicit HasPropQuery(const std::string &v)
761  : Queries::EqualityQuery<int, TargetPtr, true>(), propname(v) {
762  // default is to just do a number of rings query:
763  this->setDescription("AtomHasProp");
764  this->setDataFunc(0);
765  };
766 
767  virtual bool Match(const TargetPtr what) const {
768  bool res = what->hasProp(propname);
769  if (this->getNegation()) {
770  res = !res;
771  }
772  return res;
773  }
774 
775  //! returns a copy of this query
777  HasPropQuery *res = new HasPropQuery(this->propname);
778  res->setNegation(this->getNegation());
779  res->d_description = this->d_description;
780  return res;
781  }
782 };
783 
786 
787 //! returns a Query for matching atoms that have a particular property
788 template <class Target>
790  const std::string &property) {
791  return new HasPropQuery<const Target *>(property);
792 }
793 
794 // ! Query whether an atom has a property with a value
795 template <class TargetPtr, class T>
797  : public Queries::EqualityQuery<int, TargetPtr, true> {
798  std::string propname;
799  T val;
800  T tolerance;
801 
802  public:
804  : Queries::EqualityQuery<int, TargetPtr, true>(), propname(), val() {
805  // default is to just do a number of rings query:
806  this->setDescription("HasPropWithValue");
807  this->setDataFunc(0);
808  };
809  explicit HasPropWithValueQuery(const std::string &prop, const T &v,
810  const T &tol = 0.0)
811  : Queries::EqualityQuery<int, TargetPtr, true>(),
812  propname(prop),
813  val(v),
814  tolerance(tol) {
815  // default is to just do a number of rings query:
816  this->setDescription("HasPropWithValue");
817  this->setDataFunc(0);
818  };
819 
820  virtual bool Match(const TargetPtr what) const {
821  bool res = what->hasProp(propname);
822  if (res) {
823  try {
824  T atom_val = what->template getProp<T>(propname);
825  res = Queries::queryCmp(atom_val, this->val, this->tolerance) == 0;
826  } catch (KeyErrorException &) {
827  res = false;
828  } catch (boost::bad_any_cast &) {
829  res = false;
830  }
831 #ifdef __GNUC__
832 #if (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2))
833  catch (...) {
834  // catch all -- this is currently necessary to
835  // trap some bugs in boost+gcc configurations
836  // Normally, this is not the correct thing to
837  // do, but the only exception above is due
838  // to the boost any_cast which is trapped
839  // by the Boost python wrapper when it shouldn't
840  // be.
841  res = false;
842  }
843 #endif
844 #endif
845  }
846  if (this->getNegation()) {
847  res = !res;
848  }
849  return res;
850  }
851 
852  //! returns a copy of this query
854  HasPropWithValueQuery *res =
855  new HasPropWithValueQuery(this->propname, this->val, this->tolerance);
856  res->setNegation(this->getNegation());
857  res->d_description = this->d_description;
858  return res;
859  }
860 };
861 
862 template <class TargetPtr>
863 class HasPropWithValueQuery<TargetPtr, std::string>
864  : public Queries::EqualityQuery<int, TargetPtr, true> {
865  std::string propname;
866  std::string val;
867 
868  public:
870  : Queries::EqualityQuery<int, TargetPtr, true>(), propname(), val() {
871  // default is to just do a number of rings query:
872  this->setDescription("HasPropWithValue");
873  this->setDataFunc(0);
874  };
875  explicit HasPropWithValueQuery(const std::string &prop, const std::string &v,
876  const std::string &tol = "")
877  : Queries::EqualityQuery<int, TargetPtr, true>(), propname(prop), val(v) {
878  RDUNUSED_PARAM(tol);
879  // default is to just do a number of rings query:
880  this->setDescription("HasPropWithValue");
881  this->setDataFunc(0);
882  };
883 
884  virtual bool Match(const TargetPtr what) const {
885  bool res = what->hasProp(propname);
886  if (res) {
887  try {
888  std::string atom_val = what->template getProp<std::string>(propname);
889  res = atom_val == this->val;
890  } catch (KeyErrorException &) {
891  res = false;
892  } catch (boost::bad_any_cast &) {
893  res = false;
894  }
895 #ifdef __GNUC__
896 #if (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2))
897  catch (...) {
898  // catch all -- this is currently necessary to
899  // trap some bugs in boost+gcc configurations
900  // Normally, this is not the correct thing to
901  // do, but the only exception above is due
902  // to the boost any_cast which is trapped
903  // by the Boost python wrapper when it shouldn't
904  // be.
905  res = false;
906  }
907 #endif
908 #endif
909  }
910  if (this->getNegation()) {
911  res = !res;
912  }
913  return res;
914  }
915 
916  //! returns a copy of this query
920  this->val);
921  res->setNegation(this->getNegation());
922  res->d_description = this->d_description;
923  return res;
924  }
925 };
926 
927 template <class TargetPtr>
929  : public Queries::EqualityQuery<int, TargetPtr, true> {
930  std::string propname;
931  ExplicitBitVect val;
932  float tol;
933 
934  public:
936  : Queries::EqualityQuery<int, TargetPtr, true>(), propname(), val(), tol(0.0) {
937  this->setDescription("HasPropWithValue");
938  this->setDataFunc(0);
939  };
940 
941  explicit HasPropWithValueQuery(const std::string &prop,
942  const ExplicitBitVect &v,
943  float tol = 0.0)
944  : Queries::EqualityQuery<int, TargetPtr, true>(), propname(prop), val(v), tol(tol) {
945  this->setDescription("HasPropWithValue");
946  this->setDataFunc(0);
947  };
948 
949  virtual bool Match(const TargetPtr what) const {
950  bool res = what->hasProp(propname);
951  if (res) {
952  try {
953  const ExplicitBitVect &bv = what->template getProp<const ExplicitBitVect&>(propname);
954  const double tani = TanimotoSimilarity(val, bv);
955  res = (1.0 - tani) <= tol;
956  } catch (KeyErrorException) {
957  res = false;
958  } catch (boost::bad_any_cast) {
959  res = false;
960  }
961 #ifdef __GNUC__
962 #if (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2))
963  catch (...) {
964  // catch all -- this is currently necessary to
965  // trap some bugs in boost+gcc configurations
966  // Normally, this is not the correct thing to
967  // do, but the only exception above is due
968  // to the boost any_cast which is trapped
969  // by the Boost python wrapper when it shouldn't
970  // be.
971  res = false;
972  }
973 #endif
974 #endif
975  }
976  if (this->getNegation()) {
977  res = !res;
978  }
979  return res;
980  }
981 
982  //! returns a copy of this query
986  this->val,
987  this->tol);
988  res->setNegation(this->getNegation());
989  res->d_description = this->d_description;
990  return res;
991  }
992 };
993 
994 template <class Target, class T>
996  const std::string &propname, const T &val, const T &tolerance = T()) {
997  return new HasPropWithValueQuery<const Target *, T>(propname, val, tolerance);
998 }
999 
1000 template <class Target>
1002  const std::string &propname, const ExplicitBitVect &val, float tolerance=0.0) {
1004  tolerance);
1005 }
1006 
1010 }; // namespace RDKit
1011 
1012 #endif
HasPropQuery(const std::string &v)
Definition: QueryOps.h:760
Queries::XOrQuery< int, Atom const *, true > ATOM_XOR_QUERY
Definition: QueryOps.h:39
T * makeAtomTotalValenceQuery(int what, const std::string &descr)
returns a Query for matching total valence
Definition: QueryOps.h:369
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * makeBondIsInRingQuery()
returns a Query for matching ring bonds
T * makeAtomInRingQuery(const std::string &descr)
returns a Query for matching ring atoms
Definition: QueryOps.h:509
Pulls in all the BitVect classes.
RDKIT_GRAPHMOL_EXPORT bool isComplexQuery(const Bond *b)
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * makeQHAtomQuery()
returns a Query for matching generic QH atoms (heteroatom or H)
static int queryAtomTotalDegree(Atom const *at)
Definition: QueryOps.h:80
static int queryAtomMissingChiralTag(Atom const *at)
Definition: QueryOps.h:165
int queryCmp(const T1 v1, const T2 v2, const T1 tol)
Definition: Query.h:190
BondStereo getStereo() const
returns our stereo code
Definition: Bond.h:289
T * makeAtomHybridizationQuery(int what, const std::string &descr)
returns a Query for matching hybridization
Definition: QueryOps.h:466
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * makeBondHasStereoQuery()
returns a Query for matching bonds with stereo set
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * makeAtomInRingOfSizeQuery(int tgt)
returns a Query for matching atoms in rings of a particular size
static int queryAtomHybridization(Atom const *at)
Definition: QueryOps.h:156
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * makeBondDirEqualsQuery(Bond::BondDir what)
returns a Query for matching bond directions
T * makeAtomMassQuery(int what, const std::string &descr)
returns a Query for matching atoms with a particular mass
Definition: QueryOps.h:441
static int queryAtomHasHeteroatomNbrs(Atom const *at)
Definition: QueryOps.h:170
unsigned int numBondRings(unsigned int idx) const
returns the number of rings bond idx is involved in
Queries::OrQuery< int, Bond const *, true > BOND_OR_QUERY
Definition: QueryOps.h:37
ROMol & getOwningMol() const
returns a reference to the ROMol that owns this Bond
Definition: Bond.h:146
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * makeMHAtomQuery()
returns a Query for matching generic MH atoms (metals or H)
Queries::LessQuery< int, Atom const *, true > ATOM_LESS_QUERY
Definition: QueryOps.h:53
RDKIT_GRAPHMOL_EXPORT BOND_NULL_QUERY * makeBondNullQuery()
returns a Query for matching any bond
void setNegation(bool what)
sets whether or not we are negated
Definition: Query.h:63
Queries::Query< int, Atom const *, true > ATOM_NULL_QUERY
Definition: QueryOps.h:66
T * makeAtomNumAliphaticHeteroatomNbrsQuery(int what, const std::string &descr)
returns a Query for matching the number of aliphatic heteroatom neighbors
Definition: QueryOps.h:586
a Query implementing AND: requires all children to be true
Definition: AndQuery.h:21
T * makeAtomImplicitValenceQuery(int what, const std::string &descr)
returns a Query for matching implicit valence
Definition: QueryOps.h:353
void setTol(MatchFuncArgType what)
sets our tolerance
Definition: EqualityQuery.h:49
Atom const * ConstAtomPtr
Definition: QueryOps.h:636
Queries::EqualityQuery< int, Bond const *, true > BOND_PROP_QUERY
Definition: QueryOps.h:785
int getImplicitValence() const
returns the implicit valence for this Atom
a Query implementing AND: requires any child to be true
Definition: OrQuery.h:20
HybridizationType getHybridization() const
returns our hybridization
Definition: Atom.h:242
unsigned int getTotalNumHs(bool includeNeighbors=false) const
returns the total number of Hs (implicit and explicit) that this Atom is bound to ...
T * makeAtomMinRingSizeQuery(int tgt, const std::string &descr)
returns a Query for matching an atom&#39;s minimum ring size
Definition: QueryOps.h:528
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * makeXAtomQuery()
returns a Query for matching generic X atoms (halogens)
STL namespace.
Queries::Query< int, Bond const *, true > BOND_NULL_QUERY
Definition: QueryOps.h:65
static int queryAtomExplicitDegree(Atom const *at)
Definition: QueryOps.h:77
bool getIsAromatic() const
returns our isAromatic flag
Definition: Atom.h:220
Queries::GreaterQuery< int, Bond const *, true > BOND_GREATER_QUERY
Definition: QueryOps.h:46
static int queryBondOrder(Bond const *bond)
Definition: QueryOps.h:232
T * makeAtomHasAliphaticHeteroatomNbrsQuery(const std::string &descr)
returns a Query for matching atoms that have heteroatom neighbors
Definition: QueryOps.h:596
T * makeAtomNumHeteroatomNbrsQuery(int what, const std::string &descr)
returns a Query for matching the number of heteroatom neighbors
Definition: QueryOps.h:569
static int queryAtomImplicitHCount(Atom const *at)
Definition: QueryOps.h:103
unsigned int minBondRingSize(unsigned int idx) const
returns the size of the smallest ring bond idx is involved in
unsigned int getNumRadicalElectrons() const
returns the number of radical electrons for this Atom
Definition: Atom.h:196
Queries::Query< bool, Bond const *, true > BOND_BOOL_QUERY
Definition: QueryOps.h:31
static int getAtIdx(Atom const *at)
returns the index of an atom
Definition: QueryOps.h:700
Queries::SetQuery< int, Bond const *, true > BOND_SET_QUERY
Definition: QueryOps.h:63
T * makeAtomImplicitHCountQuery(int what, const std::string &descr)
returns a Query for matching implicit hydrogen count
Definition: QueryOps.h:417
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * makeAHAtomQuery()
returns a Query for matching generic AH atoms (any atom)
static int queryAtomMass(Atom const *at)
Definition: QueryOps.h:147
Queries::EqualityQuery< int, const Target *, true > * makePropQuery(const std::string &propname, const T &val, const T &tolerance=T())
Definition: QueryOps.h:995
T * makeAtomHasChiralTagQuery(const std::string &descr)
Definition: QueryOps.h:484
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * makeXHAtomQuery()
returns a Query for matching generic XH atoms (halogen or H)
BondType
the type of Bond
Definition: Bond.h:56
ADJ_ITER_PAIR getAtomNeighbors(Atom const *at) const
provides access to all neighbors around an Atom
static int queryAtomNumHeteroatomNbrs(Atom const *at)
Definition: QueryOps.h:183
bool nullQueryFun(T)
Definition: QueryOps.h:743
virtual bool Match(const TargetPtr what) const
returns whether or not we match the argument
Definition: QueryOps.h:949
pulls in the core RDKit functionality
Queries::GreaterEqualQuery< int, Atom const *, true > ATOM_GREATEREQUAL_QUERY
Definition: QueryOps.h:49
static int queryBondHasStereo(Bond const *bnd)
Definition: QueryOps.h:245
static int queryIsBondInRing(Bond const *bond)
Definition: QueryOps.h:270
Queries::GreaterEqualQuery< int, Bond const *, true > BOND_GREATEREQUAL_QUERY
Definition: QueryOps.h:51
Queries::Query< int, TargetPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:776
static int queryBondIsSingleOrAromatic(Bond const *bond)
Definition: QueryOps.h:235
BondDir getBondDir() const
returns our direction
Definition: Bond.h:268
double getMass() const
returns our mass
int getExplicitValence() const
returns the explicit valence (including Hs) of this atom
static int queryAtomType(Atom const *at)
Definition: QueryOps.h:143
virtual bool Match(const TargetPtr what) const
returns whether or not we match the argument
Definition: QueryOps.h:820
static int queryAtomNumAliphaticHeteroatomNbrs(Atom const *at)
Definition: QueryOps.h:211
T * makeAtomExplicitDegreeQuery(int what, const std::string &descr)
returns a Query for matching explicit degree
Definition: QueryOps.h:377
Queries::LessEqualQuery< int, Atom const *, true > ATOM_LESSEQUAL_QUERY
Definition: QueryOps.h:56
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * makeMAtomQuery()
returns a Query for matching generic M atoms (metals)
#define RDKIT_GRAPHMOL_EXPORT
Definition: export.h:307
static int queryAtomHasChiralTag(Atom const *at)
Definition: QueryOps.h:162
static int queryBondDir(Bond const *bond)
Definition: QueryOps.h:239
RingInfo * getRingInfo() const
Definition: ROMol.h:452
unsigned int getIsotope() const
returns our isotope number
Definition: Atom.h:228
static int queryAtomUnsaturated(Atom const *at)
Definition: QueryOps.h:118
Queries::LessEqualQuery< int, Bond const *, true > BOND_LESSEQUAL_QUERY
Definition: QueryOps.h:57
a Query implementing a range: arguments must fall in a particular range of values.
Definition: RangeQuery.h:27
static ATOM_RANGE_QUERY * makeAtomRangeQuery(int lower, int upper, bool lowerOpen, bool upperOpen, int func(Atom const *), const std::string &description="Atom Range")
Definition: QueryOps.h:323
int queryAtomIsInRingOfSize(Atom const *at)
Definition: QueryOps.h:296
T * makeAtomIsotopeQuery(int what, const std::string &descr)
returns a Query for matching atoms with a particular isotope
Definition: QueryOps.h:450
T * makeAtomAliphaticQuery(const std::string &descr)
returns a Query for matching aliphatic atoms
Definition: QueryOps.h:433
const int massIntegerConversionFactor
Definition: QueryOps.h:146
T * makeAtomUnsaturatedQuery(const std::string &descr)
returns a Query for matching atoms with unsaturation:
Definition: QueryOps.h:501
double TanimotoSimilarity(const SparseIntVect< IndexType > &v1, const SparseIntVect< IndexType > &v2, bool returnDistance=false, double bounds=0.0)
T * makeAtomMissingChiralTagQuery(const std::string &descr)
Definition: QueryOps.h:493
class to allow integer values to pick templates
Definition: Query.h:27
static int queryAtomIsotope(Atom const *at)
Definition: QueryOps.h:150
unsigned int getSerialNumber() const
Definition: QueryOps.h:728
Queries::LessQuery< int, Bond const *, true > BOND_LESS_QUERY
Definition: QueryOps.h:54
virtual bool Match(const TargetPtr what) const
returns whether or not we match the argument
Definition: QueryOps.h:767
Queries::Query< int, TargetPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:853
allows use of recursive structure queries (e.g. recursive SMARTS)
Definition: QueryOps.h:679
static int makeAtomType(int atomic_num, bool aromatic)
Definition: QueryOps.h:122
Bond const * ConstBondPtr
Definition: QueryOps.h:747
static int queryAtomExplicitValence(Atom const *at)
Definition: QueryOps.h:112
static int queryIsAtomInRing(Atom const *at)
Definition: QueryOps.h:255
int getFormalCharge() const
returns the formal charge of this atom
Definition: Atom.h:202
a Query implementing <= using a particular value (and an optional tolerance)
Queries::Query< bool, Atom const *, true > ATOM_BOOL_QUERY
Definition: QueryOps.h:30
unsigned int getIdx() const
returns our index within the ROMol
Definition: Atom.h:129
HasPropWithValueQuery(const std::string &prop, const std::string &v, const std::string &tol="")
Definition: QueryOps.h:875
static int queryAtomAromatic(Atom const *at)
Definition: QueryOps.h:71
Std stuff.
Definition: Atom.h:30
static int queryBondMinRingSize(Bond const *bond)
Definition: QueryOps.h:276
static int queryAtomNonHydrogenDegree(Atom const *at)
Definition: QueryOps.h:83
static int queryAtomNum(Atom const *at)
Definition: QueryOps.h:121
Queries::EqualityQuery< int, Bond const *, true > BOND_EQUALS_QUERY
Definition: QueryOps.h:43
T * makeAtomTypeQuery(int num, int aromatic, const std::string &descr)
returns a Query for matching atomic number and aromaticity
Definition: QueryOps.h:343
static void parseAtomType(int val, int &atomic_num, bool &aromatic)
Definition: QueryOps.h:125
Queries::XOrQuery< int, Bond const *, true > BOND_XOR_QUERY
Definition: QueryOps.h:40
MatchFuncArgType(* d_dataFunc)(DataFuncArgType)
Definition: Query.h:157
int getAtomicNum() const
returns our atomic number
Definition: Atom.h:115
bool hasProp(const std::string &key) const
Definition: RDProps.h:117
T * makeAtomRingBondCountQuery(int what, const std::string &descr)
returns a Query for matching atoms with a particular number of ring bonds
Definition: QueryOps.h:536
T * makeAtomAromaticQuery(const std::string &descr)
returns a Query for matching the isAromatic flag
Definition: QueryOps.h:425
static int queryAtomFormalCharge(Atom const *at)
Definition: QueryOps.h:153
a Query implementing < using a particular value (and an optional tolerance)
Definition: LessQuery.h:21
void setEndsOpen(bool lower, bool upper)
sets whether or not the ends of the range are open
Definition: RangeQuery.h:58
a Query implementing ==: arguments must match a particular value (within an optional tolerance) ...
Definition: EqualityQuery.h:23
T * makeAtomNumQuery(int what, const std::string &descr)
returns a Query for matching atomic number
Definition: QueryOps.h:335
OBOND_ITER_PAIR getAtomBonds(Atom const *at) const
provides access to all Bond objects connected to an Atom
Queries::Query< int, TargetPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:917
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * makeSingleOrAromaticBondQuery()
returns a Query for unspecified SMARTS bonds
T * makeAtomFormalChargeQuery(int what, const std::string &descr)
returns a Query for matching formal charge
Definition: QueryOps.h:458
class for representing a bond
Definition: Bond.h:47
#define RDUNUSED_PARAM(x)
Definition: Invariant.h:195
static int queryAtomHeavyAtomDegree(Atom const *at)
Definition: QueryOps.h:86
T * makeAtomExplicitValenceQuery(int what, const std::string &descr)
returns a Query for matching explicit valence
Definition: QueryOps.h:361
void insert(const MatchFuncArgType what)
insert an entry into our set
Definition: SetQuery.h:33
static int queryAtomHasAliphaticHeteroatomNbrs(Atom const *at)
Definition: QueryOps.h:197
void setDataFunc(MatchFuncArgType(*what)(DataFuncArgType))
sets our data function
Definition: Query.h:92
unsigned int getNumExplicitHs() const
returns our number of explict Hs
Definition: Atom.h:215
Queries::AndQuery< int, Bond const *, true > BOND_AND_QUERY
Definition: QueryOps.h:34
BondDir
the bond&#39;s direction (for chirality)
Definition: Bond.h:83
RDKIT_RDGENERAL_EXPORT double round(double v)
rounds a value to the closest int
static int queryIsAtomInNRings(Atom const *at)
Definition: QueryOps.h:252
MolGraph const & getTopology() const
brief returns a pointer to our underlying BGL object
Definition: ROMol.h:555
Contains general bit-comparison and similarity operations.
void setQueryMol(ROMol const *query)
sets the molecule we&#39;ll use recursively
Definition: QueryOps.h:710
HasPropWithValueQuery(const std::string &prop, const ExplicitBitVect &v, float tol=0.0)
Definition: QueryOps.h:941
Queries::Query< int, ConstAtomPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:668
RecursiveStructureQuery(ROMol const *query, unsigned int serialNumber=0)
initialize from an ROMol pointer
Definition: QueryOps.h:692
ROMol const * getQueryMol() const
returns a pointer to our query molecule
Definition: QueryOps.h:712
static int queryAtomHasImplicitH(Atom const *at)
Definition: QueryOps.h:106
#define PRECONDITION(expr, mess)
Definition: Invariant.h:108
static int queryAtomMinRingSize(Atom const *at)
Definition: QueryOps.h:273
RDKIT_GRAPHMOL_EXPORT unsigned int queryAtomAllBondProduct(Atom const *at)
Queries::Query< int, Atom const *, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:715
unsigned int getDegree() const
ROMol & getOwningMol() const
returns a reference to the ROMol that owns this Atom
Definition: Atom.h:123
Queries::AndQuery< int, Atom const *, true > ATOM_AND_QUERY
Definition: QueryOps.h:33
RDKIT_GRAPHMOL_EXPORT ATOM_EQUALS_QUERY * makeAAtomQuery()
returns a Query for matching generic A atoms (heavy atoms)
static int queryAtomNumRadicalElectrons(Atom const *at)
Definition: QueryOps.h:159
bool isAtomInRingOfSize(unsigned int idx, unsigned int size) const
returns whether or not the atom with index idx is in a size - ring.
T * makeAtomHasRingBondQuery(const std::string &descr)
returns a Query for matching atoms that have ring bonds
Definition: QueryOps.h:561
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * makeBondOrderEqualsQuery(Bond::BondType what)
returns a Query for matching bond orders
Queries::EqualityQuery< int, Atom const *, true > ATOM_EQUALS_QUERY
Definition: QueryOps.h:42
std::string d_description
Definition: Query.h:146
BondType getBondType() const
returns our bondType
Definition: Bond.h:121
T * makeAtomHasImplicitHQuery(const std::string &descr)
returns a Query for matching ring atoms
Definition: QueryOps.h:409
a class for bit vectors that are densely occupied
T * makeAtomInNRingsQuery(int what, const std::string &descr)
returns a Query for matching atoms in a particular number of rings
Definition: QueryOps.h:517
static int queryAtomAliphatic(Atom const *at)
Definition: QueryOps.h:74
Queries::RangeQuery< int, Atom const *, true > ATOM_RANGE_QUERY
Definition: QueryOps.h:59
HasPropWithValueQuery(const std::string &prop, const T &v, const T &tol=0.0)
Definition: QueryOps.h:809
T * makeAtomHeavyAtomDegreeQuery(int what, const std::string &descr)
returns a Query for matching heavy atom degree
Definition: QueryOps.h:393
a Query implementing > using a particular value (and an optional tolerance)
Definition: GreaterQuery.h:21
RDKIT_GRAPHMOL_EXPORT unsigned int queryAtomBondProduct(Atom const *at)
static int queryAtomRingBondCount(Atom const *at)
Definition: QueryOps.h:280
a Query implementing >= using a particular value (and an optional tolerance)
Pulls in all the query types.
T * makeAtomNumRadicalElectronsQuery(int what, const std::string &descr)
returns a Query for matching the number of radical electrons
Definition: QueryOps.h:474
RDKIT_RDGENERAL_EXPORT const std::string _ChiralityPossible
ChiralType getChiralTag() const
returns our chiralTag
Definition: Atom.h:235
Queries::GreaterQuery< int, Atom const *, true > ATOM_GREATER_QUERY
Definition: QueryOps.h:45
chirality that hasn&#39;t been specified
Definition: Atom.h:92
Queries::OrQuery< int, Atom const *, true > ATOM_OR_QUERY
Definition: QueryOps.h:36
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * makeBondInRingOfSizeQuery(int what)
returns a Query for matching bonds in rings of a particular size
unsigned int getTotalDegree() const
T * makeAtomSimpleQuery(int what, int func(Atom const *), const std::string &description="Atom Simple")
Definition: QueryOps.h:314
static int getAtomTypeAtomicNum(int val)
Definition: QueryOps.h:138
unsigned int numAtomRings(unsigned int idx) const
returns the number of rings atom idx is involved in
T * makeAtomHasHeteroatomNbrsQuery(const std::string &descr)
returns a Query for matching atoms that have heteroatom neighbors
Definition: QueryOps.h:578
int queryBondIsInRingOfSize(Bond const *bond)
Definition: QueryOps.h:304
int nullDataFun(T)
Definition: QueryOps.h:739
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * makeBondInNRingsQuery(int tgt)
returns a Query for matching bonds in a particular number of rings
static int queryAtomHasRingBond(Atom const *at)
Definition: QueryOps.h:258
virtual bool Match(const ConstAtomPtr what) const
Definition: QueryOps.h:653
bool isBondInRingOfSize(unsigned int idx, unsigned int size) const
returns whether or not the bond with index idx is in a size - ring.
static bool getAtomTypeIsAromatic(int val)
Definition: QueryOps.h:134
static int queryAtomRingMembership(Atom const *at)
Definition: QueryOps.h:627
Queries::EqualityQuery< int, Atom const *, true > ATOM_PROP_QUERY
Definition: QueryOps.h:784
unsigned int minAtomRingSize(unsigned int idx) const
returns the size of the smallest ring atom idx is involved in
Base class for all queries.
Definition: Query.h:46
RDKIT_GRAPHMOL_EXPORT BOND_EQUALS_QUERY * makeBondMinRingSizeQuery(int what)
returns a Query for matching a bond&#39;s minimum ring size
static int queryAtomHCount(Atom const *at)
Definition: QueryOps.h:100
Queries::RangeQuery< int, Bond const *, true > BOND_RANGE_QUERY
Definition: QueryOps.h:60
static int queryAtomTotalValence(Atom const *at)
Definition: QueryOps.h:115
unsigned int getIdx() const
returns our index within the ROMol
Definition: Bond.h:161
virtual bool Match(const TargetPtr what) const
returns whether or not we match the argument
Definition: QueryOps.h:884
The class for representing atoms.
Definition: Atom.h:69
a Query implementing XOR: requires exactly one child to be true
Definition: XOrQuery.h:21
void setDescription(const std::string &descr)
sets our text description
Definition: Query.h:68
Queries::EqualityQuery< int, const Target *, true > * makeHasPropQuery(const std::string &property)
returns a Query for matching atoms that have a particular property
Definition: QueryOps.h:789
static int queryAtomImplicitValence(Atom const *at)
Definition: QueryOps.h:109
Class to allow us to throw a KeyError from C++ and have it make it back to Python.
Definition: Exceptions.h:49
RDKIT_GRAPHMOL_EXPORT bool isAtomAromatic(const Atom *a)
RDKIT_GRAPHMOL_EXPORT ATOM_OR_QUERY * makeQAtomQuery()
returns a Query for matching generic Q atoms (heteroatoms)
T * makeAtomHCountQuery(int what, const std::string &descr)
returns a Query for matching hydrogen count
Definition: QueryOps.h:401
T * makeAtomTotalDegreeQuery(int what, const std::string &descr)
returns a Query for matching atomic degree
Definition: QueryOps.h:385
RDKIT_GRAPHMOL_EXPORT ATOM_NULL_QUERY * makeAtomNullQuery()
returns a Query for matching any atom
Queries::Query< int, TargetPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:983
Queries::SetQuery< int, Atom const *, true > ATOM_SET_QUERY
Definition: QueryOps.h:62
static int queryIsBondInNRings(Bond const *at)
Definition: QueryOps.h:242