smartsParser.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_STRUCTURE_SMARTES_PARSER_H
#define BALL_STRUCTURE_SMARTES_PARSER_H

#ifndef BALL_COMMON_H
  # include <BALL/common.h>
#endif

#include <map>
#include <set>

// needed for MSVC:
#undef CW_DEFAULT

namespace BALL 
{
  // forward declarations
  class Bond;
  class Atom;
  class Element;

  class BALL_EXPORT SmartsParser
  {
    public:

    enum ZEIsomerType
    {
      ANY_ZE = 1,
      NONE,
      Z,
      E
    };

    enum ChiralClass
    {
      CHIRAL_CLASS_UNSPECIFIED = 1,
      NONCHIRAL,
      NONCHIRAL_OR_UNSPECIFIED,
      CW_DEFAULT, // TH
      CW_DEFAULT_OR_UNSPECIFIED,
      CCW_DEFAULT, // TH
      CCW_DEFAULT_OR_UNSPECIFIED,
      CW_TH, // tetrahdral
      CW_TH_OR_UNSPECIFIED,
      CCW_TH,
      CCW_TH_OR_UNSPECIFIED,
      CW_AL, // allene-like
      CW_AL_OR_UNSPECIFIED,
      CCW_AL, 
      CCW_AL_OR_UNSPECIFIED,
      CW_SP, // square planar
      CW_SP_OR_UNSPECIFIED,
      CCW_SP,
      CCW_SP_OR_UNSPECIFIED,
      CW_TB, //trigonal bipyramidal
      CW_TB_OR_UNSPECIFIED,
      CCW_TB,
      CCW_TB_OR_UNSPECIFIED,
      CW_OH, // octahedral
      CW_OH_OR_UNSPECIFIED,
      CCW_OH,
      CCW_OH_OR_UNSPECIFIED
    };

    enum LogicalOperator
    {
      AND,
      OR,
      AND_LOW,
      NOOP
    };


    class SPAtom;

    class BALL_EXPORT SPBond 
    {
      public:

        enum SPBondOrder
        {
          SINGLE = 1,
          SINGLE_UP,
          SINGLE_UP_OR_ANY,
          SINGLE_DOWN,
          SINGLE_DOWN_OR_ANY,
          SINGLE_OR_AROMATIC,
          AROMATIC,
          DOUBLE,
          TRIPLE,
          NOT_NECESSARILY_CONNECTED,
          IN_RING,
          ANY
        };
    
        SPBond();

        SPBond(SPBondOrder bond_order);

        SPBond(SPAtom* first, SPAtom* second, SPBondOrder bond_order);

        virtual ~SPBond() ;

        ZEIsomerType getZEType() const { return ze_type_; }

        void setZEType(ZEIsomerType type) { ze_type_ = type; }

        void setBondOrder(SPBondOrder bond_order);

        SPBondOrder getBondOrder() const { return bond_order_; }

        bool isNot() const { return not_; }

        void setNot(bool is_not) { not_ = is_not; }

        // returns true if the SPBond matches the given bond
        bool equals(const Bond* bond) const;

      protected:

        ZEIsomerType  ze_type_;

        SPBondOrder bond_order_;

        bool not_;
    };
    
    class BALL_EXPORT SPAtom
    {
      public:

        enum PropertyType
        {
          ISOTOPE = 1,
          CHARGE,
          AROMATIC,
          ALIPHATIC,
          IN_NUM_RINGS,
          IN_RING_SIZE,
          IN_BRACKETS,
          CONNECTED,
          EXPLICIT_HYDROGENS,
          VALENCE,
          IMPLICIT_HYDROGENS,
          DEGREE,
          RING_CONNECTED,
          CHIRALITY,
          SYMBOL
        };

        union PropertyValue
        {
          int int_value;
          bool bool_value;
          const Element* element_value;
          ChiralClass chiral_class_value;
        };

        struct Property
        {
          public:
        
