implement dirty checking for @observable objects

pkg/observe/lib/src/observable_list.dart

 // Copyright (c) 2013, 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 observe;
 
 /**
  * Represents an observable list of model values. If any items are added,
  * removed, or replaced, then observers that are listening to [changes]
  * will be notified.
  */
 // TODO(jmesserly): remove implements List<E> once we can extend ListBase<E>

[Siggi Cherem (dart-lang), 2013/07/22 21:47:22]

remove todo =)?

[Jennifer Messerly, 2013/07/22 22:38:39]

Done.

-class ObservableList<E> extends _ListBaseWorkaround with ObservableMixin
-    implements List<E> {
-  List<ListChangeRecord> _records;
+class ObservableList<E> extends ListBase<E> with ChangeNotifierMixin {
+  List<ListChangeRecord> _listRecords;
 
   /** The inner [List<E>] with the actual storage. */
   final List<E> _list;
 
   /**
    * Creates an observable list of the given [length].
    *
    * If no [length] argument is supplied an extendable list of
    * length 0 is created.
    *
@@ skipping 148 matching lines @@
   void _rangeCheck(int start, int end) {
     if (start < 0 || start > this.length) {
       throw new RangeError.range(start, 0, this.length);
     }
     if (end < start || end > this.length) {
       throw new RangeError.range(end, start, this.length);
     }
   }
 
   void _recordChange(ListChangeRecord record) {
-    if (_records == null) {
-      _records = [];
-      queueChangeRecords(_summarizeRecords);
+    if (_listRecords == null) {
+      _listRecords = [];
+      runAsync(deliverChanges);
     }
-    _records.add(record);
+    _listRecords.add(record);
+  }
+
+  bool deliverChanges() {
+    if (_listRecords == null) return false;
+    _summarizeRecords();
+    return super.deliverChanges();
   }
 
   /**
    * We need to summarize change records. Consumers of these records want to
    * apply the batch sequentially, and ensure that they can find inserted
    * items by looking at that position in the list. This property does not
    * hold in our record-as-you-go records. Consider:
    *
    *     var model = toObservable(['a', 'b']);
    *     model.removeAt(1);
@@ skipping 10 matching lines @@
    * new list of changes records. This has the advantage of not depending
    * on the actual *values*, so we don't need to perform N^2 edit
    */
   // TODO(jmesserly): there's probably something smarter here, but this
   // algorithm is pretty simple. It has complexity equivalent to the original
   // list modifications.
   // One simple idea: we can simply update the index map as we do the operations
   // to the list, then produce the records at the end.
   void _summarizeRecords() {
     int oldLength = length;
-    for (var r in _records) {
+    for (var r in _listRecords) {
       oldLength += r.removedCount - r.addedCount;
     }
 
     if (length != oldLength) {
       notifyPropertyChange(const Symbol('length'), oldLength, length);
     }
 
-    if (_records.length == 1) {
-      notifyChange(_records[0]);
-      _records = null;
+    if (_listRecords.length == 1) {
+      notifyChange(_listRecords[0]);
+      _listRecords = null;
       return;
     }
 
     var items = [];
     for (int i = 0; i < oldLength; i++) items.add(i);
-    for (var r in _records) {
+    for (var r in _listRecords) {
       items.removeRange(r.index, r.index + r.removedCount);
 
       // Represent inserts with -1.
       items.insertAll(r.index, new List.filled(r.addedCount, -1));
     }
     assert(items.length == length);
 
-    _records = null;
+    _listRecords = null;
 
     int index = 0;
     int offset = 0;
     while (index < items.length) {
       // Skip unchanged items.
       while (index < items.length && items[index] == index + offset) {
         index++;
       }
 
       // Find inserts
@@ skipping 13 matching lines @@
 
       if (added > 0 || removed > 0) {
         notifyChange(new ListChangeRecord(startIndex, addedCount: added,
             removedCount: removed));
       }
 
       offset += removed - added;
     }
   }
 }
-
-// TODO(jmesserly): bogus type to workaround spurious VM bug with generic base
-// class and mixins.
-abstract class _ListBaseWorkaround extends ListBase<dynamic> {}