rdkit_chem 2025.09.3.1-x86_64-linux

data/Code/CMakeLists.txt

@@ -0,0 +1,44 @@
+createExportTestHeaders()
+add_subdirectory(RDGeneral)
+if(RDK_BUILD_PYTHON_WRAPPERS)
+  add_subdirectory(RDBoost)
+endif(RDK_BUILD_PYTHON_WRAPPERS)
+add_subdirectory(RDStreams)
+add_subdirectory(DataStructs)
+add_subdirectory(Geometry)
+
+add_subdirectory(Numerics)
+add_subdirectory(ForceField)
+add_subdirectory(DistGeom)
+add_subdirectory(Catalogs)
+
+add_subdirectory(GraphMol)
+add_subdirectory(Query)
+add_subdirectory(Features)
+
+add_subdirectory(DataManip)
+if(RDK_BIG_ENDIAN)
+  message("Skipping build of SimDivPickers on big endian system")
+else(RDK_BIG_ENDIAN)
+  add_subdirectory(SimDivPickers)
+endif(RDK_BIG_ENDIAN)
+
+add_subdirectory(ML)
+add_subdirectory(ChemicalFeatures)
+
+if(RDK_BUILD_SWIG_WRAPPERS)
+  add_subdirectory(RubyWrappers)
+endif()
+
+if(RDK_BUILD_PGSQL)
+  add_subdirectory(PgSQL/rdkit)
+endif(RDK_BUILD_PGSQL)
+
+add_subdirectory(MinimalLib)
+
+
+if(RDK_BUILD_FUZZ_TARGETS)
+  add_subdirectory(Fuzz)
+endif(RDK_BUILD_FUZZ_TARGETS)
+
+add_subdirectory(Bench)

data/Code/RubyWrappers/Abbreviations.i

@@ -0,0 +1,19 @@
+/*
+*
+*  Copyright (c) 2020, Greg Landrum and T5 Informatics GmbH
+*  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 <GraphMol/Abbreviations/Abbreviations.h>
+%}
+
+
+%template(AbbreviationDefinition_Vect) std::vector<RDKit::Abbreviations::AbbreviationDefinition>;
+%template(AbbreviationMatch_Vect) std::vector<RDKit::Abbreviations::AbbreviationMatch>;
+%include <GraphMol/Abbreviations/Abbreviations.h>

data/Code/RubyWrappers/AddHs.i

@@ -0,0 +1,34 @@
+/* 
+* $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/AddHs.cpp>

data/Code/RubyWrappers/Atom.i

@@ -0,0 +1,165 @@
+/*
+* $Id: Atom.i 2519 2013-05-17 03:01:18Z glandrum $
+*
+*  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 <Query/QueryObjects.h>
+#include <RDGeneral/types.h>
+#include <GraphMol/ROMol.h>
+#include <GraphMol/PeriodicTable.h>
+#include <GraphMol/SanitException.h>
+#include <GraphMol/Atom.h>
+#include <GraphMol/ConjugHybrid.cpp>
+#include <GraphMol/MolTransforms/MolTransforms.h>
+#include <Geometry/point.h>
+#include <GraphMol/MolOps.h>
+#include <GraphMol/SmilesParse/SmilesWrite.h>
+#include <GraphMol/SmilesParse/SmartsWrite.h>
+
+// from Python wrapper
+std::string describeQueryHelper(const RDKit::Atom::QUERYATOM_QUERY *q, unsigned int depth) {
+  std::string res;
+  if (q) {
+    for (unsigned int i = 0; i < depth; ++i) {
+      res += "  ";
+    }
+    res += q->getFullDescription() + "\n";
+    for (const auto &child :
+         boost::make_iterator_range(q->beginChildren(), q->endChildren())) {
+      res += describeQueryHelper(child.get(), depth + 1);
+    }
+  }
+  return res;
+}
+
+%}
+
+%ignore RDKit::Atom::Match(const Atom *) const;
+%ignore RDKit::Atom::expandQuery;
+%template(Bond_Vect) std::vector<RDKit::Bond*>;
+
+// Ignore ostream operators to prevent redefinition errors
+%ignore RDKit::operator<<;
+
+%include <GraphMol/Atom.h>
+
+%newobject RDKit::Atom::getProp;
+%newobject RDKit::Atom::getBonds;
+
+%extend RDKit::Atom {
+  std::string getProp(const std::string key){
+    std::string res;
+    ($self)->getProp(key, res);
+    return res;
+  }
+
+  /* Methods from ConjugHybrid.cpp */
+  void markConjAtomBonds() {
+    RDKit::markConjAtomBonds(($self));
+  }
+  int numBondsPlusLonePairs() {
+    return RDKit::numBondsPlusLonePairs(($self));
+  }
+  bool atomHasConjugatedBond() {
+    return RDKit::MolOps::atomHasConjugatedBond(($self));
+  }
+   /* From MolTransforms.h */
+  void transformAtom(RDGeom::Transform3D &tform) {
+  MolTransforms::transformAtom(($self), tform);
+  }
+
+  /* Based on Python wrappers and unit tests */
+  bool IsInRing(){
+    if(!($self)->getOwningMol().getRingInfo()->isInitialized()){
+      RDKit::MolOps::findSSSR(($self)->getOwningMol());
+    }
+    return ($self)->getOwningMol().getRingInfo()->numAtomRings(($self)->getIdx())!=0;
+  }
+
+  bool IsInRingSize(int size){
+    if(!($self)->getOwningMol().getRingInfo()->isInitialized()){
+      RDKit::MolOps::findSSSR(($self)->getOwningMol());
+    }
+    return ($self)->getOwningMol().getRingInfo()->isAtomInRingOfSize(($self)->getIdx(),size);
+  }
+
+  std::vector<RDKit::Bond*> *getBonds() {
+    std::vector<RDKit::Bond*> *bonds = new std::vector<RDKit::Bond*>;
+    RDKit::ROMol *parent = &($self)->getOwningMol();
+    RDKit::ROMol::OEDGE_ITER begin,end;
+    boost::tie(begin,end) = parent->getAtomBonds(($self));
+    while(begin!=end){
+      RDKit::Bond *tmpB = (*parent)[*begin];
+      bonds->push_back(tmpB);
+      begin++;
+    }
+    return bonds;
+  }
+
+  // also matches ATOM_NULL_QUERY
+  void setQuery(RDKit::ATOM_OR_QUERY *query) {
+    $self->setQuery(query);
+  }
+
+  void setQuery(RDKit::ATOM_EQUALS_QUERY *query) {
+    $self->setQuery(query);
+  }
+
+  // From Python Wrapper
+  std::string AtomGetSmarts(bool doKekule=false, bool allHsExplicit=false,
+                          bool isomericSmiles=true) {
+	std::string res;
+	if (($self)->hasQuery()) {
+	  res = RDKit::SmartsWrite::GetAtomSmarts(static_cast<const RDKit::QueryAtom *>(($self)));
+	} else {
+	  // FIX: this should not be necessary
+	  res = RDKit::SmilesWrite::GetAtomSmiles(($self), doKekule, nullptr, allHsExplicit,
+									   isomericSmiles);
+	}
+	return res;
+  }
+
+  // from Python Wrapper
+  std::string describeQuery() {
+	std::string res = "";
+	  res = describeQueryHelper(($self)->getQuery(), 0);
+	return res;
+  }
+
+
+
+}

