tcp.h

浏览该文件的文档.

 
#pragma once
 
#include <asio.hpp>
#include <array>
#include <cstdint>
#include <format>
#include <memory>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include "core/async.hpp"
#include "io/base.hpp"
#include "utils/callback.hpp"
#include "io/write_queue.hpp"
 
namespace roboctrl::io{
 
class tcp : public bare_io_base, public std::enable_shared_from_this<tcp>{
public:
    struct info_type{
        using key_type = std::string;
        using owner_type = tcp;
 
        std::string name;       
        std::string address;    
        std::uint16_t port;     
 
        const std::string& key()const{
            return name;
        }
    };
 
    explicit tcp(info_type info);
    tcp(asio::ip::tcp::socket socket, std::string key);
 
    void start();
 
    awaitable<void> send(byte_span data);
 
    awaitable<void> task();
 
    void on_close(std::function<void()> callback) { on_close_ = std::move(callback); }
 
    inline std::string desc()const{
        return std::format("tcp socket (<{}> to {}:{})",info_.name,info_.address,info_.port);
    }
 
private:
    static awaitable<void> run_with_lifetime(std::shared_ptr<tcp> self);
 
    asio::ip::tcp::socket socket_;
    write_queue write_queue_;
    info_type info_;
    std::array<std::byte,1024> buffer_;
    bool started_ {false};
    std::function<void()> on_close_;
    bool closed_notified_ {false};
 
    void notify_closed();
};
 
static_assert(bare_io<tcp>);
 
class tcp_server{
public:
    struct info_type{
        using key_type = std::string;
        using owner_type = tcp_server;
 
        std::string name;                   
        std::string address;                
        std::uint16_t port;                 
 
        const std::string& key()const{
            return name;
        }
    };
 
    explicit tcp_server(info_type info);
 
    void start();
 
    awaitable<void> task();
 
    void on_connect(std::function<awaitable<void>(std::shared_ptr<tcp>)> callback){
        on_connect_.add(std::move(callback));
    }
 
    void on_connect(std::function<void(std::shared_ptr<tcp>)> callback){
        on_connect_.add(std::move(callback));
    }
 
    inline std::string desc()const{
        return std::format("tcp server (<{}> listening on {}:{})",info_.name,info_.address,info_.port);
    }
 
private:
    std::shared_ptr<tcp> make_connection(asio::ip::tcp::socket socket);
 
    asio::ip::tcp::acceptor acceptor_;
    info_type info_;
    callback<std::shared_ptr<tcp>> on_connect_;
    std::vector<std::shared_ptr<tcp>> connections_;
    bool started_ {false};
 
    void remove_connection(const std::shared_ptr<tcp>& connection);
};
}