Merge pull request #12 from spydon/spydon.register-no-op

No-op operation on multiple register for the same type

CHANGELOG.md

@@ -1,3 +1,7 @@
+## Next
+
+- Change `QueryableOrderedSet.register` to be no-op if type is already registered
+
 ## 3.1.0
 
 - Add QueryableOrderedSet

lib/queryable_ordered_set.dart

@@ -34,13 +34,17 @@ class QueryableOrderedSet<T> extends OrderedSet<T> {
   QueryableOrderedSet([int Function(T e1, T e2)? compare]) : super(compare);
 
   /// Adds a new cache for a subtype [C] of [T], allowing you to call [query].
+  /// If the cache already exists this operation is a no-op.
   ///
   /// If the set is not empty, the current elements will be re-sorted.
   ///
   /// It is recommended to [register] all desired types at the beginning of
   /// your application to avoid recomputing the existing elements upon
   /// registration.
   void register<C extends T>() {
+    if (isRegistered<C>()) {
+      return;
+    }
     _cache[C] = _CacheEntry<C, T>(
       data: _filter<C>(),
     );
@@ -65,6 +69,9 @@ class QueryableOrderedSet<T> extends OrderedSet<T> {
     return result.data as List<C>;
   }
 
+  /// Whether type [C] is registered as a cache
+  bool isRegistered<C>() => _cache.containsKey(C);
+
   @override
   bool add(T t) {
     if (super.add(t)) {

pubspec.yaml

@@ -8,6 +8,6 @@ environment:
 
 dev_dependencies:
   test: ^1.16.0-nullsafety
-  dart_code_metrics: ^2.4.0
-  dartdoc: ^0.39.0
-  coverage: ^0.14.2
+  dart_code_metrics: ^3.2.2
+  dartdoc: ^0.42.0
+  coverage: ^1.0.3

test/queryable_ordered_set_test.dart

@@ -230,6 +230,33 @@ void main() {
         expect(orderedSet.query<Bird>(), unorderedMatches(<Bird>[]));
         expect(orderedSet.toList(), isEmpty);
       });
+      test('#isRegistered', () {
+        final orderedSet = QueryableOrderedSet<Animal>(
+          Comparing.on((e) => e.name),
+        );
+        // No caches should be registered on a clean set
+        expect(orderedSet.isRegistered<Animal>(), false);
+        expect(orderedSet.isRegistered<Mammal>(), false);
+        orderedSet.register<Animal>();
+        // It shouldn't return true for a subclass of a registered cache
+        expect(orderedSet.isRegistered<Mammal>(), false);
+        // The Animal cache should report as registered after it has been
+        // registered
+        expect(orderedSet.isRegistered<Animal>(), true);
+        orderedSet.register<Mammal>();
+        // The Mammal cache should report as registered after it has been
+        // registered
+        expect(orderedSet.isRegistered<Mammal>(), true);
+        // The Animal cache should still be reported as registered after another
+        // cache has been registered
+        expect(orderedSet.isRegistered<Animal>(), true);
+        orderedSet.register<Animal>();
+        // Both caches should still be reported as registered after a cache has
+        // been re-registered (no-op)
+        expect(orderedSet.isRegistered<Animal>(), true);
+        expect(orderedSet.isRegistered<Mammal>(), true);
+        // A call to isRegistered without a type should always be false
+      });
     });
   });
 }