Merge v1.1.7 - optimize

v1.1.7 - optimize

 - `SharedObjectField`:
   - Expose getter `instanceHandler` to allow implementation override.
   - Optimize `sharedObject` resolution.

.gitignore

@@ -13,3 +13,5 @@ build/
 pubspec.lock
 
 .DS_Store
+
+/articles

CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.1.7
+
+- `SharedObjectField`:
+  - Expose getter `instanceHandler` to allow implementation override.
+  - Optimize `sharedObject` resolution.
+
 ## 1.1.6
 
 - `SharedMap`:

lib/src/not_shared_map.dart

@@ -1,6 +1,7 @@
 import 'shared_map_base.dart';
 import 'shared_map_cached.dart';
 import 'shared_object.dart';
+import 'shared_object_field.dart';
 import 'shared_reference.dart';
 
 /// NOT shared implementation of [SharedStore].
@@ -348,6 +349,12 @@ class NotSharedStoreField extends NotSharedObject implements SharedStoreField {
 
   @override
   SharedStoreReference get sharedReference => _notSharedStore.sharedReference();
+
+  @override
+  SharedFieldInstanceHandler<SharedStoreReference, SharedStore,
+          SharedStoreField>
+      get instanceHandler => throw UnsupportedError(
+          "A `NotSharedStoreField` doesn't have an `instanceHandler`");
 }
 
 class NotSharedMapField<K, V> extends NotSharedObject
@@ -389,4 +396,10 @@ class NotSharedMapField<K, V> extends NotSharedObject
   @override
   SharedMap<K, V> sharedMapCached({Duration? timeout}) =>
       _notSharedMap.cached();
+
+  @override
+  SharedFieldInstanceHandler<SharedMapReference, SharedMap<K, V>,
+          SharedMapField<K, V>>
+      get instanceHandler => throw UnsupportedError(
+          "A `NotSharedMapField` doesn't have an `instanceHandler`");
 }

lib/src/shared_map_base.dart

@@ -324,6 +324,23 @@ abstract class SharedMapReference extends SharedReference {
   String toString() => 'SharedMapReference${toJson()}';
 }
 
+class _SharedStoreFieldGeneric extends SharedStoreField {
+  static final _instanceHandler = SharedFieldInstanceHandler<
+      SharedStoreReference, SharedStore, SharedStoreField>(
+    fieldInstantiator: _SharedStoreFieldGeneric._fromID,
+    sharedObjectInstantiator: generic.SharedStoreGeneric.from,
+    group: (generic.SharedStoreGeneric, null),
+  );
+
+  _SharedStoreFieldGeneric._fromID(super.sharedObjectID,
+      {super.sharedObjectReference})
+      : super._fromID(instanceHandler: _instanceHandler);
+
+  @override
+  SharedFieldInstanceHandler<SharedStoreReference, SharedStore,
+      SharedStoreField> get instanceHandler => _instanceHandler;
+}
+
 /// A [SharedStore] field/wrapper. This will handle the [SharedStore] in.
 class SharedStoreField extends SharedObjectField<SharedStoreReference,
     SharedStore, SharedStoreField> {
@@ -333,27 +350,20 @@ class SharedStoreField extends SharedObjectField<SharedStoreReference,
     sharedObjectInstantiator: SharedStore.from,
   );
 
