TcpSocket.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "NetTypes.h"
 
#include <cstdint>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
namespace eve::data {
class ByteData;
}
 
namespace Poco::Net {
class StreamSocket;
class ServerSocket;
}
 
namespace eve::network {
 
class Network;
 
class EVENGINE_API_PLATFORM TcpSocket {
public:
    explicit TcpSocket(Network* net);
    ~TcpSocket();
    // Class-level dllexport instantiates every member; `accepted_` is a container
    // of unique_ptr, so the implicit copy assignment would be a hard C2280.
    TcpSocket(const TcpSocket&)            = delete;
    TcpSocket& operator=(const TcpSocket&) = delete;
    TcpSocket(TcpSocket&&)                 = default;
    TcpSocket& operator=(TcpSocket&&)      = default;
 
    bool connect(std::string host, uint16_t port);
    bool listen(uint16_t port);
    TcpSocket* accept();
    bool send(eve::data::ByteData* data);
    bool sendString(std::string s);
    void close();
    bool isConnected() const;
    std::string getPeer() const;
    uint16_t getLocalPort() const;
 
    Network* network() const { return net_; }
    void setConnectedSocket(std::unique_ptr<Poco::Net::StreamSocket> sock);
    Poco::Net::StreamSocket* stream();
    Poco::Net::ServerSocket* server();
    bool isListening() const { return listening_; }
    bool takeAccepted(std::unique_ptr<TcpSocket>& out);
    void pushAccepted(std::unique_ptr<TcpSocket> sock);
    size_t pendingSendBytes() const;
 
    bool queueSend(const void* d, size_t n);
    void flushSend();
    void clearPendingSend();
 
private:
    Network* net_ = nullptr;
    std::unique_ptr<Poco::Net::StreamSocket> stream_;
    std::unique_ptr<Poco::Net::ServerSocket> server_;
    bool listening_ = false;
    bool connected_ = false;
    std::mutex acceptMu_;
    std::vector<std::unique_ptr<TcpSocket>> accepted_;
    std::string peer_;
 
    mutable std::mutex sendMu_;
    std::vector<char> pendingSend_;
};
 
}  // namespace eve::network