rdkit_chem 2019.03.3.1 → 2025.09.3.2

data/Code/RubyWrappers/MolSupplier.i

@@ -0,0 +1,83 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%include "std_string.i"
+%include "std_vector.i"
+%include "std_map.i"
+%include "std_pair.i"
+
+%{
+#include <GraphMol/FileParsers/MolSupplier.h>
+#include <GraphMol/FileParsers/MolSupplier.v1API.h>
+#include <GraphMol/Resonance.h>
+#include <GraphMol/Substruct/SubstructMatch.h>
+%}
+
+%include "Streams.i"
+%ignore RDKit::v2;
+%newobject RDKit::ForwardSDMolSupplier::next;
+%newobject RDKit::ResonanceMolSupplier::next;
+%newobject RDKit::SDMolSupplier::next;
+%newobject RDKit::SmilesMolSupplier::next;
+%newobject RDKit::TDTMolSupplier::next;
+%newobject RDKit::PDBMolSupplier::next;
+
+
+%include <GraphMol/FileParsers/MolSupplier.h>
+%include <GraphMol/FileParsers/MolSupplier.v1API.h>
+
+#ifdef RDK_USE_BOOST_IOSTREAMS
+%extend RDKit::v1::ForwardSDMolSupplier {
+    ForwardSDMolSupplier(RDKit::gzstream *strm, bool sanitize=true, bool removeHs = true,
+                  bool strictParsing = true) {
+    const bool takeOwnership = false;
+    RDKit::ForwardSDMolSupplier*foo = new RDKit::ForwardSDMolSupplier(
+                                     (std::istream*)strm,
+                                     takeOwnership,
+                                     sanitize, removeHs, strictParsing);
+    PRECONDITION(!foo->atEnd(), "LDJKLJF");
+    return foo;
+  }
+};
+#endif
+
+%include <GraphMol/Resonance.h>
+
+%extend RDKit::ResonanceMolSupplier {
+  std::vector< std::vector<std::pair<int, int> > > getSubstructMatches(RDKit::ROMol &query,bool uniquify=false, bool useChirality=false, int numThreads=1){
+    std::vector<RDKit::MatchVectType> mv;
+    SubstructMatch(*($self),query,mv,uniquify,true,useChirality,false,1000,numThreads);
+    return mv;
+  }
+}
+

data/Code/RubyWrappers/MolTransforms.i