-  static final _instanceHandlerGeneric = SharedFieldInstanceHandler<
-      SharedStoreReference, SharedStore, SharedStoreField>(
-    fieldInstantiator: (id, {sharedObjectReference}) =>
-        SharedStoreField._fromIDGeneric(id),
-    sharedObjectInstantiator: generic.SharedStoreGeneric.from,
-    group: (generic.SharedStoreGeneric, null),
-  );
-
-  SharedStoreField._fromID(super.sharedObjectID, {super.sharedObjectReference})
-      : super.fromID(instanceHandler: _instanceHandler);
-
-  SharedStoreField._fromIDGeneric(super.id)
-      : super.fromID(instanceHandler: _instanceHandlerGeneric);
+  SharedStoreField._fromID(super.sharedObjectID,
+      {super.sharedObjectReference,
+      SharedFieldInstanceHandler<SharedStoreReference, SharedStore,
+              SharedStoreField>?
+          instanceHandler})
+      : super.fromID(instanceHandler: instanceHandler ?? _instanceHandler);
 
   factory SharedStoreField(String id) => _instanceHandler.fromID(id);
 
   factory SharedStoreField.fromSharedStore(SharedStore o) {
     if (o is NotSharedStore) {
       return NotSharedStoreField(o);
     } else if (o is generic.SharedStoreGeneric) {
-      return _instanceHandlerGeneric.fromSharedObject(o);
+      return _SharedStoreFieldGeneric._instanceHandler.fromSharedObject(o);
     }
     return _instanceHandler.fromSharedObject(o);
   }
@@ -420,6 +430,10 @@ class SharedStoreField extends SharedObjectField<SharedStoreReference,
   String get sharedStoreID => sharedObjectID;
 
   SharedStore get sharedStore => sharedObject;
+
+  @override
+  SharedFieldInstanceHandler<SharedStoreReference, SharedStore,
+      SharedStoreField> get instanceHandler => _instanceHandler;
 }
 
 /// A [SharedStore] field/wrapper. This will handle the [SharedStore] in.

lib/src/shared_object_field.dart

@@ -113,8 +113,6 @@ class SharedFieldInstanceHandler<R extends SharedReference,
 
     return null;
   }
-
-  final Expando<O> _sharedObjectExpando = Expando();
 }
 
 /// Base class for [SharedObjectField] implementation.
@@ -149,15 +147,16 @@ abstract class SharedObjectField<
   static final Expando<SharedFieldInstanceHandler> _instanceHandlerExpando =
       Expando();
 
-  SharedFieldInstanceHandler<R, O, F> get _instanceHandler =>
+  /// The [SharedFieldInstanceHandler] for this [SharedObjectField] type ([F]).
+  SharedFieldInstanceHandler<R, O, F> get instanceHandler =>
       (_instanceHandlerExpando[this] ??= SharedFieldInstanceHandler<R, O, F>(
         fieldInstantiator: _fieldInstantiator,
         sharedObjectInstantiator: _sharedObjectInstantiator,
         group: _instanceHandlerGroup,
       )) as SharedFieldInstanceHandler<R, O, F>;
 
   Map<String, WeakReference<F>> get _fieldsInstances =>
-      _instanceHandler._fieldsInstances;
+      instanceHandler._fieldsInstances;
 
   R? _sharedReference;
 
@@ -177,44 +176,43 @@ abstract class SharedObjectField<
       _resolvingReferenceAsyncExpando[this]?.then((o) => o as O);
 
   void _setupInstanceFromConstructor(R? sharedObjectReference) {
-    final instanceHandler = _instanceHandler;
-    final sharedObjectExpando = instanceHandler._sharedObjectExpando;
-
-    assert(sharedObjectExpando[this] == null);
+    assert(_sharedObjectExpando[this] == null);
 
     final id = sharedObjectID;
 
     assert(instanceHandler.getInstanceByID(id) == null);
 
     _fieldsInstances[id] = WeakReference(this as F);
 
-    var o = sharedObjectExpando[this];
+    var o = _sharedObjectExpando[this];
 
     if (o == null) {
       var oAsync = instanceHandler.sharedObjectInstantiator(
           id: id, reference: sharedObjectReference);
 
       if (oAsync is Future<O>) {
         _resolvingReference = true;
+
         _resolvingReferenceAsyncExpando[this] = oAsync.then((o) {
-          sharedObjectExpando[this] = o;
+          _sharedObjectExpando[this] = o;
           _sharedReference = o.sharedReference() as R;
           _resolvingReference = false;
           _resolvingReferenceAsyncExpando[this] = null;
           return o;
         });
+
         return;
       } else {
         o = oAsync;
       }
     }
 
-    sharedObjectExpando[this] = o;
+    _sharedObjectExpando[this] = o;
     _sharedReference = o.sharedReference() as R;
   }
 
   void _setupInstance() {
-    var prev = _instanceHandler.getInstanceByID(sharedObjectID);
+    var prev = instanceHandler.getInstanceByID(sharedObjectID);
 
     if (prev == null) {
       _setupInstanceIsolateCopy();
@@ -233,30 +231,31 @@ abstract class SharedObjectField<
   }
 
   void _setupInstanceIsolateCopy() {
-    final instanceHandler = _instanceHandler;
-
-    assert(instanceHandler._sharedObjectExpando[this] == null);
+    assert(_sharedObjectExpando[this] == null);
 
     _isolateCopy = true;
 
     var reference = _sharedReference ??
         (throw StateError(
-            "An `Isolate` copy should have `_reference` defined!"));
+            "An `Isolate` copy should have `_sharedReference` defined!"));
 
     var o = instanceHandler.sharedObjectInstantiator(reference: reference) as O;
