Transport.hpp

// SPDX-FileCopyrightText: 2026 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>
 
// Third-party includes
#include <nlohmann/json.hpp>
 
// Project includes
#include "../Endpoint.hpp"
#include <dfx-utilities/CopyMoveControl.hpp>

 
namespace dfx::FdWatch
{
class Poller;
} // !namespace dfx::FdWatch
 
namespace dfx::Core
{
class Channel;
class Transport;

template<typename T>
concept DerivedFromTransport = std::derived_from<T, Transport>;

class Transport
{
    friend class Channel;
 
public:
    enum class Role
    {
        Source,      
        Destination, 
    };
 
public:
    Transport(Role role, Endpoint endpoint, nlohmann::json config);

    DFX_DISABLE_COPY_AND_MOVE(Transport);

    virtual ~Transport() = default;


    Role role() const noexcept { return _role; }

    bool isSource() const noexcept      { return _role == Role::Source; }
    bool isDestination() const noexcept { return _role == Role::Destination; }

    Endpoint const & endpoint() const noexcept { return _endpoint; }

    Channel * channel() const noexcept { return _channel; }

    Port * port() const noexcept { return _endpoint.port(); }

    NodePtr node() const noexcept { return _endpoint.node(); }

    nlohmann::json const & config() const noexcept { return _config; }

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

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

    template<DerivedFromTransport T>
    T const & as() const noexcept { return static_cast<T const &>(*this); }
 
public:
    virtual void start(FdWatch::Poller & poller) = 0;

    virtual void stop() noexcept = 0;
 
private:
    // This method is called in the Channel ctor
    void _attachToChannel(Channel * channel);
 
protected:
    Role const _role;
 
    Endpoint _endpoint;
    nlohmann::json _config;
 
private:
    Channel * _channel = nullptr;
};

using TransportPtr = std::unique_ptr<Transport>;
} // !namespace dfx::Core