port.h

// SPDX-FileCopyrightText: © 2018-2026 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <functional>
#include <stdexcept>
#include <string_view>
 
#include "dsp/graph_node.h"
#include "dsp/port_connection.h"
#include "dsp/port_fwd.h"
#include "utils/typed_uuid_reference.h"
#include "utils/utf8_string.h"
#include "utils/uuid_identifiable_object.h"
 
#include <fmt/format.h>
 
using namespace std::string_view_literals;
 
namespace zrythm::dsp
{

class Port : public utils::UuidIdentifiableObject<Port>, public dsp::graph::IProcessable
{
  Q_OBJECT
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
  Q_DISABLE_COPY_MOVE (Port)
public:
  using FullDesignationProvider =
    std::function<utils::Utf8String (const Port &port)>;
 
  ~Port () override;
 
  void set_full_designation_provider (FullDesignationProvider provider)
  {
    full_designation_provider_ = std::move (provider);
  }

  void set_full_designation_provider (const auto * owner)
  {
    full_designation_provider_ = [owner] (const Port &port) {
      return owner->get_full_designation_for_port (port);
    };
  }
 
  bool is_input () const { return flow_ == PortFlow::Input; }
  bool is_output () const { return flow_ == PortFlow::Output; }
 
  bool is_midi () const { return type_ == PortType::Midi; }
  bool is_cv () const { return type_ == PortType::CV; }
  bool is_audio () const { return type_ == PortType::Audio; }
 
  utils::Utf8String get_label () const { return label_; }
 
  auto get_symbol () const { return sym_; }
  void set_symbol (const utils::Utf8String &sym) { sym_ = sym; }
 
  // ========================================================================
  // IProcessable Interface
  // ========================================================================
 
  utils::Utf8String get_node_name () const override
  {
    return get_full_designation ();
  }
 
  // ========================================================================

  virtual void clear_buffer (std::size_t offset, std::size_t nframes) = 0;

  utils::Utf8String get_full_designation () const
  {
    return full_designation_provider_ (*this);
  }
 
  bool     has_label () const { return !label_.empty (); }
  PortType type () const { return type_; }
  PortFlow flow () const { return flow_; }
 
protected:
  Port (
    utils::Utf8String label,
    PortType          type = {},
    PortFlow          flow = {},
    QObject *         parent = nullptr);
 
  friend void
  init_from (Port &obj, const Port &other, utils::ObjectCloneType clone_type);
 
private:
  static constexpr auto kFlowId = "flow"sv;
  static constexpr auto kLabelId = "label"sv;
  static constexpr auto kSymbolId = "symbol"sv;
  static constexpr auto kPortGroupId = "portGroup"sv;
  friend void           to_json (nlohmann::json &j, const Port &p);
  friend void           from_json (const nlohmann::json &j, Port &p);
 
private:
  FullDesignationProvider full_designation_provider_ =
    [this] (const Port &port) { return get_label (); };

  PortType type_{};
  PortFlow flow_{};

  utils::Utf8String label_;

  utils::Utf8String sym_;

  std::optional<utils::Utf8String> port_group_;
 
  BOOST_DESCRIBE_CLASS (
    Port,
    (utils::UuidIdentifiableObject<Port>),
    (),
    (),
    (label_, sym_, port_group_))
};
 
template <typename PortT> class PortConnectionsCacheMixin
{
  using ElementType =
    std::pair<const PortT *, std::unique_ptr<dsp::PortConnection>>;
 
public:
  virtual ~PortConnectionsCacheMixin () = default;
 
  auto &port_sources () const { return port_sources_; }
 
  void
  set_port_sources (this auto &self, utils::RangeOf<PortT *> auto source_ports)
    [[clang::blocking]]
  {
    self.port_sources_.clear ();
    if (self.flow () != PortFlow::Input)
      {
        throw std::runtime_error (
          fmt::format (
            "Destination port '{}' must be an input port (is {})",
            self.get_full_designation (),
            self.flow () == PortFlow::Output ? "Output" : "Unknown"));
      }
    for (const auto &source_port : source_ports)
      {
        if (source_port->flow () != PortFlow::Output)
          {
            throw std::runtime_error (
              fmt::format (
                "Source port '{}' must be an output port (is {}), destination '{}'",
                source_port->get_full_designation (),
                source_port->flow () == PortFlow::Input ? "Input" : "Unknown",
                self.get_full_designation ()));
          }
        self.port_sources_.push_back (
          std::make_pair (
            source_port,
            std::make_unique<dsp::PortConnection> (
              source_port->get_uuid (), self.get_uuid (), 1.f, true, true)));
      }
  }
 
private:
  std::vector<ElementType> port_sources_;
  // std::vector<ElementType> port_destinations_;
};
 
using PortUuidReference = utils::TypedUuidReference<Port>;
 
} // namespace zrythm::dsp