Add toObservableList and toObservableMap (#81)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6969548..db46b07 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+## HEAD
+
+* Add `toObservableList` and `toObservableMap`, better typed versions of
+ `toObservable`.
+
## 0.22.1+5
Fix generic type error that occurs when using ChangeNotifier with a subclass of
diff --git a/lib/src/to_observable.dart b/lib/src/to_observable.dart
index d331913..20f8d7e 100644
--- a/lib/src/to_observable.dart
+++ b/lib/src/to_observable.dart
@@ -16,6 +16,9 @@
/// respectively. This is a convenience function to make it easier to convert
/// literals into the corresponding observable collection type.
///
+/// For better static typing, use either [toObservableList] or
+/// [toObservableMap] instead of this function.
+///
/// If [value] is not one of those collection types, or is already [Observable],
/// it will be returned unmodified.
///
@@ -30,6 +33,35 @@
toObservable(dynamic value, {bool deep = true}) =>
deep ? _toObservableDeep(value) : _toObservableShallow(value);
+/// Converts the [Iterable] to an [ObservableList].
+///
+/// If [value] is already [Observable], it will be returned unmodified.
+///
+/// By default this performs a deep conversion, but you can set [deep] to false
+/// for a shallow conversion. This does not handle circular data structures.
+/// If a conversion is peformed, mutations are only observed to the result of
+/// this function. Changing the original collection will not affect it.
+ObservableList<T> toObservableList<T>(Iterable<T> value, {bool deep: true}) {
+ if (value is Observable) return value;
+ return deep ? _toObservableDeepIterable(value) : _toObservableShallow(value);
+}
+
+/// Converts the [Map] to an [ObservableMap].
+///
+/// If [value] is already [Observable], it will be returned unmodified.
+///
+/// The returned value will use the appropriate kind of backing map: either
+/// [HashMap], [LinkedHashMap], or [SplayTreeMap].
+///
+/// By default this performs a deep conversion, but you can set [deep] to false
+/// for a shallow conversion. This does not handle circular data structures.
+/// If a conversion is peformed, mutations are only observed to the result of
+/// this function. Changing the original collection will not affect it.
+ObservableMap<K, V> toObservableMap<K, V>(Map<K, V> value, {bool deep: true}) {
+ if (value is Observable) return value;
+ return deep ? _toObservableDeepMap(value) : _toObservableShallow(value);
+}
+
dynamic _toObservableShallow(dynamic value) {
if (value is Observable) return value;
@@ -49,25 +81,29 @@
dynamic _toObservableDeep(dynamic value) {
if (value is Observable) return value;
- if (value is Map) {
- return extractMapTypeArguments(value, <K, V>() {
- var result = new ObservableMap<K, V>.createFromType(value);
- value.forEach((k, v) {
- result[_toObservableDeep(k)] = _toObservableDeep(v);
- });
- return result;
- });
- }
+ if (value is Map) return _toObservableDeepMap(value);
- if (value is Iterable) {
- return extractIterableTypeArgument(value, <T>() {
- var result = new ObservableList<T>();
- for (var element in value) {
- result.add(_toObservableDeep(element));
- }
- return result;
- });
- }
+ if (value is Iterable) return _toObservableDeepIterable(value);
return value;
}
+
+ObservableMap _toObservableDeepMap(Map<dynamic, dynamic> value) {
+ return extractMapTypeArguments(value, <K, V>() {
+ var result = new ObservableMap<K, V>.createFromType(value);
+ value.forEach((k, v) {
+ result[_toObservableDeep(k)] = _toObservableDeep(v);
+ });
+ return result;
+ });
+}
+
+ObservableList _toObservableDeepIterable(Iterable<dynamic> value) {
+ return extractIterableTypeArgument(value, <T>() {
+ var result = new ObservableList<T>();
+ for (var element in value) {
+ result.add(_toObservableDeep(element));
+ }
+ return result;
+ });
+}
