Dev

.github/CODEOWNERS

@@ -0,0 +1 @@
+* otto-link

.github/workflows/deploy_docs.yml

@@ -4,6 +4,11 @@ on:
   push:
     branches: [main, dev]
 
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+
 jobs:
   doxygen:
     runs-on: ubuntu-latest

Meta/include/meta/core/abstract_attribute.hpp

@@ -14,6 +14,7 @@
 
 #include <nlohmann/json.hpp>
 
+#include "meta/core/event.hpp"
 #include "meta/core/meta_object.hpp"
 #include "meta/serialization/serialization_mode.hpp"
 
@@ -36,6 +37,9 @@ class AbstractAttribute : public MetaObject
 public:
   virtual ~AbstractAttribute() = default;
 
+  /// Untyped event fired whenever the attribute value changes.
+  Event<AbstractAttribute &> value_changed_event;
+
   /// Returns the attribute name.
   virtual const std::string &name() const = 0;
 

Meta/include/meta/core/attribute.hpp

@@ -66,6 +66,22 @@ template <typename T> class Attribute : public AbstractAttribute
   Attribute(std::string name, T value)
       : name_(std::move(name)), value_(std::move(value))
   {
+    value_changed_conn_ = value_changed.subscribe(
+        [this](const T &) { value_changed_event.notify(*this); });
+  }
+
+  /// Sets value and notifies subscribers.
+  void set_value(const T &new_value)
+  {
+    value_ = new_value;
+    value_changed.notify(value_);
+  }
+
+  /// Sets value (by move) and notifies subscribers.
+  void set_value(T &&new_value)
+  {
+    value_ = std::move(new_value);
+    value_changed.notify(value_);
   }
 
   /// Get attribute name.
@@ -179,8 +195,9 @@ template <typename T> class Attribute : public AbstractAttribute
   }
 
 private:
-  std::string name_;
-  T           value_;
+  std::string     name_;
+  T               value_;
+  EventConnection value_changed_conn_;
 };
 
 } // namespace meta

Meta/include/meta/core/attribute_container.hpp

@@ -59,6 +59,9 @@ concept StringLike = std::is_same_v<std::decay_t<T>, std::string> ||
 class AttributeContainer : public MetaObject
 {
 public:
+  Event<AbstractAttribute &> attribute_added;
+  Event<const std::string &> attribute_removed;
+
   // -------------------------------------------------------------------------
   // Capacity
   // -------------------------------------------------------------------------
@@ -140,6 +143,8 @@ class AttributeContainer : public MetaObject
     // keep track of insertion order
     insertion_order_.push_back(name);
 
+    attribute_added.notify(*ptr);
+
     return ptr;
   }
 
@@ -174,6 +179,8 @@ class AttributeContainer : public MetaObject
     // keep track of insertion order
     insertion_order_.push_back(name);
 
+    attribute_added.notify(*ptr);
+
     return ptr;
   }
 
@@ -197,6 +204,8 @@ class AttributeContainer : public MetaObject
     // keep track of insertion order
     insertion_order_.push_back(name);
 
+    attribute_added.notify(*ptr);
+
     return ptr;
   }
 
@@ -226,6 +235,8 @@ class AttributeContainer : public MetaObject
     // keep track of insertion order
     insertion_order_.push_back(name);
 
+    attribute_added.notify(*ptr);
+
     return ptr;
   }
 

Meta/include/meta/core/container_group.hpp

@@ -12,6 +12,8 @@
 #include <memory>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
+#include <vector>
 
 #include "meta/core/attribute_container.hpp"
 #include "meta/core/meta_object.hpp"
@@ -81,7 +83,7 @@ class ContainerGroup : public MetaObject
    */
   const AttributeContainer *find(const std::string &key) const;
 
-  /// Returns the attribute names in insertion order.
+  /// Returns the container names in insertion order.
   const std::vector<std::string> &insertion_order() const;
 
   /**
@@ -90,9 +92,77 @@ class ContainerGroup : public MetaObject
    */
   void set_current(const std::string &key);
 
