LCOV - code coverage report

Current view
top level - src/converters - context_aware_converter.dart
Test
lcov.info
Date
2025-09-28
Legend
Lines
hit
not hit
Branches
taken
not taken
# not executed
HitTotalCoverage
Lines6410262.7%
Functions00-
Branches00-
Each row represents a line of source code
LineBranchHitsSource code
1import 'package:meta/meta.dart';
2
3import '../squadron_singleton.dart';
4import '../typedefs.dart';
5import 'converter.dart';
6import 'lazy_in_place_list.dart';
7import 'lazy_in_place_map.dart';
8import 'serialization_context.dart';
9
10class ContextAwareConverter extends Converter {
114 ContextAwareConverter([Converter? converter])
123 : _converter = converter ?? Squadron.converter;
13
14 final Converter _converter;
15 // use Squadron.identical to handle JS objects
16 final _arguments = SerializationContext(Squadron.identical);
17
18 // non-nullable value
194 @override
20 Cast<T> value<T extends Object>() {
218 final op = _converter.value<T>();
227 if (Converter.isNumber<T>() || Converter.isIdentity<T>(op)) {
23 // no context needed for numbers / identity converters
24 return op;
25 }
260 return (dynamic x) {
27 x as Object;
280 var ref = _arguments.getReference<T>(x);
29 if (ref != null) return ref;
300 ref = op(x);
310 _arguments.setReference(x, ref);
32 return ref;
33 };
34 }
35
36 // list
374 @override
38 Cast<List<T>> list<T extends Object>([Cast<T>? cast]) {
394 final op = cast ?? value<T>();
404 if (Converter.isIdentity<T>(op)) {
416 final toList = _converter.list<T>(); // elements will be cast
423 return (dynamic x) {
436 var ref = _arguments.getReference<List<T>>(x);
44 if (ref != null) return ref;
453 ref = toList(x);
466 _arguments.setReference(x, ref);
47 return ref;
48 };
49 } else {
502 return (dynamic x) {
514 var ref = _arguments.getReference<List<T>>(x);
52 if (ref != null) return ref;
532 ref = LazyInPlaceList(x, op); // elements will be converted upon access
544 _arguments.setReference(x, ref);
55 return ref;
56 };
57 }
58 }
59
601 @override
61 Cast<List<T?>> nlist<T extends Object>([Cast<T>? cast]) {
620 final op = cast ?? value<T>();
631 if (Converter.isIdentity<T>(op)) {
640 final toList = _converter.nlist<T>(); // elements will be cast
650 return (dynamic x) {
660 var ref = _arguments.getReference<List<T?>>(x);
67 if (ref != null) return ref;
680 ref = toList(x);
690 _arguments.setReference(x, ref);
70 return ref;
71 };
72 } else {
731 final nop = Converter.allowNull(op);
741 return (dynamic x) {
752 var ref = _arguments.getReference<List<T?>>(x);
76 if (ref != null) return ref;
771 ref = LazyInPlaceList(x, nop); // elements will be converted upon access
782 _arguments.setReference(x, ref);
79 return ref;
80 };
81 }
82 }
83
84 // set
851 @override
86 Cast<Set<T>> set<T extends Object>([Cast<T>? cast]) {
871 final op = cast ?? value<T>();
881 if (Converter.isIdentity<T>(op)) {
890 final toSet = _converter.set<T>(); // elements will be cast
900 return (dynamic x) {
910 var ref = _arguments.getReference<Set<T>>(x);
92 if (ref != null) return ref;
930 ref = toSet(x);
940 _arguments.setReference(x, ref);
95 return ref;
96 };
97 } else {
981 return (dynamic x) {
992 var ref = _arguments.getReference<Set<T>>(x);
100 if (ref != null) return ref;
101 ref = <T>{}; // TODO: implement a lazy set?
1022 _arguments.setReference(x, ref);
1032 ref.addAll((x as Iterable).map(op));
104 return ref;
105 };
106 }
107 }
108
1091 @override
110 Cast<Set<T?>> nset<T extends Object>([Cast<T>? cast]) {
1111 final op = cast ?? value<T>();
1121 if (Converter.isIdentity<T>(op)) {
1130 final toSet = _converter.nset<T>(); // elements will be cast
1140 return (dynamic x) {
1150 var ref = _arguments.getReference<Set<T?>>(x);
116 if (ref != null) return ref;
1170 ref = toSet(x);
1180 _arguments.setReference(x, ref);
119 return ref;
120 };
121 } else {
1221 final nop = Converter.allowNull(op);
1231 return (dynamic x) {
1242 var ref = _arguments.getReference<Set<T?>>(x);
125 if (ref != null) return ref;
126 ref = <T?>{}; // TODO: implement a lazy set?
1272 _arguments.setReference(x, ref);
1282 ref.addAll((x as Iterable).map(nop));
129 return ref;
130 };
131 }
132 }
133
134 // map
1352 @override
136 Cast<Map<K, V>> map<K extends Object, V extends Object>(
137 {Cast<K>? kcast, Cast<V>? vcast}) {
1382 final kop = kcast ?? value<K>();
1392 final vop = vcast ?? value<V>();
1404 if (Converter.isIdentity<K>(kop) && Converter.isIdentity<V>(vop)) {
1412 final toMap = _converter.map<K, V>(); // elements will be cast
1421 return (dynamic x) {
1432 var ref = _arguments.getReference<Map<K, V>>(x);
144 if (ref != null) return ref;
1451 ref = toMap(x);
1462 _arguments.setReference(x, ref);
147 return ref;
148 };
1491 } else if (Converter.isIdentity(kop)) {
1501 return (dynamic x) {
1512 var ref = _arguments.getReference<Map<K, V>>(x);
152 if (ref != null) return ref;
1531 ref = LazyInPlaceMap(x, vop); // elements will be converted upon access
1542 _arguments.setReference(x, ref);
155 return ref;
156 };
157 } else {
1580 return (dynamic x) {
1590 var ref = _arguments.getReference<Map<K, V>>(x);
160 if (ref != null) return ref;
1610 ref = <K, V>{}; // TODO: implements a lazy map with convertible keys?
1620 _arguments.setReference(x, ref);
1630 ref.addEntries(
1640 (x as Map).entries.map((e) => MapEntry(kop(e.key), vop(e.value))),
165 );
166 return ref;
167 };
168 }
169 }
170
1711 @override
172 Cast<Map<K, V?>> nmap<K extends Object, V extends Object>(
173 {Cast<K>? kcast, Cast<V>? vcast}) {
1741 final kop = kcast ?? value<K>();
1751 final vop = vcast ?? value<V>();
1762 if (Converter.isIdentity<K>(kop) && Converter.isIdentity<V>(vop)) {
1770 final toMap = _converter.nmap<K, V>(); // elements will be cast
1780 return (dynamic x) {
1790 var ref = _arguments.getReference<Map<K, V?>>(x);
180 if (ref != null) return ref;
1810 ref = toMap(x);
1820 _arguments.setReference(x, ref);
183 return ref;
184 };
1851 } else if (Converter.isIdentity(kop)) {
1861 final nvop = Converter.allowNull(vop);
1871 return (dynamic x) {
1882 var ref = _arguments.getReference<Map<K, V?>>(x);
189 if (ref != null) return ref;
1901 ref = LazyInPlaceMap(x, nvop); // elements will be converted upon access
1912 _arguments.setReference(x, ref);
192 return ref;
193 };
194 } else {
1950 final nvop = Converter.allowNull(vop);
1960 return (dynamic x) {
1970 var ref = _arguments.getReference<Map<K, V?>>(x);
198 if (ref != null) return ref;
1990 ref = <K, V?>{}; // TODO: implements a lazy map with convertible keys?
2000 _arguments.setReference(x, ref);
2010 ref.addEntries(
2020 (x as Map).entries.map((e) => MapEntry(kop(e.key), nvop(e.value))),
203 );
204 return ref;
205 };
206 }
207 }
208}
209
210@internal
211extension ContextAwareConverterImpl on ContextAwareConverter {
2123 void reset() => _arguments.reset();
213}

Generated by: JGENHTML version 1.6

Choose Features