parsmart.h

Go to the documentation of this file.

/**********************************************************************
parsmart.h - Daylight SMARTS parser.

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison

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 version 2 of the License.

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.
***********************************************************************/

#ifndef OB_PARSMART_H
#define OB_PARSMART_H

#include <string>
#include <vector>

#include <openbabel/babelconfig.h>

/*==========================*/
/* SMARTS Data Structures */
/*==========================*/

namespace OpenBabel
{
 class OBMol;
 class OBAtom;
 class OBBond;
 class OBBitVec;

 // mark this so that SWIG will not attempt to wrap for scripting languages

#ifndef SWIG

 typedef union _AtomExpr {
 int type;
 struct
 {
 int type;
 int value;
 }
 leaf;
 struct
 {
 int type;
 void *recur;
 }
 recur;
 struct
 {
 int type;
 union _AtomExpr *arg;
 }
 mon;
 struct
 {
 int type;
 union _AtomExpr *lft;
 union _AtomExpr *rgt;
 }
 bin;
 } AtomExpr;

 typedef union _BondExpr {
 int type;
 struct
 {
 int type;
 union _BondExpr *arg;
 }
 mon;
 struct
 {
 int type;
 union _BondExpr *lft;
 union _BondExpr *rgt;
 }
 bin;
 } BondExpr;

 typedef struct
 {
 BondExpr *expr;
 int src,dst;
 int visit;
 bool grow;
 }
 BondSpec;

 typedef struct
 {
 AtomExpr *expr;
 int visit;
 int part;
 int chiral_flag;
 int vb;
 std::vector<int> nbrs;
 }
 AtomSpec;

 typedef struct
 {
 int aalloc,acount;
 int balloc,bcount;
 bool ischiral;
 AtomSpec *atom;
 BondSpec *bond;
 int parts;
 bool hasExplicitH;
 }
 Pattern;

 typedef struct
 {
 BondExpr *closord[100];
 int closure[100];
 int closindex;
 } ParseState;

#else
 // for SWIG, just forward declare that we have some Pattern struct
 // (but this is private and not wrapped for scripting languages)
 struct Pattern;
#endif

 class OBSmartsPrivate;


 // class introduction in parsmart.cpp
 class OBAPI OBSmartsPattern
 {
 protected:
 OBSmartsPrivate *_d; 
 std::vector<bool> _growbond; 
 std::vector<std::vector<int> > _mlist; 
 Pattern *_pat; 
 std::string _str; 

 char *_buffer;
 char *LexPtr;
 char *MainPtr;

 Pattern *ParseSMARTSPattern( void );
 Pattern *ParseSMARTSPart( Pattern*, int );
 Pattern *SMARTSError( Pattern *pat );
 Pattern *ParseSMARTSError( Pattern *pat, BondExpr *expr );
 AtomExpr *ParseSimpleAtomPrimitive( void );
 AtomExpr *ParseComplexAtomPrimitive( void );
 AtomExpr *ParseAtomExpr( int level );
 BondExpr *ParseBondPrimitive( void );
 BondExpr *ParseBondExpr( int level );
 Pattern *ParseSMARTSString( char *ptr );
 Pattern *ParseSMARTSRecord( char *ptr );
 int GetVectorBinding();
 Pattern *SMARTSParser( Pattern *pat, ParseState *stat,
 int prev, int part );

 public:
 OBSmartsPattern() : _pat(NULL), _buffer(NULL), LexPtr(NULL), MainPtr(NULL) { }
 virtual ~OBSmartsPattern();

 OBSmartsPattern(const OBSmartsPattern& cp): _pat(NULL), _buffer(NULL), LexPtr(NULL), MainPtr(NULL)
 {
 *this = cp;
 }

 OBSmartsPattern& operator=(const OBSmartsPattern& cp)
 {
 if (this == &cp)
 return *this;

 if (_pat)
 delete[] _pat;
 if (_buffer)
 delete[] _buffer;
 _buffer = NULL;
 _pat = NULL;
 std::string s = cp._str;
 Init(s);
 return (*this);
 }



 bool Init(const char* pattern);
 bool Init(const std::string& pattern);


 const std::string &GetSMARTS() const { return _str; }
#ifndef SWIG 
 std::string &GetSMARTS() { return _str; }
#endif
 bool Empty() const { return(_pat == NULL); }
 bool IsValid() const { return(_pat != NULL); }

 unsigned int NumAtoms() const
 {
 return _pat ? _pat->acount : 0;
 }
 unsigned int NumBonds() const
 {
 return _pat ? _pat->bcount : 0;
 }

 void GetBond(int& src,int& dst,int& ord,int idx);
 int GetAtomicNum(int idx);
 int GetCharge(int idx);

 int GetVectorBinding(int idx) const
 {
 return(_pat->atom[idx].vb);
 }

 // number and kind of matches to return
 enum MatchType {All, Single, AllUnique};


 bool Match(OBMol &mol, bool single=false);


 bool Match(OBMol &mol, std::vector<std::vector<int> > & mlist, MatchType mtype = All) const;


 bool HasMatch(OBMol &mol) const;

 bool RestrictedMatch(OBMol &mol, std::vector<std::pair<int,int> > &pairs, bool single=false);

 bool RestrictedMatch(OBMol &mol, OBBitVec &bv, bool single=false);
 unsigned int NumMatches() const
 {
 return static_cast<unsigned int>(_mlist.size());
 }

 std::vector<std::vector<int> > &GetMapList()
 {
 return(_mlist);
 }
 std::vector<std::vector<int> >::iterator BeginMList()
 {
 return(_mlist.begin());
 }
 std::vector<std::vector<int> >::iterator EndMList()
 {
 return(_mlist.end());
 }


 std::vector<std::vector<int> > &GetUMapList();

 void WriteMapList(std::ostream&);
 };


 class OBAPI OBSmartsMatcher
 {
 protected:
 //recursive smarts cache
 std::vector<std::pair<const Pattern*,std::vector<bool> > > RSCACHE;
 // list of fragment patterns (e.g., (*).(*)
 std::vector<const Pattern*> Fragments;
 /*
 bool EvalAtomExpr(AtomExpr *expr,OBAtom *atom);
 bool EvalBondExpr(BondExpr *expr,OBBond *bond);
 int GetVectorBinding();
 int CreateAtom(Pattern*,AtomExpr*,int,int vb=0);
 */
 bool EvalAtomExpr(AtomExpr *expr,OBAtom *atom);
 bool EvalBondExpr(BondExpr *expr,OBBond *bond);
 void SetupAtomMatchTable(std::vector<std::vector<bool> > &ttab,
 const Pattern *pat, OBMol &mol);
 void FastSingleMatch(OBMol &mol,const Pattern *pat,
 std::vector<std::vector<int> > &mlist);

 friend class OBSSMatch;
 public:
 OBSmartsMatcher() {}
 virtual ~OBSmartsMatcher() {}

 bool match(OBMol &mol, const Pattern *pat,std::vector<std::vector<int> > &mlist,bool single=false);

 };

 class OBAPI OBSSMatch
 {
 protected:
 bool *_uatoms;
 OBMol *_mol;
 const Pattern *_pat;
 std::vector<int> _map;

 public:
 OBSSMatch(OBMol&,const Pattern*);
 ~OBSSMatch();
 void Match(std::vector<std::vector<int> > &v, int bidx=-1);
 };

 OBAPI void SmartsLexReplace(std::string &,
 std::vector<std::pair<std::string,std::string> > &);

} // end namespace OpenBabel

#endif // OB_PARSMART_H