            Property(PropertyType type, int value);
            
            Property(PropertyType type, bool value);
            
            Property(PropertyType type, const Element* value);
            
            Property(PropertyType type, ChiralClass value);

            virtual ~Property();

            void operator = (const Property& rhs);

            PropertyType getType() const { return type_; }

            PropertyValue getValue() const { return value_; }

          private:
            
            Property();
            
            PropertyType type_;

            PropertyValue value_;
        };
        
        SPAtom();

        SPAtom(const String& symbol);

        virtual ~SPAtom() ;


        void setProperty(PropertyType type, int int_value);
        
        void setProperty(PropertyType type, bool  flag);

        void setProperty(PropertyType type, const Element* element);

        void setProperty(PropertyType type, ChiralClass chirality);

        void setProperty(Property property);

        void addPropertiesFromSPAtom(SPAtom* sp_atom);

        void setNotProperty(PropertyType type);

        bool hasProperty(PropertyType type) const;

        PropertyValue getProperty(PropertyType type);

        Size countProperties() const;

        Size getDefaultValence(const Atom* atom) const;
        
        Size countRealValences(const Atom* atom) const;
        
        Size getNumberOfImplicitHydrogens(const Atom* atom) const;

        bool equals(const Atom* atom) const;
        
      protected:

        Atom* atom_;

        std::map<PropertyType, PropertyValue> properties_;

        std::set<PropertyType> not_properties_;
    };

    class SPNode;

    class BALL_EXPORT SPEdge
    {
      public:

        SPEdge();

        SPEdge(const SPEdge& sp_edge);

        virtual ~SPEdge();
        
        bool isInternal() const { return internal_; }

        void setInternal(bool internal) { internal_ = internal; }
        
        void setSPBond(SPBond* sp_bond) { bond_ = sp_bond; }

        SPBond* getSPBond() const { return bond_; }
        
        void setFirstSPNode(SPNode* first) { first_ = first; }

        SPNode* getFirstSPNode() const { return first_; } 
        
        void setSecondSPNode(SPNode* second) { second_ = second; }

        SPNode* getSecondSPNode() const { return second_; }
        
        SPNode* getPartnerSPNode(SPNode* node) { return node == first_ ? second_ : first_; }
        
        bool isNot() const { return is_not_; }

        void setNot(bool is_not) { is_not_ = is_not; }
      
        void setFirstSPEdge(SPEdge* first) { first_edge_ = first; }

        SPEdge* getFirstSPEdge() const { return first_edge_; }

        void setSecondSPEdge(SPEdge* second) { second_edge_ = second; }

        SPEdge* getSecondSPEdge() const { return second_edge_; }
    
        void setLogicalOperator(LogicalOperator log_op) { log_op_ = log_op; }

        LogicalOperator getLogicalOperator() const { return log_op_; }
      
      protected:

        bool internal_;

        bool is_not_;

        SPNode* first_;

        SPNode* second_;

        SPBond* bond_;

        SPEdge* first_edge_;

        SPEdge* second_edge_;

        LogicalOperator log_op_;
    };

    class BALL_EXPORT SPNode
    {
      public:
    
        typedef std::vector<SPEdge*>::iterator EdgeIterator;

        typedef std::vector<SPEdge*>::const_iterator EdgeConstIterator;
  

        SPNode();

        SPNode(SPAtom* atom);

        SPNode(SPNode* first, LogicalOperator log_op, SPNode* second);

        SPNode(const SPNode& sp_node);

        virtual ~SPNode();
        

        bool isInternal() const { return internal_; }

        void setInternal(bool internal) { internal_ = internal; }
        
        bool isRecursive() const { return recursive_; }

        void setRecursive(bool recursive); 
      
        void setComponentNumber(int no) { component_no_ = no; }

        Size getComponentNumber() const { return component_no_; }
      
        SPAtom* getSPAtom() const { return sp_atom_; }

