LCOV - code coverage report

Current view
top level - src/converters - context_aware_converter.dart
Test
lcov.info
Date
2026-02-21
Legend
Lines
hit
not hit
Branches
taken
not taken
# not executed
HitTotalCoverage
Lines6310162.4%
Functions00-
Branches00-
Each row represents a line of source code
LineBranchHitsSource code
1import '../squadron_singleton.dart';
2import '../typedefs.dart';
3import 'converter.dart';
4import 'lazy_in_place_list.dart';
5import 'lazy_in_place_map.dart';
6import 'serialization_context.dart';
7
8class ContextAwareConverter extends Converter {
94 ContextAwareConverter([Converter? converter])
103 : _converter = converter ?? Squadron.converter;
11
12 final Converter _converter;
13 // use Squadron.identical to handle JS objects
14 final _arguments = SerializationContext(Squadron.identical);
15
16 // non-nullable value
174 @override
18 Cast<T> value<T extends Object>() {
198 final op = _converter.value<T>();
207 if (Converter.isNumber<T>() || Converter.isIdentity<T>(op)) {
21 // no context needed for numbers / identity converters
22 return op;
23 }
240 return (dynamic x) {
25 x as Object;
260 var ref = _arguments.getReference<T>(x);
27 if (ref != null) return ref;
280 ref = op(x);
290 _arguments.setReference(x, ref);
30 return ref;
31 };
32 }
33
34 // list
354 @override
36 Cast<List<T>> list<T extends Object>([Cast<T>? cast]) {
374 final op = cast ?? value<T>();
384 if (Converter.isIdentity<T>(op)) {
396 final toList = _converter.list<T>(); // elements will be cast
403 return (dynamic x) {
416 var ref = _arguments.getReference<List<T>>(x);
42 if (ref != null) return ref;
433 ref = toList(x);
446 _arguments.setReference(x, ref);
45 return ref;
46 };
47 } else {
482 return (dynamic x) {
494 var ref = _arguments.getReference<List<T>>(x);
50 if (ref != null) return ref;
512 ref = LazyInPlaceList(x, op); // elements will be converted upon access
524 _arguments.setReference(x, ref);
53 return ref;
54 };
55 }
56 }
57
581 @override
59 Cast<List<T?>> nlist<T extends Object>([Cast<T>? cast]) {
600 final op = cast ?? value<T>();
611 if (Converter.isIdentity<T>(op)) {
620 final toList = _converter.nlist<T>(); // elements will be cast
630 return (dynamic x) {
640 var ref = _arguments.getReference<List<T?>>(x);
65 if (ref != null) return ref;
660 ref = toList(x);
670 _arguments.setReference(x, ref);
68 return ref;
69 };
70 } else {
711 final nop = Converter.allowNull(op);
721 return (dynamic x) {
732 var ref = _arguments.getReference<List<T?>>(x);
74 if (ref != null) return ref;
751 ref = LazyInPlaceList(x, nop); // elements will be converted upon access
762 _arguments.setReference(x, ref);
77 return ref;
78 };
79 }
80 }
81
82 // set
831 @override
84 Cast<Set<T>> set<T extends Object>([Cast<T>? cast]) {
851 final op = cast ?? value<T>();
861 if (Converter.isIdentity<T>(op)) {
870 final toSet = _converter.set<T>(); // elements will be cast
880 return (dynamic x) {
890 var ref = _arguments.getReference<Set<T>>(x);
90 if (ref != null) return ref;
910 ref = toSet(x);
920 _arguments.setReference(x, ref);
93 return ref;
94 };
95 } else {
961 return (dynamic x) {
972 var ref = _arguments.getReference<Set<T>>(x);
98 if (ref != null) return ref;
99 ref = <T>{}; // TODO: implement a lazy set?
1002 _arguments.setReference(x, ref);
1012 ref.addAll((x as Iterable).map(op));
102 return ref;
103 };
104 }
105 }
106
1071 @override
108 Cast<Set<T?>> nset<T extends Object>([Cast<T>? cast]) {
1091 final op = cast ?? value<T>();
1101 if (Converter.isIdentity<T>(op)) {
1110 final toSet = _converter.nset<T>(); // elements will be cast
1120 return (dynamic x) {
1130 var ref = _arguments.getReference<Set<T?>>(x);
114 if (ref != null) return ref;
1150 ref = toSet(x);
1160 _arguments.setReference(x, ref);
117 return ref;
118 };
119 } else {
1201 final nop = Converter.allowNull(op);
1211 return (dynamic x) {
1222 var ref = _arguments.getReference<Set<T?>>(x);
123 if (ref != null) return ref;
124 ref = <T?>{}; // TODO: implement a lazy set?
1252 _arguments.setReference(x, ref);
1262 ref.addAll((x as Iterable).map(nop));
127 return ref;
128 };
129 }
130 }
131
132 // map
1332 @override
134 Cast<Map<K, V>> map<K extends Object, V extends Object>(
135 {Cast<K>? kcast, Cast<V>? vcast}) {
1362 final kop = kcast ?? value<K>();
1372 final vop = vcast ?? value<V>();
1384 if (Converter.isIdentity<K>(kop) && Converter.isIdentity<V>(vop)) {
1392 final toMap = _converter.map<K, V>(); // elements will be cast
1401 return (dynamic x) {
1412 var ref = _arguments.getReference<Map<K, V>>(x);
142 if (ref != null) return ref;
1431 ref = toMap(x);
1442 _arguments.setReference(x, ref);
145 return ref;
146 };
1471 } else if (Converter.isIdentity(kop)) {
1481 return (dynamic x) {
1492 var ref = _arguments.getReference<Map<K, V>>(x);
150 if (ref != null) return ref;
1511 ref = LazyInPlaceMap(x, vop); // elements will be converted upon access
1522 _arguments.setReference(x, ref);
153 return ref;
154 };
155 } else {
1560 return (dynamic x) {
1570 var ref = _arguments.getReference<Map<K, V>>(x);
158 if (ref != null) return ref;
1590 ref = <K, V>{}; // TODO: implements a lazy map with convertible keys?
1600 _arguments.setReference(x, ref);
1610 ref.addEntries(
1620 (x as Map).entries.map((e) => MapEntry(kop(e.key), vop(e.value))),
163 );
164 return ref;
165 };
166 }
167 }
168
1691 @override
170 Cast<Map<K, V?>> nmap<K extends Object, V extends Object>(
171 {Cast<K>? kcast, Cast<V>? vcast}) {
1721 final kop = kcast ?? value<K>();
1731 final vop = vcast ?? value<V>();
1742 if (Converter.isIdentity<K>(kop) && Converter.isIdentity<V>(vop)) {
1750 final toMap = _converter.nmap<K, V>(); // elements will be cast
1760 return (dynamic x) {
1770 var ref = _arguments.getReference<Map<K, V?>>(x);
178 if (ref != null) return ref;
1790 ref = toMap(x);
1800 _arguments.setReference(x, ref);
181 return ref;
182 };
1831 } else if (Converter.isIdentity(kop)) {
1841 final nvop = Converter.allowNull(vop);
1851 return (dynamic x) {
1862 var ref = _arguments.getReference<Map<K, V?>>(x);
187 if (ref != null) return ref;
1881 ref = LazyInPlaceMap(x, nvop); // elements will be converted upon access
1892 _arguments.setReference(x, ref);
190 return ref;
191 };
192 } else {
1930 final nvop = Converter.allowNull(vop);
1940 return (dynamic x) {
1950 var ref = _arguments.getReference<Map<K, V?>>(x);
196 if (ref != null) return ref;
1970 ref = <K, V?>{}; // TODO: implements a lazy map with convertible keys?
1980 _arguments.setReference(x, ref);
1990 ref.addEntries(
2000 (x as Map).entries.map((e) => MapEntry(kop(e.key), nvop(e.value))),
201 );
202 return ref;
203 };
204 }
205 }
206}

Generated by: JGENHTML version 1.6

Choose Features