Clean up callback_list, remove sentinel/active/tail, callbacks return bool for removal, register before send

firmware/include/callback_list.h

@@ -1,87 +1,80 @@
 #pragma once
-#include <cstdint>
-#include <new>
 #include <utility>
 
 template <typename T, int N>
 struct callback_list {
     struct node {
-        alignas(T) uint8_t storage[sizeof(T)];
+        T value;
         node* prev = nullptr;
         node* next = nullptr;
-        bool active = false;
-
-        T& value() { return *reinterpret_cast<T*>(storage); }
-        const T& value() const { return *reinterpret_cast<const T*>(storage); }
     };
 
     node nodes[N];
     node* free_head = &nodes[0];
-    node sentinel;
+    node* head = nullptr;
 
     callback_list() {
         for (int i = 0; i < N - 1; i++) nodes[i].next = &nodes[i + 1];
         nodes[N - 1].next = nullptr;
-        sentinel.prev = &sentinel;
-        sentinel.next = &sentinel;
     }
 
-    bool empty() const { return sentinel.next == &sentinel; }
+    bool empty() const { return head == nullptr; }
 
     node* insert(T value) {
         if (!free_head) return nullptr;
-        node* n = alloc(std::move(value));
-        link_before(&sentinel, n);
+        node* n = free_head;
+        free_head = n->next;
+        n->value = std::move(value);
+        n->prev = nullptr;
+        n->next = head;
+        if (head) head->prev = n;
+        head = n;
         return n;
     }
 
     template <typename Less>
     node* insert_sorted(T value, Less&& less) {
         if (!free_head) return nullptr;
-        node* n = alloc(std::move(value));
-        node* pos = sentinel.next;
-        while (pos != &sentinel && !less(n->value(), pos->value()))
-            pos = pos->next;
-        link_before(pos, n);
+        node* n = free_head;
+        free_head = n->next;
+        n->value = std::move(value);
+        if (!head || less(n->value, head->value)) {
+            n->prev = nullptr;
+            n->next = head;
+            if (head) head->prev = n;
+            head = n;
+            return n;
+        }
+        node* cur = head;
+        while (cur->next && !less(n->value, cur->next->value))
+            cur = cur->next;
+        n->prev = cur;
+        n->next = cur->next;
+        if (cur->next) cur->next->prev = n;
+        cur->next = n;
         return n;
     }
 
     void remove(node* n) {
-        if (!n || !n->active) return;
-        n->prev->next = n->next;
-        n->next->prev = n->prev;
-        n->active = false;
-        n->value().~T();
+        if (!n) return;
+        if (n->prev) n->prev->next = n->next;
+        else head = n->next;
+        if (n->next) n->next->prev = n->prev;
+        n->value = T{};
         n->next = free_head;
         n->prev = nullptr;
         free_head = n;
     }
 
-    node* front() { return sentinel.next != &sentinel ? sentinel.next : nullptr; }
+    node* front() { return head; }
 
     template <typename Fn>
     void for_each(Fn&& fn) {
-        node* cur = sentinel.next;
-        while (cur != &sentinel) {
+        node* cur = head;
+        while (cur) {
             node* next = cur->next;
             fn(cur);
             cur = next;
         }
     }
-
-private:
-    node* alloc(T value) {
-        node* n = free_head;
-        free_head = n->next;
-        new (n->storage) T(std::move(value));
-        n->active = true;
-        return n;
-    }
-
-    void link_before(node* pos, node* n) {
-        n->prev = pos->prev;
-        n->next = pos;
-        pos->prev->next = n;
-        pos->prev = n;
-    }
 };