graph.h

Go to the documentation of this file.

// 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 <ostream>
#include <filesystem>
 
#include "../../behavior/node.h"
#include "../../behavior/copyable.h"
#include "../../behavior/input_output/multi_senders.h"
#include "../../behavior/input_output/multi_receivers.h"
 
#include "../../core/nodes/core_graph.h"
#include "../printer/options/color_scheme.h"
#include "../printer/options/structure_options.h"
#include "../printer/options/debug_options.h"
#include "../printer/dot_printer.h"
#include "../printer/jet_color.h"
#include "result_visitor.h"
 
namespace hh {
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template<size_t Separator, class ...AllTypes>
class AbstractExecutionPipeline;
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
template<size_t Separator, class ...AllTypes>
class Graph :
    public behavior::Node,
    public tool::BehaviorMultiReceiversTypeDeducer_t<tool::Inputs<Separator, AllTypes...>>,
    public tool::BehaviorMultiSendersTypeDeducer_t<tool::Outputs<Separator, AllTypes...>> {
 private:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
  friend core::CoreExecutionPipeline<Separator, AllTypes...>;
  friend AbstractExecutionPipeline<Separator, AllTypes...>;
#endif //DOXYGEN_SHOULD_SKIP_THIS
 
  std::shared_ptr<core::CoreGraph<Separator, AllTypes...>> const
      coreGraph_ = nullptr; 
  std::unique_ptr<std::set<std::shared_ptr<Node>>>
      nodes_ = nullptr; 
 
 public:
  explicit Graph(
      std::string const &name = "Graph",
      std::unique_ptr<Scheduler> scheduler = std::make_unique<DefaultScheduler>()) :
      behavior::Node(std::make_unique<core::CoreGraph<Separator, AllTypes...>>(name, std::move(scheduler), this)),
      coreGraph_(std::dynamic_pointer_cast<core::CoreGraph<Separator, AllTypes...>>(this->core())),
      nodes_(std::make_unique<std::set<std::shared_ptr<Node>>>()) {
    if (coreGraph_ == nullptr) { throw std::runtime_error("The core used by the graph should be a CoreGraph."); }
  }
 
  ~Graph() override = default;
 
  template<tool::CompatibleInputNode<typename core::GIM<Separator, AllTypes...>::inputs_t> InputNode_t>
  void inputs(std::shared_ptr<InputNode_t> inputNode) {
    auto node = std::static_pointer_cast<Node>(inputNode);
    // Store shared_ptr in case user dereference it while it is still needed
    nodes_->insert(node);
    this->coreGraph_->template setInputForAllCommonTypes<typename InputNode_t::inputs_t>(node->core().get());
  }
 
  template<
      class InputDataType,
      tool::CompatibleInputNodeForAType<InputDataType,
                                        typename core::GIM<Separator, AllTypes...>::inputs_t> InputNode_t>
  void input(std::shared_ptr<InputNode_t> inputNode) {
    auto node = std::static_pointer_cast<Node>(inputNode);
    // Store shared_ptr in case user dereference it while it is still needed
    nodes_->insert(node);
    this->coreGraph_->template setInputForACommonType<InputDataType,
                                                      typename InputNode_t::inputs_t>(node->core().get());
  }
 
  template<tool::CompatibleOutputNode<typename core::GOM<Separator, AllTypes...>::outputs_t> OutputNode_t>
  void outputs(std::shared_ptr<OutputNode_t> outputNode) {
    auto node = std::static_pointer_cast<Node>(outputNode);
    // Store shared_ptr in case user dereference it while it is still needed
    nodes_->insert(node);
 
    this->coreGraph_->template setOutputForAllCommonTypes<typename OutputNode_t::outputs_t>(node->core().get());
  }
 
  template<class OutputType,
      tool::CompatibleOutputNodeForAType<OutputType,
                                         typename core::GOM<Separator, AllTypes...>::outputs_t> OutputNode_t>
  void output(std::shared_ptr<OutputNode_t> outputNode) {
    auto node = std::static_pointer_cast<Node>(outputNode);
    // Store shared_ptr in case user dereference it while it is still needed
    nodes_->insert(node);
    this->coreGraph_->template setOutputForACommonType<OutputType,
                                                       typename OutputNode_t::outputs_t>(node->core().get());
  }
 
  template<tool::SenderNode SenderNode_t, tool::ReceiverNode ReceiverNode_t>
  void edges(std::shared_ptr<SenderNode_t> sender, std::shared_ptr<ReceiverNode_t> receiver) {
    static_assert(
        std::tuple_size_v<
            tool::Intersect_t<typename SenderNode_t::outputs_t, typename ReceiverNode_t::inputs_t>
        > != 0, "The sender and the receiver nodes should at least share a type."
    );
    auto senderNode = std::static_pointer_cast<Node>(sender);
    auto receiverNode = std::static_pointer_cast<Node>(receiver);
    // Store shared_ptr in case user dereference it while it is still needed
    nodes_->insert(senderNode);
    nodes_->insert(receiverNode);
 
    this->coreGraph_
        ->template addEdgeForAllCommonTypes<typename SenderNode_t::outputs_t, typename ReceiverNode_t::inputs_t>
            (senderNode->core().get(), receiverNode->core().get());
  }
 
  template<class CommonType,
      tool::SenderNodeForAType<CommonType> SenderNode_t, tool::ReceiverNodeForAType<CommonType> ReceiverNode_t>
  void edge(std::shared_ptr<SenderNode_t> sender, std::shared_ptr<ReceiverNode_t> receiver) {
    auto senderNode = std::static_pointer_cast<Node>(sender);
    auto receiverNode = std::static_pointer_cast<Node>(receiver);
    // Store shared_ptr in case user dereference it while it is still needed
    nodes_->insert(senderNode);
    nodes_->insert(receiverNode);
 
    this->coreGraph_->template addEdgeForACommonType<
        CommonType,
        typename SenderNode_t::outputs_t, typename ReceiverNode_t::inputs_t>
        (senderNode->core().get(), receiverNode->core().get());
  }
 
  void executeGraph(bool waitForInitialization = false) { coreGraph_->executeGraph(waitForInitialization); }
 
  void finishPushingData() { coreGraph_->finishPushingData(); }
 
  template<tool::MatchInputTypeConcept<tool::Inputs<Separator, AllTypes...>> CompatibleInputType_t>
  void pushData(std::shared_ptr<CompatibleInputType_t> data) { this->coreGraph_->broadcastAndNotifyAllInputNodes(data); }
 
  void waitForTermination() { coreGraph_->waitForTermination(); }
 
  auto getBlockingResult() { return coreGraph_->getBlockingResult(); }
 
  void createDotFile(std::filesystem::path const &dotFilePath,
                     ColorScheme colorScheme = ColorScheme::NONE,
                     StructureOptions structureOptions = StructureOptions::NONE,
                     DebugOptions debugOption = DebugOptions::NONE,
                     std::unique_ptr<ColorPicker> colorPicker = std::make_unique<JetColor>(),
                     bool verbose = false) {
    core::abstraction::GraphNodeAbstraction *core = this->coreGraph_.get();
    DotPrinter
        printer(
        std::filesystem::absolute(dotFilePath), colorScheme, structureOptions, debugOption, core,
        std::move(colorPicker), verbose);
    core->visit(&printer);
  }
 
  void deviceId(int deviceId) { this->coreGraph_->deviceId(deviceId); }
 
  void cleanGraph() {
    this->coreGraph_->cleanGraph();
  }
};
}
#endif //HEDGEHOG_GRAPH_H