Remove the lock experiment on graph

Author: code-shoily

Diff for: lib/graph/simple_graph.dart

@@ -23,22 +23,18 @@ class SimpleGraph<T> {
 
   /// Adds an edge
   void addEdge(Vertex<T> src, Vertex<T> dst, [num weight = 1]) {
-    unlockVertices(<Vertex>{src, dst});
     if (src.key == dst.key) throw Error();
 
     src = _getOrAddVertex(src);
     dst = _getOrAddVertex(dst);
     src.addConnection(dst, weight);
 
     if (!isDigraph) dst.addConnection(src, weight);
-    lockVertices(<Vertex>{src, dst});
   }
 
   /// Removes an Edge from [this], returns `false` if edge does not exists.
   bool removeEdge(Vertex src, Vertex dst) {
-    unlockVertices(<Vertex>{src, dst});
     var removed = src.removeConnection(dst);
-    lockVertices(<Vertex>{src, dst});
 
     return removed;
   }

Diff for: lib/graph/vertex.dart

@@ -5,7 +5,6 @@ import 'dart:collection';
 /// the vertex. By default, the `key` and `value` are the same.
 class Vertex<T> {
   final String _key;
-  bool _isLocked;
 
   /// Uniquely identifiable key to this [Vertex]
   String get key => _key;
@@ -27,21 +26,11 @@ class Vertex<T> {
 
   /// Constructor
   Vertex(this._key, [this.value])
-      : _isLocked = true,
-        _incomingVertices = <Vertex>{} as LinkedHashSet<Vertex>,
+      : _incomingVertices = <Vertex>{} as LinkedHashSet<Vertex>,
         _outgoingConnections = <Vertex, num>{} as LinkedHashMap<Vertex, num>;
 
-  /// Lock [this] vertex, cannot modify after it is locked
-  void lock() => _isLocked = true;
-
-  /// Unlock [this] vertex, can modify after it is unlock
-  void unlock() => _isLocked = false;
-
   /// Adds a connection with [Vertex] `dst` and with `weight`
   bool addConnection(Vertex dst, [num weight = 1]) {
-    if (_isLocked || dst._isLocked) {
-      throw UnsupportedError('Cannot add to a locked vertex');
-    }
     if (_outgoingConnections.containsKey(dst)) {
       return false;
     }
@@ -53,9 +42,6 @@ class Vertex<T> {
   /// Removes a connection with `other` with `weight`. `false` for non-existent
   /// connection.
   bool removeConnection(Vertex other, [num weight = 1]) {
-    if (_isLocked || other._isLocked) {
-      throw UnsupportedError('Cannot remove from a locked vertex');
-    }
     var outgoingRemoved = _outgoingConnections.remove(other) != null;
     var incomingRemoved = other._incomingVertices.remove(this);
 
@@ -92,17 +78,3 @@ class Vertex<T> {
   // ignore: avoid_equals_and_hash_code_on_mutable_classes
   int get hashCode => key.hashCode;
 }
-
-/// Unlocks a set of vertices
-void unlockVertices(Set<Vertex> vertices) {
-  for (var vertex in vertices) {
-    vertex.unlock();
-  }
-}
-
-/// Locks a set of vertices
-void lockVertices(Set<Vertex> vertices) {
-  for (var vertex in vertices) {
-    vertex.lock();
-  }
-}

Diff for: test/graph/simple_graph_test.dart

@@ -167,12 +167,4 @@ void main() {
     };
     expect(simpleGraph.edges.toSet(), equals(expectedEdges));
   });
-
-  test('addConnection on a cherry picked vertex throws error', () {
-    var vertices = simpleGraph.vertices;
-    var leak = Vertex('LEAK');
-    leak.unlock();
-    expect(() => vertices[0].addConnection(leak),
-        throwsA(isA<UnsupportedError>()));
-  });
 }

Diff for: test/graph/vertex_test.dart

@@ -22,22 +22,8 @@ void main() {
     c = Vertex('c');
   }
 
-  void _unlockVertices() {
-    unlockVertices(<Vertex>{
-      root,
-      rootWithValue,
-      connectedVertex,
-      toBeAdded,
-      anotherVertex,
-      a,
-      b,
-      c,
-    });
-  }
-
   setUp(() {
     _initializeVertices();
-    _unlockVertices();
     connectedVertex.addConnection(toBeAdded);
     connectedVertex.addConnection(anotherVertex);
   });
@@ -65,7 +51,7 @@ void main() {
 
   test('Cannot add vertex with the same key', () {
     expect(root.addConnection(b), isTrue);
-    var bDuplicate = Vertex(b.key)..unlock();
+    var bDuplicate = Vertex(b.key);
     expect(root.addConnection(bDuplicate), isFalse);
   });
 
@@ -79,44 +65,8 @@ void main() {
     expect(connectedVertex.removeConnection(a), isFalse);
   });
 
-  test('Trying to add to a locked vertex throws error', () {
-    var locked = Vertex('PROTECTED');
-    expect(() => locked.addConnection(root), throwsA(isA<UnsupportedError>()));
-    root.lock();
-    expect(() => root.addConnection(root), throwsA(isA<UnsupportedError>()));
-  });
-
-  test('Trying to add a locked vertex throws error', () {
-    var locked = Vertex('PROTECTED');
-    expect(() => root.addConnection(locked), throwsA(isA<UnsupportedError>()));
-    locked.unlock();
-    root.lock();
-    expect(() => locked.addConnection(root), throwsA(isA<UnsupportedError>()));
-  });
-
-  test('Trying to remove from a locked vertex throws error', () {
-    toBeAdded.lock();
-    expect(() => connectedVertex.removeConnection(toBeAdded),
-        throwsA(isA<UnsupportedError>()));
-  });
-
-  test('Trying to remove a locked vertex throws error', () {
-    connectedVertex.lock();
-    expect(() => connectedVertex.removeConnection(toBeAdded),
-        throwsA(isA<UnsupportedError>()));
-  });
-
-  test('Trying to remove a locked vertex throws error', () {
-    var locked = Vertex('PROTECTED');
-    expect(() => root.addConnection(locked), throwsA(isA<UnsupportedError>()));
-    locked.unlock();
-    root.lock();
-    expect(() => locked.addConnection(root), throwsA(isA<UnsupportedError>()));
-  });
-
   test('Check for vertex containment', () {
     var newVertex = Vertex('DISCONNECTED');
-    newVertex.unlock();
     expect(connectedVertex.containsConnectionTo(toBeAdded), isTrue);
     expect(connectedVertex.containsConnectionTo(newVertex), isFalse);
   });