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 const void *get_value_ref_void() const = 0;
  virtual void       *get_value_ref_void() = 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()
  {
    auto locked = this->data.lock();
    return locked ? locked->get_value_ref() : nullptr;
  }
 
  const T *get_value_ref() const
  {
    auto locked = this->data.lock();
    return locked ? locked->get_value_ref() : nullptr;
  } 
 
  void *get_value_ref_void() override
  {
    auto locked = this->data.lock();
    return locked ? static_cast<void *>(locked->get_value_ref()) : nullptr;
  }
 
  const void *get_value_ref_void() const override
  {
    auto locked = this->data.lock();
    return locked ? static_cast<const void *>(locked->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; }
 
  const T *get_value_ref() const { return this->data->get_value_ref(); }
  T *get_value_ref() { return this->data->get_value_ref(); } 
 
  const void *get_value_ref_void() const override
  {
    return static_cast<void *>(this->data->get_value_ref());
  }
 
  void *get_value_ref_void() override
  {
    return static_cast<void *>(this->data->get_value_ref());
  } 
 
private:
  std::shared_ptr<Data<T>>
      data; 
};
 
} // namespace gnode