standardPredicates.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: standardPredicates.h,v 1.52.16.2 2007/03/29 10:34:59 bertsch Exp $
//
 
#ifndef BALL_KERNEL_STANDARDPREDICATES_H
#define BALL_KERNEL_STANDARDPREDICATES_H
 
#ifndef BALL_DATATYPE_STRINGHASHMAP_H
# include <BALL/DATATYPE/stringHashMap.h>
#endif
 
#ifndef BALL_DATATYPE_HASHSET_H
# include <BALL/DATATYPE/hashSet.h>
#endif
 
#ifndef BALL_KERNEL_BOND_H
# include <BALL/KERNEL/bond.h>
#endif
 
#ifndef BALL_KERNEL_EXPRESSION_H
# include <BALL/KERNEL/expression.h>
#endif
 
#ifndef BALL_STRUCTURE_SMARTSMATCHER_H
# include <BALL/STRUCTURE/smartsMatcher.h>
#endif
 
#ifndef BALL_QSAR_AROMATICITYPROCESSOR_H
# include <BALL/QSAR/aromaticityProcessor.h>
#endif
 
#ifndef BALL_QSAR_RINGPERCEPTIONPROCESSOR_H
# include <BALL/QSAR/ringPerceptionProcessor.h>
#endif
 
namespace BALL 
{
  class Atom;


