Upgrade Trie to NNBD

Author: mafinar-cmb

lib/trie/trie.dart

@@ -1,19 +1,16 @@
-// @dart=2.9
 /// Trie is an ordered tree data structure used to store a dynamic set
 ///  or associative array where the keys are usually strings.
 class Trie<V extends Comparable> {
   /// Root of the trie.
-  TrieNode root;
+  TrieNode? root;
 
   /// Separates the value into it's components.
   final Function splitter;
 
   List _components;
 
   /// Initialises trie with custom set of values.
-  Trie(Set components, this.splitter) {
-    _components = [...components];
-  }
+  Trie(Set components, this.splitter) : _components = [...components];
 
   /// Generates trie of lower-case alphabets.
   Trie.ofAlphabets()
@@ -28,22 +25,22 @@ class Trie<V extends Comparable> {
 
   /// Adds a [value] to the trie.
   void add(V value) {
-    var list = _split(value);
+    var list = _split(value) as List<V>;
     if (isEmpty) {
       root ??= TrieNode({..._components});
     }
-    _add(root, list);
+    _add(root!, list);
   }
 
   /// Checks if [value] is contained in the trie.
   bool contains(V value) {
-    var list = _split(value);
-    return isEmpty ? false : _contains(root, list);
+    var list = _split(value) as List<V>;
+    return isEmpty ? false : _contains(root!, list);
   }
 
   /// Deletes [value] from the trie.
   void delete(V value) {
-    var list = _split(value);
+    var list = _split(value) as List<V>;
     var returnValue = _delete(root, list);
     returnValue ?? nullify();
   }
@@ -61,11 +58,11 @@ class Trie<V extends Comparable> {
     var path = _indexOf(value.first);
     value = value.sublist(1);
 
-    if (node.children[path] == null) {
-      node.children[path] = TrieNode(components);
+    if (node.children![path] == null) {
+      node.children![path] = TrieNode(components);
     }
 
-    _add(node.children[path], value);
+    _add(node.children![path]!, value);
   }
 
   bool _contains(TrieNode node, List<V> value) {
@@ -75,8 +72,8 @@ class Trie<V extends Comparable> {
     var path = _indexOf(value.first);
     value = value.sublist(1);
 
-    if (node.children[path] != null) {
-      return _contains(node.children[path], value);
+    if (node.children![path] != null) {
+      return _contains(node.children![path]!, value);
     } else {
       return false;
     }
@@ -85,7 +82,7 @@ class Trie<V extends Comparable> {
   /// Traverses the path following [value] and marks
   ///  `node.isValue` to `false` at end. Deletes values eagerly i.e.
   ///  cleans up any parent nodes that are no longer necessary.
-  TrieNode _delete(TrieNode node, List<V> value) {
+  TrieNode? _delete(TrieNode? node, List<V> value) {
     if (value.isEmpty) {
       // In case trie is empty and an empty value is passed.
       if (node == null) return null;
@@ -94,7 +91,7 @@ class Trie<V extends Comparable> {
 
       // Checks all the children. If null, then deletes the node.
       var allNull = true;
-      for (var child in node.children) {
+      for (var child in node.children!) {
         if (child != null) {
           allNull = false;
           break;
@@ -110,16 +107,16 @@ class Trie<V extends Comparable> {
     value = value.sublist(1);
 
     // Path to value doesn't exist.
-    if (node.children[path] == null) {
+    if (node.children![path] == null) {
       return node;
     }
 
-    node.children[path] = _delete(node.children[path], value);
+    node.children![path] = _delete(node.children![path]!, value);
 
     // Delete node if all children are null.
-    if (node.children[path] == null) {
+    if (node.children![path] == null) {
       var allNull = true;
-      for (var child in node.children) {
+      for (var child in node.children!) {
         if (child != null) {
           allNull = false;
           break;
@@ -150,11 +147,10 @@ class TrieNode<V extends Comparable> {
   bool isValue = false;
 
   /// Connection to [children].
-  List<TrieNode> children;
+  List<TrieNode?>? children;
 
   /// Initializes the node to have as many [children]
   ///  as there are components in the trie.
-  TrieNode(Set components) {
-    children = List<TrieNode>(components.length);
-  }
+  TrieNode(Set components)
+      : children = List<TrieNode?>.filled(components.length, null);
 }

test/trie/trie_test.dart

@@ -1,64 +1,65 @@
-// @dart=2.9
 import 'package:test/test.dart';
 import 'package:algorithms/trie/trie.dart';
 
 void main() {
-  Trie emptyTrie, trie, customTrie;
+  Trie? emptyTrie, trie, customTrie;
 
   setUp(() {
     emptyTrie = Trie.ofAlphabets();
 
     trie = Trie.ofAlphabets();
-    trie.add('algorithms');
+    trie!.add('algorithms');
 
     customTrie = Trie(
         {'a', 'b', 'f', 'o', 'r', 'z'}, (value) => value.toString().split(''));
-    customTrie.add('foo');
+    customTrie!.add('foo');
   });
 
   test('Components', () {
-    expect(trie.components,
+    expect(trie!.components,
         equals({...List.generate(26, (i) => String.fromCharCode(122 - i))}));
 
-    expect(customTrie.components, equals({'f', 'o', 'b', 'a', 'r', 'z'}));
+    expect(customTrie!.components, equals({'f', 'o', 'b', 'a', 'r', 'z'}));
   });
 
   test('Empty trie', () {
-    expect(emptyTrie.isEmpty, isTrue);
-    expect(trie.isEmpty, isFalse);
+    expect(emptyTrie!.isEmpty, isTrue);
+    expect(trie!.isEmpty, isFalse);
   });
 
   test('Add value', () {
-    trie.add('hi');
-    expect(trie.root.children[7].children[8].isValue, isTrue);
+    trie!.add('hi');
+    expect(trie!.root!.children![7]!.children![8]!.isValue, isTrue);
 
-    customTrie.add('bar');
-    expect(customTrie.root.children[1].children[0].children[4].isValue, isTrue);
+    customTrie!.add('bar');
+    expect(customTrie!.root!.children![1]!.children![0]!.children![4]!.isValue,
+        isTrue);
 
-    customTrie.add('baz');
-    expect(customTrie.root.children[1].children[0].children[5].isValue, isTrue);
+    customTrie!.add('baz');
+    expect(customTrie!.root!.children![1]!.children![0]!.children![5]!.isValue,
+        isTrue);
   });
 
   test('Contains value', () {
-    expect(emptyTrie.contains('test'), isFalse);
+    expect(emptyTrie!.contains('test'), isFalse);
 
-    expect(trie.contains('algorithm'), isFalse);
-    expect(trie.contains('algorithms'), isTrue);
+    expect(trie!.contains('algorithm'), isFalse);
+    expect(trie!.contains('algorithms'), isTrue);
 
-    expect(customTrie.contains('boar'), isFalse);
-    expect(customTrie.contains('foo'), isTrue);
+    expect(customTrie!.contains('boar'), isFalse);
+    expect(customTrie!.contains('foo'), isTrue);
   });
 
   test('Delete value', () {
-    emptyTrie.delete('');
-    emptyTrie.delete('test');
+    emptyTrie!.delete('');
+    emptyTrie!.delete('test');
 
-    expect(trie.contains('algorithms'), isTrue);
-    trie.delete('algorithms');
-    expect(trie.contains('algorithms'), isFalse);
+    expect(trie!.contains('algorithms'), isTrue);
+    trie!.delete('algorithms');
+    expect(trie!.contains('algorithms'), isFalse);
 
-    expect(customTrie.contains('foo'), isTrue);
-    customTrie.delete('foo');
-    expect(customTrie.contains('foo'), isFalse);
+    expect(customTrie!.contains('foo'), isTrue);
+    customTrie!.delete('foo');
+    expect(customTrie!.contains('foo'), isFalse);
   });
 }