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