mirror of
https://github.com/reactos/CMake.git
synced 2024-12-04 17:56:26 +00:00
136 lines
3.4 KiB
C++
136 lines
3.4 KiB
C++
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
|
|
#pragma once
|
|
|
|
#include "cmConfigure.h" // IWYU pragma: keep
|
|
|
|
#include "cmUVHandlePtr.h"
|
|
#include "cm_uv.h"
|
|
|
|
#include <cstddef>
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
class cmServerBase;
|
|
|
|
/***
|
|
* Given a sequence of bytes with any kind of buffering, instances of this
|
|
* class arrange logical chunks according to whatever the use case is for
|
|
* the connection.
|
|
*/
|
|
class cmConnectionBufferStrategy
|
|
{
|
|
public:
|
|
virtual ~cmConnectionBufferStrategy();
|
|
|
|
/***
|
|
* Called whenever with an active raw buffer. If a logical chunk
|
|
* becomes available, that chunk is returned and that portion is
|
|
* removed from the rawBuffer
|
|
*
|
|
* @param rawBuffer in/out parameter. Receive buffer; the buffer strategy is
|
|
* free to manipulate this buffer anyway it needs to.
|
|
*
|
|
* @return Next chunk from the stream. Returns the empty string if a chunk
|
|
* isn't ready yet. Users of this interface should repeatedly call this
|
|
* function until an empty string is returned since its entirely possible
|
|
* multiple chunks come in a single raw buffer.
|
|
*/
|
|
virtual std::string BufferMessage(std::string& rawBuffer) = 0;
|
|
|
|
/***
|
|
* Called to properly buffer an outgoing message.
|
|
*
|
|
* @param rawBuffer Message to format in the correct way
|
|
*
|
|
* @return Formatted message
|
|
*/
|
|
virtual std::string BufferOutMessage(const std::string& rawBuffer) const
|
|
{
|
|
return rawBuffer;
|
|
};
|
|
/***
|
|
* Resets the internal state of the buffering
|
|
*/
|
|
virtual void clear();
|
|
|
|
// TODO: There should be a callback / flag set for errors
|
|
};
|
|
|
|
class cmConnection
|
|
{
|
|
CM_DISABLE_COPY(cmConnection)
|
|
|
|
public:
|
|
cmConnection() {}
|
|
|
|
virtual void WriteData(const std::string& data) = 0;
|
|
|
|
virtual ~cmConnection();
|
|
|
|
virtual bool OnConnectionShuttingDown();
|
|
|
|
virtual bool IsOpen() const = 0;
|
|
|
|
virtual void SetServer(cmServerBase* s);
|
|
|
|
virtual void ProcessRequest(const std::string& request);
|
|
|
|
virtual bool OnServeStart(std::string* pString);
|
|
|
|
protected:
|
|
cmServerBase* Server = nullptr;
|
|
};
|
|
|
|
/***
|
|
* Abstraction of a connection; ties in event callbacks from libuv and notifies
|
|
* the server when appropriate
|
|
*/
|
|
class cmEventBasedConnection : public cmConnection
|
|
{
|
|
|
|
public:
|
|
/***
|
|
* @param bufferStrategy If no strategy is given, it will process the raw
|
|
* chunks as they come in. The connection
|
|
* owns the pointer given.
|
|
*/
|
|
cmEventBasedConnection(cmConnectionBufferStrategy* bufferStrategy = nullptr);
|
|
|
|
virtual void Connect(uv_stream_t* server);
|
|
|
|
virtual void ReadData(const std::string& data);
|
|
|
|
bool IsOpen() const override;
|
|
|
|
void WriteData(const std::string& data) override;
|
|
bool OnConnectionShuttingDown() override;
|
|
|
|
virtual void OnDisconnect(int errorCode);
|
|
|
|
static void on_close(uv_handle_t* handle);
|
|
|
|
template <typename T>
|
|
static void on_close_delete(uv_handle_t* handle)
|
|
{
|
|
delete reinterpret_cast<T*>(handle);
|
|
}
|
|
|
|
protected:
|
|
cm::uv_stream_ptr WriteStream;
|
|
|
|
std::string RawReadBuffer;
|
|
|
|
std::unique_ptr<cmConnectionBufferStrategy> BufferStrategy;
|
|
|
|
static void on_read(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
|
|
|
|
static void on_write(uv_write_t* req, int status);
|
|
|
|
static void on_new_connection(uv_stream_t* stream, int status);
|
|
|
|
static void on_alloc_buffer(uv_handle_t* handle, size_t suggested_size,
|
|
uv_buf_t* buf);
|
|
};
|