@alteriom/painlessmesh 1.6.1 → 1.7.2

package/src/painlessmesh/logger.hpp

@@ -1,158 +1,158 @@
-#ifndef _PAINLESS_MESH_LOGGER_HPP_
-#define _PAINLESS_MESH_LOGGER_HPP_
-
-#include <list>
-
-namespace painlessmesh {
-namespace logger {
-#include <stdarg.h>
-#include "Arduino.h"
-
-#define REMOTE_QUEUE_SIZE 10
-
-typedef enum {
-  ERROR = 1 << 0,
-  STARTUP = 1 << 1,
-  MESH_STATUS = 1 << 2,
-  CONNECTION = 1 << 3,
-  SYNC = 1 << 4,
-  S_TIME = 1 << 5,
-  COMMUNICATION = 1 << 6,
-  GENERAL = 1 << 7,
-  MSG_TYPES = 1 << 8,
-  REMOTE = 1 << 9,  // not yet implemented
-  APPLICATION = 1 << 10,
-  DEBUG = 1 << 11
-} LogLevel;
-
-class LogClass {
- public:
-  void setLogLevel(uint16_t newTypes) {
-    // set the different kinds of debug messages you want to generate.
-    types = newTypes;
-    Serial.print(F("\nsetLogLevel:"));
-    if (types & ERROR) {
-      Serial.print(F(" ERROR |"));
-    }
-    if (types & STARTUP) {
-      Serial.print(F(" STARTUP |"));
-    }
-    if (types & MESH_STATUS) {
-      Serial.print(F(" MESH_STATUS |"));
-    }
-    if (types & CONNECTION) {
-      Serial.print(F(" CONNECTION |"));
-    }
-    if (types & SYNC) {
-      Serial.print(F(" SYNC |"));
-    }
-    if (types & S_TIME) {
-      Serial.print(F(" S_TIME |"));
-    }
-    if (types & COMMUNICATION) {
-      Serial.print(F(" COMMUNICATION |"));
-    }
-    if (types & GENERAL) {
-      Serial.print(F(" GENERAL |"));
-    }
-    if (types & MSG_TYPES) {
-      Serial.print(F(" MSG_TYPES |"));
-    }
-    if (types & REMOTE) {
-      Serial.print(F(" REMOTE |"));
-    }
-    if (types & APPLICATION) {
-      Serial.print(F(" APPLICATION |"));
-    }
-    if (types & DEBUG) {
-      Serial.print(F(" DEBUG |"));
-    }
-    Serial.println();
-    return;
-  }
-  void operator()(LogLevel type, const char *format...) {
-    if (type & types) {  // Print only the message types set for output
-      va_list args;
-      va_start(args, format);
-
-      vsnprintf(str, 200, format, args);
-
-      if (types) {
-        switch (type) {
-          case ERROR:
-            Serial.print(F("ERROR: "));
-            break;
-          case STARTUP:
-            Serial.print(F("STARTUP: "));
-            break;
-          case MESH_STATUS:
-            Serial.print(F("MESH_STATUS: "));
-            break;
-          case CONNECTION:
-            Serial.print(F("CONNECTION: "));
-            break;
-          case SYNC:
-            Serial.print(F("SYNC: "));
-            break;
-          case S_TIME:
-            Serial.print(F("S_TIME: "));
-            break;
-          case COMMUNICATION:
-            Serial.print(F("COMMUNICATION: "));
-            break;
-          case GENERAL:
-            Serial.print(F("GENERAL: "));
-            break;
-          case MSG_TYPES:
-            Serial.print(F("MSG_TYPES: "));
-            break;
-          case REMOTE:
-            this->remote(format);
-            Serial.print(F("REMOTE: "));
-            break;
-          case APPLICATION:
-            Serial.print(F("APPLICATION: "));
-            break;
-          case DEBUG:
-            Serial.print(F("DEBUG: "));
-            break;
-        }
-      }
-
-      Serial.print(str);
-
-      va_end(args);
-    }
-  }
-
-  void remote(const char *format...) {
-    if (REMOTE & types) {  // Store only the message if REMOTE set
-      va_list args;
-      va_start(args, format);
-
-      vsnprintf(str, 200, format, args);
-
-      remote_queue.push_back(std::pair<uint, TSTRING>(remote_uuid, str));
-      ++remote_uuid;
-      if (remote_queue.size() > REMOTE_QUEUE_SIZE) {
-        // No place to store the reason, but do signify the queue is full,
-        // discard any follow up
-        remote_queue.pop_front();
-      }
-    }
-  }
-
-  std::list<std::pair<uint, TSTRING>> &get_remote_queue() {
-    return remote_queue;
-  }
-
- private:
-  uint16_t types = 0;
-  char str[200];
-  std::list<std::pair<uint, TSTRING>> remote_queue;
-  uint remote_uuid;
-};
-
-}  // namespace logger
-}  // namespace painlessmesh
-#endif
+#ifndef _PAINLESS_MESH_LOGGER_HPP_
+#define _PAINLESS_MESH_LOGGER_HPP_
+
+#include <list>
+
+namespace painlessmesh {
+namespace logger {
+#include <stdarg.h>
+#include "Arduino.h"
+
+#define REMOTE_QUEUE_SIZE 10
+
+typedef enum {
+  ERROR = 1 << 0,
+  STARTUP = 1 << 1,
+  MESH_STATUS = 1 << 2,
+  CONNECTION = 1 << 3,
+  SYNC = 1 << 4,
+  S_TIME = 1 << 5,
+  COMMUNICATION = 1 << 6,
+  GENERAL = 1 << 7,
+  MSG_TYPES = 1 << 8,
+  REMOTE = 1 << 9,  // not yet implemented
+  APPLICATION = 1 << 10,
+  DEBUG = 1 << 11
+} LogLevel;
+
+class LogClass {
+ public:
+  void setLogLevel(uint16_t newTypes) {
+    // set the different kinds of debug messages you want to generate.
+    types = newTypes;
+    Serial.print(F("\nsetLogLevel:"));
+    if (types & ERROR) {
+      Serial.print(F(" ERROR |"));
+    }
+    if (types & STARTUP) {
+      Serial.print(F(" STARTUP |"));
+    }
+    if (types & MESH_STATUS) {
+      Serial.print(F(" MESH_STATUS |"));
+    }
+    if (types & CONNECTION) {
+      Serial.print(F(" CONNECTION |"));
+    }
+    if (types & SYNC) {
+      Serial.print(F(" SYNC |"));
+    }
+    if (types & S_TIME) {
+      Serial.print(F(" S_TIME |"));
+    }
+    if (types & COMMUNICATION) {
+      Serial.print(F(" COMMUNICATION |"));
+    }
+    if (types & GENERAL) {
+      Serial.print(F(" GENERAL |"));
+    }
+    if (types & MSG_TYPES) {
+      Serial.print(F(" MSG_TYPES |"));
+    }
+    if (types & REMOTE) {
+      Serial.print(F(" REMOTE |"));
+    }
+    if (types & APPLICATION) {
+      Serial.print(F(" APPLICATION |"));
+    }
+    if (types & DEBUG) {
+      Serial.print(F(" DEBUG |"));
+    }
+    Serial.println();
+    return;
+  }
+  void operator()(LogLevel type, const char *format...) {
+    if (type & types) {  // Print only the message types set for output
+      va_list args;
+      va_start(args, format);
+
+      vsnprintf(str, 200, format, args);
+
+      if (types) {
+        switch (type) {
+          case ERROR:
+            Serial.print(F("ERROR: "));
+            break;
+          case STARTUP:
+            Serial.print(F("STARTUP: "));
+            break;
+          case MESH_STATUS:
+            Serial.print(F("MESH_STATUS: "));
+            break;
+          case CONNECTION:
+            Serial.print(F("CONNECTION: "));
+            break;
+          case SYNC:
+            Serial.print(F("SYNC: "));
+            break;
+          case S_TIME:
+            Serial.print(F("S_TIME: "));
+            break;
+          case COMMUNICATION:
+            Serial.print(F("COMMUNICATION: "));
+            break;
+          case GENERAL:
+            Serial.print(F("GENERAL: "));
+            break;
+          case MSG_TYPES:
+            Serial.print(F("MSG_TYPES: "));
+            break;
+          case REMOTE:
+            this->remote(format);
+            Serial.print(F("REMOTE: "));
+            break;
+          case APPLICATION:
+            Serial.print(F("APPLICATION: "));
+            break;
+          case DEBUG:
+            Serial.print(F("DEBUG: "));
+            break;
+        }
+      }
+
+      Serial.print(str);
+
+      va_end(args);
+    }
+  }
+
+  void remote(const char *format...) {
+    if (REMOTE & types) {  // Store only the message if REMOTE set
+      va_list args;
+      va_start(args, format);
+
+      vsnprintf(str, 200, format, args);
+
+      remote_queue.push_back(std::pair<uint, TSTRING>(remote_uuid, str));
+      ++remote_uuid;
+      if (remote_queue.size() > REMOTE_QUEUE_SIZE) {
+        // No place to store the reason, but do signify the queue is full,
+        // discard any follow up
+        remote_queue.pop_front();
+      }
+    }
+  }
+
+  std::list<std::pair<uint, TSTRING>> &get_remote_queue() {
+    return remote_queue;
+  }
+
+ private:
+  uint16_t types = 0;
+  char str[200];
+  std::list<std::pair<uint, TSTRING>> remote_queue;
+  uint remote_uuid;
+};
+
+}  // namespace logger
+}  // namespace painlessmesh
+#endif

