From 996a1bffa9c5463a1510620d423ccaa56af7e44f Mon Sep 17 00:00:00 2001 From: Mathieu Carbou Date: Wed, 23 Oct 2024 15:59:50 +0200 Subject: [PATCH] Code cleanup: virtual destructors, hierarchy, AsyncResponseStream, etc --- examples/CaptivePortal/CaptivePortal.ino | 3 - examples/Filters/Filters.ino | 3 - examples/SimpleServer/SimpleServer.ino | 19 +++- platformio.ini | 7 +- src/AsyncEventSource.h | 5 +- src/AsyncJson.h | 11 ++- src/AsyncMessagePack.h | 11 ++- src/AsyncWebSocket.cpp | 4 +- src/AsyncWebSocket.h | 5 +- src/ChunkPrint.h | 1 - src/ESPAsyncWebServer.h | 15 +--- src/WebAuthentication.cpp | 4 - src/WebAuthentication.h | 4 - src/WebHandlerImpl.h | 14 +-- src/WebRequest.cpp | 41 --------- src/WebResponseImpl.h | 51 +++++------ src/WebResponses.cpp | 107 +---------------------- 17 files changed, 70 insertions(+), 235 deletions(-) diff --git a/examples/CaptivePortal/CaptivePortal.ino b/examples/CaptivePortal/CaptivePortal.ino index ed9dfff..d44e7e6 100644 --- a/examples/CaptivePortal/CaptivePortal.ino +++ b/examples/CaptivePortal/CaptivePortal.ino @@ -16,9 +16,6 @@ AsyncWebServer server(80); class CaptiveRequestHandler : public AsyncWebHandler { public: - CaptiveRequestHandler() {} - virtual ~CaptiveRequestHandler() {} - bool canHandle(__unused AsyncWebServerRequest* request) { return true; } diff --git a/examples/Filters/Filters.ino b/examples/Filters/Filters.ino index de5129a..6479c15 100644 --- a/examples/Filters/Filters.ino +++ b/examples/Filters/Filters.ino @@ -18,9 +18,6 @@ AsyncWebServer server(80); class CaptiveRequestHandler : public AsyncWebHandler { public: - CaptiveRequestHandler() {} - virtual ~CaptiveRequestHandler() {} - bool canHandle(__unused AsyncWebServerRequest* request) { return true; } diff --git a/examples/SimpleServer/SimpleServer.ino b/examples/SimpleServer/SimpleServer.ino index dc30cfd..1328f1a 100644 --- a/examples/SimpleServer/SimpleServer.ino +++ b/examples/SimpleServer/SimpleServer.ino @@ -19,7 +19,7 @@ #include -#if ASYNC_JSON_SUPPORT == 1 +#if __has_include("ArduinoJson.h") #include #include #include @@ -171,7 +171,7 @@ void notFound(AsyncWebServerRequest* request) { request->send(404, "text/plain", "Not found"); } -#if ASYNC_JSON_SUPPORT == 1 +#if __has_include("ArduinoJson.h") AsyncCallbackJsonWebHandler* jsonHandler = new AsyncCallbackJsonWebHandler("/json2"); AsyncCallbackMessagePackWebHandler* msgPackHandler = new AsyncCallbackMessagePackWebHandler("/msgpack2"); #endif @@ -463,7 +463,7 @@ void setup() { request->send(200, "text/plain", "Hello, POST: " + message); }); -#if ASYNC_JSON_SUPPORT == 1 +#if __has_include("ArduinoJson.h") // JSON // receives JSON and sends JSON @@ -479,6 +479,7 @@ void setup() { }); // sends JSON + // curl -v -X GET http://192.168.4.1/json1 server.on("/json1", HTTP_GET, [](AsyncWebServerRequest* request) { AsyncJsonResponse* response = new AsyncJsonResponse(); JsonObject root = response->getRoot().to(); @@ -487,6 +488,16 @@ void setup() { request->send(response); }); + // curl -v -X GET http://192.168.4.1/json2 + server.on("/json2", HTTP_GET, [](AsyncWebServerRequest* request) { + AsyncResponseStream* response = request->beginResponseStream("application/json"); + JsonDocument doc; + JsonObject root = doc.to(); + root["hello"] = "world"; + serializeJson(root, *response); + request->send(response); + }); + // MessagePack // receives MessagePack and sends MessagePack @@ -552,7 +563,7 @@ void setup() { // Run: websocat ws://192.168.4.1/ws server.addHandler(&ws); -#if ASYNC_JSON_SUPPORT == 1 +#if __has_include("ArduinoJson.h") server.addHandler(jsonHandler); server.addHandler(msgPackHandler); #endif diff --git a/platformio.ini b/platformio.ini index 046bf57..d6ab05c 100644 --- a/platformio.ini +++ b/platformio.ini @@ -22,8 +22,10 @@ build_flags = -D CONFIG_ASYNC_TCP_STACK_SIZE=4096 upload_protocol = esptool monitor_speed = 115200 -; monitor_filters = esp32_exception_decoder, log2file -monitor_filters = esp8266_exception_decoder, log2file +monitor_filters = esp32_exception_decoder, log2file +; monitor_filters = esp8266_exception_decoder, log2file +lib_compat_mode = strict +lib_ldf_mode = chain lib_deps = ; bblanchon/ArduinoJson @ 5.13.4 ; bblanchon/ArduinoJson @ 6.21.5 @@ -52,6 +54,7 @@ lib_deps = platform = https://github.com/pioarduino/platform-espressif32/releases/download/53.03.10-rc1/platform-espressif32.zip ; board = esp32-s3-devkitc-1 ; board = esp32-c6-devkitc-1 +; board = esp32-h2-devkitm-1 [env:perf-test-AsyncTCP] platform = https://github.com/pioarduino/platform-espressif32/releases/download/53.03.10-rc1/platform-espressif32.zip diff --git a/src/AsyncEventSource.h b/src/AsyncEventSource.h index 9baa04c..10d7901 100644 --- a/src/AsyncEventSource.h +++ b/src/AsyncEventSource.h @@ -143,8 +143,8 @@ class AsyncEventSource : public AsyncWebHandler { // system callbacks (do not call) void _addClient(AsyncEventSourceClient* client); void _handleDisconnect(AsyncEventSourceClient* client); - virtual bool canHandle(AsyncWebServerRequest* request) const override final; - virtual void handleRequest(AsyncWebServerRequest* request) override final; + bool canHandle(AsyncWebServerRequest* request) const override final; + void handleRequest(AsyncWebServerRequest* request) override final; }; class AsyncEventSourceResponse : public AsyncWebServerResponse { @@ -154,7 +154,6 @@ class AsyncEventSourceResponse : public AsyncWebServerResponse { public: AsyncEventSourceResponse(AsyncEventSource* server); - virtual ~AsyncEventSourceResponse() {}; void _respond(AsyncWebServerRequest* request); size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time); bool _sourceValid() const { return true; } diff --git a/src/AsyncJson.h b/src/AsyncJson.h index 198ac4b..a54935a 100644 --- a/src/AsyncJson.h +++ b/src/AsyncJson.h @@ -74,7 +74,6 @@ class AsyncJsonResponse : public AsyncAbstractResponse { #else AsyncJsonResponse(bool isArray = false); #endif - virtual ~AsyncJsonResponse() {} JsonVariant& getRoot() { return _root; } bool _sourceValid() const { return _isValid; } size_t setLength(); @@ -120,11 +119,11 @@ class AsyncCallbackJsonWebHandler : public AsyncWebHandler { void setMaxContentLength(int maxContentLength) { _maxContentLength = maxContentLength; } void onRequest(ArJsonRequestHandlerFunction fn) { _onRequest = fn; } - virtual bool canHandle(AsyncWebServerRequest* request) const override final; - virtual void handleRequest(AsyncWebServerRequest* request) override final; - virtual void handleUpload(__unused AsyncWebServerRequest* request, __unused const String& filename, __unused size_t index, __unused uint8_t* data, __unused size_t len, __unused bool final) override final {} - virtual void handleBody(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total) override final; - virtual bool isRequestHandlerTrivial() const override final { return !_onRequest; } + bool canHandle(AsyncWebServerRequest* request) const override final; + void handleRequest(AsyncWebServerRequest* request) override final; + void handleUpload(__unused AsyncWebServerRequest* request, __unused const String& filename, __unused size_t index, __unused uint8_t* data, __unused size_t len, __unused bool final) override final {} + void handleBody(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total) override final; + bool isRequestHandlerTrivial() const override final { return !_onRequest; } }; #endif // ASYNC_JSON_SUPPORT == 1 diff --git a/src/AsyncMessagePack.h b/src/AsyncMessagePack.h index 7548f1d..78fde92 100644 --- a/src/AsyncMessagePack.h +++ b/src/AsyncMessagePack.h @@ -58,7 +58,6 @@ class AsyncMessagePackResponse : public AsyncAbstractResponse { #else AsyncMessagePackResponse(bool isArray = false); #endif - virtual ~AsyncMessagePackResponse() {} JsonVariant& getRoot() { return _root; } bool _sourceValid() const { return _isValid; } size_t setLength(); @@ -93,11 +92,11 @@ class AsyncCallbackMessagePackWebHandler : public AsyncWebHandler { void setMaxContentLength(int maxContentLength) { _maxContentLength = maxContentLength; } void onRequest(ArMessagePackRequestHandlerFunction fn) { _onRequest = fn; } - virtual bool canHandle(AsyncWebServerRequest* request) const override final; - virtual void handleRequest(AsyncWebServerRequest* request) override final; - virtual void handleUpload(__unused AsyncWebServerRequest* request, __unused const String& filename, __unused size_t index, __unused uint8_t* data, __unused size_t len, __unused bool final) override final {} - virtual void handleBody(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total) override final; - virtual bool isRequestHandlerTrivial() const override final { return !_onRequest; } + bool canHandle(AsyncWebServerRequest* request) const override final; + void handleRequest(AsyncWebServerRequest* request) override final; + void handleUpload(__unused AsyncWebServerRequest* request, __unused const String& filename, __unused size_t index, __unused uint8_t* data, __unused size_t len, __unused bool final) override final {} + void handleBody(AsyncWebServerRequest* request, uint8_t* data, size_t len, size_t index, size_t total) override final; + bool isRequestHandlerTrivial() const override final { return !_onRequest; } }; #endif // ASYNC_MSG_PACK_SUPPORT == 1 diff --git a/src/AsyncWebSocket.cpp b/src/AsyncWebSocket.cpp index 24db052..9efb6db 100644 --- a/src/AsyncWebSocket.cpp +++ b/src/AsyncWebSocket.cpp @@ -185,12 +185,12 @@ class AsyncWebSocketControl { _data = NULL; } - virtual ~AsyncWebSocketControl() { + ~AsyncWebSocketControl() { if (_data != NULL) free(_data); } - virtual bool finished() const { return _finished; } + bool finished() const { return _finished; } uint8_t opcode() { return _opcode; } uint8_t len() { return _len + 2; } size_t send(AsyncClient* client) { diff --git a/src/AsyncWebSocket.h b/src/AsyncWebSocket.h index 8a7f7b3..8ad06ea 100644 --- a/src/AsyncWebSocket.h +++ b/src/AsyncWebSocket.h @@ -350,8 +350,8 @@ class AsyncWebSocket : public AsyncWebHandler { uint32_t _getNextId() { return _cNextId++; } AsyncWebSocketClient* _newClient(AsyncWebServerRequest* request); void _handleEvent(AsyncWebSocketClient* client, AwsEventType type, void* arg, uint8_t* data, size_t len); - virtual bool canHandle(AsyncWebServerRequest* request) const override final; - virtual void handleRequest(AsyncWebServerRequest* request) override final; + bool canHandle(AsyncWebServerRequest* request) const override final; + void handleRequest(AsyncWebServerRequest* request) override final; // messagebuffer functions/objects. AsyncWebSocketMessageBuffer* makeBuffer(size_t size = 0); @@ -368,7 +368,6 @@ class AsyncWebSocketResponse : public AsyncWebServerResponse { public: AsyncWebSocketResponse(const String& key, AsyncWebSocket* server); - virtual ~AsyncWebSocketResponse() {} void _respond(AsyncWebServerRequest* request); size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time); bool _sourceValid() const { return true; } diff --git a/src/ChunkPrint.h b/src/ChunkPrint.h index 103d21e..47988e1 100644 --- a/src/ChunkPrint.h +++ b/src/ChunkPrint.h @@ -12,7 +12,6 @@ class ChunkPrint : public Print { public: ChunkPrint(uint8_t* destination, size_t from, size_t len); - virtual ~ChunkPrint() {} size_t write(uint8_t c); size_t write(const uint8_t* buffer, size_t size) { return this->Print::write(buffer, size); } }; diff --git a/src/ESPAsyncWebServer.h b/src/ESPAsyncWebServer.h index 15a60d1..b7b22ec 100644 --- a/src/ESPAsyncWebServer.h +++ b/src/ESPAsyncWebServer.h @@ -264,13 +264,8 @@ class AsyncWebServerRequest { size_t contentLength() const { return _contentLength; } bool multipart() const { return _isMultipart; } -#ifndef ESP8266 const char* methodToString() const; const char* requestedConnTypeToString() const; -#else - const __FlashStringHelper* methodToString() const; - const __FlashStringHelper* requestedConnTypeToString() const; -#endif RequestedConnectionType requestedConnType() const { return _reqconntype; } bool isExpectedRequestedConnType(RequestedConnectionType erct1, RequestedConnectionType erct2 = RCT_NOT_USED, RequestedConnectionType erct3 = RCT_NOT_USED) const; @@ -526,9 +521,7 @@ using ArMiddlewareCallback = std::function #include #include -#include "literals.h" // It is possible to restore these defines, but one can use _min and _max instead. Or std::min, std::max. @@ -38,11 +39,10 @@ class AsyncBasicResponse : public AsyncWebServerResponse { public: explicit AsyncBasicResponse(int code, const char* contentType = asyncsrv::empty, const char* content = asyncsrv::empty); - virtual ~AsyncBasicResponse() {} AsyncBasicResponse(int code, const String& contentType, const String& content = emptyString) : AsyncBasicResponse(code, contentType.c_str(), content.c_str()) {} - void _respond(AsyncWebServerRequest* request); - size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time); - bool _sourceValid() const { return true; } + void _respond(AsyncWebServerRequest* request) override final; + size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time) override final; + bool _sourceValid() const override final { return true; } }; class AsyncAbstractResponse : public AsyncWebServerResponse { @@ -62,9 +62,9 @@ class AsyncAbstractResponse : public AsyncWebServerResponse { public: AsyncAbstractResponse(AwsTemplateProcessor callback = nullptr); virtual ~AsyncAbstractResponse() {} - void _respond(AsyncWebServerRequest* request); - size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time); - bool _sourceValid() const { return false; } + void _respond(AsyncWebServerRequest* request) override final; + size_t _ack(AsyncWebServerRequest* request, size_t len, uint32_t time) override final; + virtual bool _sourceValid() const { return false; } virtual size_t _fillBuffer(uint8_t* buf __attribute__((unused)), size_t maxLen __attribute__((unused))) { return 0; } }; @@ -87,9 +87,9 @@ class AsyncFileResponse : public AsyncAbstractResponse { AsyncFileResponse(FS& fs, const String& path, const String& contentType, bool download = false, AwsTemplateProcessor callback = nullptr) : AsyncFileResponse(fs, path, contentType.c_str(), download, callback) {} AsyncFileResponse(File content, const String& path, const char* contentType = asyncsrv::empty, bool download = false, AwsTemplateProcessor callback = nullptr); AsyncFileResponse(File content, const String& path, const String& contentType, bool download = false, AwsTemplateProcessor callack = nullptr) : AsyncFileResponse(content, path, contentType.c_str(), download, callack) {} - virtual ~AsyncFileResponse(); - bool _sourceValid() const { return !!(_content); } - virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override; + ~AsyncFileResponse() { _content.close(); } + bool _sourceValid() const override final { return !!(_content); } + size_t _fillBuffer(uint8_t* buf, size_t maxLen) override final; }; class AsyncStreamResponse : public AsyncAbstractResponse { @@ -99,9 +99,8 @@ class AsyncStreamResponse : public AsyncAbstractResponse { public: AsyncStreamResponse(Stream& stream, const char* contentType, size_t len, AwsTemplateProcessor callback = nullptr); AsyncStreamResponse(Stream& stream, const String& contentType, size_t len, AwsTemplateProcessor callback = nullptr) : AsyncStreamResponse(stream, contentType.c_str(), len, callback) {} - virtual ~AsyncStreamResponse() {} - bool _sourceValid() const { return !!(_content); } - virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override; + bool _sourceValid() const override final { return !!(_content); } + size_t _fillBuffer(uint8_t* buf, size_t maxLen) override final; }; class AsyncCallbackResponse : public AsyncAbstractResponse { @@ -112,9 +111,8 @@ class AsyncCallbackResponse : public AsyncAbstractResponse { public: AsyncCallbackResponse(const char* contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr); AsyncCallbackResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) : AsyncCallbackResponse(contentType.c_str(), len, callback, templateCallback) {} - virtual ~AsyncCallbackResponse() {} - bool _sourceValid() const { return !!(_content); } - virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override; + bool _sourceValid() const override final { return !!(_content); } + size_t _fillBuffer(uint8_t* buf, size_t maxLen) override final; }; class AsyncChunkedResponse : public AsyncAbstractResponse { @@ -125,9 +123,8 @@ class AsyncChunkedResponse : public AsyncAbstractResponse { public: AsyncChunkedResponse(const char* contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr); AsyncChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback = nullptr) : AsyncChunkedResponse(contentType.c_str(), callback, templateCallback) {} - virtual ~AsyncChunkedResponse() {} - bool _sourceValid() const { return !!(_content); } - virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override; + bool _sourceValid() const override final { return !!(_content); } + size_t _fillBuffer(uint8_t* buf, size_t maxLen) override final; }; class AsyncProgmemResponse : public AsyncAbstractResponse { @@ -138,23 +135,19 @@ class AsyncProgmemResponse : public AsyncAbstractResponse { public: AsyncProgmemResponse(int code, const char* contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr); AsyncProgmemResponse(int code, const String& contentType, const uint8_t* content, size_t len, AwsTemplateProcessor callback = nullptr) : AsyncProgmemResponse(code, contentType.c_str(), content, len, callback) {} - virtual ~AsyncProgmemResponse() {} - bool _sourceValid() const { return true; } - virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override; + bool _sourceValid() const override final { return true; } + size_t _fillBuffer(uint8_t* buf, size_t maxLen) override final; }; -class cbuf; - class AsyncResponseStream : public AsyncAbstractResponse, public Print { private: - std::unique_ptr _content; + StreamString _content; public: AsyncResponseStream(const char* contentType, size_t bufferSize); AsyncResponseStream(const String& contentType, size_t bufferSize) : AsyncResponseStream(contentType.c_str(), bufferSize) {} - virtual ~AsyncResponseStream() {} - bool _sourceValid() const { return (_state < RESPONSE_END); } - virtual size_t _fillBuffer(uint8_t* buf, size_t maxLen) override; + bool _sourceValid() const override final { return (_state < RESPONSE_END); } + size_t _fillBuffer(uint8_t* buf, size_t maxLen) override final; size_t write(const uint8_t* data, size_t len); size_t write(uint8_t data); using Print::write; diff --git a/src/WebResponses.cpp b/src/WebResponses.cpp index 23f929a..7a26e92 100644 --- a/src/WebResponses.cpp +++ b/src/WebResponses.cpp @@ -20,7 +20,6 @@ */ #include "ESPAsyncWebServer.h" #include "WebResponseImpl.h" -#include "cbuf.h" using namespace asyncsrv; @@ -38,7 +37,6 @@ void* memchr(void* ptr, int ch, size_t count) { * */ -#ifndef ESP8266 const char* AsyncWebServerResponse::responseCodeToString(int code) { switch (code) { case 100: @@ -127,96 +125,6 @@ const char* AsyncWebServerResponse::responseCodeToString(int code) { return T_HTTP_CODE_ANY; } } -#else // ESP8266 -const __FlashStringHelper* AsyncWebServerResponse::responseCodeToString(int code) { - switch (code) { - case 100: - return FPSTR(T_HTTP_CODE_100); - case 101: - return FPSTR(T_HTTP_CODE_101); - case 200: - return FPSTR(T_HTTP_CODE_200); - case 201: - return FPSTR(T_HTTP_CODE_201); - case 202: - return FPSTR(T_HTTP_CODE_202); - case 203: - return FPSTR(T_HTTP_CODE_203); - case 204: - return FPSTR(T_HTTP_CODE_204); - case 205: - return FPSTR(T_HTTP_CODE_205); - case 206: - return FPSTR(T_HTTP_CODE_206); - case 300: - return FPSTR(T_HTTP_CODE_300); - case 301: - return FPSTR(T_HTTP_CODE_301); - case 302: - return FPSTR(T_HTTP_CODE_302); - case 303: - return FPSTR(T_HTTP_CODE_303); - case 304: - return FPSTR(T_HTTP_CODE_304); - case 305: - return FPSTR(T_HTTP_CODE_305); - case 307: - return FPSTR(T_HTTP_CODE_307); - case 400: - return FPSTR(T_HTTP_CODE_400); - case 401: - return FPSTR(T_HTTP_CODE_401); - case 402: - return FPSTR(T_HTTP_CODE_402); - case 403: - return FPSTR(T_HTTP_CODE_403); - case 404: - return FPSTR(T_HTTP_CODE_404); - case 405: - return FPSTR(T_HTTP_CODE_405); - case 406: - return FPSTR(T_HTTP_CODE_406); - case 407: - return FPSTR(T_HTTP_CODE_407); - case 408: - return FPSTR(T_HTTP_CODE_408); - case 409: - return FPSTR(T_HTTP_CODE_409); - case 410: - return FPSTR(T_HTTP_CODE_410); - case 411: - return FPSTR(T_HTTP_CODE_411); - case 412: - return FPSTR(T_HTTP_CODE_412); - case 413: - return FPSTR(T_HTTP_CODE_413); - case 414: - return FPSTR(T_HTTP_CODE_414); - case 415: - return FPSTR(T_HTTP_CODE_415); - case 416: - return FPSTR(T_HTTP_CODE_416); - case 417: - return FPSTR(T_HTTP_CODE_417); - case 429: - return FPSTR(T_HTTP_CODE_429); - case 500: - return FPSTR(T_HTTP_CODE_500); - case 501: - return FPSTR(T_HTTP_CODE_501); - case 502: - return FPSTR(T_HTTP_CODE_502); - case 503: - return FPSTR(T_HTTP_CODE_503); - case 504: - return FPSTR(T_HTTP_CODE_504); - case 505: - return FPSTR(T_HTTP_CODE_505); - default: - return FPSTR(T_HTTP_CODE_ANY); - } -} -#endif // ESP8266 AsyncWebServerResponse::AsyncWebServerResponse() : _code(0), _contentType(), _contentLength(0), _sendContentLength(true), _chunked(false), _headLength(0), _sentLength(0), _ackedLength(0), _writtenLength(0), _state(RESPONSE_SETUP) { @@ -646,10 +554,6 @@ size_t AsyncAbstractResponse::_fillBufferAndProcessTemplates(uint8_t* data, size * File Response * */ -AsyncFileResponse::~AsyncFileResponse() { - _content.close(); -} - void AsyncFileResponse::_setContentTypeFromPath(const String& path) { #if HAVE_EXTERN_GET_Content_Type_FUNCTION #ifndef ESP8266 @@ -865,22 +769,17 @@ AsyncResponseStream::AsyncResponseStream(const char* contentType, size_t bufferS _code = 200; _contentLength = 0; _contentType = contentType; - _content = std::unique_ptr(new cbuf(bufferSize)); // std::make_unique(bufferSize); + _content.reserve(bufferSize); } size_t AsyncResponseStream::_fillBuffer(uint8_t* buf, size_t maxLen) { - return _content->read((char*)buf, maxLen); + return _content.readBytes((char*)buf, maxLen); } size_t AsyncResponseStream::write(const uint8_t* data, size_t len) { if (_started()) return 0; - - if (len > _content->room()) { - size_t needed = len - _content->room(); - _content->resizeAdd(needed); - } - size_t written = _content->write((const char*)data, len); + size_t written = _content.write(data, len); _contentLength += written; return written; }