lkrsnik/list
1
0
Fork 0
Code Issues 1 Pull Requests Releases Wiki Activity

Implemented interlinguality and fixed some bugs"

Browse Source
This commit is contained in:
Luka
2018-12-13 08:35:36 +01:00
parent ca83cb023b
commit 5e686ff681
24 changed files with 2039 additions and 660 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
src/main/java/data/CalculateFor.java
View File

@@ -1,14 +1,34 @@
package data;
import gui.I18N;
public enum CalculateFor {
WORD("različnica"),
NORMALIZED_WORD("normalizirana različnica"),
LEMMA("lema"),
MORPHOSYNTACTIC_SPECS("oblikoskladenjska oznaka"),
MORPHOSYNTACTIC_PROPERTY("oblikoskladenjska lastnost"),
WORD_TYPE("besedna vrsta"),
DIST_WORDS("različnica"),
DIST_LEMMAS("lema");
// calculateFor.WORD=word
// calculateFor.NORMALIZED_WORD=normalized word
// calculateFor.LEMMA=lemma
// calculateFor.MORPHOSYNTACTIC_SPECS=msd
// calculateFor.MORPHOSYNTACTIC_PROPERTY=oblikoskladenjska lastnost
// calculateFor.WORD_TYPE=besedna vrsta
// calculateFor.DIST_WORDS=različnica
// calculateFor.DIST_LEMMAS=lema
// WORD("različnica"),
// NORMALIZED_WORD("normalizirana različnica"),
// LEMMA("lema"),
// MORPHOSYNTACTIC_SPECS("oblikoskladenjska oznaka"),
// MORPHOSYNTACTIC_PROPERTY("oblikoskladenjska lastnost"),
// WORD_TYPE("besedna vrsta"),
// DIST_WORDS("različnica"),
// DIST_LEMMAS("lema");
WORD("calculateFor.WORD"),
NORMALIZED_WORD("calculateFor.NORMALIZED_WORD"),
LEMMA("calculateFor.LEMMA"),
MORPHOSYNTACTIC_SPECS("calculateFor.MORPHOSYNTACTIC_SPECS"),
MORPHOSYNTACTIC_PROPERTY("calculateFor.MORPHOSYNTACTIC_PROPERTY"),
WORD_TYPE("calculateFor.WORD_TYPE"),
DIST_WORDS("calculateFor.DIST_WORDS"),
DIST_LEMMAS("calculateFor.DIST_LEMMAS");
private final String name;
@@ -18,11 +38,12 @@ public enum CalculateFor {
}
public String toString() {
return this.name;
return I18N.get(this.name);
}
public static CalculateFor factory(String cf) {
if (cf != null) {
// String name = I18N.findI18NString(cf, "calculateFor");
if (WORD.toString().equals(cf)) {
return WORD;
}
@@ -49,42 +70,42 @@ public enum CalculateFor {
if (ngram == 0) {
switch (this) {
case WORD:
return "Skupna vsota vseh črkovnih nizov različnic:";
return I18N.get("exportTable.part.totalSumLetters") + " " + I18N.get("exportTable.part.word");
case NORMALIZED_WORD:
return "Skupna vsota vseh črkovnih nizov normaliziranih različnic:";
return I18N.get("exportTable.part.totalSumLetters") + " " + I18N.get("exportTable.part.normalizedWord");
case LEMMA:
return "Skupna vsota vseh črkovnih nizov lem:";
return I18N.get("exportTable.part.totalSumLetters") + " " + I18N.get("exportTable.part.lemma");
case MORPHOSYNTACTIC_SPECS:
return "Skupna vsota vseh črkovnih nizov oblikoskladenjskih oznak:";
return I18N.get("exportTable.part.totalSumLetters") + " " + I18N.get("exportTable.part.msd");
case MORPHOSYNTACTIC_PROPERTY:
return "Skupna vsota vseh črkovnih nizov oblikoskladenjskih lastnosti:";
return I18N.get("exportTable.part.totalSumLetters") + " " + I18N.get("exportTable.part.msdProperty");
case WORD_TYPE:
return "Skupna vsota vseh črkovnih nizov besednih vrst:";
return I18N.get("exportTable.part.totalSumLetters") + " " + I18N.get("exportTable.part.wordType");
case DIST_WORDS:
return "Skupna vsota vseh črkovnih nizov različnic:";
return I18N.get("exportTable.part.totalSumLetters") + " " + I18N.get("exportTable.part.word");
case DIST_LEMMAS:
return "Skupna vsota vseh črkovnih nizov lem:";
return I18N.get("exportTable.part.totalSumLetters") + " " + I18N.get("exportTable.part.lemma");
default:
return null;
}
} else if (ngram >= 1) {
switch (this) {
case WORD:
return "Skupna vsota vseh različnic:";
return I18N.get("exportTable.part.totalSumString") + " " + I18N.get("exportTable.part.word");
case NORMALIZED_WORD:
return "Skupna vsota vseh normaliziranih različnic:";
return I18N.get("exportTable.part.totalSumString") + " " + I18N.get("exportTable.part.normalizedWord");
case LEMMA:
return "Skupna vsota vseh lem:";
return I18N.get("exportTable.part.totalSumString") + " " + I18N.get("exportTable.part.lemma");
case MORPHOSYNTACTIC_SPECS:
return "Skupna vsota vseh oblikoskladenjskih oznak:";
return I18N.get("exportTable.part.totalSumString") + " " + I18N.get("exportTable.part.msd");
case MORPHOSYNTACTIC_PROPERTY:
return "Skupna vsota vseh oblikoskladenjskih lastnosti:";
return I18N.get("exportTable.part.totalSumString") + " " + I18N.get("exportTable.part.msdProperty");
case WORD_TYPE:
return "Skupna vsota vseh besednih vrst:";
return I18N.get("exportTable.part.totalSumString") + " " + I18N.get("exportTable.part.wordType");
case DIST_WORDS:
return "Skupna vsota vseh različnic:";
return I18N.get("exportTable.part.totalSumString") + " " + I18N.get("exportTable.part.word");
case DIST_LEMMAS:
return "Skupna vsota vseh lem:";
return I18N.get("exportTable.part.totalSumString") + " " + I18N.get("exportTable.part.lemma");
default:
return null;
}
@@ -96,42 +117,42 @@ public enum CalculateFor {
if (ngram == 0) {
switch (this) {
case WORD:
return "Skupna vsota vseh najdenih črkovnih nizov različnic:";
return I18N.get("exportTable.part.totalFoundLetters") + " " + I18N.get("exportTable.part.word");
case NORMALIZED_WORD:
return "Skupna vsota vseh najdenih črkovnih nizov normaliziranih različnic:";
return I18N.get("exportTable.part.totalFoundLetters") + " " + I18N.get("exportTable.part.normalizedWord");
case LEMMA:
return "Skupna vsota vseh najdenih črkovnih nizov lem:";
return I18N.get("exportTable.part.totalFoundLetters") + " " + I18N.get("exportTable.part.lemma");
case MORPHOSYNTACTIC_SPECS:
return "Skupna vsota vseh najdenih črkovnih nizov oblikoskladenjskih oznak:";
return I18N.get("exportTable.part.totalFoundLetters") + " " + I18N.get("exportTable.part.msd");
case MORPHOSYNTACTIC_PROPERTY:
return "Skupna vsota vseh najdenih črkovnih nizov oblikoskladenjskih lastnosti:";
return I18N.get("exportTable.part.totalFoundLetters") + " " + I18N.get("exportTable.part.msdProperty");
case WORD_TYPE:
return "Skupna vsota vseh najdenih črkovnih nizov besednih vrst:";
return I18N.get("exportTable.part.totalFoundLetters") + " " + I18N.get("exportTable.part.wordType");
case DIST_WORDS:
return "Skupna vsota vseh najdenih črkovnih nizov različnic:";
return I18N.get("exportTable.part.totalFoundLetters") + " " + I18N.get("exportTable.part.word");
case DIST_LEMMAS:
return "Skupna vsota vseh najdenih črkovnih nizov lem:";
return I18N.get("exportTable.part.totalFoundLetters") + " " + I18N.get("exportTable.part.lemma");
default:
return null;
}
} else if (ngram >= 1) {
switch (this) {
case WORD:
return "Skupna vsota vseh najdenih različnic:";
return I18N.get("exportTable.part.totalFound") + " " + I18N.get("exportTable.part.word");
case NORMALIZED_WORD:
return "Skupna vsota vseh najdenih normaliziranih različnic:";
return I18N.get("exportTable.part.totalFound") + " " + I18N.get("exportTable.part.normalizedWord");
case LEMMA:
return "Skupna vsota vseh najdenih lem:";
return I18N.get("exportTable.part.totalFound") + " " + I18N.get("exportTable.part.lemma");
case MORPHOSYNTACTIC_SPECS:
return "Skupna vsota vseh najdenih oblikoskladenjskih oznak:";
return I18N.get("exportTable.part.totalFound") + " " + I18N.get("exportTable.part.msd");
case MORPHOSYNTACTIC_PROPERTY:
return "Skupna vsota vseh najdenih oblikoskladenjskih lastnosti:";
return I18N.get("exportTable.part.totalFound") + " " + I18N.get("exportTable.part.msdProperty");
case WORD_TYPE:
return "Skupna vsota vseh najdenih besednih vrst:";
return I18N.get("exportTable.part.totalFound") + " " + I18N.get("exportTable.part.wordType");
case DIST_WORDS:
return "Skupna vsota vseh najdenih različnic:";
return I18N.get("exportTable.part.totalFound") + " " + I18N.get("exportTable.part.word");
case DIST_LEMMAS:
return "Skupna vsota vseh najdenih lem:";
return I18N.get("exportTable.part.totalFound") + " " + I18N.get("exportTable.part.lemma");
default:
return null;
}
@@ -142,25 +163,25 @@ public enum CalculateFor {
public String totalAbsoluteFrequencyString(int ngram) {
if (ngram == 0) {
return "Skupna absolutna pogostost črkovnega niza";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.letterSet");
}
switch(this){
case WORD:
return "Skupna absolutna pogostost različnice";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.word2");
case NORMALIZED_WORD:
return "Skupna absolutna pogostost normalizirane različnice";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.normalizedWord2");
case LEMMA:
return "Skupna absolutna pogostost leme";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.lemma2");
case MORPHOSYNTACTIC_SPECS:
return "Skupna absolutna pogostost oblikoskladenjske oznake";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.msd2");
case MORPHOSYNTACTIC_PROPERTY:
return "Skupna absolutna pogostost oblikoskladenjske lastnosti";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.msdProperty2");
case WORD_TYPE:
return "Skupna absolutna pogostost besedne vrste";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.wordType2");
case DIST_WORDS:
return "Skupna absolutna pogostost različnice";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.word2");
case DIST_LEMMAS:
return "Skupna absolutna pogostost leme";
return I18N.get("exportTable.part.absoluteFrequency") + " " + I18N.get("exportTable.part.lemma2");
default:
return null;
}
@@ -168,25 +189,25 @@ public enum CalculateFor {
public String shareOfTotalString(int ngram) {
if (ngram == 0) {
return "Delež glede na skupno vsoto vseh najdenih črkovnih nizov";
return I18N.get("exportTable.part.letterSet2");
}
switch(this){
case WORD:
return "Delež glede na vse najdene različnice";
return I18N.get("exportTable.part.share") + " " + I18N.get("exportTable.part.word2");
case NORMALIZED_WORD:
return "Delež glede na vse najdene normalizirane različnice";
return I18N.get("exportTable.part.share") + " " + I18N.get("exportTable.part.normalizedWord2");
case LEMMA:
return "Delež glede na vse najdene leme";
return I18N.get("exportTable.part.share") + " " + I18N.get("exportTable.part.lemma2");
case MORPHOSYNTACTIC_SPECS:
return "Delež glede na vse najdene oblikoskladenjske oznake";
return I18N.get("exportTable.part.share") + " " + I18N.get("exportTable.part.msd2");
case MORPHOSYNTACTIC_PROPERTY:
return "Delež glede na vse najdene oblikoskladenjske lastnosti";
return I18N.get("exportTable.part.share") + " " + I18N.get("exportTable.part.msdProperty2");
case WORD_TYPE:
return "Delež glede na vse najdene besedne vrste";
return I18N.get("exportTable.part.share") + " " + I18N.get("exportTable.part.wordType2");
case DIST_WORDS:
return "Delež glede na vse najdene različnice";
return I18N.get("exportTable.part.share") + " " + I18N.get("exportTable.part.word2");
case DIST_LEMMAS:
return "Delež glede na vse najdene leme";
return I18N.get("exportTable.part.share") + " " + I18N.get("exportTable.part.lemma2");
default:
return null;
}
@@ -194,25 +215,23 @@ public enum CalculateFor {
public String toHeaderString(int ngram) {
if (ngram == 0) {
return "Črkovni niz";
return I18N.get("exportTable.part.letterSet3");
} else if (ngram == 1) {
switch (this) {
case WORD:
return "Različnica";
case NORMALIZED_WORD:
return "Normalizirana različnica";
case LEMMA:
return "Lema";
case MORPHOSYNTACTIC_SPECS:
return "Oblikoskladenjska oznaka";
case MORPHOSYNTACTIC_PROPERTY:
return "Oblikoskladenjska lastnost";
case WORD_TYPE:
return "Besedna vrsta";
case DIST_WORDS:
return "Različnica";
return I18N.get("exportTable.part.word3");
case NORMALIZED_WORD:
return I18N.get("exportTable.part.normalizedWord3");
case LEMMA:
case DIST_LEMMAS:
return "Lema";
return I18N.get("exportTable.part.lemma3");
case MORPHOSYNTACTIC_SPECS:
return I18N.get("exportTable.part.msd3");
case MORPHOSYNTACTIC_PROPERTY:
return I18N.get("exportTable.part.msdProperty3");
case WORD_TYPE:
return I18N.get("exportTable.part.wordType3");
default:
return null;
}
@@ -220,18 +239,18 @@ public enum CalculateFor {
switch (this) {
case WORD:
case DIST_WORDS:
return "Različnica niza";
return I18N.get("exportTable.part.word3") + " " + I18N.get("exportTable.part.set");
case NORMALIZED_WORD:
return "Normalizirana različnica niza";
return I18N.get("exportTable.part.normalizedWord3") + " " + I18N.get("exportTable.part.set");
case LEMMA:
case DIST_LEMMAS:
return "Lema niza";
return I18N.get("exportTable.part.lemma3") + " " + I18N.get("exportTable.part.set");
case MORPHOSYNTACTIC_SPECS:
return "Oblikoskladenjska oznaka niza";
return I18N.get("exportTable.part.msd3") + " " + I18N.get("exportTable.part.set");
case MORPHOSYNTACTIC_PROPERTY:
return "Oblikoskladenjska lastnost niza";
return I18N.get("exportTable.part.msdProperty3") + " " + I18N.get("exportTable.part.set");
case WORD_TYPE:
return "Besedna vrsta niza";
return I18N.get("exportTable.part.wordType3") + " " + I18N.get("exportTable.part.set");
default:
return null;
}

7
src/main/java/data/Corpus.java
View File

@@ -8,6 +8,7 @@ import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import gui.I18N;
import javafx.collections.FXCollections;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
@@ -136,15 +137,15 @@ public class Corpus {
public boolean validate() {
if (corpusType == null) {
validationErrors.add(LABEL_RESULTS_CORPUS_TYPE_NOT_SET);
validationErrors.add(I18N.get("message.LABEL_RESULTS_CORPUS_TYPE_NOT_SET"));
}
if (chosenCorpusLocation == null) {
validationErrors.add(LABEL_CORPUS_LOCATION_NOT_SET);
validationErrors.add(I18N.get("message.LABEL_CORPUS_LOCATION_NOT_SET"));
}
if (chosenResultsLocation == null) {
validationErrors.add(LABEL_RESULTS_LOCATION_NOT_SET);
validationErrors.add(I18N.get("message.LABEL_RESULTS_LOCATION_NOT_SET"));
}
if (!headerRead && corpusType != null) {

86
src/main/java/data/StatisticsNew.java
View File

@@ -12,6 +12,7 @@ import java.util.concurrent.atomic.AtomicLong;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import gui.I18N;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
@@ -112,7 +113,7 @@ public class StatisticsNew {
if(ngramLevel == 0) {
sb.append(corpus.getCorpusType().toString())
.append(separator)
.append("crke")
.append(I18N.get("exportFileName.letters"))
.append(separator)
.append(filter.getCalculateFor())
.append(separator);
@@ -120,30 +121,30 @@ public class StatisticsNew {
if (filter.getSuffixLength() != null && filter.getSuffixList() != null && filter.getPrefixLength() != null && filter.getPrefixList() != null) {
sb.append(corpus.getCorpusType().toString())
.append(separator)
.append("besedni-deli")
.append(I18N.get("exportFileName.wordParts"))
.append(separator)
.append(filter.getCalculateFor())
.append(separator);
} else {
sb.append(corpus.getCorpusType().toString())
.append(separator)
.append("besede")
.append(I18N.get("exportFileName.words"))
.append(separator)
.append(filter.getCalculateFor())
.append(separator);
}
}
else {
sb.append(filter.getAl().toString())
sb.append(corpus.getCorpusType().toString())
.append(separator)
.append(corpus.getCorpusType().toString())
.append(I18N.get("exportFileName.wordSets"))
.append(separator);
sb.append(filter.getCalculateFor().toString())
.append(separator);
// ngram value
sb.append(filter.getNgramValue()).append("-gram")
sb.append(filter.getNgramValue()).append(I18N.get("exportFileName.gram"))
.append(separator);
sb.append(filter.getSkipValue()).append("-preskok")
sb.append(filter.getSkipValue()).append(I18N.get("exportFileName.skip"))
.append(separator);
}
// TODO: assure skip is not null but zero
@@ -229,6 +230,9 @@ public class StatisticsNew {
db.delete();
}
removeMinimalOccurrences(filter.getMinimalOccurrences());
removeMinimalTaxonomy(taxonomyResult, filter.getMinimalTaxonomy());
// if no results and nothing to save, return false
if (!(taxonomyResult.get(Taxonomy.TOTAL).size() > 0)) {
analysisProducedResults = false;
@@ -237,8 +241,6 @@ public class StatisticsNew {
analysisProducedResults = true;
}
removeMinimalOccurrences(filter.getMinimalOccurrences());
removeMinimalTaxonomy(taxonomyResult, filter.getMinimalTaxonomy());
stats.add(ImmutablePair.of(resultTitle, getSortedResult(taxonomyResult.get(Taxonomy.TOTAL), Util.getValidInt(limit))));
Export.SetToCSV(stats, corpus.getChosenResultsLocation(), headerInfoBlock(), this, filter);
return true;
@@ -465,40 +467,40 @@ public class StatisticsNew {
private LinkedHashMap<String, String> headerInfoBlock() {
LinkedHashMap<String, String> info = new LinkedHashMap<>();
info.put("Korpus:", corpus.getCorpusType().toString());
info.put(I18N.get("exportHeader.corpus"), corpus.getCorpusType().toString());
setTimeEnding();
info.put("Datum:", timeEnding.format(DateTimeFormatter.ofPattern("dd.MM.yyyy hh:mm")));
info.put(I18N.get("exportHeader.date"), timeEnding.format(DateTimeFormatter.ofPattern("dd.MM.yyyy hh:mm")));
// time elapsed
long seconds = ChronoUnit.MILLIS.between(timeBeginning, timeEnding) / 1000;
info.put("Čas izvajanja:", String.valueOf(seconds) + " s");
info.put(I18N.get("exportHeader.executionTime"), String.valueOf(seconds) + " s");
if (filter.getAl() == AnalysisLevel.STRING_LEVEL) {
Integer ngramLevel = filter.getNgramValue();
if (ngramLevel == 0)
info.put("Analiza:", "črke");
info.put(I18N.get("exportHeader.analysis"), I18N.get("exportHeader.analysis.letters"));
else if (ngramLevel == 1) {
// if suffixes or prefixes are not null print word parts
if (filter.getSuffixLength() != null || filter.getSuffixList() != null || filter.getPrefixLength() != null || filter.getPrefixList() != null) {
info.put("Analiza:", "besedni deli");
info.put(I18N.get("exportHeader.analysis"), I18N.get("exportHeader.analysis.wordParts"));
} else {
info.put("Analiza:", "besede");
info.put(I18N.get("exportHeader.analysis"), I18N.get("exportHeader.analysis.words"));
}
} else
info.put("Analiza:", filter.getAl().toString());
info.put(I18N.get("exportHeader.analysis"), I18N.get("exportHeader.analysis.wordSets"));
} else {
info.put("Analiza:", filter.getAl().toString());
info.put(I18N.get("exportHeader.analysis"), filter.getAl().toString());
}
// if (filter.getAl() == AnalysisLevel.STRING_LEVEL) {
Integer ngramLevel = filter.getNgramValue();
if (ngramLevel == 0){
info.put("Število črk:", filter.getStringLength().toString());
info.put(I18N.get("exportHeader.numberLetters"), filter.getStringLength().toString());
}
// calculate for
info.put("Izračunaj za:", filter.getCalculateFor().toString());
info.put(I18N.get("exportHeader.calculateFor"), filter.getCalculateFor().toString());
// also write
if (ngramLevel > 0) {
@@ -508,34 +510,34 @@ public class StatisticsNew {
for (CalculateFor s : filter.getMultipleKeys()) {
mk.append(s.toString()).append("; ");
}
info.put("Upoštevaj tudi: ", String.join("; ", mk.substring(0, mk.length() - 2)));
info.put(I18N.get("exportHeader.alsoFilter"), String.join("; ", mk.substring(0, mk.length() - 2)));
} else {
info.put("Upoštevaj tudi: ", "");
info.put(I18N.get("exportHeader.alsoFilter"), "");
}
}
// data limitations
if (filter.getDisplayTaxonomy()){
info.put("Izpiši taksonomije: ", "da");
info.put(I18N.get("exportHeader.displayTaxonomies"), I18N.get("exportHeader.yes"));
} else {
info.put("Izpiši taksonomije: ", "ne");
info.put(I18N.get("exportHeader.displayTaxonomies"), I18N.get("exportHeader.no"));
}
// n.gram nivo
if (ngramLevel > 1) {
info.put("N-gram nivo:", String.valueOf(ngramLevel));
info.put(I18N.get("exportHeader.ngramLevel"), String.valueOf(ngramLevel));
}
// skip
if (ngramLevel > 1)
info.put("Preskok besed:", isNotEmpty(filter.getSkipValue()) ? filter.getSkipValue().toString() : "0");
info.put(I18N.get("exportHeader.skipValue"), isNotEmpty(filter.getSkipValue()) ? filter.getSkipValue().toString() : "0");
// note punctuations - ngram > 1
if(ngramLevel > 1) {
if (filter.getNotePunctuations()) {
info.put("Upoštevaj ločila: ", "da");
info.put(I18N.get("exportHeader.notePunctuations"), I18N.get("exportHeader.yes"));
} else {
info.put("Upoštevaj ločila: ", "ne");
info.put(I18N.get("exportHeader.notePunctuations"), I18N.get("exportHeader.no"));
}
}
@@ -546,28 +548,28 @@ public class StatisticsNew {
for (Collocability s : filter.getCollocability()) {
mk.append(s.toString()).append("; ");
}
info.put("Kolokabilnost: ", String.join("; ", mk.substring(0, mk.length() - 2)));
info.put(I18N.get("exportHeader.collocability"), String.join("; ", mk.substring(0, mk.length() - 2)));
} else {
info.put("Kolokabilnost: ", "");
info.put(I18N.get("exportHeader.collocability"), "");
}
}
// fragmented MSD - n-gram = 1
if (info.get("Analiza:").equals("besede")){
if (info.get(I18N.get("exportHeader.analysis")).equals(I18N.get("exportHeader.analysis.words"))){
if (filter.getWriteMsdAtTheEnd()){
info.put("Izpiši razbit MSD: ", "da");
info.put(I18N.get("exportHeader.writeMSDAtTheEnd"), I18N.get("exportHeader.yes"));
} else {
info.put("Izpiši razbit MSD: ", "ne");
info.put(I18N.get("exportHeader.writeMSDAtTheEnd"), I18N.get("exportHeader.no"));
}
}
if (filter.getSuffixLength() != null || filter.getSuffixList() != null || filter.getPrefixLength() != null || filter.getPrefixList() != null) {
if (filter.getPrefixLength() > 0 || filter.getSuffixLength() > 0) {
info.put("Dolžina predpone: ", String.valueOf(filter.getPrefixLength()));
info.put("Dolžina pripone: ", String.valueOf(filter.getSuffixLength()));
info.put(I18N.get("exportHeader.prefixLength"), String.valueOf(filter.getPrefixLength()));
info.put(I18N.get("exportHeader.suffixLength"), String.valueOf(filter.getSuffixLength()));
} else {
info.put("Seznam predpon: ", String.join("; ", filter.getPrefixList()));
info.put("Seznam pripon: ", String.join("; ", filter.getSuffixList()));
info.put(I18N.get("exportHeader.prefixList"), String.join("; ", filter.getPrefixList()));
info.put(I18N.get("exportHeader.suffixList"), String.join("; ", filter.getSuffixList()));
}
}
@@ -578,15 +580,15 @@ public class StatisticsNew {
msdPattern.append(pattern.toString()).append(" ");
}
info.put("Oznaka MSD:", msdPattern.toString());
info.put(I18N.get("exportHeader.msd"), msdPattern.toString());
} else {
info.put("Oznaka MSD:", "");
info.put(I18N.get("exportHeader.msd"), "");
}
// }
info.put("Taksonomija: ", "");
info.put(I18N.get("exportHeader.taxonomy"), "");
if (isNotEmpty(filter.getTaxonomy()) && Tax.getCorpusTypesWithTaxonomy().contains(corpus.getCorpusType()) || filter.getDisplayTaxonomy()) {
ArrayList<String> tax = Tax.getTaxonomyForInfo(corpus.getCorpusType(), filter.getTaxonomy());
@@ -631,14 +633,14 @@ public class StatisticsNew {
}
info.put("Min. št. pojavitev: ", String.valueOf(filter.getMinimalOccurrences()));
info.put("Min. št. taksonomij: ", String.valueOf(filter.getMinimalTaxonomy()));
info.put(I18N.get("exportHeader.minOccurrences"), String.valueOf(filter.getMinimalOccurrences()));
info.put(I18N.get("exportHeader.minTaxonomies"), String.valueOf(filter.getMinimalTaxonomy()));
if (corpus.getCorpusType() == CorpusType.SOLAR) {
HashMap<String, ObservableList<String>> filters = corpus.getSolarFilters();
if (!isEmpty(filters)) {
info.put("Dodatni filtri: ", "");
info.put(I18N.get("exportHeader.additionalFilters"), "");
for (Map.Entry<String, ObservableList<String>> f : filters.entrySet()) {
info.put(f.getKey(), StringUtils.join(f.getValue(), ", "));

11
src/main/java/data/Validation.java
View File

@@ -5,6 +5,7 @@ import static gui.ValidationUtil.*;
import java.util.ArrayList;
import java.util.regex.Pattern;
import gui.I18N;
import org.apache.commons.lang3.StringUtils;
import gui.Messages;
@@ -17,12 +18,12 @@ public class Validation {
// should not be null, error if null, because init failed
if (filter.getNgramValue() == null) {
errors.add(Messages.MISSING_NGRAM_LEVEL);
errors.add(I18N.get("message.MISSING_NGRAM_LEVEL"));
}
// should not be null, error if null, because init failed
if (filter.getCalculateFor() == null) {
errors.add(Messages.MISSING_CALCULATE_FOR);
errors.add(I18N.get("message.MISSING_CALCULATE_FOR"));
}
if (filter.getSkipValue() == null) {
@@ -32,20 +33,20 @@ public class Validation {
if (filter.getNgramValue() != null && ValidationUtil.isEmpty(filter.getMsd()) &&
(filter.getMsd().size() != filter.getNgramValue())) {
if (!(filter.getMsd().size() == 1 && filter.getNgramValue() == 0) && !ValidationUtil.isEmpty(filter.getMsd()))
errors.add(Messages.WARNING_MISMATCHED_NGRAM_AND_TOKENS_VALUES);
errors.add(I18N.get("message.WARNING_MISMATCHED_NGRAM_AND_TOKENS_VALUES"));
}
Integer ngramValue = filter.getNgramValue();
ArrayList<Pattern> msd = filter.getMsd();
if (ngramValue > 0 && !ValidationUtil.isEmpty(msd) && ngramValue != msd.size()) {
errors.add(String.format(Messages.WARNING_MISMATCHED_NGRAM_AND_TOKENS_VALUES, ngramValue, msd.size()));
errors.add(String.format(I18N.get("message.WARNING_MISMATCHED_NGRAM_AND_TOKENS_VALUES"), ngramValue, msd.size()));
}
if (filter.getNgramValue() != null && filter.getNgramValue() == 0 && isEmpty(filter.getStringLength())) {
// if count letters, make sure that the length is given
// TODO: check that words we're adding in xml reader are longer than this value
errors.add(Messages.MISSING_STRING_LENGTH);
errors.add(I18N.get("message.MISSING_STRING_LENGTH"));
}
return isEmpty(errors) ? null : StringUtils.join(errors, ", \n");