Changed cpp macros to c++ possibly-null classes, thanks willmmiles

Author: MitchBradley

src/AsyncEventSource.cpp

@@ -192,14 +192,14 @@ AsyncEventSourceClient::AsyncEventSourceClient(AsyncWebServerRequest *request, A
 
 AsyncEventSourceClient::~AsyncEventSourceClient() {
   // Protect message queue access (size checks and modifications) which is not thread-safe.
-  LOCK(_lockmq);
+  lock_guard_type lock(_lockmq);
   _messageQueue.clear();
   close();
 }
 
 bool AsyncEventSourceClient::_queueMessage(const char *message, size_t len) {
   // Protect message queue access (size checks and modifications) which is not thread-safe.
-  LOCK(_lockmq);
+  lock_guard_type lock(_lockmq);
 
   if (_messageQueue.size() >= SSE_MAX_QUEUED_MESSAGES) {
     async_ws_log_w("Event message queue overflow: discard message");
@@ -228,7 +228,7 @@ bool AsyncEventSourceClient::_queueMessage(const char *message, size_t len) {
 
 bool AsyncEventSourceClient::_queueMessage(AsyncEvent_SharedData_t &&msg) {
   // Protect message queue access (size checks and modifications) which is not thread-safe.
-  LOCK(_lockmq);
+  lock_guard_type lock(_lockmq);
 
   if (_messageQueue.size() >= SSE_MAX_QUEUED_MESSAGES) {
     async_ws_log_w("Event message queue overflow: discard message");
@@ -256,7 +256,7 @@ bool AsyncEventSourceClient::_queueMessage(AsyncEvent_SharedData_t &&msg) {
 
 void AsyncEventSourceClient::_onAck(size_t len __attribute__((unused)), uint32_t time __attribute__((unused))) {
   // Protect message queue access (size checks and modifications) which is not thread-safe.
-  LOCK(_lockmq);
+  lock_guard_type lock(_lockmq);
 
   // adjust in-flight len
   if (len < _inflight) {
@@ -282,7 +282,7 @@ void AsyncEventSourceClient::_onAck(size_t len __attribute__((unused)), uint32_t
 
 void AsyncEventSourceClient::_onPoll() {
   // Protect message queue access (size checks and modifications) which is not thread-safe.
-  LOCK(_lockmq);
+  lock_guard_type lock(_lockmq);
   if (_messageQueue.size()) {
     _runQueue();
   }
@@ -363,7 +363,7 @@ void AsyncEventSource::_addClient(AsyncEventSourceClient *client) {
     _connectcb(client);
   }
 
-  LOCK(_client_queue_lock);
+  lock_guard_type lock(_client_queue_lock);
   _clients.emplace_back(client);
 
   _adjust_inflight_window();
@@ -373,7 +373,7 @@ void AsyncEventSource::_handleDisconnect(AsyncEventSourceClient *client) {
   if (_disconnectcb) {
     _disconnectcb(client);
   }
-  LOCK(_client_queue_lock);
+  lock_guard_type lock(_client_queue_lock);
   for (auto i = _clients.begin(); i != _clients.end(); ++i) {
     if (i->get() == client) {
       _clients.erase(i);
@@ -387,7 +387,7 @@ void AsyncEventSource::close() {
   // While the whole loop is not done, the linked list is locked and so the
   // iterator should remain valid even when AsyncEventSource::_handleDisconnect()
   // is called very early
-  LOCK(_client_queue_lock);
+  lock_guard_type lock(_client_queue_lock);
   for (const auto &c : _clients) {
     if (c->connected()) {
       /**
@@ -404,7 +404,7 @@ void AsyncEventSource::close() {
 size_t AsyncEventSource::avgPacketsWaiting() const {
   size_t aql = 0;
   uint32_t nConnectedClients = 0;
-  LOCK(_client_queue_lock);
+  lock_guard_type lock(_client_queue_lock);
   for (const auto &c : _clients) {
     if (c->connected()) {
       aql += c->packetsWaiting();
@@ -416,7 +416,7 @@ size_t AsyncEventSource::avgPacketsWaiting() const {
 
 AsyncEventSource::SendStatus AsyncEventSource::send(const char *message, const char *event, uint32_t id, uint32_t reconnect) {
   AsyncEvent_SharedData_t shared_msg = std::make_shared<String>(generateEventMessage(message, event, id, reconnect));
-  LOCK(_client_queue_lock);
+  lock_guard_type lock(_client_queue_lock);
   size_t hits = 0;
   size_t miss = 0;
   for (const auto &c : _clients) {
@@ -432,7 +432,7 @@ AsyncEventSource::SendStatus AsyncEventSource::send(const char *message, const c
 }
 
 size_t AsyncEventSource::count() const {
-  LOCK(_client_queue_lock);
+  lock_guard_type lock(_client_queue_lock);
   size_t n_clients{0};
   for (const auto &i : _clients) {
     if (i->connected()) {

src/AsyncEventSource.h

@@ -136,7 +136,7 @@ class AsyncEventSourceClient {
   size_t _inflight{0};                    // num of unacknowledged bytes that has been written to socket buffer
   size_t _max_inflight{SSE_MAX_INFLIGH};  // max num of unacknowledged bytes that could be written to socket buffer
   std::list<AsyncEventSourceMessage> _messageQueue;
-  MAKE_LOCK(_lockmq);
+  mutable mutex_type _lockmq;
   bool _queueMessage(const char *message, size_t len);
   bool _queueMessage(AsyncEvent_SharedData_t &&msg);
   void _runQueue();
@@ -203,7 +203,7 @@ class AsyncEventSourceClient {
     return _lastId;
   }
   size_t packetsWaiting() const {
-    LOCK(_lockmq);
+    lock_guard_type lock(_lockmq);
     return _messageQueue.size();
   };
 
@@ -243,7 +243,7 @@ class AsyncEventSource : public AsyncWebHandler {
   std::list<std::unique_ptr<AsyncEventSourceClient>> _clients;
   // Same as for individual messages, protect mutations of _clients list
   // since simultaneous access from different tasks is possible
-  MAKE_LOCK(_client_queue_lock);
+  mutable mutex_type _client_queue_lock;
   ArEventHandlerFunction _connectcb = nullptr;
   ArEventHandlerFunction _disconnectcb = nullptr;
 

src/AsyncWebSocket.cpp

@@ -294,7 +294,7 @@ AsyncWebSocketClient::AsyncWebSocketClient(AsyncClient *client, AsyncWebSocket *
 
 AsyncWebSocketClient::~AsyncWebSocketClient() {
   {
-    LOCK(_lock);
+    lock_guard_type lock(_lock);
     _messageQueue.clear();
     _controlQueue.clear();
   }
@@ -310,7 +310,7 @@ void AsyncWebSocketClient::_clearQueue() {
 void AsyncWebSocketClient::_onAck(size_t len, uint32_t time) {
   _lastMessageTime = millis();
 
-  UNIQUE_LOCK(_lock);
+  unique_lock_type lock(_lock);
 
   async_ws_log_v("[%s][%" PRIu32 "] START ACK(%u, %" PRIu32 ") Q:%u", _server->url(), _clientId, len, time, _messageQueue.size());
 
@@ -328,7 +328,7 @@ void AsyncWebSocketClient::_onAck(size_t len, uint32_t time) {
             Due to _client->close() shall call the callback function _onDisconnect()
             The calling flow _onDisconnect() --> _handleDisconnect() --> ~AsyncWebSocketClient()
           */
-          UNLOCK();
+          lock.unlock();
           _client->close();
         }
         return;
@@ -358,11 +358,11 @@ void AsyncWebSocketClient::_onPoll() {
     return;
   }
 
-  UNIQUE_LOCK(_lock);
+  unique_lock_type lock(_lock);
   if (_client && _client->canSend() && (!_controlQueue.empty() || !_messageQueue.empty())) {
     _runQueue();
   } else if (_keepAlivePeriod > 0 && (millis() - _lastMessageTime) >= _keepAlivePeriod && (_controlQueue.empty() && _messageQueue.empty())) {
-    UNLOCK();
+    lock.unlock();
     ping((uint8_t *)AWSC_PING_PAYLOAD, AWSC_PING_PAYLOAD_LEN);
   }
 }
@@ -426,17 +426,17 @@ void AsyncWebSocketClient::_runQueue() {
 }
 
 bool AsyncWebSocketClient::queueIsFull() const {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   return (_messageQueue.size() >= WS_MAX_QUEUED_MESSAGES) || (_status != WS_CONNECTED);
 }
 
 size_t AsyncWebSocketClient::queueLen() const {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   return _messageQueue.size();
 }
 
 bool AsyncWebSocketClient::canSend() const {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   return _messageQueue.size() < WS_MAX_QUEUED_MESSAGES;
 }
 
@@ -445,7 +445,7 @@ bool AsyncWebSocketClient::_queueControl(uint8_t opcode, const uint8_t *data, si
     return false;
   }
 
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
 
   _controlQueue.emplace_back(opcode, data, len, mask);
   async_ws_log_v("[%s][%" PRIu32 "] QUEUE CTRL (%u) << %" PRIu8, _server->url(), _clientId, _controlQueue.size(), opcode);
@@ -462,7 +462,7 @@ bool AsyncWebSocketClient::_queueMessage(AsyncWebSocketSharedBuffer buffer, uint
     return false;
   }
 
-  UNIQUE_LOCK(_lock);
+  unique_lock_type lock(_lock);
 
   if (_messageQueue.size() >= WS_MAX_QUEUED_MESSAGES) {
     if (closeWhenFull) {
@@ -474,7 +474,7 @@ bool AsyncWebSocketClient::_queueMessage(AsyncWebSocketSharedBuffer buffer, uint
           Due to _client->close() shall call the callback function _onDisconnect()
           The calling flow _onDisconnect() --> _handleDisconnect() --> ~AsyncWebSocketClient()
         */
-        UNLOCK();
+        lock.unlock();
         _client->close();
       }
 
@@ -969,7 +969,7 @@ void AsyncWebSocket::_handleEvent(AsyncWebSocketClient *client, AwsEventType typ
 }
 
 AsyncWebSocketClient *AsyncWebSocket::_newClient(AsyncWebServerRequest *request) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   _clients.emplace_back(request, this);
   // we've just detached AsyncTCP client from AsyncWebServerRequest
   _handleEvent(&_clients.back(), WS_EVT_CONNECT, request, NULL, 0);
@@ -979,7 +979,7 @@ AsyncWebSocketClient *AsyncWebSocket::_newClient(AsyncWebServerRequest *request)
 }
 
 void AsyncWebSocket::_handleDisconnect(AsyncWebSocketClient *client) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   const auto client_id = client->id();
   const auto iter = std::find_if(std::begin(_clients), std::end(_clients), [client_id](const AsyncWebSocketClient &c) {
     return c.id() == client_id;
@@ -990,14 +990,14 @@ void AsyncWebSocket::_handleDisconnect(AsyncWebSocketClient *client) {
 }
 
 bool AsyncWebSocket::availableForWriteAll() {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   return std::none_of(std::begin(_clients), std::end(_clients), [](const AsyncWebSocketClient &c) {
     return c.queueIsFull();
   });
 }
 
 bool AsyncWebSocket::availableForWrite(uint32_t id) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   const auto iter = std::find_if(std::begin(_clients), std::end(_clients), [id](const AsyncWebSocketClient &c) {
     return c.id() == id;
   });
@@ -1008,14 +1008,14 @@ bool AsyncWebSocket::availableForWrite(uint32_t id) {
 }
 
 size_t AsyncWebSocket::count() const {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   return std::count_if(std::begin(_clients), std::end(_clients), [](const AsyncWebSocketClient &c) {
     return c.status() == WS_CONNECTED;
   });
 }
 
 AsyncWebSocketClient *AsyncWebSocket::client(uint32_t id) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   const auto iter = std::find_if(_clients.begin(), _clients.end(), [id](const AsyncWebSocketClient &c) {
     return c.id() == id && c.status() == WS_CONNECTED;
   });
@@ -1033,7 +1033,7 @@ void AsyncWebSocket::close(uint32_t id, uint16_t code, const char *message) {
 }
 
 void AsyncWebSocket::closeAll(uint16_t code, const char *message) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   for (auto &c : _clients) {
     if (c.status() == WS_CONNECTED) {
       c.close(code, message);
@@ -1042,7 +1042,7 @@ void AsyncWebSocket::closeAll(uint16_t code, const char *message) {
 }
 
 void AsyncWebSocket::cleanupClients(uint16_t maxClients) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   const size_t c = count();
   if (c > maxClients) {
     async_ws_log_v("[%s] CLEANUP %" PRIu32 " (%u/%" PRIu16 ")", _url.c_str(), _clients.front().id(), c, maxClients);
@@ -1063,7 +1063,7 @@ bool AsyncWebSocket::ping(uint32_t id, const uint8_t *data, size_t len) {
 }
 
 AsyncWebSocket::SendStatus AsyncWebSocket::pingAll(const uint8_t *data, size_t len) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   size_t hit = 0;
   size_t miss = 0;
   for (auto &c : _clients) {
@@ -1172,7 +1172,7 @@ AsyncWebSocket::SendStatus AsyncWebSocket::textAll(AsyncWebSocketMessageBuffer *
 }
 
 AsyncWebSocket::SendStatus AsyncWebSocket::textAll(AsyncWebSocketSharedBuffer buffer) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   size_t hit = 0;
   size_t miss = 0;
   for (auto &c : _clients) {
@@ -1262,7 +1262,7 @@ AsyncWebSocket::SendStatus AsyncWebSocket::binaryAll(AsyncWebSocketMessageBuffer
   return status;
 }
 AsyncWebSocket::SendStatus AsyncWebSocket::binaryAll(AsyncWebSocketSharedBuffer buffer) {
-  LOCK(_lock);
+  lock_guard_type lock(_lock);
   size_t hit = 0;
   size_t miss = 0;
   for (auto &c : _clients) {

src/AsyncWebSocket.h

@@ -230,7 +230,7 @@ class AsyncWebSocketClient {
   uint8_t _pstate;
   uint32_t _lastMessageTime;
   uint32_t _keepAlivePeriod;
-  MAKE_LOCK(_lock);
+  mutable mutex_type _lock;
   std::deque<AsyncWebSocketControl> _controlQueue;
   std::deque<AsyncWebSocketMessage> _messageQueue;
   bool closeWhenFull = true;
@@ -378,7 +378,7 @@ class AsyncWebSocket : public AsyncWebHandler {
   AwsEventHandler _eventHandler;
   AwsHandshakeHandler _handshakeHandler;
   bool _enabled;
-  MAKE_LOCK(_lock);
+  mutable mutex_type _lock;
 
 public:
   typedef enum {

src/ESPAsyncWebServer.h

@@ -56,21 +56,30 @@
 
 #if defined(ESP32) || defined(HOST)
 #include <mutex>
-#define MAKE_LOCK(var)   mutable std::recursive_mutex var
-#define LOCK(var)        std::lock_guard<std::recursive_mutex> lock(var)
-#define UNIQUE_LOCK(var) std::unique_lock<std::recursive_mutex> lock(var)
-#define UNLOCK()         lock.unlock()
+typedef std::recursive_mutex mutex_type;
+typedef std::lock_guard<mutex_type> lock_guard_type;
+typedef std::unique_lock<mutex_type> unique_lock_type;
 #else
-#define MAKE_LOCK(var)
-#define LOCK(var) \
-  do {            \
-  } while (0)
-#define UNIQUE_LOCK(var) \
-  do {                   \
-  } while (0)
-#define UNLOCK() \
-  do {           \
-  } while (0)
+// Do-nothing locks that will evaporate under optimization
+class null_mutex {
+public:
+  void lock() {}
+  void unlock() {}
+  bool try_lock() {
+    return true;
+  };
+};
+typedef null_mutex mutex_type;
+
+class lock_guard_type {
+public:
+  lock_guard_type(mutex_type &) {};
+};
+class unique_lock_type {
+public:
+  unique_lock_type(mutex_type &) {};
+  void unlock() {};
+};
 #endif
 
 #include "AsyncWebServerVersion.h"