RDKit: FilterMatchers.h Source File

| RDKit Open-source cheminformatics and machine learning.

Loading...
Searching...
No Matches
FilterMatchers.h
Go to the documentation of this file.
1// Copyright (c) 2015, Novartis Institutes for BioMedical Research Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8// * Redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer.
10// * Redistributions in binary form must reproduce the above
11// copyright notice, this list of conditions and the following
12// disclaimer in the documentation and/or other materials provided
13// with the distribution.
14// * Neither the name of Novartis Institutes for BioMedical Research Inc.
15// nor the names of its contributors may be used to endorse or promote
16// products derived from this software without specific prior written
17// permission.
18//
19// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30//
31
32#include <RDGeneral/export.h>
33#ifndef __RD_FILTER_MATCHER_H__
34#define __RD_FILTER_MATCHER_H__
35#include <utility>
36
37#include <GraphMol/RDKitBase.h>
38#include <GraphMol/Substruct/SubstructMatch.h>
39#include "FilterMatcherBase.h"
40#include <GraphMol/MolPickler.h>
41
42#ifdef RDK_USE_BOOST_SERIALIZATION
43#include <RDGeneral/BoostStartInclude.h>
44#include <boost/serialization/shared_ptr.hpp>
45#include <RDGeneral/BoostEndInclude.h>
46#endif
47
48namespace RDKit {
49
50namespace {
51std::string getArgName(const boost::shared_ptr<FilterMatcherBase> &arg) {
52 if (arg.get()) {
53 return arg->getName();
54 }
55 return "<nullmatcher>";
56}
57} // namespace
58
59 namespace FilterMatchOps {
60 class RDKIT_FILTERCATALOG_EXPORT And : public FilterMatcherBase {
61 boost::shared_ptr<FilterMatcherBase> arg1;
62 boost::shared_ptr<FilterMatcherBase> arg2;
63
64 public:
65 // !Default Constructor for serialization
66 And() : FilterMatcherBase("And"), arg1(), arg2() {}
67
68 //! Constructs an Ander
69 //! True if arg1 and arg2 FilterMatchers are true
70
71 And(const FilterMatcherBase &arg1, const FilterMatcherBase &arg2)
72 : FilterMatcherBase("And"), arg1(arg1.copy()), arg2(arg2.copy()) {}
73
74 And(boost::shared_ptr<FilterMatcherBase> arg1,
75 boost::shared_ptr<FilterMatcherBase> arg2)
76 : FilterMatcherBase("And"),
77 arg1(std::move(arg1)),
78 arg2(std::move(arg2)) {}
79
80 And(const And &rhs)
81 : FilterMatcherBase(rhs), arg1(rhs.arg1), arg2(rhs.arg2) {}
82
83 std::string getName() const override {
84 return "(" + getArgName(arg1) + " " + FilterMatcherBase::getName() + " " +
85 getArgName(arg2) + ")";
86 }
87
88 bool isValid() const override {
89 return arg1.get() && arg2.get() && arg1->isValid() && arg2->isValid();
90 }
91
92 bool hasMatch(const ROMol &mol) const override {
93 PRECONDITION(isValid(),
94 "FilterMatchOps::And is not valid, null arg1 or arg2");
95 return arg1->hasMatch(mol) && arg2->hasMatch(mol);
96 }
97
98 bool getMatches(const ROMol &mol,
99 std::vector<FilterMatch> &matchVect) const override {
100 PRECONDITION(isValid(),
101 "FilterMatchOps::And is not valid, null arg1 or arg2");
102 std::vector<FilterMatch> matches;
103 if (arg1->getMatches(mol, matches) && arg2->getMatches(mol, matches)) {
104 matchVect = matches;
105 return true;
106 }
107 return false;
108 }
109
110 boost::shared_ptr<FilterMatcherBase> copy() const override {
111 return boost::shared_ptr<FilterMatcherBase>(new And(*this));
112 }
113
114 private:
115#ifdef RDK_USE_BOOST_SERIALIZATION
116 friend class boost::serialization::access;
117 template <class Archive>
118 void serialize(Archive &ar, const unsigned int version) {
119 RDUNUSED_PARAM(version);
120 ar &boost::serialization::base_object<FilterMatcherBase>(*this);
121
122 ar & arg1;
123 ar & arg2;
124 }
125#endif
126};
127
128 class RDKIT_FILTERCATALOG_EXPORT Or : public FilterMatcherBase {
129 boost::shared_ptr<FilterMatcherBase> arg1;
130 boost::shared_ptr<FilterMatcherBase> arg2;
131
132 public:
133 // !Default Constructor for serialization
134 Or() : FilterMatcherBase("Or"), arg1(), arg2() {}
135
136 //! Constructs or Ander
137 //! true if arg1 or arg2 are true
138 Or(const FilterMatcherBase &arg1, const FilterMatcherBase &arg2)
139 : FilterMatcherBase("Or"), arg1(arg1.copy()), arg2(arg2.copy()) {}
140
141 Or(boost::shared_ptr<FilterMatcherBase> arg1,
142 boost::shared_ptr<FilterMatcherBase> arg2)
143 : FilterMatcherBase("Or"), arg1(std::move(arg1)), arg2(std::move(arg2)) {}
144
145 Or(const Or &rhs) : FilterMatcherBase(rhs), arg1(rhs.arg1), arg2(rhs.arg2) {}
146
147 std::string getName() const override {
148 return "(" + getArgName(arg1) + " " + FilterMatcherBase::getName() + " " +
149 getArgName(arg2) + ")";
150 }
151
152 bool isValid() const override {
153 return arg1.get() && arg2.get() && arg1->isValid() && arg2->isValid();
154 }
155
156 bool hasMatch(const ROMol &mol) const override {
157 PRECONDITION(isValid(), "Or is not valid, null arg1 or arg2");
158 return arg1->hasMatch(mol) || arg2->hasMatch(mol);
159 }
160
161 bool getMatches(const ROMol &mol,
162 std::vector<FilterMatch> &matchVect) const override {
163 PRECONDITION(isValid(),
164 "FilterMatchOps::Or is not valid, null arg1 or arg2");
165 // we want both matches to run in order to accumulate all matches
166 // into matchVect, otherwise the or can be arbitrary...
167 bool res1 = arg1->getMatches(mol, matchVect);
168 bool res2 = arg2->getMatches(mol, matchVect);
169 return res1 || res2;
170 }
171
172 boost::shared_ptr<FilterMatcherBase> copy() const override {
173 return boost::shared_ptr<FilterMatcherBase>(new Or(*this));
174 }
175
176#ifdef RDK_USE_BOOST_SERIALIZATION
177 friend class boost::serialization::access;
178 template <class Archive>
179 void serialize(Archive &ar, const unsigned int version) {
180 RDUNUSED_PARAM(version);
181 ar &boost::serialization::base_object<FilterMatcherBase>(*this);
182 ar & arg1;
183 ar & arg2;
184 }
185#endif
186};
187
188 class RDKIT_FILTERCATALOG_EXPORT Not : public FilterMatcherBase {
189 boost::shared_ptr<FilterMatcherBase> arg1;
190
191 public:
192 // !Default Constructor for serialization
193 Not() : FilterMatcherBase("Not"), arg1() {}
194
195 //! Constructs a Noter
196 //! true if arg1 is false (note, never returns matches
197 /// from getMatches since a false internal match matches
198 /// nothing!
199 Not(const FilterMatcherBase &arg1)
200 : FilterMatcherBase("Not"), arg1(arg1.copy()) {}
201
202 Not(boost::shared_ptr<FilterMatcherBase> arg1)
203 : FilterMatcherBase("Not"), arg1(std::move(arg1)) {}
204
205 Not(const Not &rhs) : FilterMatcherBase(rhs), arg1(rhs.arg1) {}
206
207 std::string getName() const override {
208 return "(" + FilterMatcherBase::getName() + " " + getArgName(arg1) + ")";
209 }
210
211 bool isValid() const override { return arg1.get() && arg1->isValid(); }
212
213 bool hasMatch(const ROMol &mol) const override {
214 PRECONDITION(isValid(), "FilterMatchOps::Not: arg1 is null");
215 return !arg1->hasMatch(mol);
216 }
217
218 bool getMatches(const ROMol &mol, std::vector<FilterMatch> &) const override {
219 PRECONDITION(isValid(), "FilterMatchOps::Not: arg1 is null");
220 // If we are a not, we really can't hold the match for
221 // this query since by definition it won't exist!
222 std::vector<FilterMatch> matchVect;
223 return !arg1->getMatches(mol, matchVect);
224 }
225
226 boost::shared_ptr<FilterMatcherBase> copy() const override {
227 return boost::shared_ptr<FilterMatcherBase>(new Not(*this));
228 }
229
230 private:
231#ifdef RDK_USE_BOOST_SERIALIZATION
232 friend class boost::serialization::access;
233 template <class Archive>
234 void serialize(Archive &ar, const unsigned int version) {
235 RDUNUSED_PARAM(version);
236 ar &boost::serialization::base_object<FilterMatcherBase>(*this);
237 ar & arg1;
238 }
239#endif
240};
241} // namespace FilterMatchOps
242
243 RDKIT_FILTERCATALOG_EXPORT extern const char *SMARTS_MATCH_NAME_DEFAULT;
244 class RDKIT_FILTERCATALOG_EXPORT SmartsMatcher : public FilterMatcherBase {
245 ROMOL_SPTR d_pattern;
246 unsigned int d_min_count{0};
247 unsigned int d_max_count;
248
249 public:
250 //! Construct a SmartsMatcher
251 SmartsMatcher(const std::string &name = SMARTS_MATCH_NAME_DEFAULT)
252 : FilterMatcherBase(name),
253 d_pattern(),
254
255 d_max_count(UINT_MAX) {}
256
257 //! Construct a SmartsMatcher from a query molecule
258 /*
259 \param pattern query molecule used as the substructure search
260 \param unsigned int minCount minimum number of times the pattern needs to
261 appear
262 \param maxCount the maximum number of times the pattern should appear
263 a value of UINT_MAX indicates the pattern can exist any number of times.
264 [default UINT_MAX]
265
266 */
267 SmartsMatcher(const ROMol &pattern, unsigned int minCount = 1,
268 unsigned int maxCount = UINT_MAX);
269
270 //! Construct a SmartsMatcher
271 /*
272 \param name name for the smarts pattern
273 \param pattern query molecule used as the substructure search
274 \param unsigned int minCount minimum number of times the pattern needs to
275 appear
276 \param maxCount the maximum number of times the pattern should appear
277 a value of UINT_MAX indicates the pattern can exist any number of times.
278 [default UINT_MAX]
279
280 */
281
282 SmartsMatcher(const std::string &name, const ROMol &pattern,
283 unsigned int minCount = 1, unsigned int maxCount = UINT_MAX);
284
285 //! Construct a SmartsMatcher from a smarts pattern
286 /*
287 \param name name for the smarts pattern
288 \param smarts smarts pattern to use for the filter
289 \param unsigned int minCount minimum number of times the pattern needs to
290 appear
291 \param maxCount the maximum number of times the pattern should appear
292 a value of UINT_MAX indicates the pattern can exist any number of times.
293 [default UINT_MAX]
294 */
295
296 SmartsMatcher(const std::string &name, const std::string &smarts,
297 unsigned int minCount = 1, unsigned int maxCount = UINT_MAX);
298
299 //! Construct a SmartsMatcher from a shared_ptr
300 /*
301 \param name name for the smarts pattern
302 \param pattern shared_ptr query molecule used as the substructure search
303 \param unsigned int minCount minimum number of times the pattern needs to
304 appear
305 \param maxCount the maximum number of times the pattern should appear
306 a value of UINT_MAX indicates the pattern can exist any number of times.
307 [default UINT_MAX]
308 */
309
310 SmartsMatcher(const std::string &name, ROMOL_SPTR onPattern,
311 unsigned int minCount = 1, unsigned int maxCount = UINT_MAX);
312
313 SmartsMatcher(const SmartsMatcher &rhs);
314
315 //! Returns True if the Smarts pattern is valid
316 bool isValid() const override { return d_pattern.get(); }
317
318 //! Return the shared_ptr to the underlying query molecule
319 const ROMOL_SPTR &getPattern() const { return d_pattern; }
320 //! Set the smarts pattern for the matcher
321 void setPattern(const std::string &smarts);
322 //! Set the query molecule for the matcher
323 void setPattern(const ROMol &mol);
324 //! Set the shared query molecule for the matcher
325 void setPattern(const ROMOL_SPTR &pat) { d_pattern = pat; }
326
327 //! Get the minimum match count for the pattern to be true
328 unsigned int getMinCount() const { return d_min_count; }
329 //! Set the minimum match count for the pattern to be true
330 void setMinCount(unsigned int val) { d_min_count = val; }
331 //! Get the maximum match count for the pattern to be true
332 unsigned int getMaxCount() const { return d_max_count; }
333 //! Set the maximum match count for the pattern to be true
334 void setMaxCount(unsigned int val) { d_max_count = val; }
335
336 bool getMatches(const ROMol &mol,
337 std::vector<FilterMatch> &matchVect) const override;
338 bool hasMatch(const ROMol &mol) const override;
339 boost::shared_ptr<FilterMatcherBase> copy() const override {
340 return boost::shared_ptr<FilterMatcherBase>(new SmartsMatcher(*this));
341 }
342
343 private:
344#ifdef RDK_USE_BOOST_SERIALIZATION
345 friend class boost::serialization::access;
346 template <class Archive>
347 void save(Archive &ar, const unsigned int version) const {
348 RDUNUSED_PARAM(version);
349 ar &boost::serialization::base_object<FilterMatcherBase>(*this);
350 std::string res;
351 MolPickler::pickleMol(*d_pattern.get(), res);
352 ar & res;
353 ar & d_min_count;
354 ar & d_max_count;
355 }
356 template <class Archive>
357 void load(Archive &ar, const unsigned int version) {
358 ar &boost::serialization::base_object<FilterMatcherBase>(*this);
359 RDUNUSED_PARAM(version);
360 std::string res;
361 ar & res;
362 d_pattern = boost::shared_ptr<ROMol>(new ROMol(res));
363 ar & d_min_count;
364 ar & d_max_count;
365 }
366 BOOST_SERIALIZATION_SPLIT_MEMBER();
367#endif
368};
369
370// ------------------------------------------------------------------
371// Syntactic sugar for the following style patterns
372// Add exclusion patterns
373// using FilterMatchOps;
374// And(new SmartsMatcher(pat1),
375// new Not(SmartsMatcher(pat2)))
376// The exclusion match never adds any FilterMatches when getMatches
377// is called, the main intent is for it to be used with an
378// And construct, such as:
379// And(SmartsMatcher(..), ExclusionList(...))
380//
381// which will return the SmartsMatcher FilterMatch only if no patterns
382// in the exclusion list are found.
383 class RDKIT_FILTERCATALOG_EXPORT ExclusionList : public FilterMatcherBase {
384 std::vector<boost::shared_ptr<FilterMatcherBase>> d_offPatterns;
385
386 public:
387 ExclusionList() : FilterMatcherBase("Not any of"), d_offPatterns() {}
388
389 //! Constructs an ExclusionList
390 //! true if non of the FilterMatcherBases are true
391 //! Syntactic sugar for
392 //! using FilterMatchOps;
393 //! And(Not(SmartsMatcher(pat1),
394 //! And(Not(SmartsMatcher(pat2)),
395 //! And(Not(Single...
396
397 ExclusionList(std::vector<boost::shared_ptr<FilterMatcherBase>> offPatterns)
398 : FilterMatcherBase("Not any of"),
399 d_offPatterns(std::move(offPatterns)) {}
400
401 std::string getName() const override {
402 std::string res;
403 res = "(" + FilterMatcherBase::getName();
404 for (size_t i = 0; i < d_offPatterns.size(); ++i) {
405 res += " " + d_offPatterns[i]->getName();
406 }
407 res += ")";
408 return res;
409 }
410
411 bool isValid() const override {
412 for (size_t i = 0; i < d_offPatterns.size(); ++i) {
413 if (!d_offPatterns[i]->isValid()) {
414 return false;
415 }
416 }
417 return true;
418 }
419
420 void addPattern(const FilterMatcherBase &base) {
421 PRECONDITION(base.isValid(), "Invalid FilterMatcherBase");
422 d_offPatterns.push_back(base.copy());
423 }
424
425 void setExclusionPatterns(
426 const std::vector<boost::shared_ptr<FilterMatcherBase>> &offPatterns) {
427 d_offPatterns = offPatterns;
428 }
429
430 bool getMatches(const ROMol &mol, std::vector<FilterMatch> &) const override {
431 PRECONDITION(isValid(),
432 "ExclusionList: one of the exclusion pattens is invalid");
433 bool result = true;
434 for (size_t i = 0; i < d_offPatterns.size() && result; ++i) {
435 result &= !d_offPatterns[i]->hasMatch(mol);
436 }
437
438 return result;
439 }
440
441 bool hasMatch(const ROMol &mol) const override {
442 PRECONDITION(isValid(),
443 "ExclusionList: one of the exclusion pattens is invalid");
444 bool result = true;
445 for (size_t i = 0; i < d_offPatterns.size() && result; ++i) {
446 result &= !d_offPatterns[i]->hasMatch(mol);
447 }
448
449 return result;
450 }
451
452 boost::shared_ptr<FilterMatcherBase> copy() const override {
453 return boost::shared_ptr<FilterMatcherBase>(new ExclusionList(*this));
454 }
455
456 private:
457#ifdef RDK_USE_BOOST_SERIALIZATION
458 friend class boost::serialization::access;
459 template <class Archive>
460 void serialize(Archive &ar, const unsigned int version) {
461 RDUNUSED_PARAM(version);
462 ar &boost::serialization::base_object<FilterMatcherBase>(*this);
463 ar & d_offPatterns;
464 }
465#endif
466};
467
468 class RDKIT_FILTERCATALOG_EXPORT FilterHierarchyMatcher
469 : public FilterMatcherBase {
470 std::vector<boost::shared_ptr<FilterHierarchyMatcher>> d_children;
471 boost::shared_ptr<FilterMatcherBase> d_matcher;
472
473 public:
474 // !Default Constructor for serialization
475 FilterHierarchyMatcher() : FilterMatcherBase(), d_matcher() {}
476 //! Constructs a FilterHierarchyMatcher from a FilterMatchBase
477 //! A FilterHierarchyMatcher is a tree hierarchy where to
478 //! match a child node, one needs to match the parent first.
479 //! For each branch, the lowest nodes are returned when
480 //! getting the filter matches.
481 /*
482 \param matcher FilterMatcherBase to match this node against
483 */
484 FilterHierarchyMatcher(const FilterMatcherBase &matcher)
485 : FilterMatcherBase(), d_matcher(matcher.copy()) {}
486
487 //! Return the name for this node (from the underlying FilterMatcherBase)
488 std::string getName() const override {
489 if (d_matcher.get()) {
490 return d_matcher->getName();
491 }
492 return "FilterMatcherHierarchy root";
493 }
494
495 //! returns true if this node has a valid matcher
496 bool isValid() const override { return d_matcher->isValid(); }
497
498 //! Set a new FilterMatcherBase for this node
499 /*
500 \param matcher The new FilterMatcherBase
501 */
502 void setPattern(const FilterMatcherBase &matcher) {
503 PRECONDITION(matcher.isValid(), "Adding invalid patterns is not allowed.");
504 d_matcher = matcher.copy();
505 PRECONDITION(getName() == d_matcher->getName(), "Opps");
506 }
507
508 //! add a FilterHierarchy as a child.
509 //! returns the FilterHierarchy pointer used in the tree (this is a
510 //! shallow copy of the original)
511 /*
512 \param hierarchy The new FilterHierarchyMatcher child for this node
513 */
514 boost::shared_ptr<FilterHierarchyMatcher> addChild(
515 const FilterHierarchyMatcher &hierarchy) {
516 PRECONDITION(hierarchy.d_matcher.get() && hierarchy.d_matcher->isValid(),
517 "Only one root node is allowed in a FilterHierarchyMatcher");
518
519 d_children.push_back(boost::shared_ptr<FilterHierarchyMatcher>(
520 new FilterHierarchyMatcher(hierarchy)));
521 return d_children.back();
522 }
523
524 //! returns the FilterMatches against the given molecule
525 /*
526 \param mol The molecule to match against
527 \param matches The vector of FilterMatch objects that match
528 */
529 bool getMatches(const ROMol &mol,
530 std::vector<FilterMatch> &matches) const override;
531
532 //! Does this node match the molecule
533 /*
534 \param mol The molecule to match against
535 */
536 bool hasMatch(const ROMol &mol) const override {
537 std::vector<FilterMatch> temp;
538 return getMatches(mol, temp);
539 }
540
541 //! copys the FilterHierarchyMatcher into a FilterMatcherBase
542 boost::shared_ptr<FilterMatcherBase> copy() const override {
543 return boost::shared_ptr<FilterMatcherBase>(
544 new FilterHierarchyMatcher(*this));
545 }
546
547 private:
548#ifdef RDK_USE_BOOST_SERIALIZATION
549 friend class boost::serialization::access;
550 template <class Archive>
551 void serialize(Archive &ar, const unsigned int version) {
552 RDUNUSED_PARAM(version);
553 ar &boost::serialization::base_object<FilterMatcherBase>(*this);
554 ar & d_children;
555 ar & d_matcher;
556 }
557#endif
558};
559
560#ifdef RDK_USE_BOOST_SERIALIZATION
561// Register all known filter matcher types for serialization
562template <class Archive>
563void registerFilterMatcherTypes(Archive &ar) {
564 ar.register_type(static_cast<FilterMatchOps::And *>(nullptr));
565 ar.register_type(static_cast<FilterMatchOps::Or *>(nullptr));
566 ar.register_type(static_cast<FilterMatchOps::Not *>(nullptr));
567 ar.register_type(static_cast<SmartsMatcher *>(nullptr));
568 ar.register_type(static_cast<ExclusionList *>(nullptr));
569 ar.register_type(static_cast<FilterHierarchyMatcher *>(nullptr));
570}
571#endif
572} // namespace RDKit
573
574#ifdef RDK_USE_BOOST_SERIALIZATION
575BOOST_CLASS_VERSION(RDKit::SmartsMatcher, 1)
576BOOST_CLASS_VERSION(RDKit::ExclusionList, 1)
577BOOST_CLASS_VERSION(RDKit::FilterHierarchyMatcher, 1)
578#endif
579
580#endif
BoostEndInclude.h
BoostStartInclude.h
FilterMatcherBase.h
RDUNUSED_PARAM
#define RDUNUSED_PARAM(x)
Definition Invariant.h:196
PRECONDITION
#define PRECONDITION(expr, mess)
Definition Invariant.h:108
MolPickler.h
RDKitBase.h
pulls in the core RDKit functionality
SubstructMatch.h
RDKit::ExclusionList
Definition FilterMatchers.h:383
RDKit::ExclusionList::getMatches
bool getMatches(const ROMol &mol, std::vector< FilterMatch > &) const override
getMatches
Definition FilterMatchers.h:430
RDKit::ExclusionList::hasMatch
bool hasMatch(const ROMol &mol) const override
hasMatches
Definition FilterMatchers.h:441
RDKit::ExclusionList::ExclusionList
ExclusionList()
Definition FilterMatchers.h:387
RDKit::ExclusionList::setExclusionPatterns
void setExclusionPatterns(const std::vector< boost::shared_ptr< FilterMatcherBase > > &offPatterns)
Definition FilterMatchers.h:425
RDKit::ExclusionList::ExclusionList
ExclusionList(std::vector< boost::shared_ptr< FilterMatcherBase > > offPatterns)
Definition FilterMatchers.h:397
RDKit::ExclusionList::addPattern
void addPattern(const FilterMatcherBase &base)
Definition FilterMatchers.h:420
RDKit::ExclusionList::isValid
bool isValid() const override
Definition FilterMatchers.h:411
RDKit::ExclusionList::getName
std::string getName() const override
Definition FilterMatchers.h:401
RDKit::ExclusionList::copy
boost::shared_ptr< FilterMatcherBase > copy() const override
Definition FilterMatchers.h:452
RDKit::FilterHierarchyMatcher
Definition FilterMatchers.h:469
RDKit::FilterHierarchyMatcher::setPattern
void setPattern(const FilterMatcherBase &matcher)
Set a new FilterMatcherBase for this node.
Definition FilterMatchers.h:502
RDKit::FilterHierarchyMatcher::getMatches
bool getMatches(const ROMol &mol, std::vector< FilterMatch > &matches) const override
returns the FilterMatches against the given molecule
RDKit::FilterHierarchyMatcher::isValid
bool isValid() const override
returns true if this node has a valid matcher
Definition FilterMatchers.h:496
RDKit::FilterHierarchyMatcher::copy
boost::shared_ptr< FilterMatcherBase > copy() const override
copys the FilterHierarchyMatcher into a FilterMatcherBase
Definition FilterMatchers.h:542
RDKit::FilterHierarchyMatcher::getName
std::string getName() const override
Return the name for this node (from the underlying FilterMatcherBase)
Definition FilterMatchers.h:488
RDKit::FilterHierarchyMatcher::FilterHierarchyMatcher
FilterHierarchyMatcher(const FilterMatcherBase &matcher)
Definition FilterMatchers.h:484
RDKit::FilterHierarchyMatcher::FilterHierarchyMatcher
FilterHierarchyMatcher()
Definition FilterMatchers.h:475
RDKit::FilterHierarchyMatcher::addChild
boost::shared_ptr< FilterHierarchyMatcher > addChild(const FilterHierarchyMatcher &hierarchy)
Definition FilterMatchers.h:514
RDKit::FilterHierarchyMatcher::hasMatch
bool hasMatch(const ROMol &mol) const override
Does this node match the molecule.
Definition FilterMatchers.h:536
RDKit::FilterMatchOps::And
Definition FilterMatchers.h:60
RDKit::FilterMatchOps::And::getMatches
bool getMatches(const ROMol &mol, std::vector< FilterMatch > &matchVect) const override
getMatches
Definition FilterMatchers.h:98
RDKit::FilterMatchOps::And::And
And(const FilterMatcherBase &arg1, const FilterMatcherBase &arg2)
Definition FilterMatchers.h:71
RDKit::FilterMatchOps::And::getName
std::string getName() const override
Definition FilterMatchers.h:83
RDKit::FilterMatchOps::And::hasMatch
bool hasMatch(const ROMol &mol) const override
hasMatches
Definition FilterMatchers.h:92
RDKit::FilterMatchOps::And::isValid
bool isValid() const override
Definition FilterMatchers.h:88
RDKit::FilterMatchOps::And::copy
boost::shared_ptr< FilterMatcherBase > copy() const override
Definition FilterMatchers.h:110
RDKit::FilterMatchOps::And::And
And()
Definition FilterMatchers.h:66
RDKit::FilterMatchOps::And::And
And(boost::shared_ptr< FilterMatcherBase > arg1, boost::shared_ptr< FilterMatcherBase > arg2)
Definition FilterMatchers.h:74
RDKit::FilterMatchOps::And::And
And(const And &rhs)
Definition FilterMatchers.h:80
RDKit::FilterMatchOps::Not
Definition FilterMatchers.h:188
RDKit::FilterMatchOps::Not::Not
Not(const Not &rhs)
Definition FilterMatchers.h:205
RDKit::FilterMatchOps::Not::isValid
bool isValid() const override
Definition FilterMatchers.h:211
RDKit::FilterMatchOps::Not::Not
Not()
Definition FilterMatchers.h:193
RDKit::FilterMatchOps::Not::hasMatch
bool hasMatch(const ROMol &mol) const override
hasMatches
Definition FilterMatchers.h:213
RDKit::FilterMatchOps::Not::getName
std::string getName() const override
Definition FilterMatchers.h:207
RDKit::FilterMatchOps::Not::Not
Not(const FilterMatcherBase &arg1)
Definition FilterMatchers.h:199
RDKit::FilterMatchOps::Not::copy
boost::shared_ptr< FilterMatcherBase > copy() const override
Definition FilterMatchers.h:226
RDKit::FilterMatchOps::Not::Not
Not(boost::shared_ptr< FilterMatcherBase > arg1)
Definition FilterMatchers.h:202
RDKit::FilterMatchOps::Not::getMatches
bool getMatches(const ROMol &mol, std::vector< FilterMatch > &) const override
getMatches
Definition FilterMatchers.h:218
RDKit::FilterMatchOps::Or
Definition FilterMatchers.h:128
RDKit::FilterMatchOps::Or::Or
Or(boost::shared_ptr< FilterMatcherBase > arg1, boost::shared_ptr< FilterMatcherBase > arg2)
Definition FilterMatchers.h:141
RDKit::FilterMatchOps::Or::hasMatch
bool hasMatch(const ROMol &mol) const override
hasMatches
Definition FilterMatchers.h:156
RDKit::FilterMatchOps::Or::Or
Or()
Definition FilterMatchers.h:134
RDKit::FilterMatchOps::Or::isValid
bool isValid() const override
Definition FilterMatchers.h:152
RDKit::FilterMatchOps::Or::Or
Or(const Or &rhs)
Definition FilterMatchers.h:145
RDKit::FilterMatchOps::Or::copy
boost::shared_ptr< FilterMatcherBase > copy() const override
Definition FilterMatchers.h:172
RDKit::FilterMatchOps::Or::Or
Or(const FilterMatcherBase &arg1, const FilterMatcherBase &arg2)
Definition FilterMatchers.h:138
RDKit::FilterMatchOps::Or::getName
std::string getName() const override
Definition FilterMatchers.h:147
RDKit::FilterMatchOps::Or::getMatches
bool getMatches(const ROMol &mol, std::vector< FilterMatch > &matchVect) const override
getMatches
Definition FilterMatchers.h:161
RDKit::FilterMatcherBase::copy
virtual boost::shared_ptr< FilterMatcherBase > copy() const =0
RDKit::FilterMatcherBase::isValid
virtual bool isValid() const =0
RDKit::FilterMatcherBase::FilterMatcherBase
FilterMatcherBase(std::string name=DEFAULT_FILTERMATCHERBASE_NAME)
Definition FilterMatcherBase.h:82
RDKit::FilterMatcherBase::getName
virtual std::string getName() const
Definition FilterMatcherBase.h:94
RDKit::MolPickler::pickleMol
static void pickleMol(const ROMol *mol, std::ostream &ss)
pickles a molecule and sends the results to stream ss
RDKit::ROMol
Definition ROMol.h:199
RDKit::SmartsMatcher
Definition FilterMatchers.h:244
RDKit::SmartsMatcher::isValid
bool isValid() const override
Returns True if the Smarts pattern is valid.
Definition FilterMatchers.h:316
RDKit::SmartsMatcher::setPattern
void setPattern(const ROMol &mol)
Set the query molecule for the matcher.
RDKit::SmartsMatcher::getMaxCount
unsigned int getMaxCount() const
Get the maximum match count for the pattern to be true.
Definition FilterMatchers.h:332
RDKit::SmartsMatcher::getMinCount
unsigned int getMinCount() const
Get the minimum match count for the pattern to be true.
Definition FilterMatchers.h:328
RDKit::SmartsMatcher::hasMatch
bool hasMatch(const ROMol &mol) const override
hasMatches
RDKit::SmartsMatcher::SmartsMatcher
SmartsMatcher(const ROMol &pattern, unsigned int minCount=1, unsigned int maxCount=UINT_MAX)
Construct a SmartsMatcher from a query molecule.
RDKit::SmartsMatcher::setPattern
void setPattern(const std::string &smarts)
Set the smarts pattern for the matcher.
RDKit::SmartsMatcher::getPattern
const ROMOL_SPTR & getPattern() const
Return the shared_ptr to the underlying query molecule.
Definition FilterMatchers.h:319
RDKit::SmartsMatcher::copy
boost::shared_ptr< FilterMatcherBase > copy() const override
Definition FilterMatchers.h:339
RDKit::SmartsMatcher::setPattern
void setPattern(const ROMOL_SPTR &pat)
Set the shared query molecule for the matcher.
Definition FilterMatchers.h:325
RDKit::SmartsMatcher::setMinCount
void setMinCount(unsigned int val)
Set the minimum match count for the pattern to be true.
Definition FilterMatchers.h:330
RDKit::SmartsMatcher::getMatches
bool getMatches(const ROMol &mol, std::vector< FilterMatch > &matchVect) const override
getMatches
RDKit::SmartsMatcher::setMaxCount
void setMaxCount(unsigned int val)
Set the maximum match count for the pattern to be true.
Definition FilterMatchers.h:334
RDKit::SmartsMatcher::SmartsMatcher
SmartsMatcher(const std::string &name, ROMOL_SPTR onPattern, unsigned int minCount=1, unsigned int maxCount=UINT_MAX)
Construct a SmartsMatcher from a shared_ptr.
RDKit::SmartsMatcher::SmartsMatcher
SmartsMatcher(const std::string &name=SMARTS_MATCH_NAME_DEFAULT)
Construct a SmartsMatcher.
Definition FilterMatchers.h:251
RDKit::SmartsMatcher::SmartsMatcher
SmartsMatcher(const std::string &name, const ROMol &pattern, unsigned int minCount=1, unsigned int maxCount=UINT_MAX)
Construct a SmartsMatcher.
RDKit::SmartsMatcher::SmartsMatcher
SmartsMatcher(const SmartsMatcher &rhs)
RDKit::SmartsMatcher::SmartsMatcher
SmartsMatcher(const std::string &name, const std::string &smarts, unsigned int minCount=1, unsigned int maxCount=UINT_MAX)
Construct a SmartsMatcher from a smarts pattern.
export.h
RDKIT_FILTERCATALOG_EXPORT
#define RDKIT_FILTERCATALOG_EXPORT
Definition export.h:185
RDKit::FilterMatchOps
Definition FilterMatchers.h:59
RDKit
Std stuff.
Definition Abbreviations.h:19
RDKit::ROMOL_SPTR
boost::shared_ptr< ROMol > ROMOL_SPTR
Definition ChemTransforms.h:22
RDKit::SMARTS_MATCH_NAME_DEFAULT
RDKIT_FILTERCATALOG_EXPORT const char * SMARTS_MATCH_NAME_DEFAULT