LCOV - code coverage report
Current view: | top level - src/repositories - memory_repository.dart (source / functions) |  |  | Hit | Total | Coverage
Test: | lcov.info |  | Lines: | 45 | 45 | 100.0 %
Date: | 2021-10-11 06:57:03 |  | Functions: | 0 | 0 | -

              Line data    Source code
           1             : import 'dart:async';
           2             :
           3             : import 'dart:collection';
           4             :
           5             : import 'package:meta/meta.dart';
           6             : import 'package:widgetbook/src/models/model.dart';
           7             : import 'package:widgetbook/src/repositories/repository.dart';
           8             :
           9             : class MemoryRepository<Item extends Model> extends Repository<Item> {
          10           3 :   MemoryRepository({Map<String, Item>? initialConfiguration})
          11           1 :       : memory = initialConfiguration ?? HashMap(),
          12           3 :         _streamController = StreamController<List<Item>>.broadcast() {
          13           9 :     _streamController.onListen = _emitChangesToStream;
          14             :   }
          15             :
          16             :   @internal
          17             :   final Map<String, Item> memory;
          18             :
          19             :   final StreamController<List<Item>> _streamController;
          20             :
          21           3 :   void _emitChangesToStream() {
          22          15 :     _streamController.add(memory.values.toList());
          23             :   }
          24             :
          25           1 :   String _addItemAndEmitChangesToStream(Item item) {
          26           1 :     final id = _addItem(item);
          27           1 :     _emitChangesToStream();
          28             :     return id;
          29             :   }
          30             :
          31           1 :   String _addItem(Item item) {
          32           4 :     memory.putIfAbsent(item.id, () => item);
          33           1 :     return item.id;
          34             :   }
          35             :
          36           1 :   @override
          37             :   String addItem(Item item) {
          38           1 :     return _addItemAndEmitChangesToStream(item);
          39             :   }
          40             :
          41           2 :   void _deleteItemAndEmitChangesToStream(Item item) {
          42           2 :     _deleteItem(item);
          43           2 :     _emitChangesToStream();
          44             :   }
          45             :
          46           2 :   void _deleteItem(Item item) {
          47           6 :     memory.remove(item.id);
          48             :   }
          49             :
          50           2 :   @override
          51             :   void deleteItem(Item item) {
          52           2 :     _deleteItemAndEmitChangesToStream(item);
          53             :   }
          54             :
          55           2 :   @override
          56             :   Stream<List<Item>> getStreamOfItems() {
          57           4 :     return _streamController.stream;
          58             :   }
          59             :
          60           2 :   @override
          61             :   void setItem(Item item) {
          62           6 :     if (!memory.containsKey(item.id)) {
          63           1 :       _addItemAndEmitChangesToStream(item);
          64             :     } else {
          65           2 :       updateItem(item);
          66             :     }
          67             :   }
          68             :
          69           2 :   @override
          70             :   void updateItem(Item item) {
          71           6 :     memory[item.id] = item;
          72           2 :     _emitChangesToStream();
          73             :   }
          74             :
          75           2 :   @override
          76             :   bool doesItemExist(String id) {
          77           4 :     return memory.containsKey(id);
          78             :   }
          79             :
          80           2 :   @override
          81             :   Item getItem(String id) {
          82           4 :     return memory[id]!;
          83             :   }
          84             :
          85           2 :   @override
          86             :   void deleteAll() {
          87           4 :     memory.clear();
          88           2 :     _emitChangesToStream();
          89             :   }
          90             :
          91           2 :   @override
          92             :   void addAll(Iterable<Item> items) {
          93           2 :     final map = HashMap<String, Item>.fromIterable(
          94             :       items,
          95           4 :       key: (dynamic k) => k.id as String,
          96           2 :       value: (dynamic v) => v as Item,
          97             :     );
          98           4 :     memory.addAll(map);
          99           2 :     _emitChangesToStream();
         100             :   }
         101             :
         102           1 :   @override
         103             :   Future<void> closeStream() {
         104           2 :     return _streamController.close();
         105             :   }
         106             : }

Generated by: LCOV version 1.15