data/Code/RubyWrappers/AtomIterators.i

@@ -0,0 +1,77 @@
+/* 
+* $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/AtomIterators.h>
+#include <GraphMol/ROMol.h>
+%}
+
+
+%include <GraphMol/AtomIterators.h>
+/* Equality testing operators have been overloaded, so we need to expose them in a different way.
+   These 'rename' lines appear to have to precede the 'template' definitions. */
+%rename(eq) RDKit::AtomIterator_<RDKit::Atom,RDKit::ROMol>::operator==;
+%rename(ne) RDKit::AtomIterator_<RDKit::Atom,RDKit::ROMol>::operator!=;
+%rename(eq) RDKit::HeteroatomIterator_<RDKit::Atom,RDKit::ROMol>::operator==;
+%rename(ne) RDKit::HeteroatomIterator_<RDKit::Atom,RDKit::ROMol>::operator!=;
+%rename(eq) RDKit::AromaticAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator==;
+%rename(ne) RDKit::AromaticAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator!=;
+%rename(eq) RDKit::QueryAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator==;
+%rename(ne) RDKit::QueryAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator!=;
+/* Increment and decrement operators currently necessary */
+%rename(next) RDKit::AtomIterator_<RDKit::Atom,RDKit::ROMol>::operator++;
+%rename(next) RDKit::HeteroatomIterator_<RDKit::Atom,RDKit::ROMol>::operator++;
+%rename(next) RDKit::AromaticAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator++;
+%rename(next) RDKit::QueryAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator++;
+%rename(prev) RDKit::AtomIterator_<RDKit::Atom,RDKit::ROMol>::operator--;
+%rename(prev) RDKit::HeteroatomIterator_<RDKit::Atom,RDKit::ROMol>::operator--;
+%rename(prev) RDKit::AromaticAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator--;
+%rename(prev) RDKit::QueryAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator--;
+/* A better name for the iterator's Atom object */
+%rename(getAtom) RDKit::AtomIterator_<RDKit::Atom,RDKit::ROMol>::operator*;
+%rename(getAtom) RDKit::HeteroatomIterator_<RDKit::Atom,RDKit::ROMol>::operator*;
+%rename(getAtom) RDKit::AromaticAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator*;
+%rename(getAtom) RDKit::QueryAtomIterator_<RDKit::Atom,RDKit::ROMol>::operator*;
+
+%template(AtomIterator) RDKit::AtomIterator_<RDKit::Atom,RDKit::ROMol>;
+%template(HeteroatomIterator) RDKit::HeteroatomIterator_<RDKit::Atom,RDKit::ROMol>;
+%template(AromaticAtomIterator) RDKit::AromaticAtomIterator_<RDKit::Atom,RDKit::ROMol>;
+%template(QueryAtomIterator) RDKit::QueryAtomIterator_<RDKit::Atom,RDKit::ROMol>;
+
+
+