  class BALL_EXPORT TruePredicate
    : public ExpressionPredicate
  {
    public:
      BALL_CREATE(TruePredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT FalsePredicate
    : public ExpressionPredicate
  {
    public:
    BALL_CREATE(FalsePredicate)
 
    
    virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT SelectedPredicate
    : public ExpressionPredicate
  {
    public:
      BALL_CREATE(SelectedPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT AtomNamePredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(AtomNamePredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT AtomTypePredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(AtomTypePredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT ElementPredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(ElementPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT ResiduePredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(ResiduePredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT ResidueIDPredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(ResidueIDPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT ProteinPredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(ProteinPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT ChainPredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(ChainPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT SecondaryStructurePredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(SecondaryStructurePredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT SolventPredicate
    : public  ExpressionPredicate
  {
    public:
    BALL_CREATE(SolventPredicate)
 
    
    virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT MoleculePredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(MoleculePredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT BackBonePredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(BackBonePredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT NucleicAcidPredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(NucleicAcidPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT NucleotidePredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(NucleotidePredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT InRingPredicate
    : public  ExpressionPredicate
  {
    public:
 
      BALL_CREATE(InRingPredicate)
 
      
      InRingPredicate();

      InRingPredicate(Size n);

      ~InRingPredicate();

      virtual bool operator () (const Atom& atom) const;
 
  };

  class BALL_EXPORT NumberOfBondsPredicate
    : public  ExpressionPredicate
  {
    public:

      NumberOfBondsPredicate();
 
      BALL_CREATE(NumberOfBondsPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
 
    protected:
      bool testPredicate_(const Atom& atom, Bond::Order order) const;
  };
 

  class BALL_EXPORT SingleBondsPredicate
    : public NumberOfBondsPredicate
  {
    public:
      BALL_CREATE(SingleBondsPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };
 

  class BALL_EXPORT DoubleBondsPredicate
    : public NumberOfBondsPredicate
  {
    public:
      BALL_CREATE(DoubleBondsPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
 
  };
 

  class BALL_EXPORT TripleBondsPredicate
    : public DoubleBondsPredicate
  {
    public:
      BALL_CREATE(TripleBondsPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };
 

  class BALL_EXPORT AromaticBondsPredicate
    : public ExpressionPredicate
  {
    public:
      BALL_CREATE(AromaticBondsPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
 
    protected:
      bool testPredicate_(const Atom& atom) const;
  };
 

  class BALL_EXPORT ConnectedToPredicate
    : public  ExpressionPredicate
  {
 
    public:
 
      class BALL_EXPORT CTPNode
      {
        public:
 
          enum BondType
          {
            BONDTYPE__UNINITIALISED = 0,
            BONDTYPE__ANY           = 1,
            BONDTYPE__SINGLE        = 2,
            BONDTYPE__DOUBLE        = 3,
            BONDTYPE__TRIPLE        = 4,
            BONDTYPE__QUADRUPLE     = 5,
            BONDTYPE__AROMATIC      = 6
          };
 
          typedef std::list<CTPNode*>::iterator Iterator;
          typedef std::list<CTPNode*>::const_iterator ConstIterator;
 
          /*
           */
          CTPNode();
 
          /*
           */
          CTPNode(const CTPNode& node);
 
          /*
           */
          virtual ~CTPNode();
 
          /*
          */
          virtual void destroy();
 
          /*
           */
          void setParent(CTPNode* parent);
 
          /*
           */
          CTPNode* getParent() const;
 
          /*
           */
          void addChild(CTPNode* child);
 
          /*
           */
          void removeChild(CTPNode* child);
 
          /*
           */
          ::std::list<CTPNode*>& getChildren();
 
          Iterator begin();
 
          ConstIterator begin() const;
 
          Iterator end();
 
          ConstIterator end() const;
 
          /*
           */
          Size getNumberOfChildren() const;
 
          /*
           */
          void setBondType(Size type);
 
          /*
           */
          void setBondType(char type);
 
          /*
           */
          Size getBondType() const;
 
          /*
           */
          char getBondTypeChar() const;
 
          /*
           */
          String getSymbol() const;
 
          /*
           */
          void setSymbol(const String& symbol);
 
          /*
           */
          void setFinished();
 
          /*
           */
          void unsetFinished();
 
          /*
           */
          bool isFinished() const;
 
          /*
           */
          void setLinked();
 
          /*
           */
          void unsetLinked();
 
          /*
           */
          bool isLinked() const;
 
          /*
           */
          void linkWith(CTPNode* partner);
 
          /*
           */
          const HashSet<CTPNode*>& getLinkSet() const;
 
 
        private: 
 
          /*
           */
          String element_symbol_;
 
          /* Bond type means the bond connecting *to* this node.
           */
          Size bond_type_;
 
          /*
           */
          std::list<CTPNode*> children_;
 
          /*
           */
          CTPNode* parent_;
 
          /*
           */
          bool finished_;
 
          /*
           */
          bool linked_;
 
          /*
           */
          HashSet<CTPNode*> link_set_;
 
          /*
          */
          struct greater_
            : public binary_function<const CTPNode*, const CTPNode*, bool>
          {
 
            bool operator () (const CTPNode* a, const CTPNode* b) const
            {
              if ((a != 0) && (b != 0))
              {
                if (a->getSymbol() == "*")
                {
                  return true;
                }
                else
                {
                  return false;
                }
              }
              else
              {
                Log.error() << "greater_: got NULL pointers" << std::endl;
                return false;
              }
            }
 
          };
 
      };
 
    public:
      BALL_CREATE(ConnectedToPredicate)
 
      ConnectedToPredicate();
 
      ConnectedToPredicate(const ConnectedToPredicate& predicate);
 
      virtual ~ConnectedToPredicate();
 
      virtual void clear();

      virtual bool operator () (const Atom& atom) const;
    
      void dump() const;
 
      void dump(const CTPNode* current) const;
 
      virtual void setArgument(const String& argument);
 
    private:
      /*_ The syntax tree
      */
      CTPNode* tree_;
 
      /*_ Needed for realising parsing of loops (or links).
      */
      HashMap<char, std::pair<CTPNode*, CTPNode*> > link_map_;
 
      /*_ Needed for realising parsing of loops (or links).
      */
      char link_mark_;
 
      /*_ Keep it consistent
      */
      CTPNode* createNewNode_(CTPNode* node);
    
      /*_
      */
      CTPNode* parse_();
 
      // Clean up nodes created if parse_ exits with a parse error.
      void cleanUpNodes_(std::vector<CTPNode*>& all_nodes);
 
      /*_
      */
      CTPNode* parse_(const String& input);
 
      bool bondOrderMatch_(const Bond& bond, const CTPNode& node) const;
 
      bool find_(const Atom& atom, const CTPNode* current,
          HashSet<const Bond*>& visited) const;
 
  };

  class BALL_EXPORT SpHybridizedPredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(SpHybridizedPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT Sp2HybridizedPredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(Sp2HybridizedPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };
 

  class BALL_EXPORT Sp3HybridizedPredicate
    : public  ExpressionPredicate
  {
    public:
      BALL_CREATE(Sp3HybridizedPredicate)
 
      
      virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT ChargePredicate
    : public  ExpressionPredicate
  {
    public:
    BALL_CREATE(ChargePredicate)
 
    
    virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT AxialPredicate
    : public  ExpressionPredicate
  {
    public:
    BALL_CREATE(AxialPredicate)
 
    
    virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT Conformation4C1Predicate
    : public  ExpressionPredicate
  {
    public:
    BALL_CREATE(Conformation4C1Predicate)
 
    
    virtual bool operator () (const Atom& atom) const;
  };

  class BALL_EXPORT RingFinder
  {
    public:
 
      // BALL_CREATE(RingFinder)

      RingFinder();

      RingFinder(Size n);

      virtual ~RingFinder();

      bool operator () (const Atom& atom);

      bool dfs(const Atom& atom, const Size limit);

      void setRingSize(Size n);

      const HashSet<const Bond*>& getVisitedBonds() const;

      const std::vector<const Atom*>& getRingAtoms() const;
 
    private:

      const Atom* first_atom_;
      
      Size n_;

      bool exact_;
 
      /*_
      */
      HashSet<const Bond*> visited_bonds_;
 
      /*_
      */
      std::vector<const Atom*> ring_atoms_;
 
  };

  class BALL_EXPORT SMARTSPredicate
    : public ExpressionPredicate
  {
    public:

    SMARTSPredicate();

    SMARTSPredicate(const SMARTSPredicate& pred);

    virtual ~SMARTSPredicate();
  
    BALL_CREATE(SMARTSPredicate)
 
    
    virtual bool operator () (const Atom& atom) const;
 
    mutable SmartsMatcher matcher_;
    mutable Molecule* last_molecule_;
    mutable AromaticityProcessor arom_proc_;
    mutable RingPerceptionProcessor ring_proc_;
    // when was the aromaticity lastly calculated for a given molecule:
    static HashMap<Molecule*, TimeStamp> call_time_map_;
    static Molecule dummy_molecule_;
    mutable HashSet<Atom*> matches_;
  };
 

} // namespace BALL
 
#endif // BALL_KERNEL_STANDARDPREDICATES_H