Removed AsyncWebSocketBuffer

src/AsyncWebSocket.h

@@ -84,137 +84,25 @@ typedef enum { WS_CONTINUATION, WS_TEXT, WS_BINARY, WS_DISCONNECT = 0x08, WS_PIN
 typedef enum { WS_MSG_SENDING, WS_MSG_SENT, WS_MSG_ERROR } AwsMessageStatus;
 typedef enum { WS_EVT_CONNECT, WS_EVT_DISCONNECT, WS_EVT_PONG, WS_EVT_ERROR, WS_EVT_DATA } AwsEventType;
 
-class AsyncWebSocketMessageBuffer {
+class AsyncWebSocketMessage
-  private:
-    std::unique_ptr<uint8_t[]> _data;
-    //uint8_t * _data;
-    size_t _len{};
-    //bool _lock;
-    //uint32_t _count;
-
-  public:
-    AsyncWebSocketMessageBuffer();
-    AsyncWebSocketMessageBuffer(size_t size);
-    AsyncWebSocketMessageBuffer(uint8_t *data, size_t size);
-    //AsyncWebSocketMessageBuffer(const AsyncWebSocketMessageBuffer &);
-    //AsyncWebSocketMessageBuffer(AsyncWebSocketMessageBuffer &&);
-    ~AsyncWebSocketMessageBuffer(); 
-    //void operator ++(int i) { Serial.printf("AsyncWebSocketMessageBuffer::operator++() this=0x%llx\r\n", uint64_t(this)); (void)i; _count++; }
-    //void operator --(int i) { Serial.printf("AsyncWebSocketMessageBuffer::operator--() this=0x%llx\r\n", uint64_t(this)); (void)i; if (_count > 0) { _count--; } ;  }
-    bool reserve(size_t size);
-    //void lock() { Serial.printf("AsyncWebSocketMessageBuffer::lock() this=0x%llx\r\n", uint64_t(this)); _lock = true; }
-    //void unlock() { Serial.printf("AsyncWebSocketMessageBuffer::unlock() this=0x%llx\r\n", uint64_t(this)); _lock = false; }
-    uint8_t *get() { Serial.printf("AsyncWebSocketMessageBuffer::get() this=0x%llx\r\n", uint64_t(this)); return _data.get(); }
-    size_t length() { Serial.printf("AsyncWebSocketMessageBuffer::length() this=0x%llx\r\n", uint64_t(this)); return _len; }
-    //uint32_t count() { Serial.printf("AsyncWebSocketMessageBuffer::count() this=0x%llx\r\n", uint64_t(this)); return _count; }
-    //bool canDelete() { Serial.printf("AsyncWebSocketMessageBuffer::canDelete() this=0x%llx\r\n", uint64_t(this)); return (!_count && !_lock); }
-
-    //friend AsyncWebSocket;
-
-};
-
-class AsyncWebSocketMessage {
-  protected:
-    uint8_t _opcode;
-    bool _mask;
-    AwsMessageStatus _status;
-  public:
-    AsyncWebSocketMessage():_opcode(WS_TEXT),_mask(false),_status(WS_MSG_ERROR){}
-    virtual ~AsyncWebSocketMessage(){}
-    virtual void ack(size_t len __attribute__((unused)), uint32_t time __attribute__((unused))){}
-    virtual size_t send(AsyncClient *client __attribute__((unused))){ return 0; }
-    virtual bool finished(){ return _status != WS_MSG_SENDING; }
-    virtual bool betweenFrames() const { return false; }
-};
-
-class AsyncWebSocketBasicMessage: public AsyncWebSocketMessage {
-  private:
-    size_t _len;
-    size_t _sent;
-    size_t _ack;
-    size_t _acked;
-    uint8_t * _data;
-public:
-    AsyncWebSocketBasicMessage(const char * data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false);
-    AsyncWebSocketBasicMessage(uint8_t opcode=WS_TEXT, bool mask=false);
-    virtual ~AsyncWebSocketBasicMessage() override;
-    virtual bool betweenFrames() const override { return _acked == _ack; }
-    virtual void ack(size_t len, uint32_t time) override ;
-    virtual size_t send(AsyncClient *client) override ;
-};
-
-class AsyncWebSocketMultiMessage: public AsyncWebSocketMessage {
-  private:
-    uint8_t * _data;
-    size_t _len;
-    size_t _sent;
-    size_t _ack;
-    size_t _acked;
-    std::shared_ptr<AsyncWebSocketMessageBuffer> _WSbuffer;
-
-public:
-    AsyncWebSocketMultiMessage(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
-    virtual ~AsyncWebSocketMultiMessage() override;
-    virtual bool betweenFrames() const override { return _acked == _ack; }
-    virtual void ack(size_t len, uint32_t time) override ;
-    virtual size_t send(AsyncClient *client) override ;
-};
-
-class PolymorphMessageContainer
 {
-    union {
+private:
-        AsyncWebSocketBasicMessage basicMessage;
+    std::shared_ptr<std::vector<uint8_t>> _WSbuffer;
-        AsyncWebSocketMultiMessage multiMessage;
+    uint8_t _opcode{WS_TEXT};
-    };
+    bool _mask{false};
-
+    AwsMessageStatus _status{WS_MSG_ERROR};
-    enum class Type : uint8_t { Basic, Multi };
+    size_t _sent{};
-    const Type type;
+    size_t _ack{};
+    size_t _acked{};
 
 public:
-    PolymorphMessageContainer() = delete;
+    AsyncWebSocketMessage(std::shared_ptr<std::vector<uint8_t>> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
-    PolymorphMessageContainer(const PolymorphMessageContainer &) = delete;
-    PolymorphMessageContainer &operator=(const PolymorphMessageContainer &) = delete;
 
-    PolymorphMessageContainer(const char *data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false) :
+    bool finished() const { return _status != WS_MSG_SENDING; }
-        type{Type::Basic}
+    bool betweenFrames() const { return _acked == _ack; }
-    {
-        new (&basicMessage) AsyncWebSocketBasicMessage{data, len, opcode, mask};
-    }
 
-    PolymorphMessageContainer(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false) :
+    void ack(size_t len, uint32_t time);
-        type{Type::Multi}
+    size_t send(AsyncClient *client);
-    {
-        new (&multiMessage) AsyncWebSocketMultiMessage{buffer, opcode, mask};
-    }
-
-    ~PolymorphMessageContainer()
-    {
-        switch (type)
-        {
-        case Type::Basic: basicMessage.~AsyncWebSocketBasicMessage(); break;
-        case Type::Multi: multiMessage.~AsyncWebSocketMultiMessage(); break;
-        }
-    }
-
-    AsyncWebSocketMessage &get()
-    {
-        switch (type)
-        {
-        case Type::Basic: return basicMessage;
-        case Type::Multi: return multiMessage;
-        }
-        __builtin_unreachable();
-    }
-
-    const AsyncWebSocketMessage &get() const
-    {
-        switch (type)
-        {
-        case Type::Basic: return basicMessage;
-        case Type::Multi: return multiMessage;
-        }
-        __builtin_unreachable();
-    }
 };
 
 class AsyncWebSocketClient {
@@ -227,7 +115,7 @@ class AsyncWebSocketClient {
     AsyncWebLock _lock;
 
     std::queue<AsyncWebSocketControl> _controlQueue;
-    std::queue<PolymorphMessageContainer> _messageQueue;
+    std::queue<AsyncWebSocketMessage> _messageQueue;
 
     uint8_t _pstate;
     AwsFrameInfo _pinfo;
@@ -235,9 +123,8 @@ class AsyncWebSocketClient {
     uint32_t _lastMessageTime;
     uint32_t _keepAlivePeriod;
 
-    void _queueControl(uint8_t opcode, uint8_t *data=NULL, size_t len=0, bool mask=false);
+    void _queueControl(uint8_t opcode, const uint8_t *data=NULL, size_t len=0, bool mask=false);
-    void _queueMessage(const char *data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false);
+    void _queueMessage(std::shared_ptr<std::vector<uint8_t>> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
-    void _queueMessage(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
     void _runQueue();
 
   public:
@@ -260,7 +147,7 @@ class AsyncWebSocketClient {
 
     //control frames
     void close(uint16_t code=0, const char * message=NULL);
-    void ping(uint8_t *data=NULL, size_t len=0);
+    void ping(const uint8_t *data=NULL, size_t len=0);
 
     //set auto-ping period in seconds. disabled if zero (default)
     void keepAlivePeriod(uint16_t seconds){
@@ -271,29 +158,27 @@ class AsyncWebSocketClient {
     }
 
     //data packets
-    void message(const char *data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false) { _queueMessage(data, len, opcode, mask); }
+    void message(std::shared_ptr<std::vector<uint8_t>> buffer, uint8_t opcode=WS_TEXT, bool mask=false) { _queueMessage(buffer, opcode, mask); }
-    void message(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false) { _queueMessage(buffer, opcode, mask); }
     bool queueIsFull() const;
 
     size_t printf(const char *format, ...)  __attribute__ ((format (printf, 2, 3)));
 #ifndef ESP32
     size_t printf_P(PGM_P formatP, ...)  __attribute__ ((format (printf, 2, 3)));
 #endif
-    void text(const char * message, size_t len);
-    void text(const char * message);
-    void text(uint8_t * message, size_t len);
-    void text(char * message);
-    void text(const String &message);
-    void text(const __FlashStringHelper *data);
-    void text(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer);
 
-    void binary(const char * message, size_t len);
+    void text(std::shared_ptr<std::vector<uint8_t>> buffer);
-    void binary(const char * message);
+    void text(const uint8_t *message, size_t len);
-    void binary(uint8_t * message, size_t len);
+    void text(const char *message, size_t len);
-    void binary(char * message);
+    void text(const char *message);
+    void text(const String &message);
+    void text(const __FlashStringHelper *message);
+
+    void binary(std::shared_ptr<std::vector<uint8_t>> buffer);
+    void binary(const uint8_t *message, size_t len);
+    void binary(const char *message, size_t len);
+    void binary(const char *message);
     void binary(const String &message);
-    void binary(const __FlashStringHelper *data, size_t len);
+    void binary(const __FlashStringHelper *message, size_t len);
-    void binary(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer);
 
     bool canSend() const;
 
@@ -335,42 +220,34 @@ class AsyncWebSocket: public AsyncWebHandler {
     void closeAll(uint16_t code=0, const char * message=NULL);
     void cleanupClients(uint16_t maxClients = DEFAULT_MAX_WS_CLIENTS);
 
-    void ping(uint32_t id, uint8_t *data=NULL, size_t len=0);
+    void ping(uint32_t id, const uint8_t *data=NULL, size_t len=0);
-    void pingAll(uint8_t *data=NULL, size_t len=0); //  done
+    void pingAll(const uint8_t *data=NULL, size_t len=0); //  done
 
-    void text(uint32_t id, const char * message, size_t len);
+    void text(uint32_t id, const uint8_t *message, size_t len);
-    void text(uint32_t id, const char * message);
+    void text(uint32_t id, const char *message, size_t len);
-    void text(uint32_t id, uint8_t * message, size_t len);
+    void text(uint32_t id, const char *message);
-    void text(uint32_t id, char * message);
     void text(uint32_t id, const String &message);
     void text(uint32_t id, const __FlashStringHelper *message);
 
+    void textAll(std::shared_ptr<std::vector<uint8_t>> buffer);
+    void textAll(const uint8_t *message, size_t len);
     void textAll(const char * message, size_t len);
     void textAll(const char * message);
-    void textAll(uint8_t * message, size_t len);
-    void textAll(char * message);
     void textAll(const String &message);
     void textAll(const __FlashStringHelper *message); //  need to convert
-    void textAll(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer);
 
-    void binary(uint32_t id, const char * message, size_t len);
+    void binary(uint32_t id, const uint8_t *message, size_t len);
-    void binary(uint32_t id, const char * message);
+    void binary(uint32_t id, const char *message, size_t len);
-    void binary(uint32_t id, uint8_t * message, size_t len);
+    void binary(uint32_t id, const char *message);
-    void binary(uint32_t id, char * message);
     void binary(uint32_t id, const String &message);
     void binary(uint32_t id, const __FlashStringHelper *message, size_t len);
 
-    void binaryAll(const char * message, size_t len);
+    void binaryAll(std::shared_ptr<std::vector<uint8_t>> buffer);
-    void binaryAll(const char * message);
+    void binaryAll(const uint8_t *message, size_t len);
-    void binaryAll(uint8_t * message, size_t len);
+    void binaryAll(const char *message, size_t len);
-    void binaryAll(char * message);
+    void binaryAll(const char *message);
     void binaryAll(const String &message);
     void binaryAll(const __FlashStringHelper *message, size_t len);
-    void binaryAll(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer);
-
-    void message(uint32_t id, const char *data, size_t len, uint8_t opcode=WS_TEXT, bool mask=false);
-    void message(uint32_t id, std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
-    void messageAll(std::shared_ptr<AsyncWebSocketMessageBuffer> buffer, uint8_t opcode=WS_TEXT, bool mask=false);
 
     size_t printf(uint32_t id, const char *format, ...)  __attribute__ ((format (printf, 3, 4)));
     size_t printfAll(const char *format, ...)  __attribute__ ((format (printf, 2, 3)));
@@ -393,13 +270,6 @@ class AsyncWebSocket: public AsyncWebHandler {
     virtual bool canHandle(AsyncWebServerRequest *request) override final;
     virtual void handleRequest(AsyncWebServerRequest *request) override final;
 
-
-    //  messagebuffer functions/objects. 
-    std::shared_ptr<AsyncWebSocketMessageBuffer> makeBuffer(size_t size = 0);
-    std::shared_ptr<AsyncWebSocketMessageBuffer> makeBuffer(uint8_t * data, size_t size);
-    std::list<std::weak_ptr<AsyncWebSocketMessageBuffer>> _buffers;
-    void _cleanBuffers(); 
-
     const auto &getClients() const { return _clients; }
 };