query.h

Go to the documentation of this file.

/**********************************************************************
 query.h - OBQuery, OBQueryAtom & OBQueryBond classes.

 Copyright (C) 2010 by Tim Vandermeersch

 This file is part of the Open Babel project.
 For more information, see <http://openbabel.org/>

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 02110-1301, USA.
 **********************************************************************/
#ifndef OB_QUERY_H
#define OB_QUERY_H

#include <openbabel/bond.h> // TODO: Move OBBond code out of this header
#include <openbabel/bitvec.h>
#include <openbabel/tokenst.h>

namespace OpenBabel {

 class OBQueryBond;
 class OBMol;


 class OBAPI OBQueryAtom
 {
 public:
 friend class OBQuery;
 friend class OBQueryBond;
 OBQueryAtom(int atomicNum = 6, bool isInRing = false, bool isAromatic = false) :
 m_atomicNum(atomicNum), m_isInRing(isInRing), m_isAromatic(isAromatic) {}

 virtual ~OBQueryAtom() {}

 unsigned int GetIndex() const
 {
 return m_index;
 }
 const std::vector<OBQueryBond*>& GetBonds() const
 {
 return m_bonds;
 }
 const std::vector<OBQueryAtom*>& GetNbrs() const
 {
 return m_nbrs;
 }
 virtual bool Matches(const OBAtom *atom) const
 {
 if (atom->GetAtomicNum() != m_atomicNum)
 return false;
 if (atom->IsAromatic() != m_isAromatic)
 return false;
 if (m_isInRing)
 if (!atom->IsInRing())
 return false;
 return true;
 }
 protected:
 unsigned int m_index;
 unsigned int m_atomicNum;
 bool m_isInRing, m_isAromatic;
 std::vector<OBQueryBond*> m_bonds;
 std::vector<OBQueryAtom*> m_nbrs;
 };

 class OBAPI OBQueryBond
 {
 public:
 friend class OBQuery;
 OBQueryBond(OBQueryAtom *begin, OBQueryAtom *end, int order = 1, bool aromatic = false) :
 m_begin(begin), m_end(end), m_order(order), m_aromatic(aromatic)
 {
 m_begin->m_bonds.push_back(this);
 m_end->m_bonds.push_back(this);
 m_begin->m_nbrs.push_back(m_end);
 m_end->m_nbrs.push_back(m_begin);
 }

 virtual ~OBQueryBond() {}

 unsigned int GetIndex() const
 {
 return m_index;
 }
 OBQueryAtom* GetBeginAtom() const { return m_begin; }
 OBQueryAtom* GetEndAtom() const { return m_end; }
 virtual bool Matches(const OBBond *bond) const
 {
 if (m_aromatic)
 return bond->IsAromatic();
 return bond->GetBondOrder() == m_order;
 }
 protected:
 unsigned int m_index;
 OBQueryAtom *m_begin, *m_end;
 unsigned int m_order;
 bool m_aromatic;
 };

 class OBAPI OBQuery
 {
 public:
 ~OBQuery();
 unsigned int NumAtoms() const
 {
 return m_atoms.size();
 }
 unsigned int NumBonds() const
 {
 return m_bonds.size();
 }
 const std::vector<OBQueryAtom*>& GetAtoms() const
 {
 return m_atoms;
 }
 const std::vector<OBQueryBond*>& GetBonds() const
 {
 return m_bonds;
 }
 OBQueryBond* GetBond(OBQueryAtom *begin, OBQueryAtom *end) const
 {
 for (unsigned int i = 0; i < begin->GetBonds().size(); ++i)
 if (begin->GetNbrs()[i] == end)
 return begin->GetBonds()[i];
 return 0;
 }
 void AddAtom(OBQueryAtom *atom)
 {
 atom->m_index = m_atoms.size();
 m_atoms.push_back(atom);
 }
 void AddBond(OBQueryBond *bond)
 {
 bond->m_index = m_bonds.size();
 m_bonds.push_back(bond);
 }
 protected:
 std::vector<OBQueryAtom*> m_atoms;
 std::vector<OBQueryBond*> m_bonds;
 };

 OBAPI OBQuery* CompileMoleculeQuery(OBMol *mol, const OBBitVec &mask = OBBitVec());

 OBAPI OBQuery* CompileSmilesQuery(const std::string &smiles, const OBBitVec &mask = OBBitVec());

}

#endif