Observer.h

/* Copyright (c) Queen's Printer for Ontario, 2020. */
/* Copyright (c) His Majesty the King in Right of Canada as represented by the Minister of Natural Resources, 2025. */
 
/* SPDX-License-Identifier: AGPL-3.0-or-later */
 
#pragma once
#include <memory>
#include <string>
#include "Event.h"
#include "GridMap.h"
#include "Scenario.h"
namespace fs::sim
{
class Event;
class Scenario;
class IObserver
{
public:
  virtual ~IObserver() = default;
  IObserver(const IObserver& rhs) = delete;
  IObserver(IObserver&& rhs) = delete;
  IObserver& operator=(const IObserver& rhs) = delete;
  IObserver& operator=(IObserver&& rhs) = delete;
  virtual void handleEvent(const Event& event) = 0;
  virtual void save(const string& dir, const string& base_name) const = 0;
  virtual void reset() = 0;
  static string makeName(const string& base_name, const string& suffix);
protected:
  IObserver() = default;
};
template <typename T>
class MapObserver
  : public IObserver
{
public:
  ~MapObserver() override = default;
  MapObserver(const MapObserver& rhs) = delete;
  MapObserver(MapObserver&& rhs) = delete;
  MapObserver& operator=(const MapObserver& rhs) = delete;
  MapObserver& operator=(MapObserver&& rhs) = delete;
  MapObserver(const Scenario& scenario, T nodata, string suffix)
    : map_(scenario.model().environment().makeMap<T>(nodata)),
      scenario_(scenario),
      suffix_(std::move(suffix))
  {
  }
  [[nodiscard]] virtual T getValue(const Event& event) const = 0;
  void handleEvent(const Event& event) override
  {
    map_->set(event.cell(), getValue(event));
  }
  void save(const string& dir, const string& base_name) const override
  {
    map_->saveToFile(dir, makeName(base_name, suffix_));
  }
  void reset() noexcept override
  {
    map_->clear();
  }
protected:
  unique_ptr<data::GridMap<T>> map_;
  const Scenario& scenario_;
  string suffix_;
};
class ArrivalObserver final
  : public MapObserver<DurationSize>
{
public:
  ~ArrivalObserver() override = default;
  ArrivalObserver(const ArrivalObserver& rhs) = delete;
  ArrivalObserver(ArrivalObserver&& rhs) = delete;
  ArrivalObserver& operator=(const ArrivalObserver& rhs) = delete;
  ArrivalObserver& operator=(ArrivalObserver&& rhs) = delete;
  explicit ArrivalObserver(const Scenario& scenario);
  [[nodiscard]] DurationSize getValue(const Event& event) const noexcept override;
};
class SourceObserver final
  : public MapObserver<CellIndex>
{
public:
  ~SourceObserver() override = default;
  SourceObserver(const SourceObserver& rhs) = delete;
  SourceObserver(SourceObserver&& rhs) = delete;
  SourceObserver& operator=(const SourceObserver& rhs) = delete;
  SourceObserver& operator=(SourceObserver&& rhs) = delete;
  explicit SourceObserver(const Scenario& scenario);
  [[nodiscard]] CellIndex getValue(const Event& event) const noexcept override;
};
class IntensityObserver final
  : public MapObserver<IntensitySize>
{
public:
  ~IntensityObserver() override = default;
  IntensityObserver(const IntensityObserver& rhs) = delete;
  IntensityObserver(IntensityObserver&& rhs) = delete;
  IntensityObserver& operator=(const IntensityObserver& rhs) = delete;
  IntensityObserver& operator=(IntensityObserver&& rhs) = delete;
  explicit IntensityObserver(const Scenario& scenario) noexcept;
  [[nodiscard]] IntensitySize getValue(const Event& event) const noexcept override;
  void save(const string& dir, const string& base_name) const override;
};
}