node.h

// Copyright 2018-2019 Delft University of Technology
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <utility>
#include <optional>
#include <string>
#include <memory>
#include <vector>
#include <unordered_map>
 
#include "cerata/object.h"
#include "cerata/type.h"
#include "cerata/domain.h"
 
namespace cerata {
 
// Forward declarations.
class Edge;
class Graph;
class Port;
class Literal;
class Signal;
class Parameter;
class Expression;
 
class Node : public Object, public std::enable_shared_from_this<Node> {
 public:
  enum class NodeID {
    PORT,            
    SIGNAL,          
    PARAMETER,       
    LITERAL,         
    EXPRESSION,      
  };
 
  Node(std::string name, NodeID id, std::shared_ptr<Type> type);
 
  inline Type *type() const { return type_.get(); }
  Node *SetType(const std::shared_ptr<Type> &type);
 
  inline NodeID node_id() const { return node_id_; }
  inline bool Is(NodeID node_id) const { return node_id_ == node_id; }
 
#ifndef NODE_CAST_DECL_FACTORY
#define NODE_CAST_DECL_FACTORY(NODE_TYPE, NODE_ID)                            \
  inline bool Is##NODE_TYPE() const { return node_id_ == (NodeID::NODE_ID); } \
  NODE_TYPE* As##NODE_TYPE();                                                 \
  const NODE_TYPE* As##NODE_TYPE() const;
#endif
  NODE_CAST_DECL_FACTORY(Port, PORT)
  NODE_CAST_DECL_FACTORY(Signal, SIGNAL)
  NODE_CAST_DECL_FACTORY(Literal, LITERAL)
  NODE_CAST_DECL_FACTORY(Parameter, PARAMETER)
  NODE_CAST_DECL_FACTORY(Expression, EXPRESSION)
 
  
  virtual bool AddEdge(const std::shared_ptr<Edge> &edge) = 0;
  virtual bool RemoveEdge(Edge *edge) = 0;
  virtual std::vector<Edge *> edges() const;
  virtual std::vector<Edge *> sources() const { return {}; }
  virtual std::vector<Edge *> sinks() const { return {}; }
 
  void SetArray(NodeArray *array) { array_ = array; }
  std::optional<NodeArray *> array() const { return array_; }
 
  Node *Replace(Node *replacement);
 
  virtual Node *CopyOnto(Graph *dst, const std::string &name, NodeMap *rebinding) const;
 
  void AppendReferences(std::vector<Object *> *out) const override;
 
  virtual std::string ToString() const;
 
 protected:
  NodeID node_id_;
  std::shared_ptr<Type> type_;
  std::optional<NodeArray *> array_ = {};
};
 
std::string ToString(Node::NodeID id);
 
typedef std::unordered_map<const Node *, Node *> NodeMap;
 
struct MultiOutputNode : public Node {
  std::vector<std::shared_ptr<Edge>> outputs_;
 
  MultiOutputNode(std::string name, Node::NodeID id, std::shared_ptr<Type> type)
      : Node(std::move(name), id, std::move(type)) {}
 
  std::vector<Edge *> sources() const override { return {}; }
  std::vector<Edge *> sinks() const override { return ToRawPointers(outputs_); }
 
  bool RemoveEdge(Edge *edge) override;
  bool AddEdge(const std::shared_ptr<Edge> &edge) override;
 
  inline std::shared_ptr<Edge> output(size_t i) const { return outputs_[i]; }
  inline size_t num_outputs() const { return outputs_.size(); }
};
 
struct NormalNode : public MultiOutputNode {
  std::shared_ptr<Edge> input_;
 
  NormalNode(std::string name, Node::NodeID id, std::shared_ptr<Type> type)
      : MultiOutputNode(std::move(name), id, std::move(type)) {}
 
  std::vector<Edge *> sources() const override;
 
  std::optional<Edge *> input() const;
 
  bool AddEdge(const std::shared_ptr<Edge> &edge) override;
 
  bool RemoveEdge(Edge *edge) override;
};
 
void GetObjectReferences(const Object &obj, std::vector<Object *> *out);
 
void ImplicitlyRebindNodes(Graph *dst, const std::vector<Node *> &nodes, NodeMap *rebinding);
 
}  // namespace cerata