+  /**
+   * @brief Set the active container to the first container in the list.
+   * @throws std::runtime_error if there are no containers in the group.
+   */
+  void set_current_to_first();
+
   /// Clear all containers.
   void clear();
 
+  // -------------------------------------------------------------------------
+  // Attribute Synchronization
+  // -------------------------------------------------------------------------
+
+  /**
+   * @brief Detects attribute keys shared across at least two containers with
+   *        matching types.
+   * @return Vector of shared attribute keys in insertion order.
+   */
+  std::vector<std::string> shared_attributes() const;
+
+  /**
+   * @brief Checks whether an attribute key is shared across at least two
+   *        containers with matching types.
+   * @param key Attribute identifier.
+   * @return true if shared, false otherwise.
+   */
+  bool is_shared(const std::string &key) const;
+
+  /**
+   * @brief Enable or disable synchronization for an attribute key across
+   *        containers in this group.
+   *
+   * When enabled, the attribute's current value (from the active container, or
+   * the first container containing it) is propagated to all matching
+   * containers, and subsequent updates in any container are kept in sync.
+   *
+   * @param key Attribute identifier.
+   * @param synchronize Whether to synchronize.
+   */
+  void set_synchronized(const std::string &key, bool synchronize = true);
+
+  /**
+   * @brief Check whether an attribute is marked for synchronization.
+   * @param key Attribute identifier.
+   * @return true if synchronized.
+   */
+  bool is_synchronized(const std::string &key) const;
+
+  /**
+   * @brief Get the set of currently synchronized attribute keys.
+   * @return Constant reference to the set of synchronized attribute names.
+   */
+  const std::unordered_set<std::string> &synchronized_attributes() const;
+
+  /**
+   * @brief Synchronizes all detected shared attributes across containers.
+   * @param synchronize Whether to enable or disable synchronization for all.
+   */
+  void synchronize_all(bool synchronize = true);
+
+  /// Disables synchronization for all attributes.
+  void clear_synchronizations();
+
+  /**
+   * @brief Manually propagate the value of an attribute from the active
+   *        container (or first containing container) to all other matching
+   *        containers in the group.
+   * @param key Attribute identifier.
+   */
+  void sync_attribute(const std::string &key);
+
   // -------------------------------------------------------------------------
   // Serialization
   // -------------------------------------------------------------------------
@@ -135,6 +205,19 @@ class ContainerGroup : public MetaObject
   std::vector<std::string> insertion_order_;
   AttributeContainer      *current_ = nullptr;
 
+  std::unordered_set<std::string> synchronized_attributes_;
+  bool                            is_synchronizing_ = false;
+
+  // Track event connections per container
+  std::unordered_map<std::string, std::vector<EventConnection>>
+      container_connections_;
+
+  void bind_container(const std::string &key, AttributeContainer &container);
+  void bind_attribute(const std::string &container_key,
+                      AbstractAttribute &attr);
+  void sync_attribute_across_containers(const std::string &key,
+                                        AbstractAttribute &source);
+
   /**
    * @brief Removes stale entries from insertion_order_ that no longer exist
    *        in attributes_ (e.g. after external erasure or clear).

Meta/src/attribute_container.cpp

@@ -38,6 +38,10 @@ ConstAttrIterator AttributeContainer::cend() const
 void AttributeContainer::clear()
 {
   Logger::log()->trace("AttributeContainer::clear");
+
+  for (const auto &name : insertion_order_)
+    attribute_removed.notify(name);
+
   attributes_.clear();
   compact_insertion_order();
 }
@@ -179,6 +183,7 @@ void AttributeContainer::json_from(const nlohmann::json &j,
                                                        std::move(new_attr));
 
       it = insert_it;
+      attribute_added.notify(*it->second);
     }
     else
     {