mirror of
https://github.com/rdkit/rdkit.git
synced 2026-06-03 21:44:30 +08:00
930c7d6345
* Query atom information in swig * Atom query swig wrapping working * SWIG wrapper for queries * Add match to QueryAtom and QueryBond * CShart test * Added Java test * Replace var with type for Java test * Apply suggestions from code review Co-authored-by: Paolo Tosco <paolo.tosco.mail@gmail.com> * Update Code/JavaWrappers/Queries.i Co-authored-by: Paolo Tosco <paolo.tosco.mail@gmail.com> * Apply suggestions from code review Co-authored-by: Paolo Tosco <paolo.tosco.mail@gmail.com> * Get SWIG build working again * Remove trailing whitespace from Queries.i * Update Queries.i to use shared_ptr * small simplification * remove boost::make_iterator from ROMol.i * further simplification --------- Co-authored-by: Paolo Tosco <paolo.tosco.mail@gmail.com> Co-authored-by: ptosco <paolo.tosco@novartis.com>
288 lines
11 KiB
OpenEdge ABL
288 lines
11 KiB
OpenEdge ABL
//
|
|
// 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());
|
|
}
|
|
}
|
|
}
|