package/src/painlessmesh/memory.hpp

@@ -1,120 +1,120 @@
-#ifndef _PAINLESS_MESH_MEMORY_HPP_
-#define _PAINLESS_MESH_MEMORY_HPP_
-
-/**
- * Memory management utilities for painlessMesh
- * 
- * This module provides optimized memory management utilities to reduce
- * allocations and improve performance in memory-constrained environments.
- */
-
-#include "painlessmesh/configuration.hpp"
-#include <memory>
-#include <vector>
-
-namespace painlessmesh {
-namespace memory {
-
-/**
- * Object pool for frequently allocated types
- * Reduces allocation overhead for commonly used objects
- */
-template<typename T>
-class ObjectPool {
-public:
-    ObjectPool(size_t initial_size = 10) {
-        pool_.reserve(initial_size);
-        for (size_t i = 0; i < initial_size; ++i) {
-            pool_.emplace_back(std::make_unique<T>());
-        }
-    }
-    
-    std::unique_ptr<T> acquire() {
-        if (!pool_.empty()) {
-            auto obj = std::move(pool_.back());
-            pool_.pop_back();
-            return obj;
-        }
-        return std::make_unique<T>();
-    }
-    
-    void release(std::unique_ptr<T> obj) {
-        if (pool_.size() < max_pool_size_) {
-            // Reset object to default state before returning to pool
-            *obj = T{};
-            pool_.push_back(std::move(obj));
-        }
-        // If pool is full, let unique_ptr destroy the object automatically
-    }
-    
-    size_t size() const { return pool_.size(); }
-    
-private:
-    std::vector<std::unique_ptr<T>> pool_;
-    static constexpr size_t max_pool_size_ = 20; // Prevent unlimited growth
-};
-
-/**
- * Pre-sized string buffer to avoid frequent reallocations
- */
-class StringBuffer {
-public:
-    explicit StringBuffer(size_t initial_capacity = 512) {
-        buffer_.reserve(initial_capacity);
-    }
-    
-    void clear() { buffer_.clear(); }
-    
-    void append(const TSTRING& str) {
-        if (buffer_.capacity() < buffer_.size() + str.length()) {
-            buffer_.reserve(std::max(buffer_.capacity() * 2, buffer_.size() + str.length()));
-        }
-        buffer_ += str;
-    }
-    
-    const TSTRING& str() const { return buffer_; }
-    TSTRING& str() { return buffer_; }
-    
-    size_t capacity() const { return buffer_.capacity(); }
-    size_t size() const { return buffer_.size(); }
-    
-private:
-    TSTRING buffer_;
-};
-
-/**
- * Memory usage statistics for monitoring
- */
-struct MemoryStats {
-    size_t total_allocated = 0;
-    size_t total_freed = 0;
-    size_t current_usage = 0;
-    size_t peak_usage = 0;
-    size_t allocation_count = 0;
-    
-    void record_allocation(size_t size) {
-        total_allocated += size;
-        current_usage += size;
-        peak_usage = std::max(peak_usage, current_usage);
-        ++allocation_count;
-    }
-    
-    void record_deallocation(size_t size) {
-        total_freed += size;
-        current_usage = (current_usage >= size) ? current_usage - size : 0;
-    }
-    
-    void reset() {
-        *this = MemoryStats{};
-    }
-};
-
-// Global memory statistics (optional, can be disabled for production)
-#ifdef PAINLESS_MESH_ENABLE_MEMORY_STATS
-extern MemoryStats global_memory_stats;
-#endif
-
-} // namespace memory
-} // namespace painlessmesh
-
+#ifndef _PAINLESS_MESH_MEMORY_HPP_
+#define _PAINLESS_MESH_MEMORY_HPP_
+
+/**
+ * Memory management utilities for painlessMesh
+ * 
+ * This module provides optimized memory management utilities to reduce
+ * allocations and improve performance in memory-constrained environments.
+ */
+
+#include "painlessmesh/configuration.hpp"
+#include <memory>
+#include <vector>
+
+namespace painlessmesh {
+namespace memory {
+
+/**
+ * Object pool for frequently allocated types
+ * Reduces allocation overhead for commonly used objects
+ */
+template<typename T>
+class ObjectPool {
+public:
+    ObjectPool(size_t initial_size = 10) {
+        pool_.reserve(initial_size);
+        for (size_t i = 0; i < initial_size; ++i) {
+            pool_.emplace_back(std::make_unique<T>());
+        }
+    }
+    
+    std::unique_ptr<T> acquire() {
+        if (!pool_.empty()) {
+            auto obj = std::move(pool_.back());
+            pool_.pop_back();
+            return obj;
+        }
+        return std::make_unique<T>();
+    }
+    
+    void release(std::unique_ptr<T> obj) {
+        if (pool_.size() < max_pool_size_) {
+            // Reset object to default state before returning to pool
+            *obj = T{};
+            pool_.push_back(std::move(obj));
+        }
+        // If pool is full, let unique_ptr destroy the object automatically
+    }
+    
+    size_t size() const { return pool_.size(); }
+    
+private:
+    std::vector<std::unique_ptr<T>> pool_;
+    static constexpr size_t max_pool_size_ = 20; // Prevent unlimited growth
+};
+
+/**
+ * Pre-sized string buffer to avoid frequent reallocations
+ */
+class StringBuffer {
+public:
+    explicit StringBuffer(size_t initial_capacity = 512) {
+        buffer_.reserve(initial_capacity);
+    }
+    
+    void clear() { buffer_.clear(); }
+    
+    void append(const TSTRING& str) {
+        if (buffer_.capacity() < buffer_.size() + str.length()) {
+            buffer_.reserve(std::max(buffer_.capacity() * 2, buffer_.size() + str.length()));
+        }
+        buffer_ += str;
+    }
+    
+    const TSTRING& str() const { return buffer_; }
+    TSTRING& str() { return buffer_; }
+    
+    size_t capacity() const { return buffer_.capacity(); }
+    size_t size() const { return buffer_.size(); }
+    
+private:
+    TSTRING buffer_;
+};
+
+/**
+ * Memory usage statistics for monitoring
+ */
+struct MemoryStats {
+    size_t total_allocated = 0;
+    size_t total_freed = 0;
+    size_t current_usage = 0;
+    size_t peak_usage = 0;
+    size_t allocation_count = 0;
+    
+    void record_allocation(size_t size) {
+        total_allocated += size;
+        current_usage += size;
+        peak_usage = std::max(peak_usage, current_usage);
+        ++allocation_count;
+    }
+    
+    void record_deallocation(size_t size) {
+        total_freed += size;
+        current_usage = (current_usage >= size) ? current_usage - size : 0;
+    }
+    
+    void reset() {
+        *this = MemoryStats{};
+    }
+};
+
+// Global memory statistics (optional, can be disabled for production)
+#ifdef PAINLESS_MESH_ENABLE_MEMORY_STATS
+extern MemoryStats global_memory_stats;
+#endif
+
+} // namespace memory
+} // namespace painlessmesh
+
 #endif // _PAINLESS_MESH_MEMORY_HPP_