Updated charted DEP to 0.4.X

packages/charted/lib/charts/data_transformers/aggregation.dart

 //
 // Copyright 2014 Google Inc. All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 //
 
 part of charted.charts;
 
 ///Function callback to filter items in the input
 typedef bool AggregationFilterFunc(var item);
 
+typedef int CompareFunc(dynamic a, dynamic b);
+
 typedef dynamic FieldAccessor(dynamic item, dynamic key);
 
 /// Given list of items, dimensions and facts, compute
 /// aggregates (COUNT, SUM, MIN, MAX) for facts at each dimension level.
 class AggregationModel {
   // Number of aggregations we collect on each fact
   int _aggregationTypesCount = 0;
 
   // Currently supported list of aggregations.
   static final List<String> supportedAggregationTypes = [
@@ skipping 58 matching lines @@
   // Cache of entities created for the facts on this aggregation view.
   Map<String, AggregationItem> _entityCache;
 
   // List of field names that aggregation items will have.
   List<String> _itemFieldNamesCache;
 
   // Walk through the map, by splitting key at '.'
   final bool walkThroughMap;
 
   // Map of fieldName to comparator function.
-  final Map<String, Function> comparators;
+  final Map<String, CompareFunc> comparators;
 
   // Timing operations
   static final Logger _logger = new Logger('aggregations');
   Stopwatch _timeItWatch;
   String _timeItName;
 
   FieldAccessor dimensionAccessor;
   FieldAccessor factsAccessor;
 
   /// Create a new [AggregationModel] from a [collection] of items,
   /// list of [dimensions] on which the items are grouped and a list of [facts]
   /// on which aggregations are computed.
-  AggregationModel(List collection, List dimensions, List facts,
+  AggregationModel(Iterable collection, List dimensions, List facts,
       {List<String> aggregationTypes,
       this.walkThroughMap: false,
-      this.comparators,
+      this.comparators: const <String, CompareFunc>{},
       this.dimensionAccessor,
       this.factsAccessor}) {
     _init(collection, dimensions, facts, aggregationTypes);
   }
 
   void _timeItStart(String name) {
     _timeItName = name;
     _timeItWatch = new Stopwatch();
     _timeItWatch.start();
   }
 
   void _timeItEnd() {
     _timeItWatch.stop();
     _logger.info('[aggregations/$_timeItName] '
         '${_timeItWatch.elapsed.inMilliseconds}ms/${_rows.length}r');
   }
 
   List get factFields => _factFields;
   List get dimensionFields => _dimFields;
 
   /// Initialize the view
-  void _init(List collection, List dimensions, List facts,
+  void _init(Iterable collection, List dimensions, List facts,
       List<String> aggregationTypes) {
     if (collection == null) {
       throw new ArgumentError('Data cannot be empty or null');
     }
 
     if (facts == null || facts.isEmpty) {
       throw new ArgumentError('Facts cannot be empty or null');
     }
 
     if (dimensions == null) {
@@ skipping 17 matching lines @@
       }
     } else {
       aggregationTypes = ['sum'];
     }
 
     // Always adding 'count' for correct computation of average and count.
     if (!aggregationTypes.contains('valid')) {
       aggregationTypes.add('valid');
     }
 
-    _rows = collection;
+    _rows = new List.from(collection, growable: false);
     _dimFields = new List.from(dimensions, growable: false);
     _factFields = new List.from(facts, growable: false);
     _entityCache = new Map<String, AggregationItem>();
 
     _createBuffers();
 
     _aggregationTypesCount = aggregationTypes.length;
     for (int i = 0; i < _aggregationTypesCount; i++) {
       switch (aggregationTypes[i]) {
         case 'sum':
@@ skipping 84 matching lines @@
           entity.update();
         } else {
           _entityCache.remove(key);
           entity.clear();
         }
       }
     });
   }
 
   final Map<String, List> _parsedKeys = {};
+
   /// Get value from a map-like object
   dynamic _fetch(var item, String key) {
     if (walkThroughMap && key.contains('.')) {
       return walk(item, key, _parsedKeys);
     } else {
       return item[key];
     }
   }
 
   /// Preprocess Data
@@ skipping 37 matching lines @@
           _dimToIntMap[di][dimensionVal] = dimensionValCount[di];
           dimensionValEnum = dimensionValCount[di]++;
         }
         _dimEnumCache[dimDataOffset + di] = dimensionValEnum;
       }
     }
 
     // Sort all dimensions internally
     // The resulting arrays would be used to sort the entire data
 
