refactor(collection items): Collection items indexes are int

Author: vicb

lib/change_detection/change_detection.dart

@@ -174,34 +174,34 @@ abstract class ChangedKeyValue<K, V> extends MapKeyValue<K, V> {
  * as a list of [CollectionChangeItem]s which contain the item as well as its
  * current and previous position in the list.
  */
-abstract class CollectionChangeRecord<K, V> {
+abstract class CollectionChangeRecord<V> {
   /** The underlying iterable object */
   Iterable get iterable;
 
   /** A list of [CollectionItem]s which are in the iteration order. */
-  CollectionItem<K, V> get collectionHead;
+  CollectionItem<V> get collectionHead;
   /** A list of new [AddedItem]s. */
-  AddedItem<K, V> get additionsHead;
+  AddedItem<V> get additionsHead;
   /** A list of [MovedItem]s. */
-  MovedItem<K, V> get movesHead;
+  MovedItem<V> get movesHead;
   /** A list of [RemovedItem]s. */
-  RemovedItem<K, V> get removalsHead;
+  RemovedItem<V> get removalsHead;
 
-  void forEachAddition(void f(AddedItem<K, V> addition));
-  void forEachMove(void f(MovedItem<K, V> move));
-  void forEachRemoval(void f(RemovedItem<K, V> removal));
+  void forEachAddition(void f(AddedItem<V> addition));
+  void forEachMove(void f(MovedItem<V> move));
+  void forEachRemoval(void f(RemovedItem<V> removal));
 }
 
 /**
  * Each changed item in the collection is wrapped in a [CollectionChangeItem],
  * which tracks the [item]s [currentKey] and [previousKey] location.
  */
-abstract class CollectionChangeItem<K, V> { // TODO(misko): change <K,V> to <V> since K is int.
+abstract class CollectionChangeItem<V> {
   /** Previous item location in the list or [null] if addition. */
-  K get previousKey; // TODO(misko): rename to previousIndex
+  int get previousIndex;
 
   /** Current item location in the list or [null] if removal. */
-  K get currentKey; // TODO(misko): rename to CurrentIndex
+  int get currentIndex;
 
   /** The item. */
   V get item;
@@ -211,30 +211,30 @@ abstract class CollectionChangeItem<K, V> { // TODO(misko): change <K,V> to <V>
  * Used to create a linked list of collection items. These items are always in
  * the iteration order of the collection.
  */
-abstract class CollectionItem<K, V> extends CollectionChangeItem<K, V> {
-  CollectionItem<K, V> get nextCollectionItem;
+abstract class CollectionItem<V> extends CollectionChangeItem<V> {
+  CollectionItem<V> get nextCollectionItem;
 }
 
 /**
  * A linked list of new items added to the collection. These items are always in
  * the iteration order of the collection.
  */
-abstract class AddedItem<K, V> extends CollectionChangeItem<K, V> {
-  AddedItem<K, V> get nextAddedItem;
+abstract class AddedItem<V> extends CollectionChangeItem<V> {
+  AddedItem<V> get nextAddedItem;
 }
 
 /**
  * A linked list of items  moved in the collection. These items are always in
  * the iteration order of the collection.
  */
-abstract class MovedItem<K, V> extends CollectionChangeItem<K, V> {
-  MovedItem<K, V> get nextMovedItem;
+abstract class MovedItem<V> extends CollectionChangeItem<V> {
+  MovedItem<V> get nextMovedItem;
 }
 
 /**
  * A linked list of items removed  from the collection. These items are always
  * in the iteration order of the collection.
  */
-abstract class RemovedItem<K, V> extends CollectionChangeItem<K, V> {
-  RemovedItem<K, V> get nextRemovedItem;
+abstract class RemovedItem<V> extends CollectionChangeItem<V> {
+  RemovedItem<V> get nextRemovedItem;
 }

lib/change_detection/dirty_checking_change_detector.dart

@@ -663,41 +663,41 @@ class KeyValueRecord<K, V> implements KeyValue<K, V>, AddedKeyValue<K, V>,
 }
 
 
-class _CollectionChangeRecord<K, V> implements CollectionChangeRecord<K, V> {
+class _CollectionChangeRecord<V> implements CollectionChangeRecord<V> {
   Iterable _iterable;
   /** Used to keep track of items during moves. */
   DuplicateMap _items = new DuplicateMap();
 
   /** Used to keep track of removed items. */
   DuplicateMap _removedItems = new DuplicateMap();
 
-  ItemRecord<K, V> _collectionHead, _collectionTail;
-  ItemRecord<K, V> _additionsHead, _additionsTail;
-  ItemRecord<K, V> _movesHead, _movesTail;
-  ItemRecord<K, V> _removalsHead, _removalsTail;
+  ItemRecord<V> _collectionHead, _collectionTail;
+  ItemRecord<V> _additionsHead, _additionsTail;
+  ItemRecord<V> _movesHead, _movesTail;
+  ItemRecord<V> _removalsHead, _removalsTail;
 
-  CollectionChangeItem<K, V> get collectionHead => _collectionHead;
-  CollectionChangeItem<K, V> get additionsHead => _additionsHead;
-  CollectionChangeItem<K, V> get movesHead => _movesHead;
-  CollectionChangeItem<K, V> get removalsHead => _removalsHead;
+  CollectionChangeItem<V> get collectionHead => _collectionHead;
+  CollectionChangeItem<V> get additionsHead => _additionsHead;
+  CollectionChangeItem<V> get movesHead => _movesHead;
+  CollectionChangeItem<V> get removalsHead => _removalsHead;
 
-  void forEachAddition(void f(AddedItem<K, V> addition)){
+  void forEachAddition(void f(AddedItem<V> addition)){
     ItemRecord record = _additionsHead;
     while(record != null) {
       f(record);
       record = record._nextAddedRec;
     }
   }
 
-  void forEachMove(void f(MovedItem<K, V> change)) {
+  void forEachMove(void f(MovedItem<V> change)) {
     ItemRecord record = _movesHead;
     while(record != null) {
       f(record);
       record = record._nextMovedRec;
     }
   }
 
-  void forEachRemoval(void f(RemovedItem<K, V> removal)){
+  void forEachRemoval(void f(RemovedItem<V> removal)){
     ItemRecord record = _removalsHead;
     while(record != null) {
       f(record);
@@ -758,14 +758,14 @@ class _CollectionChangeRecord<K, V> implements CollectionChangeRecord<K, V> {
 
     record = _additionsHead;
     while(record != null) {
-      record.previousKey = record.currentKey;
+      record.previousIndex = record.currentIndex;
       record = record._nextAddedRec;
     }
     _additionsHead = _additionsTail = null;
 
     record = _movesHead;
     while(record != null) {
-      record.previousKey = record.currentKey;
+      record.previousIndex = record.currentIndex;
       var nextRecord = record._nextMovedRec;
       assert((record._nextMovedRec = null) == null);
       record = nextRecord;
@@ -857,8 +857,8 @@ class _CollectionChangeRecord<K, V> implements CollectionChangeRecord<K, V> {
     ItemRecord reinsertRecord = _removedItems.get(item);
     if (reinsertRecord != null) {
       record = _collection_reinsertAfter(reinsertRecord, record._prevRec, index);
-    } else if (record.currentKey != index) {
-      record.currentKey = index;
+    } else if (record.currentIndex != index) {
+      record.currentIndex = index;
       _moves_add(record);
     }
     return record;
@@ -950,7 +950,7 @@ class _CollectionChangeRecord<K, V> implements CollectionChangeRecord<K, V> {
     }
 
     _items.put(record);
-    record.currentKey = index;
+    record.currentIndex = index;
     return record;
   }
 
@@ -994,7 +994,7 @@ class _CollectionChangeRecord<K, V> implements CollectionChangeRecord<K, V> {
   }
 
   ItemRecord _removals_add(ItemRecord record) {
-    record.currentKey = null;
+    record.currentIndex = null;
     _removedItems.put(record);
 
     if (_removalsTail == null) {
@@ -1049,27 +1049,27 @@ removals: ${removals.join(", ")}'
   }
 }
 
-class ItemRecord<K, V> implements CollectionItem<K, V>, AddedItem<K, V>,
-    MovedItem<K, V>, RemovedItem<K, V> {
-  K previousKey = null;
-  K currentKey = null;
+class ItemRecord<V> implements CollectionItem<V>, AddedItem<V>, MovedItem<V>,
+    RemovedItem<V> {
+  int previousIndex = null;
+  int currentIndex = null;
   V item = _INITIAL_;
 
-  ItemRecord<K, V> _prevRec, _nextRec;
-  ItemRecord<K, V> _prevDupRec, _nextDupRec;
-  ItemRecord<K, V> _prevRemovedRec, _nextRemovedRec;
-  ItemRecord<K, V> _nextAddedRec, _nextMovedRec;
+  ItemRecord<V> _prevRec, _nextRec;
+  ItemRecord<V> _prevDupRec, _nextDupRec;
+  ItemRecord<V> _prevRemovedRec, _nextRemovedRec;
+  ItemRecord<V> _nextAddedRec, _nextMovedRec;
 
-  CollectionItem<K, V> get nextCollectionItem => _nextRec;
-  RemovedItem<K, V> get nextRemovedItem => _nextRemovedRec;
-  AddedItem<K, V> get nextAddedItem => _nextAddedRec;
-  MovedItem<K, V> get nextMovedItem => _nextMovedRec;
+  CollectionItem<V> get nextCollectionItem => _nextRec;
+  RemovedItem<V> get nextRemovedItem => _nextRemovedRec;
+  AddedItem<V> get nextAddedItem => _nextAddedRec;
+  MovedItem<V> get nextMovedItem => _nextMovedRec;
 
   ItemRecord(this.item);
 
-  toString() => previousKey == currentKey ?
-      '$item' :
-      '$item[$previousKey -> $currentKey]';
+  String toString() => previousIndex == currentIndex
+      ? '$item'
+      : '$item[$previousIndex -> $currentIndex]';
 }
 
 class _DuplicateItemRecordList {
@@ -1107,7 +1107,7 @@ class _DuplicateItemRecordList {
     ItemRecord record = head;
     while(record != null) {
       if (hideIndex == null ||
-          hideIndex < record.currentKey && identical(record.item, key)) {
+          hideIndex < record.currentIndex && identical(record.item, key)) {
         return record;
       }
       record = record._nextDupRec;

test/change_detection/dirty_checking_change_detector_spec.dart

@@ -398,7 +398,7 @@ main() => describe('DirtyCheckingChangeDetector', () {
 
     it('should do basic operations', () {
       var k1 = 'a';
-      var r1 = new ItemRecord(k1)..currentKey = 1;
+      var r1 = new ItemRecord(k1)..currentIndex = 1;
       map.put(r1);
       expect(map.get(k1, 2)).toEqual(null);
       expect(map.get(k1, 1)).toEqual(null);
@@ -409,8 +409,8 @@ main() => describe('DirtyCheckingChangeDetector', () {
 
     it('should do basic operations on duplicate keys', () {
       var k1 = 'a';
-      var r1 = new ItemRecord(k1)..currentKey = 1;
-      var r2 = new ItemRecord(k1)..currentKey = 2;
+      var r1 = new ItemRecord(k1)..currentIndex = 1;
+      var r2 = new ItemRecord(k1)..currentIndex = 2;
       map..put(r1)..put(r2);
       expect(map.get(k1, 0)).toEqual(r1);
       expect(map.get(k1, 1)).toEqual(r2);