smartsMatcher.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
 
#ifndef BALL_STRUCTURE_SMARTSMATCHER_H
#define BALL_STRUCTURE_SMARTSMATCHER_H
 
#ifndef BALL_STRUCTURE_SMARTSPARSER_H
# include <BALL/STRUCTURE/smartsParser.h>
#endif
 
#include <vector>
#include <set>
#include <map>
 
#include <boost/shared_ptr.hpp>
 
namespace BALL 
{
  // forward declaration
  class Molecule;
 
  class BALL_EXPORT SmartsMatcher
  {
    public: 
 
      typedef std::vector<std::set<const Atom*> > Match;
 
 
      SmartsMatcher();
 
      virtual ~SmartsMatcher();
 
 
      void match(Match& matches, Molecule& mol, const String& smarts);
 
      void match(Match& matches, Molecule& mol, const String& smarts, const std::set<const Atom*>& start_atoms);
 
      void match(std::vector<Match>& matches, Molecule& mol, const std::vector<String>& smarts);
 
      void match(std::vector<Match>& matches, Molecule& mol, const std::vector<String>& smarts, const std::set<const Atom*>& start_atoms);
 
      void setSSSR(const std::vector<std::vector<Atom*> >& sssr);
 
      void unsetSSSR();
 
 
    private:
      
      SmartsMatcher(const SmartsMatcher& matcher);
 
      SmartsMatcher& operator = (const SmartsMatcher& matcher);
 
 
    protected:
 
      typedef SmartsParser::SPNode SPNode;
      typedef SmartsParser::SPEdge SPEdge;
      typedef SmartsParser::SPAtom SPAtom;
      typedef SmartsParser::SPBond SPBond;
 
      class RecStructCore_
      {
        public:
          
          RecStructCore_();
 
          RecStructCore_(const RecStructCore_&);
 
          virtual ~RecStructCore_();
 
          RecStructCore_& operator = (const RecStructCore_&);
 
          void clear();
      
          std::vector<std::set<const Atom*> > matched_atoms;
 
          std::vector<std::map<const SPNode*, const Atom*> > mapped_atoms;
 
          std::vector<std::set<const Atom*> > visited_atoms;
 
          std::vector<std::set<const Bond*> > visited_bonds;
 
          std::vector<std::set<const SPEdge*> > visited_edges;
 
          std::vector<std::pair<const SPNode*, const Atom*> > first_matches;
      };
 
      class RecStructPool_
      {
        public:
          
          RecStructPool_();
 
          virtual ~RecStructPool_();
 
          RecStructCore_* getNextFree();
 
          Position getLastPosition();
 
          void destroy(Position pos);
 
        private:
 
          void resize_();
 
          RecStructPool_(const RecStructPool_&);
 
          RecStructPool_& operator = (const RecStructPool_&);
  
          std::vector<RecStructCore_*> rec_struct_pool_;
 
          std::vector<Position> free_list_;
 
          Position last_position_;
      };
 
 
      class RecStruct_
      {
        private:
          RecStructCore_* rec_struct_core_;
      
        public:
          
          RecStruct_();
 
          RecStruct_(const RecStruct_& rec_struct);
 
          virtual ~RecStruct_();
 
          RecStruct_& operator = (const RecStruct_&); 
 
          std::vector<std::set<const Atom*> >& matched_atoms;
 
          std::vector<std::map<const SPNode*, const Atom*> >& mapped_atoms;
 
          std::vector<std::set<const Atom*> >& visited_atoms;
 
          std::vector<std::set<const Bond*> >& visited_bonds;
 
          std::vector<std::set<const SPEdge*> >& visited_edges;
 
          std::vector<std::pair<const SPNode*, const Atom*> >& first_matches;
 
          void add(const RecStruct_& rec_struct);
 
          void add(const RecStruct_& rec_struct, Size i);
 
          void clear();
 
          void dump(const String& name, Size depth_ = 0);
 
        private:
        
          Position pos_;
      };
 
      static boost::shared_ptr<RecStructPool_> pool_;
 
      bool evaluateRingEdges_(const std::set<const Atom*>& matching, const std::map<const SPNode*, const Atom*>& mapping, const String& smarts);
      
      void evaluate_( RecStruct_& rs, SPNode* start_node, const Atom* start_atom);
  
      bool evaluate_node_(RecStruct_& rs, SPNode* start_node, const Atom* start_atom);
  
      bool evaluate_edge_(RecStruct_& rs, SPEdge* start_node, const Atom* start_atom, const Bond* start_bond);
 
      std::map<SPNode*, std::vector<std::set<const Atom*> > > rec_matches_;
 
      bool has_user_sssr_;
 
      std::vector<std::vector<Atom*> > sssr_;
 
      // debug output depth
      Size depth_;
  };
  
} // namespace BALL
 
#endif // BALL_STRUCTURE_SMARTSMATCHER_H