Merge pull request #19 from thehighestmath/Separation_GUI_and_logic

Separation gui and logic

Author: thehighestmath

build.gradle

@@ -22,6 +22,12 @@ repositories {
     mavenCentral()
 }
 
+
+test {
+    useJUnitPlatform()
+}
+
 dependencies {
-    testCompile group: 'junit', name: 'junit', version: '4.12'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'
 }

build/libs/SummerPractice-all-1.0-SNAPSHOT.jar

@@ -0,0 +1,17 @@
+7
+e d 7
+e c 6
+a e 1
+c d 2
+a b 3
+b e 4
+b c 5
+
+
+--- Result ---
+From	To		Distance
+a		e		1
+c		d		2
+a		b		3
+b		c		5
+a b c d e

build/resources/test/test1.txt

@@ -0,0 +1,4 @@
+Manifest-Version: 1.0
+Implementation-Title: Gradle Jar File Example
+Main-Class: ru.etu.practice.Main
+

build/tmp/fatJar/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+

build/tmp/jar/MANIFEST.MF

@@ -0,0 +1,52 @@
+package ru.etu.practice;
+
+public class Edge {
+    @Override
+    public String toString() {
+        return "Edge " + " " + from + "—" + to + " " + distance;
+    }
+
+    /**
+     * way from -> to == way to -> to
+     */
+    public Node from;
+    public Node to;
+    public int distance;
+
+    public Edge(Node from, Node to, int distance) {
+        this.from = from;
+        this.to = to;
+        this.distance = distance;
+
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null) {
+            return false;
+        }
+        Edge other = (Edge) o;
+        return this.to.getName() == other.to.getName() && this.from.getName() == other.from.getName() && this.distance == other.distance ||
+                this.from.getName() == other.to.getName() && this.to.getName() == other.from.getName() && this.distance == other.distance;
+    }
+
+    public boolean equalsWay(Edge other){
+        if (this == other) {
+            return true;
+        }
+        if (other == null) {
+            return false;
+        }
+        return this.to.getName() == other.to.getName() && this.from.getName() == other.from.getName() ||
+                this.from.getName() == other.to.getName() && this.to.getName() == other.from.getName();
+    }
+
+}

src/main/java/ru/etu/practice/Edge.java

@@ -2,199 +2,56 @@
 
 import java.util.*;
 
