graph.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 <memory>
#include <string>
#include <optional>
#include <utility>
#include <vector>
#include <unordered_map>
 
#include "cerata/node.h"
#include "cerata/array.h"
#include "cerata/pool.h"
 
namespace cerata {
 
// Forward Decl.
class Component;
class Instance;
 
class Graph : public Named {
 public:
  enum ID {
    COMPONENT,  
    INSTANCE    
  };
 
  Graph(std::string name, ID id) : Named(std::move(name)), id_(id) {}
 
  ID id() const { return id_; }
  bool IsComponent() const { return id_ == COMPONENT; }
  bool IsInstance() const { return id_ == INSTANCE; }
  virtual Graph &Add(const std::shared_ptr<Object> &object);
  virtual Graph &Add(const std::vector<std::shared_ptr<Object>> &objects);
  virtual Graph &Remove(Object *obj);
 
  template<typename T>
  std::vector<T *> GetAll() const {
    std::vector<T *> result;
    for (const auto &o : objects_) {
      auto co = std::dynamic_pointer_cast<T>(o);
      if (co != nullptr) {
        result.push_back(co.get());
      }
    }
    return result;
  }
 
  template<typename T>
  T *Get(const std::string &name) const {
    for (const auto &o : objects_) {
      if (o->name() == name) {
        auto result = dynamic_cast<T *>(o.get());
        if (result == nullptr) {
          CERATA_LOG(FATAL, "Object with name " + name + " is not of type " + ::cerata::ToString<T>());
        }
        return result;
      }
    }
    CERATA_LOG(FATAL, "Object with name " + name + " does not exist on graph " + this->name()
        + "\n Should be one of the following: " + ToStringAllOjects());
  }
 
  std::optional<Node *> FindNode(const std::string &node_name) const;
  Node *GetNode(const std::string &node_name) const;
  inline Node *operator()(const std::string &node_name) const { return GetNode(node_name); }
 
  std::vector<Node *> GetNodesOfTypes(std::initializer_list<Node::NodeID> ids) const;
  size_t CountNodes(Node::NodeID id) const;
  size_t CountArrays(Node::NodeID id) const;
  std::vector<Node *> GetNodes() const { return GetAll<Node>(); }
  std::vector<Node *> GetNodesOfType(Node::NodeID id) const;
  std::vector<NodeArray *> GetArraysOfType(Node::NodeID id) const;
  std::vector<Node *> GetImplicitNodes() const;
 
  PortArray *prt_arr(const std::string &name) const;
  SignalArray *sig_arr(const std::string &name) const;
  Port *prt(const std::string &name) const;
  Signal *sig(const std::string &name) const;
  Parameter *par(const std::string &name) const;
 
  Parameter *par(const Parameter &param) const;
  Parameter *par(const std::shared_ptr<Parameter> &param) const;
 
  std::unordered_map<std::string, std::string> meta() const { return meta_; }
  std::vector<Object *> objects() const { return ToRawPointers(objects_); }
  bool Has(const std::string &name);
 
  Graph &SetMeta(const std::string &key, std::string value);
 
  std::string ToString() const { return name(); }
 
  std::string ToStringAllOjects() const;
 
 protected:
  ID id_;
  std::vector<std::shared_ptr<Object>> objects_;
  std::unordered_map<std::string, std::string> meta_;
};
 
class Component : public Graph {
 public:
  explicit Component(std::string name) : Graph(std::move(name), COMPONENT) {}
 
  Graph &Add(const std::shared_ptr<Object> &object) override;
  Graph &Add(const std::vector<std::shared_ptr<Object>> &objects) override;
  Graph &Remove(Object *object) override;
 
  Instance *Instantiate(Component *comp, const std::string &name = "");
 
  Instance *Instantiate(const std::shared_ptr<Component> &comp, const std::string &name = "");
 
  std::vector<Instance *> children() const { return ToRawPointers(children_); }
 
  virtual std::vector<const Component *> GetAllInstanceComponents() const;
 
  bool HasChild(const std::string &name) const;
  bool HasChild(const Instance &inst) const;
 
  NodeMap *inst_to_comp_map() { return &inst_to_comp; }
 
 protected:
  Component &AddChild(std::unique_ptr<Instance> child);
 
  std::vector<std::unique_ptr<Instance>> children_;
 
  bool was_instantiated = false;
 
  NodeMap inst_to_comp;
};
 
std::shared_ptr<Component> component(std::string name,
                                     const std::vector<std::shared_ptr<Object>> &nodes,
                                     ComponentPool *component_pool = default_component_pool());
std::shared_ptr<Component> component(std::string name,
                                     ComponentPool *component_pool = default_component_pool());
 
class Instance : public Graph {
 public:
  Graph &Add(const std::shared_ptr<Object> &obj) override;
  Component *component() const { return component_; }
  Graph *parent() const { return parent_; }
  Graph &SetParent(Graph *parent);
  NodeMap *comp_to_inst_map() { return &comp_to_inst; }
 
 protected:
  friend Component;
  explicit Instance(Component *comp, std::string name, Component* parent);
  static std::unique_ptr<Instance> Make(Component *component, const std::string &name, Component* parent);
  Component *component_;
  Graph *parent_;
  NodeMap comp_to_inst;
};
 
}  // namespace cerata