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