diff --git a/unitex/src/fr/umlv/unitex/expr/Concatenation.java b/unitex/src/fr/umlv/unitex/expr/Concatenation.java new file mode 100644 index 000000000..d62712367 --- /dev/null +++ b/unitex/src/fr/umlv/unitex/expr/Concatenation.java @@ -0,0 +1,94 @@ +package fr.umlv.unitex.expr; + +import java.util.List; + +public class Concatenation extends Operator { + + @Override + public boolean equals(Object o) { + if (!(o instanceof Value)) { + return false; + } + Concatenation c= (Concatenation) o; + return c.getOperands().equals(this.getOperands()); + } + + + @Override + protected String getOpSymbol() { + return " "; + } + + + + public String getOpeningSymbol() { + return ""; + } + + public String getClosingSymbol() { + return ""; + } + + + /* + public void addOperand(Parallelization p) { + super.addOperand(p); + } + */ + + /* + public void addOperand(Value v) { + super.addOperand(v); + } + */ + + /* + public void addOperand(Value v) { + this.addOperand(v); + } + */ + + /* + public void addOperand(Concatenation c) { + List list = c.getOperands(); + for (Expression e : list) { + this.addOperand(e); + } + } + */ + + + public void addOperand(Expression expr) { + if (expr instanceof Concatenation) { + for (Expression e : expr.getOperands()) { + this.addOperand(e); + } + } + else { + super.addOperand(expr); + } + } + + + public void addOperands(Expression expr, int start, int end) { + List list = expr.getOperands(); + for (int i = start; i < end; i++) { + this.addOperand(list.get(i)); + } + } + + + + + /* + public void addOperand(Expression expr, int start, int end) { + List list = expr.getOperands(); + for (int i = start; i < end; i++) { + this.addOperand(list.get(i)); + } + } + */ + + + +} diff --git a/unitex/src/fr/umlv/unitex/expr/Expression.java b/unitex/src/fr/umlv/unitex/expr/Expression.java new file mode 100644 index 000000000..48d3e5168 --- /dev/null +++ b/unitex/src/fr/umlv/unitex/expr/Expression.java @@ -0,0 +1,14 @@ +package fr.umlv.unitex.expr; + +import java.util.ArrayList; +import java.util.List; + +public interface Expression { + + + List getOperands(); + + int getOperandsSize(); + + +} diff --git a/unitex/src/fr/umlv/unitex/expr/Kleene.java b/unitex/src/fr/umlv/unitex/expr/Kleene.java new file mode 100644 index 000000000..9da8840dd --- /dev/null +++ b/unitex/src/fr/umlv/unitex/expr/Kleene.java @@ -0,0 +1,367 @@ +package fr.umlv.unitex.expr; + +import java.util.AbstractMap.SimpleEntry; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import fr.umlv.unitex.graphrendering.GenericGraphBox; +import fr.umlv.unitex.graphrendering.TfstGraphBox; +import fr.umlv.unitex.io.GraphIO; + +public class Kleene { + + private final HashMap, Expression> map = new HashMap<>(); + private final HashMap, Expression> tmpMap = new HashMap<>(); + private final GraphIO graph; + + + + public Kleene(GraphIO graph) { + this.graph = graph; + } + + + @SuppressWarnings("unchecked") + ArrayList[] computeReverseTransitions(GraphIO graph) { + final ArrayList[] reverse = new ArrayList[graph.getBoxes().size()]; + for (int i = 0; i < reverse.length; i++) { + reverse[i] = new ArrayList(); + } + for (int i = 0; i < reverse.length; i++) { + final TfstGraphBox box = (TfstGraphBox) graph.getBoxes().get(i); + if (box == null) + continue; + /* We explore all outgoing transitions */ + for (final GenericGraphBox gb : box.transitions) { + final int destIndex = getBoxIndex((TfstGraphBox) gb, graph.getBoxes()); + reverse[destIndex].add(i); + } + } + return reverse; + } + + + int getBoxIndex(TfstGraphBox b, ArrayList boxes) { + if (b == null) + return -1; + for (int i = 0; i < boxes.size(); i++) { + if (b.equals(boxes.get(i))) + return i; + } + // If the box is unknown then we return -1 + return -1; + } + + + + private List topologicalSort(GraphIO graph) { + ArrayList boxes = graph.getBoxes(); + int[] renumber = new int[boxes.size()]; + final int[] incoming = new int[boxes.size()]; + final ArrayList[] reverse = computeReverseTransitions(graph); + for (int i = 0; i < incoming.length; i++) { + incoming[i] = reverse[i].size(); + } + /* + * We set up the renumber array so that renumber[q] will give us the + * rank of the node #q after the topological sort + */ + for (int q = 0; q < incoming.length; q++) { + int old = 0; + while (old < incoming.length && incoming[old] != 0) { + old++; + } + if (old == incoming.length) { + /* + * If that happens, we have automaton that is not acyclic + */ + //sortedNodes = null; + //renumber = null; + return null; + } + renumber[old] = q; + incoming[old] = -1; + for (final GenericGraphBox gb : boxes.get(old).transitions) { + final int destIndex = getBoxIndex((TfstGraphBox) gb, boxes); + incoming[destIndex]--; + } + } + /* + * Finally, we create another array so that sortedNodes[x] will give us + * the index of the node whose rank is x + */ + List sortedNodes = new ArrayList<>(Collections.nCopies(boxes.size(), 0)); + for (int q = 0; q < renumber.length; q++) { + //sortedNodes[renumber[q]] = q; + sortedNodes.set(renumber[q], q); + } + + return sortedNodes; + } + + + + + + public Concatenation factorizeExpressions(Expression expr1, Expression expr2) { + int size1, size2, i; + boolean isConcat = false; + List operands1, operands2; + Concatenation concat = new Concatenation(), tmpConcat1, tmpConcat2; + Parallelization p = new Parallelization(); + + size1 = expr1.getOperandsSize(); + size2 = expr2.getOperandsSize(); + + operands1 = expr1.getOperands(); + operands2 = expr2.getOperands(); + + //System.out.println("\n\nexp1 ->" + expr1 + "\nexp2" + expr2 + "\n\n"); + + /* + if (expr2 instanceof Concatenation) { + System.out.println(expr1); + } + if (operands2.get(0) instanceof Concatenation) { + System.out.println(expr2); + } + */ + + + for (i = 0; i < size1 - 1 && i < size2 - 2; i++) { + //System.out.println("\n\nCompa ->" + operands1.get(i) + " -- " + operands2.get(i) + "\n\n"); + + if (operands1.get(i) == operands2.get(i)) { + concat.addOperand(operands1.get(i)); + } + else { + break; + } + } + + if (i != size1 - 1) { + tmpConcat1 = new Concatenation(); + for (int j = i; j < size1; j++) { + tmpConcat1.addOperand(operands1.get(j)); + } + p.addOperand(tmpConcat1); + isConcat = true; + } + else { + p.addOperand(operands1.get(i)); + } + + /* + if (i > size2 - 2) { + System.out.println("HAHAHAHA"); + System.out.println("SIZE2 : " + (size2 - 1) + " - i : " + i + "\n"); + } + */ + + if (i != size2 - 2) { + tmpConcat2 = new Concatenation(); + for (int j = i; j < size2 - 1; j++) { + tmpConcat2.addOperand(operands2.get(j)); + } + p.addOperand(tmpConcat2); + } + else { + p.addOperand(operands2.get(i)); + } + + + //System.out.println("PARA1 -> " + p + "\n"); + + Expression expr = p; + if (isConcat && p.getOperandsSize() > 2) { + p.simplify(); + } + else if (isConcat) { + /*System.out.println("AAA"); + System.out.println("EXPR1 -> " + expr1 + "\n"); + System.out.println("EXPR2 -> " + expr2 + "\n");*/ + + expr = p.simplifyAsConcatenation(); + } + + //System.out.println("PARA2 -> " + expr + "\n"); + + concat.addOperand(expr); + concat.addOperand(operands2.get(size2 - 1)); + + return concat; + } + + /* + if (i != size2 - 2) { + tmpConcat2 = new Concatenation(); + for (j = i; j < size2 - 1; j++) { + tmpConcat2.addOperand(operands2.get(j)); + } + p.addOperand(tmpConcat2); + } + else { + p.addOperand(operands2.get(i)); + } + + + if (isConcat) { + p.simplify(); + } + + + concat.addOperand(p); + concat.addOperand(operands2.get(size2 - 1)); + + return concat; + } + */ + + + + + public String kleeneAlgo() { + int i, j, k, index; + Expression expr1, expr2, expr3; + + List sortedNodes = topologicalSort(graph); + //System.out.println(sortedNodes); + + for (i = 0; i < graph.getnBoxes(); i++) { + List transitions = graph.getBoxes().get(i).getTransitions(); + for (j = 0; j < transitions.size(); j++) { + index = graph.getBoxes().indexOf(transitions.get(j)); + map.put(new SimpleEntry(sortedNodes.indexOf(i), sortedNodes.indexOf(index)), new Value(transitions.get(j).getContent())); + } + } + + //System.out.println(map + "\n\n"); + + for (k = 1; k < sortedNodes.size(); k++) { + //for (i = 0; i < k; i++) { + for (j = k + 1; j < sortedNodes.size(); j++) { + expr1 = map.get(new SimpleEntry(0, k)); + expr2 = map.get(new SimpleEntry(k, j)); + expr3 = map.get(new SimpleEntry(0, j)); + +/* + System.out.println("j : " + j + " - k : " + k ); + + if(expr1 != null) { + expr1.toString(); + System.out.println("A"); + } + + if(expr2 != null) { + expr2.toString(); + System.out.println("B"); + } + + if (k == 489 && j == 490) { + System.out.println(expr1); + } + + if(expr3 != null) { + expr3.toString(); + System.out.println("C"); + } + + System.out.println("Z"); +*/ + Concatenation concat = new Concatenation(); + + if (expr1 != null && expr2 != null) { + + /* + Concatenation concat = new Concatenation(); + concat.addOperand(expr1); + concat.addOperand(expr2); + */ + if (expr3 != null) { + if (expr1 instanceof Value) { + /* + System.out.println("EXP1 -> " + expr1); + System.out.println("EXP2 -> " + expr2); + System.out.println("EXP3 -> " + expr3); + */ + + Parallelization p = new Parallelization(); + if (expr3.getOperandsSize() == 2) { + Expression firstOperand = expr3.getOperands().get(0); + p.addOperand(expr1); + p.addOperand(firstOperand); + concat.addOperand(p); + concat.addOperand(expr2); + //System.out.println(i + " - " + j +" - " + k); + //System.out.println("VAL1 -> " + concat + "\n"); + } + else { + Concatenation tmpConcat = new Concatenation(); + tmpConcat.addOperands(expr3, 0, expr3.getOperandsSize() - 1); + p.addOperand(expr1); + p.addOperand(tmpConcat); + concat.addOperand(p); + concat.addOperand(expr2); + //System.out.println(i + " - " + j +" - " + k); + //System.out.println("VAL2 -> " + concat + "\n"); + } + + tmpMap.put(new SimpleEntry(0, j), concat); + } + + else { + Concatenation tmp = factorizeExpressions(expr1, expr3); + /* + System.out.println(i + " - " + j +" - " + k); + System.out.println("expr1 -> " + expr1); + System.out.println("expr3 -> " + expr3); + System.out.println("PARA -> " + tmp + "\n"); + */ + tmpMap.put(new SimpleEntry(0, j), factorizeExpressions(expr1, expr3)); + } + } + /* + Parallelization p = new Parallelization(); + p.addOperand(concat); + p.addOperand(expr3); + tmpMap.put(new SimpleEntry(i, j), p); + */ + + //System.out.println(i + "," + j + "," + k + " -> PARALLELE"); + else { + concat.addOperand(expr1); + concat.addOperand(expr2); + //System.out.println(i + " - " + j +" - " + k); + //System.out.println("CONCAT -> " + concat + "\n"); + tmpMap.put(new SimpleEntry(0, j), concat); + } + } + //System.out.println(i + "," + j + " : 1 -> " + expr1 + " 2 -> " + expr2 + " 3 -> " + expr3 + "\n"); + //} + } + + Set, Expression>> s = tmpMap.entrySet(); + for (Map.Entry, Expression> e : s) { + map.put(e.getKey(), e.getValue()); + } + + tmpMap.clear(); + } + + //System.out.println(graph.getBoxes().get(106).getContent()); + System.out.println(sortedNodes); + return map.get(new SimpleEntry(0, sortedNodes.size() - 1)).toString(); + } + + + @Override + public String toString() { + return map.toString(); + } + +} diff --git a/unitex/src/fr/umlv/unitex/expr/Main.java b/unitex/src/fr/umlv/unitex/expr/Main.java new file mode 100644 index 000000000..e7e6abcaf --- /dev/null +++ b/unitex/src/fr/umlv/unitex/expr/Main.java @@ -0,0 +1,111 @@ +package fr.umlv.unitex.expr; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; + + + +public class Main { + + public static void main(String[] args) throws IOException { + + Parallelization p = new Parallelization(); + Parallelization p2 = new Parallelization(); + Parallelization p3 = new Parallelization(); + + + Concatenation c = new Concatenation(); + Concatenation c2= new Concatenation(); + + + p.addOperand(new Value("le")); + p.addOperand(new Value("la")); + + c.addOperand(p); + c.addOperand(new Value("aaa")); + + System.out.println(c); + + c2.addOperand(p); + c2.addOperand(new Value("bbb")); + + System.out.println(c2); + + p2.addOperand(c2); + p2.addOperand(new Value("hello")); + + System.out.println(p2); + + + p3.addOperand(c); + p3.addOperand(p2); + + System.out.println(p3 + "\n"); + + + p3.simplify(); + System.out.println(p3); + + /* + Concatenation c2 = new Concatenation(); + + + + Parallelization p2 = new Parallelization(); + + + p2.addOperand(new Value("poisson")); + p2.addOperand(new Value("verseau")); + p2.addOperand(new Value("scorpion")); + + + c.addOperand(new Value("bidule")); + c.addOperand(new Value("machin")); + c.addOperand(new Value("chose")); + + Expression e = c; + + c2.addOperand(new Value("hello")); + c2.addOperand(new Value("bonjour")); + c2.addOperand(e); + + c.addOperand(p2); + + + p.addOperand(new Value("Hello")); + p.addOperand(new Value("Coucou")); + p.addOperand(new Value("Salut")); + p.addOperand(c); + + + // TODO + p.addOperand(p2); + + System.out.println(c2.getOperandsSize()); + System.out.println(c2.getOperands().get(4)); + + + + final File sentenceGrf = new File("cursentence.grf"); + + System.out.println(sentenceGrf); + + FileReader fileReader = new FileReader(sentenceGrf); + BufferedReader bufferedReader = new BufferedReader(fileReader); + + for (int i = 0; i < 25; i++) { + System.out.println(bufferedReader.readLine()); + } + + bufferedReader.close(); + + GraphIO g = GraphIO.loadGraph(sentenceGrf, true, true); + + */ + + + } +} diff --git a/unitex/src/fr/umlv/unitex/expr/Operator.java b/unitex/src/fr/umlv/unitex/expr/Operator.java new file mode 100644 index 000000000..04d6302a8 --- /dev/null +++ b/unitex/src/fr/umlv/unitex/expr/Operator.java @@ -0,0 +1,106 @@ +package fr.umlv.unitex.expr; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + + +public abstract class Operator implements Expression { + + private final ArrayList operands = new ArrayList<>(); + + + + public void addOperand(Expression expr) { + operands.add(expr); + } + + public void removeOperand(int index) { + operands.remove(index); + } + + + /* + public void addOperand(Expression expr, int start, int end) { + List list = expr.getOperands(); + for (int i = start; i < end; i++) { + this.addOperand(list.get(i)); + } + } + */ + + protected abstract String getOpSymbol(); + protected abstract String getOpeningSymbol(); + protected abstract String getClosingSymbol(); + + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(this.getOpeningSymbol()); + + /* + if (operands.size() == 0) { + if (this instanceof Concatenation) { + System.out.println("CONCAT"); + } + else { + System.out.println("PARA"); + } + return "XXX"; + } + */ + + int i; + for (i = 0; i < operands.size() - 1; i++) { + sb.append(operands.get(i)).append(this.getOpSymbol()); + } + + + //sb.append(operands.stream().map(op -> op.toString()).collect(Collectors.joining(this.getOpSymbol()))); + sb.append(operands.get(i)).append(this.getClosingSymbol()); + + return sb.toString(); + } + + /* + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + if (operands.size() > 1) { + sb.append(this.getOpeningSymbol()); + } + + int i; + for (i = 0; i < operands.size() - 1; i++) { + sb.append(operands.get(i)).append(this.getOpSymbol()); + } + + + //sb.append(operands.stream().map(op -> op.toString()).collect(Collectors.joining(this.getOpSymbol()))); + sb.append(operands.get(i)); + + if (operands.size() > 1) { + sb.append(this.getClosingSymbol()); + } + + return sb.toString(); + } + */ + + + + public List getOperands() { + return Collections.unmodifiableList(operands); + } + + + + public int getOperandsSize() { + return operands.size(); + } + + + + + +} diff --git a/unitex/src/fr/umlv/unitex/expr/Parallelization.java b/unitex/src/fr/umlv/unitex/expr/Parallelization.java new file mode 100644 index 000000000..01d2d2a54 --- /dev/null +++ b/unitex/src/fr/umlv/unitex/expr/Parallelization.java @@ -0,0 +1,192 @@ +package fr.umlv.unitex.expr; + +import java.util.List; + +public class Parallelization extends Operator { + + + + @Override + public String getOpSymbol() { + return " | "; + } + + + public String getOpeningSymbol() { + return "("; + } + + public String getClosingSymbol() { + return ")"; + } + + + /* + public void addOperand(Concatenation c) { + super.addOperand(c); + } + + + + public void addOperand(Value v) { + super.addOperand(v); + } + + + + public void addOperand(Parallelization p) { + List list = p.getOperands(); + for (Expression e : list) { + this.addOperand(e); + } + } + */ + + + public void addOperand(Expression expr) { + if (expr instanceof Parallelization) { + for (Expression e : expr.getOperands()) { + this.addOperand(e); + } + } + else { + super.addOperand(expr); + } + } + + + @Override + public boolean equals(Object o) { + if (!(o instanceof Parallelization)) { + return false; + } + Parallelization p = (Parallelization) o; + return p.getOperands().equals(this.getOperands()); + } + + + public void simplify() { + List operands = this.getOperands(); + Expression firstOperand = operands.get(0), tmpOperand; + + if (firstOperand.getOperandsSize() == 1) { + return; + } + + for (int i = 1; i < operands.size(); i++) { + tmpOperand = operands.get(i); + if (tmpOperand.getOperandsSize() != 1) { + if (firstOperand.getOperands().get(0).toString().equals(tmpOperand.getOperands().get(0).toString())) { + + Concatenation concat = new Concatenation(); + concat.addOperand(firstOperand.getOperands().get(0)); + Parallelization tmpPara = new Parallelization(); + + this.removeOperand(i); + this.removeOperand(0); + + int j; + for (j = 1; j < firstOperand.getOperandsSize() && j < tmpOperand.getOperandsSize(); j++) { + if (firstOperand.getOperands().get(j).toString().equals(tmpOperand.getOperands().get(j).toString())) { + concat.addOperand(firstOperand.getOperands().get(j)); + } + else { + break; + } + } + + //concat.addOperand(firstOperand.getOperands().get(0)); + + tmpPara.addOperand(firstOperand.getOperands().get(j)); + tmpPara.addOperand(tmpOperand.getOperands().get(j)); + concat.addOperand(tmpPara); + + this.addOperand(concat); + return; + } + } + } + } + + + + public Expression simplifyAsConcatenation() { + if (this.getOperandsSize() != 2) { + throw new IllegalStateException("Parallelization must contain exactly two operands to be simplified as a concatenation"); + } + + List operands = this.getOperands(); + Expression firstOperand = operands.get(0), secondOperand = operands.get(1); + + int firstOperandSize = firstOperand.getOperandsSize(), secondOperandSize = secondOperand.getOperandsSize(); + + if (firstOperandSize == 1 || secondOperandSize == 1) { + return this; + } + + /* + System.out.println("PARA -> " + this + "\n"); + + System.out.println("AAAAAAAAA"); + System.out.println("FIRST : " + firstOperand.getOperands().get(0).toString() +"\n"); + + System.out.println("BBBBBBBBBBB"); + System.out.println("SECOND : " + secondOperand.getOperands().get(0).toString() +"\n"); + */ + + /* + if (firstOperand.getOperands().get(0).getOperandsSize() == 0) { + System.out.println("HAHAHHAAH"); + } + if (secondOperand.getOperands().get(0).getOperandsSize() == 0) { + System.out.println("BBBBB"); + } + */ + + if (firstOperand.getOperands().get(0).toString().equals(secondOperand.getOperands().get(0).toString())) { + Concatenation concat = new Concatenation(); + Parallelization tmpPara = new Parallelization(); + concat.addOperand(firstOperand.getOperands().get(0)); + + + if (firstOperandSize > 2) { + Concatenation tmpConcat = new Concatenation(); + for (int i = 1; i < firstOperandSize; i++) { + tmpConcat.addOperand(firstOperand.getOperands().get(i)); + } + tmpPara.addOperand(tmpConcat); + } + else { + tmpPara.addOperand(firstOperand.getOperands().get(1)); + } + + + if (secondOperandSize > 2) { + Concatenation tmpConcat = new Concatenation(); + for (int i = 1; i < secondOperandSize; i++) { + tmpConcat.addOperand(secondOperand.getOperands().get(i)); + } + tmpPara.addOperand(tmpConcat); + } + else { + tmpPara.addOperand(secondOperand.getOperands().get(1)); + } + + concat.addOperand(tmpPara); + + return concat; + } + + return this; + } + + + /*public void addOperand(Expression expr, int start, int end) { + List list = expr.getOperands(); + for (int i = start; i < end; i++) { + this.addOperand(list.get(i)); + } + }*/ + + +} diff --git a/unitex/src/fr/umlv/unitex/expr/Value.java b/unitex/src/fr/umlv/unitex/expr/Value.java new file mode 100644 index 000000000..968956d08 --- /dev/null +++ b/unitex/src/fr/umlv/unitex/expr/Value.java @@ -0,0 +1,52 @@ +package fr.umlv.unitex.expr; + +import java.util.ArrayList; +import java.util.List; + +public class Value implements Expression { + + private final String value; + + + public Value(String value) { + if (value.charAt(0) == '{') { + this.value = value.substring(1, value.length() - 1); + } + else { + this.value = value; + } + } + + + @Override + public String toString() { + return value; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof Value)) { + return false; + } + Value v = (Value) o; + if (v.value.equals(this.value)) { + return true; + } + return false; + } + + + + @Override + public List getOperands() { + List list = new ArrayList(); + list.add(this); + return list; + } + + @Override + public int getOperandsSize() { + return 1; + } + +} diff --git a/unitex/src/fr/umlv/unitex/frames/ExportTextAsPOSListDialog.java b/unitex/src/fr/umlv/unitex/frames/ExportTextAsPOSListDialog.java index c4d2e8819..1fc7fe7ad 100644 --- a/unitex/src/fr/umlv/unitex/frames/ExportTextAsPOSListDialog.java +++ b/unitex/src/fr/umlv/unitex/frames/ExportTextAsPOSListDialog.java @@ -29,14 +29,20 @@ import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.lang.reflect.InvocationTargetException; +import java.util.ArrayList; +import java.util.Arrays; import javax.swing.JDialog; +import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JProgressBar; import fr.umlv.unitex.common.project.manager.GlobalProjectManager; import fr.umlv.unitex.config.Config; import fr.umlv.unitex.config.ConfigManager; +import fr.umlv.unitex.expr.Kleene; +import fr.umlv.unitex.graphrendering.GenericGraphBox; +import fr.umlv.unitex.graphrendering.TfstGraphBox; import fr.umlv.unitex.io.Encoding; import fr.umlv.unitex.io.GraphIO; import fr.umlv.unitex.io.UnicodeIO; @@ -94,7 +100,14 @@ void configure(File o, TagFilter f, boolean delafStyle1) { this.filter = f; this.delafStyle = delafStyle1; } + + + + + + + public void launch() { canceled = false; progress.setMinimum(0); @@ -117,6 +130,7 @@ public void run() { final File sentenceTok = new File(sntDir, "foo.tok"); final TfstTableModel model = new TfstTableModel(filter, delafStyle); + final ArrayList errorList = new ArrayList<>(); try { final OutputStreamWriter writer = encoding .getOutputStreamWriter(output); @@ -130,7 +144,23 @@ public void run() { final String text = readSentenceText(sentenceText); TokensInfo.loadTokensInfo(sentenceTok, text); final GraphIO g = GraphIO.loadGraph(tmpGrf, true, true); + if (g == null) { + errorList.add(i); + continue; + } model.init(g.getBoxes()); + + /* + if (i == 3652) { + + Kleene k = new Kleene(g); + System.out.println(k.kleeneAlgo()); + + break; + } + */ + + if (model.getRowCount() == 0) { /* * If the sentence automaton has been emptied, we @@ -140,12 +170,12 @@ public void run() { final String s = TokensInfo.getTokenAsString(j); UnicodeIO.writeString(writer, s); } - } else - for (int j = 0; j < model.getRowCount(); j++) { - final TokenTags t = model.getTokenTags(j); - UnicodeIO.writeString(writer, t.toString() - + " "); - } + } else { + Kleene k = new Kleene(g); + System.out.println(k.kleeneAlgo()); + //UnicodeIO.writeString(writer, k.kleeneAlgo() + " ");*/ + } + /* And we add a sentence delimiter */ UnicodeIO.writeString(writer, "{S}\n"); final int z = i; @@ -190,6 +220,17 @@ public void run() { e.printStackTrace(); } } + + if (!errorList.isEmpty()) { + StringBuilder sb = new StringBuilder("The following sentence(s) couldn't " + + "be exported: \n"); + for(int j = 0; j < errorList.size(); j++) { + sb.append("Sentence #").append(errorList.get(j)).append("\n"); + } + JOptionPane.showMessageDialog(null, + sb.toString(), "Warning", + JOptionPane.WARNING_MESSAGE); + } } }).start(); }