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