Channel.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 <memory>
#include <optional>
 
// Project includes
#include "../messages/Message.hpp"
#include <dfx-hooks/Delivery.hpp>
#include <dfx-utilities/CopyMoveControl.hpp>
 
namespace dfx::Core
{
class InputPort;
class OutputPort;
class Channel;

template<typename T>
concept DerivedFromChannel = std::derived_from<T, Channel>;

class Channel
{
public:
    using Id = uint32_t;
 
public:
    Channel(Id id, InputPort & inputPort, OutputPort & outputPort);

    DISABLE_COPY_AND_MOVE(Channel);

    virtual ~Channel() = default;

    Id id() const noexcept { return _id; }
 
public:

    virtual bool pushMessage(MessagePtr msg) = 0;

    virtual bool hasPendingMessage() const = 0;

    virtual std::size_t pendingMessageCount() const = 0;

    virtual std::optional<MessagePtr> pop() = 0;

 
public:
    template<DerivedFromChannel T>
    bool is() const noexcept { return dynamic_cast<T const *>(this) != nullptr; }

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

    template<DerivedFromChannel T>
    T const & as() const noexcept { return static_cast<T const &>(*this); }
 
public:
    InputPort & inputPort() const noexcept   { return _inputPort; }

    OutputPort & outputPort() const noexcept { return _outputPort; }
 
public:
    void setDeliveryHook(Hooks::Delivery * hook)
    { _deliveryHook = hook; }
 
protected:
    InputPort & _inputPort;   
    OutputPort & _outputPort; 
 
    Hooks::Delivery * _deliveryHook = nullptr; 
 
private:
    Id _id;
};

using ChannelPtr = std::shared_ptr<Channel>;
} // !namespace dfx::Core