terminal.h

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-3-Clause
#ifndef TTG_BASE_TERMINAL_H
#define TTG_BASE_TERMINAL_H
 
#include <string>
#include <vector>
#include "ttg/fwd.h"
 
namespace ttg {
 
  class TerminalBase {
   public:
    static constexpr bool is_a_terminal = true;
    bool is_pull_terminal = false; //< Default is push terminal
 
    enum class Type {
      Write,   
      Read,    
      Consume  
    };
 
   private:
    TTBase *tt;              //< Pointer to containing operation
    size_t n = 0;            //< Index of terminal
    std::string name = "";   //< Name of terminal
    bool connected = false;  //< True if is connected
    Type type;
    std::string key_type_str;    //< String describing key type
    std::string value_type_str;  //< String describing value type
 
    std::vector<TerminalBase *> successors_;
    std::vector<TerminalBase *> predecessors_; //This is required for pull terminals.
 
    TerminalBase(const TerminalBase &) = delete;
    TerminalBase(TerminalBase &&) = delete;
 
    friend class TTBase;
    template <typename keyT, typename valueT>
    friend class In;
    template <typename keyT, typename valueT>
    friend class Out;
 
   protected:
    TerminalBase(Type type) : type(type) {}
 
    void set(TTBase *tt, size_t index, const std::string &name, const std::string &key_type_str,
             const std::string &value_type_str, Type type) {
      this->tt = tt;
      this->n = index;
      this->name = name;
      this->key_type_str = key_type_str;
      this->value_type_str = value_type_str;
      this->type = type;
    }
 
    void connect_base(TerminalBase *successor) {
      successors_.push_back(successor);
      connected = true;
      successor->connected = true;
    }
 
    void connect_pull(TerminalBase *predecessor) {
      predecessors_.push_back(predecessor);
      predecessor->connected = true;
      connected = true;
    }
 
  public:
    TTBase *get_tt() const {
      if (!tt) throw "ttg::TerminalBase:get_tt() but tt is null";
      return tt;
    }
 
    size_t get_index() const {
      if (!tt) throw "ttg::TerminalBase:get_index() but tt is null";
      return n;
    }
 
    const std::string &get_name() const {
      if (!tt) throw "ttg::TerminalBase:get_name() but tt is null";
      return name;
    }
 
    const std::string &get_key_type_str() const {
      if (!tt) throw "ttg::TerminalBase:get_key_type_str() but tt is null";
      return key_type_str;
    }
 
    const std::string &get_value_type_str() const {
      if (!tt) throw "ttg::TerminalBase:get_value_type_str() but tt is null";
      return value_type_str;
    }
 
    Type get_type() const { return this->type; }
 
    const std::vector<TerminalBase *> &get_connections() const { return successors_; }
    // Get connections to predecessors
    const std::vector<TerminalBase *> &get_predecessors() const {return predecessors_; }
 
    //Connect Container pull terminals without incoming terminals
    //This is a hack, is there a better way?
    void connect_pull_nopred(TerminalBase *p) {
      p->connected = true;
    }
 
    bool is_connected() const { return connected; }
 
    virtual void connect(TerminalBase *in) = 0;
 
    virtual ~TerminalBase() = default;
  };
 
  namespace meta {
    template <typename T, typename = void>
    inline constexpr bool is_terminal_v = false;
    template <typename T>
    inline constexpr bool is_terminal_v<T, std::is_base_of<TerminalBase, T>> = true;
    template <typename T>
    struct is_terminal : std::bool_constant<is_terminal_v<T>> {};
  }  // namespace meta
}  // namespace ttg
 
#endif  // TTG_BASE_TERMINAL_H