data/Code/RubyWrappers/AtomPairs.i

@@ -0,0 +1,95 @@
+/* 
+* $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/BitVects.h>
+#include <DataStructs/SparseIntVect.h>
+#include <GraphMol/Fingerprints/AtomPairs.h>
+%}
+%include <DataStructs/BitVects.h>
+%include <DataStructs/SparseIntVect.h>
+
+// Use base types (int/unsigned int) instead of boost::int32_t/uint32_t to avoid
+// duplicate swig::traits definitions (boost types are typedefs to base types)
+%rename(eq) RDKit::SparseIntVect<unsigned int>::operator==;
+%rename(ne) RDKit::SparseIntVect<unsigned int>::operator!=;
+%rename(eq) RDKit::SparseIntVect<int>::operator==;
+%rename(ne) RDKit::SparseIntVect<int>::operator!=;
+// SparseIntVect<long long> operators removed - Ruby SWIG lacks swig::traits for long long int
+
+%template(SparseIntVectu32) RDKit::SparseIntVect<unsigned int>;
+%template(SparseIntVect32) RDKit::SparseIntVect<int>;
+// SparseIntVect64 removed - Ruby SWIG lacks swig::traits for long long int
+
+%ignore RDKit::SparseIntVect<unsigned int>::getNonzeroElements const;
+%ignore RDKit::SparseIntVect<int>::getNonzeroElements const;
+
+%extend RDKit::SparseIntVect<unsigned int> {
+  std::vector<std::pair<unsigned int, int> > getNonzero() const{
+    std::vector<std::pair<unsigned int, int> > res;
+    for(std::map<unsigned int,int>::const_iterator es=$self->getNonzeroElements().begin();
+        es!=$self->getNonzeroElements().end();++es){
+      res.push_back(std::make_pair((unsigned int)es->first,(int)es->second));
+    }
+    return res;
+  }
+}
+%extend RDKit::SparseIntVect<int> {
+  std::vector<std::pair<int, int> > getNonzero() const{
+    std::vector<std::pair<int, int> > res;
+    for(std::map<int,int>::const_iterator es=$self->getNonzeroElements().begin();
+        es!=$self->getNonzeroElements().end();++es){
+      res.push_back(std::make_pair((int)es->first,(int)es->second));
+    }
+    return res;
+  }
+}
+// getNonzero for SparseIntVect<boost::int64_t> removed - Ruby SWIG lacks swig::traits for long long int
+// %extend RDKit::SparseIntVect<boost::int64_t> {
+//   std::vector<std::pair<boost::int64_t, int> > getNonzero() const{
+//     std::vector<std::pair<boost::int64_t, int> > res;
+//     for(std::map<boost::int64_t,int>::const_iterator es=$self->getNonzeroElements().begin();
+//         es!=$self->getNonzeroElements().end();++es){
+//       res.push_back(std::make_pair((boost::int64_t)es->first,(int)es->second));
+//     }
+//     return res;
+//   }
+// }
+%newobject getAtomPairFingerprint;
+%newobject getHashedAtomPairFingerprint;
+%newobject getHashedAtomPairFingerprintAsBitVect;
+%newobject getTopologicalTorsionFingerprint;
+%newobject getHashedTopologicalTorsionFingerprint;
+%newobject getHashedTopologicalTorsionFingerprintAsBitVect;
+%include <GraphMol/Fingerprints/AtomPairs.h>

data/Code/RubyWrappers/AvalonLib.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 "std_pair.i"
+%{
+#include <AvalonTools/AvalonTools.h>
+%}
+
+%template(StringInt_Pair) std::pair<std::string, int >;
+%include <AvalonTools/AvalonTools.h>
+

data/Code/RubyWrappers/BitOps.i

@@ -0,0 +1,72 @@
+/*
+* $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 <DataStructs/BitOps.h>
+#include <DataStructs/ExplicitBitVect.h>
+#include <DataStructs/BitVectUtils.h>
+%}
+
+%include <DataStructs/BitVect.h>
+%include <DataStructs/BitOps.h>
+%include <DataStructs/BitVectUtils.h>
+
+/* Only the following are tested */
+/* We expect that SWIG can figure out the overloading so we don't need to add a suffix like EBV to the name */
+%template(OnBitProjSimilarity) OnBitProjSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(FoldFingerprint) FoldFingerprint<ExplicitBitVect>;
+
+%template(AllProbeBitsMatch) AllProbeBitsMatch<ExplicitBitVect>;
+%template(AllProbeBitsMatch) AllProbeBitsMatch<ExplicitBitVect>;
+%template(TanimotoSimilarity) TanimotoSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(CosineSimilarity) CosineSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(KulczynskiSimilarity) KulczynskiSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(DiceSimilarity) DiceSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(TverskySimilarity) TverskySimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(SokalSimilarity) SokalSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(McConnaugheySimilarity) McConnaugheySimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(AsymmetricSimilarity) AsymmetricSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(BraunBlanquetSimilarity) BraunBlanquetSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(RusselSimilarity) RusselSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(OnBitSimilarity) OnBitSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(NumBitsInCommon) NumBitsInCommon<ExplicitBitVect,ExplicitBitVect>;
+%template(AllBitSimilarity) AllBitSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(OnBitsInCommon) OnBitsInCommon<ExplicitBitVect,ExplicitBitVect>;
+%template(OffBitsInCommon) OffBitsInCommon<ExplicitBitVect,ExplicitBitVect>;
+%template(OnBitProjSimilarity) OnBitProjSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(OffBitProjSimilarity) OffBitProjSimilarity<ExplicitBitVect,ExplicitBitVect>;
+%template(BitVectToText) BitVectToText<ExplicitBitVect>;
+%template(FromBitString) FromBitString<ExplicitBitVect>;
+%template(FromDaylightString) FromDaylightString<ExplicitBitVect>;
+%template(BitVectToFPSText) BitVectToFPSText<ExplicitBitVect>;
+%template(UpdateBitVectFromFPSText) UpdateBitVectFromFPSText<ExplicitBitVect>;

