modify vectors collection in graph

core/src/main/java/ru/trader/analysis/graph/AbstractGraph.java

@@ -4,11 +4,8 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import ru.trader.analysis.AnalysisCallBack;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collection;
+import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.RecursiveAction;
 
@@ -19,7 +16,7 @@ public abstract class AbstractGraph<T> implements Graph<T> {
     private final static Logger LOG = LoggerFactory.getLogger(AbstractGraph.class);
 
     protected Vertex<T> root;
-    protected final Map<T, Vertex<T>> vertexes;
+    protected final List<Vertex<T>> vertexes;
     private final GraphCallBack callback;
 
     protected int minJumps;
@@ -30,7 +27,7 @@ public abstract class AbstractGraph<T> implements Graph<T> {
 
     protected AbstractGraph(AnalysisCallBack callback) {
         this.callback = new GraphCallBack(callback);
-        vertexes = new ConcurrentHashMap<>(50, 0.9f, THRESHOLD);
+        vertexes = new CopyOnWriteArrayList<>();
     }
 
     protected abstract GraphBuilder createGraphBuilder(Vertex<T> vertex, Collection<T> set, int deep, double limit);
@@ -43,7 +40,7 @@ public abstract class AbstractGraph<T> implements Graph<T> {
             minJumps = maxDeep;
         } else {
             minJumps = 1;
-            for (Vertex<T> vertex : vertexes.values()) {
+            for (Vertex<T> vertex : vertexes) {
                 int jumps = maxDeep - vertex.getLevel();
                 if (jumps > minJumps) minJumps = jumps;
             }
@@ -52,24 +49,29 @@ public abstract class AbstractGraph<T> implements Graph<T> {
     }
 
     private Vertex<T> getInstance(T entry, int deep){
-        Vertex<T> vertex = vertexes.get(entry);
+        Vertex<T> vertex = getVertex(entry).orElse(null);
+        if (vertex == null) {
+            synchronized (vertexes){
+                vertex = getVertex(entry).orElse(null);
                 if (vertex == null){
                     LOG.trace("Is new vertex");
-            vertex = new Vertex<>(entry);
+                    vertex = new Vertex<>(entry, vertexes.size());
                     vertex.setLevel(deep);
-            vertexes.put(entry, vertex);
+                    vertexes.add(vertex);
+                }
+            }
         }
         return vertex;
     }
 
     @Override
     public boolean isAccessible(T entry){
-        return vertexes.containsKey(entry);
+        return getVertex(entry).isPresent();
     }
 
     @Override
-    public Vertex<T> getVertex(T entry){
+    public Optional<Vertex<T>> getVertex(T entry){
-        return vertexes.get(entry);
+        return vertexes.stream().filter(v -> v.isEntry(entry)).findFirst();
     }
 
     @Override
@@ -87,6 +89,11 @@ public abstract class AbstractGraph<T> implements Graph<T> {
         return root.getLevel() - minJumps;
     }
 
+    @Override
+    public int getSize() {
+        return vertexes.size();
+    }
+
     protected abstract class GraphBuilder extends RecursiveAction {
         protected final Vertex<T> vertex;
         protected final Collection<T> set;

core/src/main/java/ru/trader/analysis/graph/Graph.java

@@ -1,13 +1,17 @@
 package ru.trader.analysis.graph;
 
+import java.util.Optional;
+
 public interface Graph<T> {
     boolean isAccessible(T entry);
 
-    Vertex<T> getVertex(T entry);
+    Optional<Vertex<T>> getVertex(T entry);
 
     Vertex<T> getRoot();
 
     int getMinJumps();
 
     int getMinLevel();
+
+    int getSize();
 }

core/src/main/java/ru/trader/analysis/graph/Vertex.java

@@ -8,10 +8,12 @@ import java.util.Optional;
 public class Vertex<T> {
     private final ArrayList<Edge<T>> edges = new ArrayList<>();
     private final T entry;
+    private final int index;
     private volatile int level = -1;
 
-    public Vertex(T entry) {
+    public Vertex(T entry, int index) {
         this.entry = entry;
+        this.index = index;
     }
 
     public T getEntry() {
@@ -22,6 +24,10 @@ public class Vertex<T> {
         return this.entry.equals(entry);
     }
 
+    public int getIndex() {
+        return index;
+    }
+
     public void setLevel(int level) {
         this.level = level;
     }
@@ -51,10 +57,6 @@ public class Vertex<T> {
         return edges.stream().filter((e) -> e.isConnect(target)).findFirst();
     }
 
-    public void sortEdges(){
-        edges.sort(Comparator.<Edge<T>>naturalOrder());
-    }
-
     public boolean isConnected(T other){
         return getEdge(other).isPresent();
     }

core/src/test/java/ru/trader/analysis/graph/GraphTest.java

@@ -10,6 +10,7 @@ import ru.trader.core.Profile;
 import ru.trader.core.Ship;
 
 import java.util.ArrayList;
+import java.util.Optional;
 
 public class GraphTest extends Assert {
     private final static Logger LOG = LoggerFactory.getLogger(GraphTest.class);
@@ -89,7 +90,7 @@ public class GraphTest extends Assert {
         assertFalse(graph.isAccessible(x9));
         assertFalse(graph.isAccessible(x10));
 
-        Vertex<Point> x = graph.getVertex(x5);
+        Optional<Vertex<Point>> x = graph.getVertex(x5);
         // x5 -> x4, x5 -> x6
         checkEdges(x, new Point[]{x4, x6}, new Point[]{x1, x2, x3, x7, x8, x9, x10});
         // x4 -> x5
@@ -101,7 +102,8 @@ public class GraphTest extends Assert {
 
     }
 
-    private void checkEdges(Vertex<Point> vertex, Point[] trueEdge, Point[] falseEdge){
+    private void checkEdges(Optional<Vertex<Point>> v, Point[] trueEdge, Point[] falseEdge){
+        Vertex<Point> vertex = v.get();
         for (Point point : trueEdge) {
             assertTrue(String.format("%s must have edge to %s", vertex, point), vertex.isConnected(point));
         }
@@ -133,7 +135,7 @@ public class GraphTest extends Assert {
         assertFalse(graph.isAccessible(x9));
         assertFalse(graph.isAccessible(x10));
 
-        Vertex<Point> x = graph.getVertex(x5);
+        Optional<Vertex<Point>> x = graph.getVertex(x5);
         // x5 -> x4, x5 -> x6
         checkEdges(x, new Point[]{x4, x6}, new Point[]{x1, x2, x3, x7, x8, x9, x10});
         // x3 -> x4
@@ -171,7 +173,7 @@ public class GraphTest extends Assert {
         assertFalse(graph.isAccessible(x9));
         assertFalse(graph.isAccessible(x10));
 
-        Vertex<Point> x = graph.getVertex(x5);
+        Optional<Vertex<Point>> x = graph.getVertex(x5);
         // x5 -> x4, x5 -> x3, x5 -> x6
         checkEdges(x, new Point[]{x3, x4, x6}, new Point[]{x1, x2, x7, x8, x9, x10});
         // x2 -> x3, x2 -> x4