@@ -0,0 +1,39 @@
+/* 
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/MolTransforms/MolTransforms.h>
+%}
+
+%rename(Transform3D) RDGeom::Transform3D;
+%include <GraphMol/MolTransforms/MolTransforms.h>

data/Code/RubyWrappers/MolWriters.i

@@ -0,0 +1,41 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/FileParsers/FileWriters.h>
+#include <GraphMol/FileParsers/MolWriters.h>
+%}
+
+%include <GraphMol/FileParsers/FileWriters.h>
+%include <GraphMol/FileParsers/MolWriters.h>
+

data/Code/RubyWrappers/MonomerInfo.i

@@ -0,0 +1,42 @@
+/* 
+* $Id$
+*
+*  Copyright (c) 2013, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%include "std_string.i"
+
+%{
+#include <GraphMol/MonomerInfo.h>
+%}
+
+%include <GraphMol/MonomerInfo.h>
+
+

data/Code/RubyWrappers/MorganFingerprints.h

@@ -0,0 +1,21 @@
+
+#include <RDGeneral/export.h>
+#include <GraphMol/Atom.h>
+#include <GraphMol/GraphMol.h>
+#include <GraphMol/Fingerprints/MorganFingerprints.h>
+#include <DataStructs/BitVects.h>
+#include <vector>
+
+RDKit::SparseIntVect<std::uint32_t> *getFeatureFingerprint(
+    const RDKit::ROMol &mol, unsigned int radius, bool useChirality = false,
+    bool useBondTypes = true, bool useCounts = true) {
+  std::vector<std::uint32_t> *invars =
+      new std::vector<std::uint32_t>(mol.getNumAtoms());
+  RDKit::MorganFingerprints::getFeatureInvariants(mol, *invars);
+  RDKit::SparseIntVect<std::uint32_t> *res =
+      RDKit::MorganFingerprints::getFingerprint(
+          mol, static_cast<unsigned int>(radius), invars, 0, useChirality,
+          useBondTypes, useCounts, false, 0);
+  delete invars;
+  return res;
+}

data/Code/RubyWrappers/MorganFingerprints.i

@@ -0,0 +1,66 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+%{
+#include <boost/cstdint.hpp>
+#include <DataStructs/SparseIntVect.h>
+#include <GraphMol/Fingerprints/MorganFingerprints.h>
+#include <MorganFingerprints.h>
+%}
+
+//%include <DataStructs/SparseIntVect.h>
+
+
+%newobject RDKit::MorganFingerprints::getFingerprint;
+%rename(MorganFingerprintMol) RDKit::MorganFingerprints::getFingerprint;
+%newobject RDKit::MorganFingerprints::getFingerprintAsBitVect;
+%rename(getMorganFingerprintAsBitVect) RDKit::MorganFingerprints::getFingerprintAsBitVect;
+%include <GraphMol/Fingerprints/MorganFingerprints.h>
+
+%include <DataStructs/BitOps.h>
+%template(TanimotoSimilarityEBV) TanimotoSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(DiceSimilarity) DiceSimilarity<ExplicitBitVect,ExplicitBitVect>;
+// Use base types (int/unsigned int) to avoid duplicate swig::traits definitions
+%template(DiceSimilarity) RDKit::DiceSimilarity<unsigned int>;
+%template(DiceSimilarity) RDKit::DiceSimilarity<int>;
+// DiceSimilarity<long long> removed - Ruby SWIG lacks swig::traits for long long int
+%template(TanimotoSimilaritySIVu32) RDKit::TanimotoSimilarity<unsigned int>;
+%template(TanimotoSimilaritySIVi32) RDKit::TanimotoSimilarity<int>;
+// TanimotoSimilaritySIVi64 removed - Ruby SWIG lacks swig::traits for long long int
+%template(TverskySimilarity) RDKit::TverskySimilarity<unsigned int>;
+%template(TverskySimilarity) RDKit::TverskySimilarity<int>;
+// TverskySimilarity<long long> removed - Ruby SWIG lacks swig::traits for long long int
+
+
+%include "MorganFingerprints.h"

data/Code/RubyWrappers/PeriodicTable.i

@@ -0,0 +1,44 @@
+/* 
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <map>
+#include <vector>
+#include <RDGeneral/types.h>
+#include <GraphMol/atomic_data.h>
+#include <GraphMol/PeriodicTable.h>
+%}
+
+%include <RDGeneral/types.h>
+%include <GraphMol/atomic_data.h>
+%include <GraphMol/PeriodicTable.h>

data/Code/RubyWrappers/Queries.i

@@ -0,0 +1,289 @@
+/*
+*
+*  Copyright (C) 2024 Gareth Jones, Glysade LLC
+*
+*   @@ All Rights Reserved @@
+*  This file is part of the RDKit.
+*  The contents are covered by the terms of the BSD license
+*  which is included in the file license.txt, found at the root
+*  of the RDKit source tree.
+*
+*/
+
+%include <boost_shared_ptr.i>
+%shared_ptr(RDKit::QueryAtom)
+%shared_ptr(RDKit::QueryBond)
+
+// Adapted from the Python Wrappers
+
+%{
+#include <GraphMol/RDKitBase.h>
+#include <GraphMol/RDKitQueries.h>
+#include <RDGeneral/types.h>
+%}
+
+%include <GraphMol/RDKitBase.h>;
+%include <GraphMol/RDKitQueries.h>;
+%include <RDGeneral/types.h>;
+
+/*
+  NOTE: it looks like there is a typo in the below code
+  ATOM_GREATER_QUERY is intentionally being used for the LessQueryAtom
+  and ATOM_LESS_QUERY for GreaterQueryAtom in the python API.
+  The C++ API is internally consistent and logical, but having
+  AtomNumLessQueryAtom(6) return atoms where 6 is less than their atomic
+  number feels backwards in Python.
+
+ */
+ %define QAFUNC1(funcname, func, type)
+ %inline %{
+
+   boost::shared_ptr<RDKit::QueryAtom> funcname ## EqualsQueryAtom(type val, bool negate=false) {
+    boost::shared_ptr<RDKit::QueryAtom> res(new RDKit::QueryAtom());
+    res->setQuery(RDKit:: ## func(val));
+    if (negate) {
+      res->getQuery()->setNegation(true);
+    }
+    return res;
+  }
+
+  boost::shared_ptr<RDKit::QueryAtom> funcname ## LessQueryAtom(type val, bool negate=false) {
+    boost::shared_ptr<RDKit::QueryAtom> res(new RDKit::QueryAtom());
+    res->setQuery(
+        RDKit:: ## func <RDKit::ATOM_GREATER_QUERY>(val, std::string( # funcname "Less")));
+    if (negate) {
+      res->getQuery()->setNegation(true);
+    }
+    return res;
+  }
+
+  boost::shared_ptr<RDKit::QueryAtom> funcname ## GreaterQueryAtom(type val, bool negate=false) {
+    boost::shared_ptr<RDKit::QueryAtom> res(new RDKit::QueryAtom());
+    res->setQuery(
+        RDKit:: ## func <RDKit::ATOM_LESS_QUERY>(val, std::string(# funcname "Greater")));
+    if (negate) {
+      res->getQuery()->setNegation(true);
+    }
+    return res;
+  }
+%}
+%enddef
+
+%define QAFUNC2(funcname, func, type)
+%inline %{
+  boost::shared_ptr<RDKit::QueryAtom> funcname(bool negate=false) {
+    boost::shared_ptr<RDKit::QueryAtom> res(new RDKit::QueryAtom());
+    res->setQuery(RDKit:: ## func());
+    if (negate) {
+      res->getQuery()->setNegation(true);
+    }
+    return res;
+  }
+%}
+%enddef
+
+QAFUNC1(AtomNum, makeAtomNumQuery, int);
+QAFUNC1(ExplicitValence, makeAtomExplicitValenceQuery, int);
+QAFUNC1(TotalValence, makeAtomTotalValenceQuery, int);
+QAFUNC1(ExplicitDegree, makeAtomExplicitDegreeQuery, int);
+QAFUNC1(TotalDegree, makeAtomTotalDegreeQuery, int);
+QAFUNC1(NonHydrogenDegree, makeAtomNonHydrogenDegreeQuery, int);
+QAFUNC1(HCount, makeAtomHCountQuery, int);
+QAFUNC1(Mass, makeAtomMassQuery, int);
+QAFUNC1(Isotope, makeAtomIsotopeQuery, int);
+QAFUNC1(FormalCharge, makeAtomFormalChargeQuery, int);
+QAFUNC1(Hybridization, makeAtomHybridizationQuery, int);
+QAFUNC1(InNRings, makeAtomInNRingsQuery, int);
+QAFUNC1(MinRingSize, makeAtomMinRingSizeQuery, int);
+QAFUNC1(RingBondCount, makeAtomRingBondCountQuery, int);
+QAFUNC1(NumRadicalElectrons, makeAtomNumRadicalElectronsQuery, int);
+QAFUNC1(NumHeteroatomNeighbors, makeAtomNumHeteroatomNbrsQuery, int);
+QAFUNC1(NumAliphaticHeteroatomNeighbors,
+        makeAtomNumAliphaticHeteroatomNbrsQuery, int);
+
+QAFUNC2(IsUnsaturatedQueryAtom, makeAtomUnsaturatedQuery, int);
+QAFUNC2(IsAromaticQueryAtom, makeAtomAromaticQuery, int);
+QAFUNC2(IsAliphaticQueryAtom, makeAtomAliphaticQuery, int);
+QAFUNC2(IsInRingQueryAtom, makeAtomInRingQuery, int);
+QAFUNC2(HasChiralTagQueryAtom, makeAtomHasChiralTagQuery, int);
+QAFUNC2(MissingChiralTagQueryAtom, makeAtomMissingChiralTagQuery, int);
+QAFUNC2(IsBridgeheadQueryAtom, makeAtomIsBridgeheadQuery, int);
+QAFUNC2(AAtomQueryAtom, makeAAtomQuery, int);
+QAFUNC2(AHAtomQueryAtom, makeAHAtomQuery, int);
+QAFUNC2(QAtomQueryAtom, makeQAtomQuery, int);
+QAFUNC2(QHAtomQueryAtom, makeQHAtomQuery, int);
+QAFUNC2(XAtomQueryAtom, makeXAtomQuery, int);
+QAFUNC2(XHAtomQueryAtom, makeXHAtomQuery, int);
+QAFUNC2(MAtomQueryAtom, makeMAtomQuery, int);
+QAFUNC2(MHAtomQueryAtom, makeMHAtomQuery, int);
+
+%{
+
+  template <class Ob, class Ret, class T>
+  boost::shared_ptr<Ret> PropQuery(const std::string &propname, const T &v, bool negate) {
+	boost::shared_ptr<Ret> res(new Ret());
+	res->setQuery(RDKit::makePropQuery<Ob, T>(propname, v));
+	if (negate) {
+	  res->getQuery()->setNegation(true);
+	}
+	return res;
+  }
+
+  template <class Ob, class Ret, class T>
+  boost::shared_ptr<Ret> PropQueryWithTol(const std::string &propname, const T &v, bool negate,
+						const T &tol = T()) {
+	boost::shared_ptr<Ret> res(new Ret());
+	res->setQuery(RDKit::makePropQuery<Ob, T>(propname, v, tol));
+	if (negate) {
+	  res->getQuery()->setNegation(true);
+	}
+	return res;
+  }
+
+  template <class Ob, class Ret>
+  boost::shared_ptr<Ret> PropQueryWithTol(const std::string &propname, const ExplicitBitVect &v,
+						bool negate=false, float tol = 0.0) {
+	boost::shared_ptr<Ret> res(new Ret());
+	res->setQuery(RDKit::makePropQuery<Ob>(propname, v, tol));
+	if (negate) {
+	  res->getQuery()->setNegation(true);
+	}
+	return res;
+  }
+
+  boost::shared_ptr<RDKit::QueryAtom> HasPropQueryAtom(const std::string &propname, bool negate=false) {
+	boost::shared_ptr<RDKit::QueryAtom> res(new RDKit::QueryAtom());
+	res->setQuery(RDKit::makeHasPropQuery<RDKit::Atom>(propname));
+	if (negate) {
+	  res->getQuery()->setNegation(true);
+	}
+	return res;
+  }
+
+  boost::shared_ptr<RDKit::QueryAtom> HasIntPropWithValueQueryAtom(const std::string &propname, int val, bool negate=false) {
+ 	return PropQuery<RDKit::Atom, RDKit::QueryAtom, int>(propname, val, negate);
+  }
+
+  boost::shared_ptr<RDKit::QueryAtom> HasBoolPropWithValueQueryAtom(const std::string &propname, bool val, bool negate=false) {
+	return PropQuery<RDKit::Atom, RDKit::QueryAtom, bool>(propname, val, negate);
+  }
+
+  boost::shared_ptr<RDKit::QueryAtom> HasStringPropWithValueQueryAtom(const std::string &propname, const std::string &val, bool negate=false) {
+	return PropQuery<RDKit::Atom, RDKit::QueryAtom, std::string>(propname, val, negate);
+  }
+
+  boost::shared_ptr<RDKit::QueryAtom> HasDoublePropWithValueQueryAtom(const std::string &propname, double val, bool negate=false, double tol=0) {
+	return PropQueryWithTol<RDKit::Atom, RDKit::QueryAtom, double>(propname, val, negate, tol);
+  }
+
+  boost::shared_ptr<RDKit::QueryAtom> HasBitVectPropWithValueQueryAtom(const std::string  &propname, const ExplicitBitVect &val, bool negate=false, float tol=0) {
+	return PropQueryWithTol<RDKit::Atom, RDKit::QueryAtom>(propname, val, negate, tol);
+  }
+
+  boost::shared_ptr<RDKit::QueryBond> HasPropQueryBond(const std::string &propname, bool negate=false) {
+	boost::shared_ptr<RDKit::QueryBond> res(new RDKit::QueryBond());
+	res->setQuery(RDKit::makeHasPropQuery<RDKit::Bond>(propname));
+	if (negate) {
+	  res->getQuery()->setNegation(true);
+	}
+	return res;
+  }
+
+  boost::shared_ptr<RDKit::QueryBond> HasIntPropWithValueQueryBond(const std::string &propname, int val, bool negate=false) {
+    return PropQuery<RDKit::Bond, RDKit::QueryBond, int>(propname, val, negate);
+  }
+
+  boost::shared_ptr<RDKit::QueryBond> HasBoolPropWithValueQueryBond(const std::string &propname, bool val, bool negate=false) {
+    return PropQuery<RDKit::Bond, RDKit::QueryBond, bool>(propname, val, negate);
+  }
+
+  boost::shared_ptr<RDKit::QueryBond> HasStringPropWithValueQueryBond(const std::string &propname, const std::string &val, bool negate=false) {
+    return PropQuery<RDKit::Bond, RDKit::QueryBond, std::string>(propname, val, negate);
+  }
+
+  boost::shared_ptr<RDKit::QueryBond> HasDoublePropWithValueQueryBond(const std::string &propname, double val, bool negate=false, double tol=0) {
+    return PropQueryWithTol<RDKit::Bond, RDKit::QueryBond, double>(propname, val, negate, tol);
+  }
+
+%}
+
+boost::shared_ptr<RDKit::QueryAtom> HasPropQueryAtom(const std::string &propname, bool negate=false);
+boost::shared_ptr<RDKit::QueryBond> HasPropQueryBond(const std::string &propname, bool negate=false);
+boost::shared_ptr<RDKit::QueryAtom> HasIntPropWithValueQueryAtom(const std::string &propname, int val, bool negate=false);
+boost::shared_ptr<RDKit::QueryAtom> HasBoolPropWithValueQueryAtom(const std::string &propname, bool val, bool negate=false);
+boost::shared_ptr<RDKit::QueryAtom> HasStringPropWithValueQueryAtom(const std::string &propname, const std::string &val, bool negate=false);
+boost::shared_ptr<RDKit::QueryAtom> HasDoublePropWithValueQueryAtom(const std::string &propname, double val, bool negate=false, double tol=0);
+boost::shared_ptr<RDKit::QueryAtom> HasBitVectPropWithValueQueryAtom(const std::string  &propname, const ExplicitBitVect &val, bool negate=false, float tol=0);
+boost::shared_ptr<RDKit::QueryBond> HasPropQueryBond(const std::string &propname, bool negate=false);
+boost::shared_ptr<RDKit::QueryBond> HasIntPropWithValueQueryBond(const std::string &propname, int val, bool negate=false);
+boost::shared_ptr<RDKit::QueryBond> HasBoolPropWithValueQueryBond(const std::string &propname, bool val, bool negate=false);
+boost::shared_ptr<RDKit::QueryBond> HasStringPropWithValueQueryBond(const std::string &propname, const std::string &val, bool negate=false);
+boost::shared_ptr<RDKit::QueryBond> HasDoublePropWithValueQueryBond(const std::string &propname, double val, bool negate=false, double tol=0);
+
+%extend RDKit::QueryAtom {
+  void ExpandQuery(const RDKit::QueryAtom *other, Queries::CompositeQueryType how=Queries::COMPOSITE_AND, bool maintainOrder=true) {
+	PRECONDITION(other, "bad atoms");
+	if (other->hasQuery()) {
+	  const RDKit::QueryAtom::QUERYATOM_QUERY *qry = other->getQuery();
+	  ($self)->expandQuery(qry->copy(), how, maintainOrder);
+	}
+  }
+
+  void setQuery(const RDKit::QueryAtom *other) {
+	PRECONDITION(other, "bad atoms");
+	if (other->hasQuery()) {
+	  ($self)->setQuery(other->getQuery()->copy());
+	}
+  }
+}
+
+%extend RDKit::Atom {
+  void ExpandQuery(const RDKit::QueryAtom *other, Queries::CompositeQueryType how=Queries::COMPOSITE_AND, bool maintainOrder=true) {
+  PRECONDITION(other, "bad atoms");
+  if (other->hasQuery()) {
+	  const RDKit::QueryAtom::QUERYATOM_QUERY *qry = other->getQuery();
+	  ($self)->expandQuery(qry->copy(), how, maintainOrder);
+	}
+  }
+
+  void setQuery(const RDKit::QueryAtom *other) {
+	PRECONDITION(other, "bad atoms");
+	if (other->hasQuery()) {
+	  ($self)->setQuery(other->getQuery()->copy());
+	}
+  }
+}
+
+%extend RDKit::QueryBond {
+  void ExpandQuery(const RDKit::QueryBond *other, Queries::CompositeQueryType how=Queries::COMPOSITE_AND, bool maintainOrder=true) {
+	PRECONDITION(other, "bad bonds");
+	if (other->hasQuery()) {
+	  const RDKit::QueryBond::QUERYBOND_QUERY *qry = other->getQuery();
+	  ($self)->expandQuery(qry->copy(), how, maintainOrder);
+	}
+  }
+
+  void SetQuery(const RDKit::QueryBond *other) {
+	PRECONDITION(other, "bad bonds");
+	if (other->hasQuery()) {
+	  ($self)->setQuery(other->getQuery()->copy());
+	}
+  }
+}
+
+%extend RDKit::Bond {
+  void ExpandQuery(const RDKit::QueryBond *other, Queries::CompositeQueryType how=Queries::COMPOSITE_AND, bool maintainOrder=true) {
+	PRECONDITION(other, "bad bonds");
+	if (other->hasQuery()) {
+	  const RDKit::QueryBond::QUERYBOND_QUERY *qry = other->getQuery();
+	  ($self)->expandQuery(qry->copy(), how, maintainOrder);
+	}
+  }
+
+  void SetQuery(const RDKit::QueryBond *other) {
+	PRECONDITION(other, "bad bonds");
+	if (other->hasQuery()) {
+	  ($self)->setQuery(other->getQuery()->copy());
+	}
+  }
+}

data/Code/RubyWrappers/QueryAtom.i

@@ -0,0 +1,47 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/QueryAtom.h>
+%}
+
+%ignore RDKit::QueryAtom::expandQuery;
+%ignore RDKit::QueryAtom::setQuery;
+
+%include <GraphMol/QueryAtom.h>
+
+%extend RDKit::QueryAtom {
+	bool MatchAtom(RDKit::Atom const *what) {
+		return ($self)->Match(what);
+	}
+}