data/Code/RubyWrappers/Bond.i

@@ -0,0 +1,87 @@
+/*
+* $Id: Bond.i 2519 2013-05-17 03:01:18Z glandrum $
+*
+*  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 <RDGeneral/types.h>
+#include <GraphMol/Bond.h>
+#include <GraphMol/FileParsers/MolFileStereochem.h>
+%}
+
+%ignore RDKit::Bond::getValenceContrib(const Atom *) const;
+%ignore RDKit::Bond::Match(const Bond *) const;
+%ignore RDKit::Bond::setBeginAtom(Atom *at);
+%ignore RDKit::Bond::setEndAtom(Atom *at);
+%ignore RDKit::getTwiceBondType(const RDKit::Bond &b);
+%ignore RDKit::Bond::setQuery;
+%ignore RDKit::Bond::expandQuery;
+
+// Ignore ostream operators to prevent redefinition errors
+%ignore RDKit::operator<<;
+
+%include <GraphMol/Bond.h>
+
+%extend RDKit::Bond {
+  std::string getProp(const std::string key){
+    std::string res;
+    ($self)->getProp(key, res);
+    return res;
+  }
+
+  /* Methods from MolFileStereoChem.h */
+  Bond::BondDir DetermineBondWedgeState(const std::map<int, std::unique_ptr<RDKit::Chirality::WedgeInfoBase>> &wedgeBonds,
+                                        const RDKit::Conformer *conf) {
+    return RDKit::DetermineBondWedgeState(($self), wedgeBonds, conf);
+  }
+
+  /* Based on corresponding methods in Atom.i */
+   bool IsInRing(){
+    if(!($self)->getOwningMol().getRingInfo()->isInitialized()){
+      RDKit::MolOps::findSSSR(($self)->getOwningMol());
+    }
+    return ($self)->getOwningMol().getRingInfo()->numBondRings(($self)->getIdx())!=0;
+  }
+
+  bool IsInRingSize(int size){
+    if(!($self)->getOwningMol().getRingInfo()->isInitialized()){
+      RDKit::MolOps::findSSSR(($self)->getOwningMol());
+    }
+    return ($self)->getOwningMol().getRingInfo()->isBondInRingOfSize(($self)->getIdx(),size);
+  }
+
+}
+