-    instanceHandler._sharedObjectExpando[this] = o;
+
+    _sharedObjectExpando[this] = o;
 
     _fieldsInstances[sharedObjectID] = WeakReference(this as F);
   }
 
+  static final Expando<ReferenceableType> _sharedObjectExpando = Expando();
+
   /// The [SharedObject] ([O]) of this instance. This [SharedObject] will be
   /// automatically shared among `Isolate` copies.
   ///
   /// See [isAuxiliaryInstance], [isResolvingReference] and [sharedObjectAsync].
   O get sharedObject {
     _setupInstance();
 
-    var o = _instanceHandler._sharedObjectExpando[this];
+    var o = _sharedObjectExpando[this];
     if (o == null) {
       if (_resolvingReference) {
         throw StateError(
@@ -267,7 +266,7 @@ abstract class SharedObjectField<
       }
     }
 
-    return o;
+    return o as O;
   }
 
   /// Asynchronous version of [sharedObject].

pubspec.yaml

@@ -1,6 +1,6 @@
 name: shared_map
 description: Offers a versatile, synchronized Map for efficient sharing between Dart application parts, including Isolates or external apps.
-version: 1.1.6
+version: 1.1.7
 repository: https://github.com/gmpassos/shared_map
 
 environment:

test/shared_map_generic_test.dart

@@ -3,6 +3,7 @@ import 'dart:async';
 import 'package:shared_map/shared_map.dart';
 import 'package:shared_map/src/not_shared_map.dart';
 import 'package:shared_map/src/shared_map_generic.dart';
+import 'package:shared_map/src/shared_object_field.dart';
 import 'package:test/test.dart';
 
 void main() {
@@ -130,11 +131,29 @@ void _doTest<K, V, T extends SharedMap<K, V>>(
 
           expect(await m2!.get('a'), isNull);
           expect(await m2.keys(), equals([]));
+
+          expect(() => storeField1.instanceHandler,
+              throwsA(isA<UnsupportedError>()));
+
+          expect(() => sharedMapField.instanceHandler,
+              throwsA(isA<UnsupportedError>()));
         } else {
           expect(m2, isA<SharedMap<String, int>>());
 
           expect(await m2!.get('a'), equals(222));
           expect(await m2.keys(), equals(['a', 'b', 'c']));
+
+          expect(
+              storeField1.instanceHandler,
+              isA<
+                  SharedFieldInstanceHandler<SharedStoreReference, SharedStore,
+                      SharedStoreField>>());
+
+          expect(
+              sharedMapField.instanceHandler,
+              isA<
+                  SharedFieldInstanceHandler<SharedMapReference,
+                      SharedMap<String, int>, SharedMapField<String, int>>>());
         }
       }
 
@@ -174,7 +193,6 @@ void _doTest<K, V, T extends SharedMap<K, V>>(
 
           expect(await cached2.putIfAbsent('a', 6666), equals(333));
         }
-
         return;
       }