array.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 "cerata/node.h"
#include "cerata/port.h"
#include "cerata/type.h"
#include "cerata/signal.h"
 
namespace cerata {
 
class NodeArray : public Object {
 public:
  Node::NodeID node_id() { return node_id_; }
 
  NodeArray(std::string name, Node::NodeID id, std::shared_ptr<Node> base, const std::shared_ptr<Node> &size);
 
  void SetParent(Graph *new_parent) override;
 
  inline Node *size() const { return size_.get(); }
 
  void SetSize(const std::shared_ptr<Node> &size);
  void SetType(const std::shared_ptr<Type> &type);
  Type *type() const { return base_->type(); }
 
  std::shared_ptr<Object> Copy() const override;
 
  NodeArray *CopyOnto(Graph *dst, const std::string &name, NodeMap *rebinding);
 
  std::shared_ptr<Node> Append(bool increment_size = true);
  std::vector<Node *> nodes() const { return ToRawPointers(nodes_); }
  Node *node(size_t i) const;
  Node *operator[](size_t i) const { return node(i); }
  size_t num_nodes() const { return nodes_.size(); }
  size_t IndexOf(const Node &n) const;
 
  std::string ToString() const { return name(); }
 
  std::shared_ptr<Node> base() const { return base_; }
 
  // @brief Append all objects referenced by this node array.
  void AppendReferences(std::vector<Object *> *out) const override {
    // This includes the size node and its references.
    out->push_back(size_.get());
    size_->AppendReferences(out);
    // And the references of the base node.
    base_->AppendReferences(out);
  }
 
 protected:
  Node::NodeID node_id_;
  void IncrementSize();
  std::shared_ptr<Node> base_;
  std::shared_ptr<Node> size_;
  std::vector<std::shared_ptr<Node>> nodes_;
};
 
class SignalArray : public NodeArray {
 public:
  SignalArray(const std::shared_ptr<Signal> &base, const std::shared_ptr<Node> &size)
      : NodeArray(base->name(), Node::NodeID::SIGNAL, base, size) {}
};
 
std::shared_ptr<SignalArray> signal_array(const std::string &name,
                                          const std::shared_ptr<Type> &type,
                                          const std::shared_ptr<Node>& size,
                                          const std::shared_ptr<ClockDomain> &domain = default_domain());
 
class PortArray : public NodeArray, public Term {
 public:
  PortArray(const std::shared_ptr<Port> &base, const std::shared_ptr<Node> &size);
  std::shared_ptr<Object> Copy() const override;
};
 
std::shared_ptr<PortArray> port_array(const std::string &name,
                                      const std::shared_ptr<Type> &type,
                                      const std::shared_ptr<Node> &size,
                                      Port::Dir dir = Port::Dir::IN,
                                      const std::shared_ptr<ClockDomain> &domain = default_domain());
 
std::shared_ptr<PortArray> port_array(const std::shared_ptr<Port> &base_node,
                                      const std::shared_ptr<Node> &size);
 
}  // namespace cerata