TransportIO.h

Go to the documentation of this file.

//
// Copyright (c) 2002-2026 WEINZIERL ENGINEERING GmbH
// All rights reserved.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY,
// WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
//
 
#ifndef __BAOSLIB_TRANSPORT_IO_H__
#define __BAOSLIB_TRANSPORT_IO_H__
 
#include "baos/BaosLib_export.h"
#include "baos/config.h"
#include "baos/connection/IOEvent.h"
 
#include "transport/ProtocolStack.h"
 
#include "wzcpp/features/concurrent/executor.h"
#include "wzcpp/features/timer/timer.h"
 
 
#include <array>
#include <atomic>
#include <chrono>
#include <memory>
#include <string>
 
 
namespace wz::baos::transport
{
 
class ProtocolLayer;
class ProtocolStack;
 
/******************************************************************
 * TransportIO
 ******************************************************************/
 
class BAOSLIB_EXPORT TransportIO
{
public:
    using Clock          = std::chrono::system_clock;  
    using UPtr       = std::unique_ptr<TransportIO>;        
    using UniqueLock = std::unique_lock<std::mutex>;  
    enum class PromiseState
    {
        UNUSED,
        SET,
        RESOLVED
    };
    struct BaosPromise
    {
        protocol::ResponsePromise prom;  // Promise from the BAOS connection to resolve later
        PromiseState state{PromiseState::UNUSED};  
    };
 
    TransportIO(BaosMsgQueue& msgQueue,
                wzcpp::ExecutorBase& executor,
                wzcpp::TimerManager<Clock>& timerManager);
 
    virtual ~TransportIO();
 
    TransportIO(const TransportIO&) = delete;
 
    TransportIO& operator=(const TransportIO&) = delete;
 
    TransportIO(TransportIO&&) = delete;
 
    TransportIO& operator=(TransportIO&&) = delete;
 
    template <typename LayerType>
    void addLayer(std::uint32_t layerId)
    {
        transportStack_->addLayer(std::make_unique<LayerType>(layerId, *transportStack_, timerManager_));
    }
 
    ProtocolLayer& getLayer(unsigned int layerId);
 
    void start();
 
    virtual void stop() = 0;
 
    virtual void send(const Buffer& frame) = 0;
 
 
    virtual void close() = 0;
 
    virtual void waitForFinished() = 0;
 
    virtual bool isOpen();
 
    bool isIdle() const;
 
    void onTimersElapsed(wzcpp::TimerManager<Clock>::TimerIdList& timerIds);
 
protected:
    virtual void eventHandler() = 0;
 
    virtual void sendToIo(const Buffer& frame) = 0;
 
protected:
    static std::atomic<std::uint64_t> msgId;  
    std::unique_ptr<ProtocolStack> transportStack_; 
    std::atomic<bool> shouldStop_{false};   
    std::condition_variable cvFinished_;      
    mutable std::mutex cvFinished_mut_;       
    bool stopped_{false};                     
 
    std::atomic<bool> isOpen_{false};         
    TransportMsgQueue msgQueue_;              
    BaosMsgQueue& bMsgQ_;                     
    wzcpp::ExecutorBase& executor_;           
    wzcpp::TimerManager<Clock>& timerManager_;
    wzcpp::TimerManager<Clock>::AllTimersCallbackId timerCallbackId_{0}; 
    BaosPromise connectionPromise_;           
};
 
}  // namespace wz::baos::transport
 
#endif  //__BAOSLIB_TRANSPORT_IO_H__