LCOV - code coverage report
Current view: top level - lib - remove_aware_map.dart (source / functions) Hit Total Coverage
Test: lcov.info Lines: 15 50 30.0 %
Date: 2022-05-19 20:34:37 Functions: 0 0 -

          Line data    Source code
       1             : typedef void HasRemovedCallback(dynamic key, dynamic value);
       2             : 
       3             : class RemoveAwareMap<K, V> implements Map<K, V> {
       4             : 
       5             :   HasRemovedCallback? hasRemovedCallback;
       6             : 
       7             :   Map<K, V> impl = Map<K, V>();
       8             : 
       9           2 :   @override
      10             :   V? operator [](Object? key) {
      11           4 :     return impl[key];
      12             :   }
      13             : 
      14           2 :   @override
      15             :   void operator []=(key, value) {
      16           4 :     impl[key] = value;
      17             :   }
      18             : 
      19           0 :   @override
      20             :   void addAll(Map<K, V> other) {
      21           0 :     impl.addAll(other);
      22             :   }
      23             : 
      24           0 :   @override
      25             :   void addEntries(Iterable<MapEntry<K, V>> newEntries) {
      26           0 :     impl.addEntries(newEntries);
      27             :   }
      28             : 
      29           0 :   @override
      30             :   Map<RK, RV> cast<RK, RV>() {
      31           0 :     return impl.cast<RK, RV>();
      32             :   }
      33             : 
      34           0 :   @override
      35             :   void clear() {
      36           0 :     Map<K, V> temp = Map.from(impl);
      37           0 :     impl.clear();
      38           0 :     if (hasRemovedCallback != null) {
      39           0 :       temp.forEach(hasRemovedCallback!);
      40             :     }
      41             :   }
      42             : 
      43           1 :   @override
      44             :   bool containsKey(Object? key) {
      45           2 :     return impl.containsKey(key);
      46             :   }
      47             : 
      48           0 :   @override
      49             :   bool containsValue(Object? value) {
      50           0 :     return impl.containsValue(value);
      51             :   }
      52             : 
      53           0 :   @override
      54           0 :   Iterable<MapEntry<K, V>> get entries => impl.entries;
      55             : 
      56           0 :   @override
      57             :   void forEach(void f(K key, V value)) {
      58           0 :     impl.forEach(f);
      59             :   }
      60             : 
      61           1 :   @override
      62           2 :   bool get isEmpty => impl.isEmpty;
      63             : 
      64           0 :   @override
      65           0 :   bool get isNotEmpty => impl.isNotEmpty;
      66             : 
      67           0 :   @override
      68           0 :   Iterable<K> get keys => impl.keys;
      69             : 
      70           0 :   @override
      71           0 :   int get length => impl.length;
      72             : 
      73           0 :   @override
      74             :   Map<K2, V2> map<K2, V2>(MapEntry<K2, V2> f(K key, V value)) {
      75           0 :     return impl.map<K2, V2>(f);
      76             :   }
      77             : 
      78           1 :   @override
      79             :   V putIfAbsent(K key, V ifAbsent()) {
      80           2 :     return impl.putIfAbsent(key, ifAbsent);
      81             :   }
      82             : 
      83           2 :   @override
      84             :   V? remove(Object? key) {
      85           4 :     bool containsKey = impl.containsKey(key);
      86           4 :     V? value = impl.remove(key);
      87           2 :     if (containsKey && hasRemovedCallback != null) {
      88           2 :       hasRemovedCallback!(key, value);
      89             :     }
      90             :     return value;
      91             :   }
      92             : 
      93           0 :   @override
      94             :   void removeWhere(bool predicate(K key, V value)) {
      95           0 :     impl.removeWhere((K key, V value) {
      96             :       bool removed = predicate(key, value);
      97           0 :       if (removed && hasRemovedCallback != null) {
      98           0 :         hasRemovedCallback!(key, value);
      99             :       }
     100             :       return removed;
     101             :     });
     102             :   }
     103             : 
     104           0 :   @override
     105             :   V update(K key, V update(V value), {V ifAbsent()?}) {
     106           0 :     return impl.update(key, update, ifAbsent: ifAbsent);
     107             :   }
     108             : 
     109           0 :   @override
     110             :   void updateAll(V update(K key, V value)) {
     111           0 :     impl.updateAll(update);
     112             :   }
     113             : 
     114           0 :   @override
     115           0 :   Iterable<V> get values => impl.values;
     116             : }

Generated by: LCOV version 1.15