instance.hpp

#ifndef INSTANCE_HPP
#define INSTANCE_HPP
 
#include "job.hpp"    // for Job
#include "traits.hpp" // for Traits
 
#include <cstddef>  // for ptrdiff_t, size_t
#include <iterator> // for input_iterator_tag
#include <memory>   // IWYU pragma: keep
#include <string>   // for string
#include <vector>   // for vector
class LagGraph;
class Resource;
class ResVec;
 
class Instance {
public:
  class JobContainer {
  public:
    JobContainer(const Instance * instance);
 
    class iterator {
    public:
      typedef std::input_iterator_tag iterator_category;
      typedef Job value_type;
      typedef Job * pointer;
      typedef Job & reference;
      typedef size_t size_type;
      typedef std::ptrdiff_t difference_type;
 
      iterator(const JobContainer & c);
      iterator(const JobContainer & c, unsigned int pos);
 
      const value_type & operator*();
      const value_type * operator->();
 
      iterator operator++(int);
      iterator & operator++();
      iterator operator--(int);
      iterator & operator--();
 
      bool operator==(const iterator & other) const;
      bool operator!=(const iterator & other) const;
 
    private:
      const JobContainer & c;
      unsigned int i;
    };
 
    iterator begin() const;
    iterator end() const;
 
    bool operator==(const JobContainer & other) const;
 
  private:
    const Instance * instance;
  };
 
  // copy & move assignment / construction need to *not* copy the cached
  // container
  void swap(Instance & other);
  Instance & operator=(Instance other);
  Instance(const Instance & other);
  Instance(Instance && other);
 
  Instance();
 
  Instance(const std::string instance_id, Traits wanted_traits);
 
  // copy-and-substitute
  Instance(const Instance & origin, std::vector<bool> && job_is_substituted,
           std::vector<Job> && substitutions);
 
  ~Instance();
 
  LagGraph & get_laggraph();
 
  const LagGraph & get_laggraph() const;
 
  unsigned int add_job(Job && job);
 
  unsigned int add_resource(Resource && resource);
 
  unsigned int job_count() const;
 
  const Job & get_job(unsigned int i) const;
 
  const JobContainer & get_jobs() const;
 
  unsigned int resource_count() const;
 
  const Resource & get_resource(unsigned int i) const;
 
  const Traits & get_traits() const;
 
  void compute_traits();
 
  const std::string & get_id() const;
 
  Instance clone() const;
 
  bool check_feasibility() const;
 
  void set_window_extension(unsigned int window_extension_limit,
                            unsigned int window_extension_job_limit);
  void set_window_extension_hard_deadline(Maybe<unsigned int> deadline);
  
  unsigned int get_window_extension_limit() const;
  unsigned int get_window_extension_job_limit() const;
  Maybe<unsigned int> get_window_extension_hard_deadline() const;
 
  double
  calculate_max_costs(const std::vector<unsigned int> & start_times) const;
 
  double calculate_costs(const ResVec & ressource_usage,
                         const ResVec & additional_usage) const;
 
  double calculate_costs(const ResVec & ressource_usage) const;
 
  unsigned int get_latest_deadline() const;
 
private:
  // These things are shared across substituted instances
  std::shared_ptr<std::vector<Resource>> resources;
  std::shared_ptr<std::vector<Job>> jobs;
  std::shared_ptr<std::string> instance_id;
  std::shared_ptr<LagGraph> laggraph;
 
  std::vector<bool> job_is_substituted;
  std::vector<Job> substitutions;
  JobContainer cached_container;
 
  unsigned int window_extension_limit;
  unsigned int window_extension_job_limit;
  Maybe<unsigned int> window_extension_hard_deadline;
 
  Traits wanted_traits;
  Traits computed_traits;
};
 
#endif