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>
#include <openbabel/mol.h>

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

namespace OpenBabel
{

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

#ifndef SWIG

  typedef union _AtomExpr {
    int type;
    struct
    {
      int type;
      int prop;
      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;

#define BE_LEAF      0x01
#define BE_ANDHI     0x02
#define BE_ANDLO     0x03
#define BE_NOT       0x04
#define BE_OR        0x05

#define BL_CONST     0x01
#define BL_TYPE      0x02

#define BT_SINGLE     0x01
#define BT_DOUBLE     0x02
#define BT_TRIPLE     0x03
#define BT_AROM       0x04
#define BT_UP         0x05
#define BT_DOWN       0x06
#define BT_UPUNSPEC   0x07
#define BT_DOWNUNSPEC 0x08
#define BT_RING       0x09
#define BT_QUAD       0x0A //quadruple bond $

  typedef union _BondExpr {
    int type;
    struct
    {
      int type;
      int prop;
      int value;
    }
      leaf;
    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;
  }
  AtomSpec;

  typedef struct
  {
    int aalloc,acount;
    int balloc,bcount;
    bool ischiral;
    AtomSpec *atom;
    BondSpec *bond;
    int parts;
    bool hasExplicitH;
    std::vector<int> bond_parse_order; // Used to recover the order in which bonds were parsed
  }
  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