@alteriom/painlessmesh 1.6.1

package/src/painlessmesh/layout.hpp

@@ -0,0 +1,188 @@
+#ifndef _PAINLESS_MESH_LAYOUT_HPP_
+#define _PAINLESS_MESH_LAYOUT_HPP_
+
+#include <list>
+#include <memory>
+
+#include "painlessmesh/protocol.hpp"
+
+namespace painlessmesh {
+namespace layout {
+
+#include <memory>
+/**
+ * Whether the tree contains the given nodeId
+ */
+inline bool contains(protocol::NodeTree nodeTree, uint32_t nodeId) {
+  if (nodeTree.nodeId == nodeId) {
+    return true;
+  }
+  for (auto&& s : nodeTree.subs) {
+    if (contains(s, nodeId)) return true;
+  }
+  return false;
+}
+
+inline protocol::NodeTree excludeRoute(protocol::NodeTree&& tree,
+                                       uint32_t exclude) {
+  // Make sure to exclude any subs with nodeId == 0,
+  // even if exlude is not set to zero
+  tree.subs.remove_if([exclude](protocol::NodeTree s) {
+    return s.nodeId == 0 || s.nodeId == exclude;
+  });
+  return tree;
+}
+
+template <class T>
+class Layout {
+ public:
+  size_t stability = 0;
+  std::list<std::shared_ptr<T> > subs;
+
+  /** Return the nodeId of the node that we are running on.
+   *
+   * On the ESP hardware nodeId is uniquely calculated from the MAC address of
+   * the node.
+   */
+  uint32_t getNodeId() { return nodeId; }
+
+  /**
+   * Check whether this node is a root node.
+   */
+  bool isRoot() { return root; }
+
+  protocol::NodeTree asNodeTree() {
+    auto nt = protocol::NodeTree(nodeId, root);
+    for (auto&& s : subs) {
+      if (s->nodeId == 0) continue;
+      nt.subs.push_back(protocol::NodeTree(*s));
+    }
+    return nt;
+  }
+
+ protected:
+  uint32_t nodeId = 0;
+  bool root = false;
+};
+
+template <class T>
+void syncLayout(Layout<T>& layout, uint32_t changedId) {
+  // TODO: this should be called from changed connections and dropped
+  // connections events
+  for (auto&& sub : layout.subs) {
+    if (sub->connected() && !sub->newConnection && sub->nodeId != 0 &&
+        sub->nodeId != changedId) {  // Exclude current
+      sub->nodeSyncTask.forceNextIteration();
+    }
+  }
+  layout.stability /= 2;
+}
+
+class Neighbour : public protocol::NodeTree {
+ public:
+  // Inherit constructors
+  using protocol::NodeTree::NodeTree;
+
+  /**
+   * Is the passed nodesync valid
+   *
+   * If not then the caller of this function should probably disconnect
+   * this neighbour.
+   */
+  bool validSubs(protocol::NodeTree tree) {
+    if (nodeId == 0)  // Cant really know, so valid as far as we know
+      return true;
+    if (nodeId != tree.nodeId) return false;
+    for (auto&& s : tree.subs) {
+      if (layout::contains(s, nodeId)) return false;
+    }
+    return true;
+  }
+
+  /**
+   * Update subs with the new subs
+   *
+   * \param tree The possible new tree with this node as base
+   *
+   * Generally one probably wants to call validSubs before calling this
+   * function.
+   *
+   * \return Whether we adopted the new tree
+   */
+  bool updateSubs(protocol::NodeTree tree) {
+    if (nodeId == 0 || tree != (*this)) {
+      nodeId = tree.nodeId;
+      subs = tree.subs;
+      root = tree.root;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Create a request
+   */
+  protocol::NodeSyncRequest request(NodeTree&& layout) {
+    auto subTree = excludeRoute(std::move(layout), nodeId);
+    return protocol::NodeSyncRequest(subTree.nodeId, nodeId, subTree.subs,
+                                     subTree.root);
+  }
+
+  /**
+   * Create a reply
+   */
+  protocol::NodeSyncReply reply(NodeTree&& layout) {
+    auto subTree = excludeRoute(std::move(layout), nodeId);
+    return protocol::NodeSyncReply(subTree.nodeId, nodeId, subTree.subs,
+                                   subTree.root);
+  }
+};
+
+/**
+ * The size of the mesh (the number of nodes)
+ */
+inline uint32_t size(protocol::NodeTree nodeTree) {
+  auto no = 1;
+  for (auto&& s : nodeTree.subs) {
+    no += size(s);
+  }
+  return no;
+}
+
+/**
+ * Whether the top node in the tree is also the root of the mesh
+ */
+inline bool isRoot(protocol::NodeTree nodeTree) {
+  if (nodeTree.root) return true;
+  return false;
+}
+
+/**
+ * Whether any node in the tree is also root of the mesh
+ */
+inline bool isRooted(protocol::NodeTree nodeTree) {
+  if (isRoot(nodeTree)) return true;
+  for (auto&& s : nodeTree.subs) {
+    if (isRooted(s)) return true;
+  }
+  return false;
+}
+
+/**
+ * Return all nodes in a list container
+ */
+inline std::list<uint32_t> asList(protocol::NodeTree nodeTree,
+                                  bool includeSelf = true) {
+  std::list<uint32_t> lst;
+  if (includeSelf) lst.push_back(nodeTree.nodeId);
+  for (auto&& s : nodeTree.subs) {
+    lst.splice(lst.end(), asList(s));
+  }
+  return lst;
+}
+
+}  // namespace layout
+}  // namespace painlessmesh
+
+#endif
+

package/src/painlessmesh/logger.hpp

@@ -0,0 +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

package/src/painlessmesh/memory.hpp

@@ -0,0 +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
+
+#endif // _PAINLESS_MESH_MEMORY_HPP_