StandardProblemIteration.hpp

#pragma once
 
#include <string>
 
#include "ProblemIterationInterface.hpp"
 
namespace AMDiS
{
  // forward declarations
  class AdaptInfo;
  class Flag;
  class ProblemStatBase;
 
  class StandardProblemIteration
      : public virtual ProblemIterationInterface
  {
  public:
    explicit StandardProblemIteration(ProblemStatBase& prob)
      : problem_(prob)
    {}
 
    void beginIteration(AdaptInfo& adaptInfo) override;
 
    Flag oneIteration(AdaptInfo& adaptInfo, Flag toDo) override;
 
    void endIteration(AdaptInfo& adaptInfo) override;
 
    std::string const& name() const override;
 
    int numProblems() const override
    {
      return 1;
    }
 
    ProblemStatBase& problem(int number = 0) override;
 
    ProblemStatBase& problem(std::string const& name) override;
 
  protected:
    Flag buildAndAdapt(AdaptInfo& adaptInfo, Flag toDo);
 
  protected:
    ProblemStatBase& problem_;
  };
 
 
 
  template <class Model>
  class StandardProblemIterationAdaptor
      : public StandardProblemIteration
  {
    template <class Self>
    static ProblemStatBase& asProblemStatBase(Self& self)
    {
      Model& model = static_cast<Model&>(self);
      return dynamic_cast<ProblemStatBase&>(model);
    }
 
  public:
    StandardProblemIterationAdaptor()
      : StandardProblemIteration(asProblemStatBase(*this))
    {}
 
    StandardProblemIterationAdaptor(StandardProblemIterationAdaptor const&)
      : StandardProblemIteration(asProblemStatBase(*this))
    {}
 
    StandardProblemIterationAdaptor(StandardProblemIterationAdaptor&&)
      : StandardProblemIteration(asProblemStatBase(*this))
    {}
  };
 
 
} // end namespace AMDiS