        void setSPAtom(SPAtom* sp_atom) { sp_atom_ = sp_atom; }
    
        SPEdge* getFirstEdge() const { return first_edge_; }

        void setFirstEdge(SPEdge* first) { first_edge_ = first; }

        SPEdge* getSecondEdge() const { return second_edge_; }

        void setSecondEdge(SPEdge* second) { second_edge_ = second; }
    
        bool getNot() const { return is_not_; }

        void setNot(bool is_not) { is_not_ = is_not; }
  

        //void setInBrackets() { in_brackets_ = true; }

        void addSPEdge(SPEdge* sp_edge) { edges_.push_back(sp_edge); }

        void setLogicalOperator(LogicalOperator log_op) { log_op_ = log_op; }

        LogicalOperator getLogicalOperator() const { return log_op_; }  

        Size countEdges() const { return edges_.size(); }

        EdgeIterator begin() { return edges_.begin(); }

        EdgeIterator end() { return edges_.end(); }

        EdgeConstIterator begin() const { return edges_.begin(); }

        EdgeConstIterator end() const { return edges_.end(); }

      protected:
        
        bool internal_;

        bool is_not_;

        bool recursive_;

        //bool in_brackets_;

        LogicalOperator log_op_;

        std::vector<SPEdge*> edges_;

        SPEdge* first_edge_;

        SPEdge* second_edge_;

        SPAtom* sp_atom_;

        int component_no_;
    };

  
    SmartsParser();
      
    SmartsParser(const SmartsParser& parser);

    virtual ~SmartsParser();
    
    void parse(const String& s)
      throw(Exception::ParseError);

    SPAtom* createAtom(const String& symbol, bool in_bracket = false);

    void setRoot(SPNode* root) { root_ = root; }

    SPNode* getRoot() const { return root_; }

    void dumpTree();
    
    void clear();
    
    void addRingConnection(SPNode* spnode, Size index);
    
    std::map<Size, std::vector<SPNode*> > getRingConnections() const;
  
    void setSSSR(const std::vector<std::vector<Atom*> >& sssr);

    void setNeedsSSSR(bool needs_sssr) { needs_SSSR_ = needs_sssr; }

    bool getNeedsSSSR() const { return needs_SSSR_; }

    void setRecursive(bool recursive) { recursive_ = recursive; }

    bool isRecursive() const { return recursive_; }

    void setComponentGrouping(bool component_grouping) { component_grouping_ = component_grouping; }

    bool hasComponentGrouping() const { return component_grouping_; }

    struct State
    {
      Size          char_count;
      SmartsParser* current_parser;
      const char*   buffer;
    };
    
    static State state;

    const std::set<SPNode*>& getNodes() const { return nodes_; }

    const std::set<SPEdge*>& getEdges() const { return edges_; }

    void addEdge(SPEdge* edge) { edges_.insert(edge); }

    void addNode(SPNode* node) { nodes_.insert(node); }

    bool hasRecursiveEdge(SPEdge* edge) const { return rec_edges_.find(edge) != rec_edges_.end(); }

    void addRecursiveEdge(SPEdge* edge) { rec_edges_.insert(edge); }

    void setNextComponentNumberToSubTree(SPNode* spnode);

    protected:

      bool needs_SSSR_;

      bool recursive_;

      bool component_grouping_;

      static vector<std::set<const Atom*> >* sssr_;

      void dumpTreeRecursive_(SPNode* node, Size depth);

      void dumpTreeRecursive_(SPEdge* edge, Size depth);
      
      std::map<Size, std::vector<SPNode*> > ring_connections_;
    
      static SmartsParser* current_parser_;
      
      std::set<SPEdge*> edges_;
      
      std::set<SPNode*> nodes_;

      std::set<SPEdge*> rec_edges_;

      SPNode* root_;

      int component_no_;
  };
  
} // namespace BALL

#endif // BALL_STRUCTURE_SMARTS_PARSER_H