Adding an inheriting data model to Node

tools/dom/templates/html/impl/impl_Node.darttemplate

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of $LIBRARYNAME;
 
 /**
  * Lazy implementation of the child nodes of an element that does not request
  * the actual child nodes of an element until strictly necessary greatly
  * improving performance for the typical cases where it is not required.
@@ skipping 317 matching lines @@
         // Should use $dom_firstChild, Bug 8886.
         this.insertBefore(newNodes[0], refChild);
       }
     } else {
       for (var node in newNodes) {
         this.insertBefore(node, refChild);
       }
     }
   }
 
+  // Note that this may either be the locally set model or a cached value
+  // of the inherited model. This is cached to minimize model change
+  // notifications.
+  var _model;
+  bool _hasLocalModel;
+  StreamController _modelChangedStream;
+
+  /**
+   * The data model which is inherited through the tree.
+   *
+   * Setting this will propagate the value to all descendant nodes. If the
+   * model is not set on this node then it will be inherited from ancestor
+   * nodes.
+   *
+   * [clearModel] must be used to remove the model property from this node
+   * and have the model inherit from ancestor nodes.
+   */
+  @Experimental
+  get model {
+    // If we have a change handler then we've cached the model locally.
+    if (_modelChangedStream != null) {
+      return _model;
+    }
+    // Otherwise start looking up the tree.
+    for (var node = this; node != null; node = node.parentNode) {
+      if (node._hasLocalModel == true) {
+        return node._model;
+      }
+    }
+    return null;
+  }
+
+  @Experimental
+  void set model(value) {
+    var changed = model != value;
+    _model = value;
+    _hasLocalModel = true;
+    _ModelTreeObserver.initialize();
+
+    if (changed) {
+      if (_modelChangedStream != null) {
+        _modelChangedStream.add(value);

[Jennifer Messerly, 2013/03/15 18:49:21]

A couple more questions:

* Should this be the node instead? The benefit to that is you can get the model
from the node but not vice versa. Then I could have one closure that handles
modelChanged for a bunch of nodes. Kind of analogous to .NET's (object sender,
EventArgs args) pattern.

Then again, I could also close over the node at the cost of an extra allocation.
Maybe it's premature to be optimizing :)

* Maybe this should be lighter weight than a stream, since it's kind of an
implementation detail? In observers I used callbacks, because I was trying to
keep it low-level. OTOH, maybe that was a mistake and I should use streams there
too.

[blois, 2013/03/15 20:14:10]

Changed callback to be Node rather than model, should be efficient as the model
is always cached locally when generating change events.

Discussed streams, will use for now, but not committed to them long-term.

+      }
+      // Propagate new model to all descendants.
+      _ModelTreeObserver.propagateModel(this, value, false);
+    }
+  }
+
+  /**
+   * Clears the locally set model and makes this model be inherited from parent
+   * nodes.
+   */
+  @Experimental
+  void clearModel() {
+    if (_hasLocalModel == true) {
+      _hasLocalModel = false;
+
+      // Propagate new model to all descendants.
+      if (parentNode != null) {
+        _ModelTreeObserver.propagateModel(this, parentNode.model, false);
+      } else {
+        _ModelTreeObserver.propagateModel(this, null, false);
+      }
+    }
+  }
+
+  /**
+   * Get a stream of models, whenever the model changes.
+   */
+  Stream get onModelChanged {
+    if (_modelChangedStream == null) {
+      // Ensure the model is cached locally to minimize change notifications.
+      _model = model;
+      _modelChangedStream = new StreamController.broadcast();
+    }
+    return _modelChangedStream.stream;
+  }
+
 $!MEMBERS
 }