dockResult.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: dockResult.h,v 1.2.16.2 2007/08/07 16:16:15 bertsch Exp $
//

#ifndef BALL_DOCKING_COMMON_DOCKRESULT_H
#define BALL_DOCKING_COMMON_DOCKRESULT_H

#ifndef BALL_DATATYPE_OPTIONS_H
# include <BALL/DATATYPE/options.h>
#endif

#ifndef BALL_DOCKING_COMMON_CONFORMATIONSET_H
# include <BALL/DOCKING/COMMON/conformationSet.h>
#endif

namespace BALL
{
    class BALL_EXPORT DockResult
    {
      public:


        DockResult()
          throw();

        DockResult(const String& docking_algorithm, ConformationSet* conformation_set,
                    const Options& docking_options)
          throw();

        DockResult(const DockResult& dock_res)
          throw();

        virtual ~DockResult()
          throw();



        const DockResult& operator = (const DockResult& dock_res)
          throw();



        void setConformationSet(ConformationSet* conformation_set)
          throw();

        const String& getDockingAlgorithm() const
          throw();

        const Options& getDockingOptions() const
          throw();

        const ConformationSet* getConformationSet() const
          throw();

        ConformationSet* getConformationSet()
          throw();

        /*  Sets scoring flag by which all scores are sorted displayed
            a negative index corresponds to sorting by snapshot index
         */
         void sortBy(Index scoring_index)
          throw(Exception::IndexOverflow);

        /*  Get the number of the scoring by which all scores are sorted displayed
         */
        Index isSortedBy() const
          throw();

        float operator()(Position i, Position j)
          throw(Exception::IndexOverflow);

        const vector < ConformationSet::Conformation > getScores(Position i) const
          throw(Exception::IndexOverflow);

        const String& getScoringName(Position i) const
          throw(Exception::IndexOverflow);

        const Options& getScoringOptions(Position i) const
          throw(Exception::IndexOverflow);

        Size numberOfScorings() const
          throw();

        void addScoring(const String& name, const Options& options, vector < ConformationSet::Conformation > scores)
          throw();

        void deleteScoring(Position i)
          throw(Exception::IndexOverflow);



        bool writeDockResult(const String& filename)
          throw();

        bool writeDockResult(std::ostream& file) const
          throw();

        bool readDockResult(const String& filename)
          throw();

        bool readDockResult(std::istream& file)
          throw();

        friend std::ostream& operator <<(std::ostream& out, const DockResult& dock_res)
          throw();

        friend std::istream& operator >>(std::istream& in, DockResult& dock_res)
          throw();


      protected:

  class Scoring_
        {
          public:

            Scoring_() throw();

            Scoring_(const Scoring_& scoring)
              throw();

            Scoring_(const String& name, const Options& options, const vector<float>& scores, const vector<Index>& snapshot_order) throw();

            ~Scoring_() throw();

            const Scoring_& operator = (const Scoring_& scoring)
              throw();

            String name_;
            Options options_;
            vector<float> scores_;
            vector<Index> snapshot_order_;
        };

        class Compare_
        {
          public:

            Compare_() throw();

            ~Compare_() throw();

            //bool operator() (const std::pair<Index, float>& a, const std::pair<Index, float>& b) const
            bool operator() (const ConformationSet::Conformation& a, const ConformationSet::Conformation& b) const
              throw();
        };

        String docking_algorithm_;
        Options docking_options_;
        ConformationSet* conformation_set_;
        vector<Scoring_> scorings_;
        Index sorted_by_;
    };

    std::ostream& operator <<(std::ostream& out, const DockResult& dock_res)
      throw();

    std::istream& operator >>(std::istream& in, DockResult& dock_res)
      throw();
}
#endif