-    List oldSortOrders = _dimSortOrders;
+    List<List<int>> oldSortOrders = _dimSortOrders;
     _dimSortOrders = new List.generate(dimensionsCount, (i) {
       if (groupBy && i < _dimPrefixLength) {
         return oldSortOrders[i];
       }
 
       List dimensionVals = new List.from(_dimToIntMap[i].keys);
-      List retval = new List(_dimToIntMap[i].length);
+      List<int> retval = new List<int>(_dimToIntMap[i].length);
 
       // When a comparator is not specified, our implementation of the
       // comparator tries to gracefully handle null values.
-      dimensionVals.sort(
-          comparators != null && comparators.containsKey(_dimFields[i])
-              ? comparators[_dimFields[i]]
-              : _defaultDimComparator);
+      if (comparators.containsKey(_dimFields[i])) {
+        dimensionVals.sort(comparators[_dimFields[i]]);
+      } else {
+        dimensionVals.sort(_defaultDimComparator);
+      }
 
       for (int si = 0; si < retval.length; ++si) {
         retval[_dimToIntMap[i][dimensionVals[si]]] = si;
       }
       return retval;
     }, growable: false);
 
     // Create a list of sorted indices - only if we are not having a full
     // overlap of dimensionFields.
     if (!groupBy || _dimPrefixLength != _dimFields.length) {
       _sorted = new List<int>.generate(_rows.length, (i) => i, growable: false);
       _sorted.sort(_comparator);
     }
 
     // Pre-compute frequently used values
     _offsetSortedIndex = factsCount * _aggregationTypesCount;
     _offsetFilteredCount = factsCount * _aggregationTypesCount + 1;
 
     _timeItEnd();
   }
 
   // Ensures that null dimension values don't cause an issue with sorting
-  _defaultDimComparator(Comparable left, Comparable right) =>
+  int _defaultDimComparator(Comparable left, Comparable right) =>
       (left == null && right == null)
           ? 0
           : (left == null) ? -1 : (right == null) ? 1 : left.compareTo(right);
 
   /// Given item indices in rows, compare them based
   /// on the sort orders created while pre-processing data.
-  _comparator(int one, int two) {
+  int _comparator(int one, int two) {
     if (one == two) {
       return 0;
     }
 
     int offsetOne = _dimFields.length * one;
     int offsetTwo = _dimFields.length * two;
 
     for (int i = 0; i < _dimFields.length; ++i) {
       int diff = _dimSortOrders[i][_dimEnumCache[offsetOne + i]] -
           _dimSortOrders[i][_dimEnumCache[offsetTwo + i]];
@@ skipping 157 matching lines @@
     throw new UnimplementedError();
   }
 
   /// Return an [AggregationItem] that represents facts for dimension
   /// represented by [dimension] Only one instance of an entity is created
   /// per dimension (even if this function is called multiple times)
   ///
   /// Callers of this method can observe the returned entity for updates to
   /// aggregations caused by changes to filter or done through add, remove
   /// or modify of items in the collection.
-  AggregationItem facts(List dimension) {
+  AggregationItem facts(List<String> dimension) {
     List<int> enumeratedList = new List<int>();
     for (int i = 0; i < dimension.length; ++i) {
       enumeratedList.add(_dimToIntMap[i][dimension[i]]);
     }
 
     String key = enumeratedList.join(':');
     AggregationItem item = _entityCache[key];
 
     if (item == null && _dimToAggrMap.containsKey(key)) {
       item = new _AggregationItemImpl(this, dimension, key);
       _entityCache[key] = item;
     }
 
     return item;
   }
 
   /// Return a list of values that are present for a dimension field.
   List valuesForDimension(dynamic dimensionFieldName) {
     int di = _dimFields.indexOf(dimensionFieldName);
     if (di < 0) {
       return null;
     }
     List values = new List.from(_dimToIntMap[di].keys);
-    values.sort(
-        comparators != null && comparators.containsKey(dimensionFieldName)
-            ? comparators[dimensionFieldName]
-            : _defaultDimComparator);
+    if (comparators.containsKey(dimensionFieldName)) {
+      values.sort(comparators[dimensionFieldName]);
+    } else {
+      values.sort(_defaultDimComparator);
+    }
     return values;
   }
 }
 
 /// Parse a path for nested map-like objects.
 /// Caches the parsed key in the passed map.
 ///
 /// Takes map keys of the format:
 ///     "list(key=val;val=m).another(state=good).state"
 /// and outputs:
@@ skipping 91 matching lines @@
         });
         if (match) {
           return current[i];
         }
       }
     } else {
       return current[part];
     }
   });
 }