Protect vertex write operation without unlocking

Author: mafinar-cmb

lib/graph/graph.dart

@@ -3,40 +3,45 @@ import 'vertex.dart';
 /// A Graph Type
 class Graph<T> {
   /// Vertices of this graph
-  Set<Vertex<T>> vertices;
+  Set<Vertex<T>> _vertices;
+  List<Vertex<T>> get vertices => List<Vertex<T>>.unmodifiable(_vertices);
 
   /// Settings for this graph
   /// Is this a Digraph?
-  bool isDigraph;
+  final bool isDigraph;
 
   /// Does this graph allow loops?
-  bool allowLoops;
+  final bool allowLoops;
 
   /// Create a new graph
   Graph({this.isDigraph = true, this.allowLoops = false}) {
-    vertices = <Vertex<T>>{};
+    _vertices = <Vertex<T>>{};
   }
 
   /// Total number of vertices for this graph
-  int get numberOfVertices => vertices.length;
+  int get numberOfVertices => _vertices.length;
 
   /// Total number of edges
   int get numberOfEdges =>
-      vertices.map((v) => v.outDegree).fold(0, (a, b) => a + b);
+      _vertices.map((v) => v.outDegree).fold(0, (a, b) => a + b);
 
   /// Adds an edge
   void addEdge(Vertex src, Vertex dst, [num weight = 1]) {
+    src.unlock();
+    dst.unlock();
     if (src.key == dst.key && !allowLoops) throw Error();
 
     src = _getOrAddVertex(src);
     dst = _getOrAddVertex(dst);
     src.addConnection(dst, weight);
 
     if (!isDigraph) dst.addConnection(src, weight);
+    src.lock();
+    dst.lock();
   }
 
   /// Checks if vertex is included
-  bool containsVertex(Vertex vertex) => vertices.contains(vertex);
+  bool containsVertex(Vertex vertex) => _vertices.contains(vertex);
 
   /// Checks if this is a null graph
   bool get isNull => numberOfVertices == 0;
@@ -48,14 +53,14 @@ class Graph<T> {
   bool get isEmpty => numberOfEdges == 0;
 
   /// Adds a new vertex
-  bool addVertex(Vertex vertex) => vertices.add(vertex);
+  bool addVertex(Vertex vertex) => _vertices.add(vertex);
 
   Vertex<T> _getOrAddVertex(Vertex vertex) =>
-      vertices.add(vertex) ? vertex : vertex;
+      _vertices.add(vertex) ? vertex : vertex;
 
   /// Gets an edge list for [this].
   List<List> get edges => [
-        for (var vertex in vertices) ...[
+        for (var vertex in _vertices) ...[
           for (var connection in vertex.outgoingConnections.entries)
             [vertex, connection.key, connection.value]
         ]

lib/graph/vertex.dart

@@ -5,6 +5,7 @@ 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;
@@ -26,13 +27,19 @@ class Vertex<T> {
 
   /// Constructor
   Vertex(this._key, [T value])
-      : _incomingVertices = <Vertex>{} as LinkedHashSet,
+      : _isLocked = true,
+        _incomingVertices = <Vertex>{} as LinkedHashSet,
         _outgoingConnections = <Vertex, num>{} as LinkedHashMap {
     this.value = value ?? key;
   }
 
+  void lock() => _isLocked = true;
+  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;
     }
@@ -44,6 +51,8 @@ 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);
 

test/graph/graph_test.dart

@@ -134,4 +134,12 @@ 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>()));
+  });
 }

test/graph/vertex_test.dart

@@ -7,15 +7,25 @@ void main() {
   Vertex rootWithValue;
   Vertex connectedVertex;
   Vertex toBeAdded;
+  Vertex anotherVertex;
 
   setUp(() {
     root = Vertex('A');
     rootWithValue = Vertex('a', 'Wake up');
 
     connectedVertex = Vertex('0');
     toBeAdded = Vertex('1');
+    anotherVertex = Vertex('2');
+
+    // For test purposes, unlock all vertices
+    root.unlock();
+    rootWithValue.unlock();
+    connectedVertex.unlock();
+    toBeAdded.unlock();
+    anotherVertex.unlock();
+
     connectedVertex.addConnection(toBeAdded);
-    connectedVertex.addConnection(Vertex('2'));
+    connectedVertex.addConnection(anotherVertex);
   });
 
   test('Initialization of a node', () {
@@ -28,6 +38,8 @@ void main() {
   test('Successfully add a vertex', () {
     var b = Vertex('B');
     var c = Vertex('C');
+    b.unlock();
+    c.unlock();
     expect(root.addConnection(b), isTrue);
     expect(root.addConnection(c), isTrue);
     expect(root.outgoingConnections.containsKey(b), isTrue);
@@ -38,6 +50,7 @@ void main() {
 
   test('Unsuccessfully add a vertex', () {
     var b = Vertex('B');
+    b.unlock();
     root.addConnection(b);
     expect(root.addConnection(b), isFalse);
   });
@@ -50,19 +63,59 @@ void main() {
 
   test('Unsuccessfully remove a vertex', () {
     var aVertex = Vertex('-1');
+    aVertex.unlock();
     expect(connectedVertex.removeConnection(aVertex), isFalse);
   });
 
+  test('Trying to add to a locked vertex throws error', () {
+    var locked = Vertex('PROTECTED');
+    expect(() => locked.addConnection(root), throwsA(isA<Error>()));
+    root.lock();
+    expect(() => root.addConnection(root), throwsA(isA<Error>()));
+  });
+
+  test('Trying to add a locked vertex throws error', () {
+    var locked = Vertex('PROTECTED');
+    expect(() => root.addConnection(locked), throwsA(isA<Error>()));
+    locked.unlock();
+    root.lock();
+    expect(() => locked.addConnection(root), throwsA(isA<Error>()));
+  });
+
+  test('Trying to remove from a locked vertex throws error', () {
+    toBeAdded.lock();
+    expect(() => connectedVertex.removeConnection(toBeAdded),
+        throwsA(isA<Error>()));
+  });
+
+  test('Trying to remove a locked vertex throws error', () {
+    connectedVertex.lock();
+    expect(() => connectedVertex.removeConnection(toBeAdded),
+        throwsA(isA<Error>()));
+  });
+
+  test('Trying to remove a locked vertex throws error', () {
+    var locked = Vertex('PROTECTED');
+    expect(() => root.addConnection(locked), throwsA(isA<Error>()));
+    locked.unlock();
+    root.lock();
+    expect(() => locked.addConnection(root), throwsA(isA<Error>()));
+  });
+
   test('Check for vertex containment', () {
+    var newVertex = Vertex('DISCONNECTED');
+    newVertex.unlock();
     expect(connectedVertex.containsConnectionTo(toBeAdded), isTrue);
-    expect(connectedVertex.containsConnectionTo(Vertex('I am not connected')),
-        isFalse);
+    expect(connectedVertex.containsConnectionTo(newVertex), isFalse);
   });
 
   test('Get a list of vertices', () {
     var a = Vertex('A');
     var b = Vertex('B');
     var c = Vertex('C');
+    a.unlock();
+    b.unlock();
+    c.unlock();
     root.addConnection(a);
     root.addConnection(b);
     root.addConnection(c);
@@ -78,8 +131,10 @@ void main() {
   });
 
   test('Get out degree for vertex', () {
+    Vertex c = Vertex('c');
+    c.unlock();
     expect(root.outDegree, equals(0));
-    connectedVertex.addConnection(Vertex('C'));
+    connectedVertex.addConnection(c);
     expect(connectedVertex.outDegree, equals(3));
   });