solution.hpp

#ifndef SOLUTION_HPP
#define SOLUTION_HPP
 
#include "../datastructures/maybe.hpp" // for Maybe
#include "../util/log.hpp"             // for Log
 
#include <vector> // for vector
class InconsistentResultError;
class Instance;
 
class Solution {
public:
  // TODO FIXME is this still "optimal?"
 
  Solution(const Instance & instance, bool optimal,
           std::vector<Maybe<unsigned int>> & start_times,
           Maybe<double> lower_bound);
 
  Solution(const Instance & instance, bool optimal,
           std::vector<Maybe<unsigned int>> && start_times,
           Maybe<double> lower_bound);
 
  Solution(const Instance & instance, bool optimal,
           std::vector<unsigned int> & start_times, Maybe<double> lower_bound);
 
  explicit Solution(const Instance & instance);
 
  // TODO this only here so Solution can be wrapped in a Maybe.
  Solution();
 
  // Copying & moving
  Solution(const Solution & other);
  Solution(Solution && other);
  Solution & operator=(const Solution & other);
  Solution & operator=(Solution && other);
 
  void print() const;
 
  void print_jobs() const;
 
  void print_profile() const;
 
  double get_costs() const;
  double get_overshoot_costs() const;
  double get_investment_costs() const;
 
  double get_costs_lower_bound() const;
 
  const Instance * get_instance() const;
 
  unsigned int get_start_time(unsigned int job_id) const;
 
  bool job_scheduled(unsigned int job_id) const;
 
  bool is_feasible() const;
 
  bool is_optimal() const;
 
  double get_max_usage(unsigned int rid) const;
 
  Maybe<double> get_lower_bound() const;
 
  bool verify(int seed, InconsistentResultError * error_out = nullptr) const;
 
private:
  const Instance * instance;
  bool optimal;
  std::vector<Maybe<unsigned int>> start_times;
  Maybe<double> lower_bound;
 
  void compute_durations() const;
  mutable std::vector<unsigned int> durations;
 
  void compute_costs() const;
  mutable Maybe<double> costs;
  mutable Maybe<double> overshoot_costs;
  mutable Maybe<double> investment_costs;
 
  // TODO this is ugly
  mutable std::vector<double> max_usage;
 
  Log l;
};
 
#endif