port.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
 * Public License. The full license is in the file LICENSE, distributed with
 * this software. */
 
#pragma once
#include "gnode/data.hpp"
#include "gnode/logger.hpp"
#include <memory>
#include <string>
#include <typeinfo>
 
namespace gnode
{
 
enum PortType
{
  IN, 
  OUT 
};
 
class Port
{
public:
  Port() = default;
 
  Port(std::string label) : label(label) {}
 
  virtual ~Port() = default;
 
  std::string get_data_type() const { return this->data_type; }
 
  std::string get_label() const { return this->label; }
 
  virtual std::shared_ptr<BaseData> get_data_shared_ptr_downcasted() const
  {
    return nullptr;
  }
 
  virtual PortType get_port_type() const = 0;
 
  virtual void *get_value_ref_void() const = 0;
 
  virtual void set_data(std::shared_ptr<BaseData> /* data */) {}
 
protected:
  std::string data_type; 
 
private:
  std::string label = "no label"; 
};
 
template <typename T> class Input : public Port
{
public:
  Input() = default;
 
  Input(std::string label) : Port(label) { this->data_type = typeid(T).name(); }
 
  virtual ~Input() = default;
 
  PortType get_port_type() const override { return PortType::IN; }
 
  T *get_value_ref() const
  {
    return this->data.lock() ? this->data.lock()->get_value_ref() : nullptr;
  }
 
  void *get_value_ref_void() const override
  {
    return this->data.lock() ? (void *)this->data.lock()->get_value_ref()
                             : nullptr;
  }
 
  void set_data(std::shared_ptr<BaseData> data) override
  {
    this->data = std::dynamic_pointer_cast<Data<T>>(std::move(data));
  }
 
private:
  std::weak_ptr<Data<T>>
      data; 
};
 
template <typename T> class Output : public Port
{
public:
  Output() : data(std::make_shared<Data<T>>())
  {
    this->data_type = typeid(T).name();
  }
 
  template <typename... Args>
  explicit Output(std::string label, Args &&...args)
      : Port(label),
        data(std::make_shared<Data<T>>(std::forward<Args>(args)...))
  {
    this->data_type = typeid(T).name();
  }
 
  virtual ~Output() = default;
 
  std::shared_ptr<BaseData> get_data_shared_ptr_downcasted() const override
  {
    return std::static_pointer_cast<BaseData>(this->data);
  }
 
  std::string get_data_type() const { return typeid(T).name(); }
 
  PortType get_port_type() const override { return PortType::OUT; }
 
  T *get_value_ref() const { return this->data->get_value_ref(); }
 
  void *get_value_ref_void() const override
  {
    return (void *)this->data->get_value_ref();
  }
 
private:
  std::shared_ptr<Data<T>>
      data; 
};
 
} // namespace gnode