Port.hpp

// SPDX-FileCopyrightText: 2025 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <concepts>
#include <optional>
#include <string>
 
// Project includes
#include "../channels/Channel.hpp"
#include "Kind.hpp"
#include <dfx-hooks/Port.hpp>
#include <dfx-utilities/CopyMoveControl.hpp>
#include <dfx-utilities/EnumString.hpp>
 
namespace dfx::Core
{
class Node;
class Port;
 
using NodePtr  = std::shared_ptr<Node>;
using NodeWPtr = std::weak_ptr<Node>;

template<typename T>
concept DerivedFromPort = std::derived_from<T, Port>;

class Port
{
public:
    using Id = uint32_t;
 
public:
    enum class Mode
    {
        Input,  
        Output, 
    };
 
public:
    ENABLE_DEFAULT_MOVE_DISABLE_COPY(Port);
    virtual ~Port();

    NodePtr node() const noexcept { return _node.lock(); }


    Id id() const noexcept                                         { return _id; }
    std::string const & name() const noexcept                      { return _name; }
    Mode mode() const noexcept                                     { return _mode; }
    Kind kind() const noexcept                                     { return _kind; }
    bool isInput() const noexcept                                  { return _mode == Mode::Input; }
    bool isOutput() const noexcept                                 { return _mode == Mode::Output; }
    std::optional<bool> allowsMimeTypePropagation() const noexcept { return _allowsMimeTypePropagation; }


    template<DerivedFromPort T>
    T & as() noexcept { return static_cast<T &>(*this); }

    template<DerivedFromPort T>
    T const & as() const noexcept { return static_cast<T const &>(*this); }
 
public:

    void addChannel(ChannelPtr channel);

    void removeChannel(ChannelPtr channel);

    bool hasChannel(ChannelPtr channel) const noexcept;

    std::size_t channelCount() const noexcept   { return _channels.size(); }

    ChannelPtr channel(std::size_t index) const { return _channels.at(index); }

 
public:

    void registerHook(Hooks::Port * hook);

    void deregisterHook(Hooks::Port * hook);

 
public:
    static void validatePortName(std::string_view name);
 
protected:
    Port(Id id, NodeWPtr node, Mode mode, Kind kind, std::string name, std::optional<bool> allowsMimeTypePropagation);
 
protected:
    std::vector<Hooks::Port *> hooks;
 
private:
    Id          _id;
    NodeWPtr    _node;
    Mode        _mode;
    Kind        _kind;
    std::string _name;
    std::optional<bool> _allowsMimeTypePropagation;
 
private:
    std::vector<ChannelPtr> _channels;
};
} // !namespace dfx::Core
 
DECLARE_ENUM_STRING_FUNCTIONS(dfx::Core::Port::Mode);