graph.h

// NIST-developed software is provided by NIST as a public service. You may use, copy and distribute copies of the
// software in any medium, provided that you keep intact this entire notice. You may improve, modify and create
// derivative works of the software or any portion of the software, and you may copy and distribute such modifications
// or works. Modified works should carry a notice stating that you changed the software and should note the date and
// nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the
// source of the software. NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND,
// EXPRESS, IMPLIED, IN FACT OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR
// WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE
// CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS
// THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE. You
// are solely responsible for determining the appropriateness of using and distributing the software and you assume
// all risks associated with its use, including but not limited to the risks and costs of program errors, compliance
// with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of 
// operation. This software is not intended to be used in any situation where a failure could cause risk of injury or
// damage to property. The software developed by NIST employees is not subject to copyright protection within the
// United States.


#ifndef HEDGEHOG_GRAPH_H
#define HEDGEHOG_GRAPH_H

#include <cassert>
#include <ostream>

#include "scheduler/abstract_scheduler.h"
#include "printer/dot_printer.h"
#include "../core/node/core_graph.h"
#include "../tools/helper.h"
#include "../tools/traits.h"
#include "../tools/logger.h"
#include "../behavior/io/multi_receivers.h"
#include "../behavior/io/sender.h"

namespace hh {

template<class GraphOutput, class ...GraphInputs>
class Graph :
    public behavior::MultiReceivers<GraphInputs...>,
    public behavior::Sender<GraphOutput>,
    public virtual behavior::Node {
  static_assert(traits::isUnique<GraphInputs...>, "A Graph can't accept multiple inputs with the same type.");
  static_assert(sizeof... (GraphInputs) >= 1, "A node need to have one output type and at least one output type.");
 private:
  std::shared_ptr<core::CoreGraph<GraphOutput, GraphInputs...>> graphCore_ = nullptr; 
  std::set<std::shared_ptr<Node>> insideNodes_ = {};      

 public:
  Graph() {
    graphCore_ = std::make_shared<core::CoreGraph<GraphOutput, GraphInputs...>>(this, core::NodeType::Graph, "Graph");
  }

  explicit Graph(std::string_view const &name) {
    graphCore_ = std::make_shared<core::CoreGraph<GraphOutput, GraphInputs...>>(this, core::NodeType::Graph, name);
  }

  explicit Graph(std::string_view const &name, std::unique_ptr<AbstractScheduler> scheduler) {
    if (!scheduler) {
      std::ostringstream oss;
      oss << "Internal error, the graph's scheduler is null, please instantiate an AbstractScheduler.";
      HLOG_SELF(0, oss.str())
      throw (std::runtime_error(oss.str()));
    }
    graphCore_ =
        std::make_shared<core::CoreGraph<GraphOutput, GraphInputs...>>(
            this, core::NodeType::Graph, name, std::move(scheduler));
  }

  virtual ~Graph() = default;

  std::shared_ptr<core::CoreNode> core() final { return this->graphCore_; }

  std::string_view const &name() { return this->core()->name(); }

  void deviceId(int deviceId) { this->graphCore_->deviceId(deviceId); }

  template<
      class UserDefinedMultiReceiver,
      class InputsMR = typename UserDefinedMultiReceiver::inputs_t,
      class InputsG = typename behavior::MultiReceivers<GraphInputs...>::inputs_t,
      class isMultiReceiver = typename std::enable_if_t<
          std::is_base_of_v<typename helper::HelperMultiReceiversType<InputsMR>::type, UserDefinedMultiReceiver>
      >,
      class isInputCompatible = typename std::enable_if_t<traits::is_included_v<InputsMR, InputsG>>>
  void input(std::shared_ptr<UserDefinedMultiReceiver> input) {
    assert(input != nullptr);
    this->insideNodes_.insert(input);
    auto test = std::dynamic_pointer_cast<typename helper::HelperMultiReceiversType<InputsMR>::type>(input);
    if (test == nullptr) { std::cout << "big problem " << input << std::endl; }
    this->graphCore_->input(test);
  }

  template<
      class UserDefinedSender,
      class IsSender = typename std::enable_if_t<
          std::is_base_of_v<
              behavior::Sender<GraphOutput>, UserDefinedSender
          >
      >
  >
  void output(std::shared_ptr<UserDefinedSender> output) {
    assert(output != nullptr);
    this->insideNodes_.insert(output);
    this->graphCore_->output(std::static_pointer_cast<behavior::Sender<GraphOutput>>(output));
  }

  template<
      class UserDefinedSender, class UserDefinedMultiReceiver,
      class Output = typename UserDefinedSender::output_t,
      class Inputs = typename UserDefinedMultiReceiver::inputs_t,
      class IsSender = typename std::enable_if_t<std::is_base_of_v<behavior::Sender<Output>, UserDefinedSender>>,
      class IsMultiReceivers = typename std::enable_if_t<
          std::is_base_of_v<
              typename helper::HelperMultiReceiversType<Inputs>::type, UserDefinedMultiReceiver
          >
      >
  >
  void addEdge(std::shared_ptr<UserDefinedSender> from, std::shared_ptr<UserDefinedMultiReceiver> to) {
    static_assert(traits::Contains_v<Output, Inputs>,
                  "The given io cannot be linked to this io: No common types.");
    this->insideNodes_.insert(from);
    this->insideNodes_.insert(to);
    this->graphCore_->addEdge(std::static_pointer_cast<behavior::Sender<Output>>(from),
                              std::static_pointer_cast<typename helper::HelperMultiReceiversType<Inputs>::type>(to));
  }

  void executeGraph() { this->graphCore_->executeGraph(); }

  template<
      class Input,
      class = typename std::enable_if_t<traits::Contains<Input, GraphInputs...>::value>
  >
  void pushData(std::shared_ptr<Input> data) { this->graphCore_->broadcastAndNotifyToAllInputs(data); }

  void finishPushingData() { this->graphCore_->finishPushingData(); }

  std::shared_ptr<GraphOutput> getBlockingResult() { return this->graphCore_->getBlockingResult(); }

  void waitForTermination() { this->graphCore_->waitForTermination(); }

  void createDotFile(std::filesystem::path const &dotFilePath,
                     ColorScheme colorScheme = ColorScheme::NONE,
                     StructureOptions structureOptions = StructureOptions::NONE,
                     DebugOptions debugOption = DebugOptions::NONE) {
    auto core = this->core().get();
    DotPrinter printer(std::filesystem::absolute(dotFilePath), colorScheme, structureOptions, debugOption, core);
    core->visit(&printer);
  }
};

}
#endif //HEDGEHOG_GRAPH_H