-class Edge {
-    /**
-     * way from -> to == way to -> to
-     */
-    public char from;
-    public char to;
-    public int distance;
-
-    public Edge(char from, char to, int distance) {
-        this.from = from;
-        this.to = to;
-        this.distance = distance;
-
-    }
-}
-
 public class Graph {
-    private static final int SIZE = 26;
-
-    private int countVertexes;
-
-    private final int[][] inputGraph;
-    private final int[][] outputGraph;
-
-
-    private final List<Edge> inputEdges;
-    private final List<Edge> outputEdges;
-
-    private final Set<Character> inputVertices;
-    private final List<Set<Character>> outputVertices;
-
-
-    public Graph() {
-        inputGraph = new int[SIZE][SIZE];
-        outputGraph = new int[SIZE][SIZE];
-        inputEdges = new LinkedList<>();
-        outputEdges = new LinkedList<>();
-        inputVertices = new HashSet<>();
-        outputVertices = new LinkedList<>();
-    }
-
-    public void readGraph() {
-        // TODO adapter
-        System.out.println("Ready to enter");
-        try (Scanner scanner = new Scanner(System.in)) {
-//            scanner.useDelimiter("[\n ]");
-            int n = Integer.parseInt(scanner.nextLine());
-//            System.out.println(n);
-            for (int i = 0; i < n; i++) {
-                String[] parts = scanner.nextLine().split(" ");
-                char from = parts[0].toLowerCase().toCharArray()[0];
-                char to = parts[1].toLowerCase().toCharArray()[0];
-                int distance = Integer.parseInt(parts[2]);
-
-                assert (from >= 'a' && from <= 'z');
-                assert (to >= 'a' && to <= 'z');
-                assert (distance > 0);
-
-                while (inputGraph[from - 'a'][to - 'a'] != 0) {
-                    parts = scanner.nextLine().split(" ");
-                    from = parts[0].toLowerCase().toCharArray()[0];
-                    to = parts[1].toLowerCase().toCharArray()[0];
-                    distance = Integer.parseInt(parts[2]);
-                }
+//    private static final int SIZE = 26;
 
-                Edge edge = new Edge(from, to, distance);
-                inputEdges.add(edge);
+    private List<Edge> inputEdges;
+    private List<Node> inputVertices;
+    public boolean isModified = false;
 
-                Character vertex1 = from;
-                Character vertex2 = to;
-                inputVertices.add(vertex1);
-                inputVertices.add(vertex2);
+//    public
 
-//                System.out.println(from + " " + to + " " + distance);
-                inputGraph[from - 'a'][to - 'a'] = distance;
-                inputGraph[to - 'a'][from - 'a'] = distance;
-            }
-        }
-        countVertexes = inputVertices.size();
+    public List<Edge> getInputEdges() {
+        return inputEdges;
     }
 
-    public void printGraph() {
-        for (int i = 0; i < SIZE; i++) {
-            for (int j = 0; j < SIZE; j++) {
-                System.out.print(inputGraph[i][j] + " ");
-            }
-            System.out.println();
-        }
+    public List<Node> getInputVertices() {
+        return inputVertices;
     }
 
-    private void printEdges(List<Edge> edges) {
-        System.out.println("From\tTo\t\tDistance");
-//        System.out.println("F\tT\tD");
-        for (Edge edge : edges) {
-            System.out.println(
-                    edge.from + "\t\t" +
-                            edge.to + "\t\t" +
-                            edge.distance
-            );
-        }
-    }
-
-    public void sortEdges() {
-        inputEdges.sort(new Comparator<Edge>() {
-            @Override
-            public int compare(Edge edge1, Edge edge2) {
-                int distance1 = edge1.distance;
-                int distance2 = edge2.distance;
-                return Integer.compare(distance1, distance2);
-            }
-        });
-        System.err.println(State.SORT);
-    }
-
-    private State nextStep(Edge edge) {
-        State state = null;
-        Set<Character> tempVertexes = new HashSet<>();
-        Character vertex1 = edge.from;
-        Character vertex2 = edge.to;
-        tempVertexes.add(vertex1);
-        tempVertexes.add(vertex2);
-
-        boolean hasFound = false;
-        for (Set<Character> currently : outputVertices) {
-            if (isOld(currently, tempVertexes)) {
-                return State.LOOP;
-            }
-            if (isCommon(currently, tempVertexes)) {
-                hasFound = true;
-                currently.addAll(tempVertexes);
-                state = State.APPEND;
-            }
-        }
-
-        for (int i = 0; i < outputVertices.size(); i++) {
-            for (int j = i + 1; j < outputVertices.size(); j++) {
-                Set<Character> first = outputVertices.get(i);
-                Set<Character> second = outputVertices.get(j);
-                if (isCommon(first, second)) {
-                    state = State.CONNECT_COMPONENTS;
-                    first.addAll(second);
-                    second.clear();
-                }
-            }
-        }
-
-        outputEdges.add(edge);
-        if (!hasFound) {
-            state = State.NEW_COMPONENT;
-            outputVertices.add(tempVertexes);
-        }
-        if (outputVertices.get(0).size() == countVertexes) {
-            state = State.END;
-        }
-//        assert state != null;
-        return state;
+    public Graph() {
+        this.inputEdges = new LinkedList<>();
+        this.inputVertices = new LinkedList<>();
     }
 
-    public void kraskal() {
-        for (Edge edge : inputEdges) {
-            State state = nextStep(edge);
-            System.err.println(state);
-            if (state == State.END) {
-                break;
-            }
-        }
-    }
+//    public void initGraph(List<Edge> inputEdges, List<Node> inputVertices) {
+//        this.inputEdges = new LinkedList<>(inputEdges);
+//        this.inputVertices = new LinkedList<>(inputVertices);
+//    }
 
-    private boolean isCommon(Set<Character> first, Set<Character> second) {
-        Set<Character> all = new HashSet<>();
-        all.addAll(first);
-        all.addAll(second);
-        return all.size() != (first.size() + second.size());
+    public void addEdge(Node from, Node to, int distance) {
+        Edge newEdge = new Edge(from, to, distance);
+        for (Edge edge : inputEdges)
+            if (edge.equalsWay(newEdge))
+                return;
+        inputEdges.add(newEdge);
+        isModified = true;
     }
 
-    private boolean isOld(Set<Character> first, Set<Character> second) {
-        Set<Character> all = new HashSet<>();
-        all.addAll(first);
-        all.addAll(second);
-        return all.size() == first.size();
+    public void addVertex(Node node) {
+        if (!inputVertices.contains(node))
+            inputVertices.add(node);
+        isModified = true;
     }
 
-    public void printResult() {
-        printEdges(outputEdges);
-        for (Set<Character> vertices : outputVertices) {
-            for (Character vertex : vertices) {
-                System.out.print(vertex + " ");
-            }
-            System.out.println();
-        }
+    public void addVertex() {
+        int len = inputVertices.size();
+        inputVertices.add(new Node((char)('a' + len)));
     }
 
-    public void printInputEdges() {
-        printEdges(inputEdges);
+    public void clear() {
+        inputVertices.clear();
+        inputEdges.clear();
+        isModified = false;
     }
 }