Revision: 7152
http://languagetool.svn.sourceforge.net/languagetool/?rev=7152&view=rev
Author: dnaber
Date: 2012-06-02 00:47:45 +0000 (Sat, 02 Jun 2012)
Log Message:
-----------
start refactoring of index searcher (work in progress)
Modified Paths:
--------------
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Indexer.java
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/PatternRuleNotFoundException.java
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/PatternRuleQueryBuilder.java
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Searcher.java
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/UnsupportedPatternRuleException.java
trunk/JLanguageTool/src/test/org/languagetool/dev/index/IndexerSearcherTest.java
trunk/JLanguageTool/src/test/org/languagetool/dev/index/PatternRuleQueryBuilderTest.java
Modified: trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Indexer.java
===================================================================
--- trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Indexer.java
2012-06-02 00:36:52 UTC (rev 7151)
+++ trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Indexer.java
2012-06-02 00:47:45 UTC (rev 7152)
@@ -96,10 +96,13 @@
run(br, new Indexer(dir, language), isSentence);
}
- public static void run(BufferedReader reader, Indexer indexer, boolean
isSentence)
- throws IOException {
- indexer.index(reader, isSentence, -1);
- indexer.close();
+ public static void run(BufferedReader reader, Indexer indexer, boolean
isSentence) throws IOException {
+ try {
+ indexer.index(reader, isSentence, -1);
+ } finally {
+ // TODO: let caller close indexer
+ indexer.close();
+ }
}
public void index(String content, boolean isSentence, int docCount) throws
IOException {
Modified:
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/PatternRuleNotFoundException.java
===================================================================
---
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/PatternRuleNotFoundException.java
2012-06-02 00:36:52 UTC (rev 7151)
+++
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/PatternRuleNotFoundException.java
2012-06-02 00:47:45 UTC (rev 7152)
@@ -18,13 +18,14 @@
*/
package org.languagetool.dev.index;
+import java.io.File;
import java.io.IOException;
public class PatternRuleNotFoundException extends IOException {
private static final long serialVersionUID = -220557881967037175L;
- public PatternRuleNotFoundException(String ruleId) {
- super("Can not find pattern rule '" + ruleId + "'");
+ public PatternRuleNotFoundException(String ruleId, File ruleFile) {
+ super("Could not find pattern rule '" + ruleId + "' in rule file " +
ruleFile);
}
}
Modified:
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/PatternRuleQueryBuilder.java
===================================================================
---
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/PatternRuleQueryBuilder.java
2012-06-02 00:36:52 UTC (rev 7151)
+++
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/PatternRuleQueryBuilder.java
2012-06-02 00:47:45 UTC (rev 7152)
@@ -41,13 +41,21 @@
private static final int MAX_SKIP = 1000;
- public Query buildQuery(PatternRule rule, boolean checkUnsupportedRule)
+ public Query buildQuery(PatternRule rule)
throws UnsupportedPatternRuleException {
- return next(rule.getElements().iterator(), checkUnsupportedRule);
+ return next(rule.getElements().iterator(), true);
}
+ public Query buildPossiblyRelaxedQuery(PatternRule rule) {
+ try {
+ return next(rule.getElements().iterator(), false);
+ } catch (UnsupportedPatternRuleException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
// create the next SpanQuery from the top Element in the Iterator.
- private SpanQuery next(Iterator<Element> it, boolean checkUnsupportedRule)
+ private SpanQuery next(Iterator<Element> it, boolean
throwExceptionOnUnsupportedRule)
throws UnsupportedPatternRuleException {
// no more Element
@@ -70,7 +78,7 @@
patternElement.isPOStagRegularExpression());
} catch (UnsupportedPatternRuleException e) {
- if (checkUnsupportedRule) {
+ if (throwExceptionOnUnsupportedRule) {
throw e;
} else {
// create an empty token for the unsupported token, so that it can
match any term with any
@@ -101,7 +109,7 @@
}
// recursion invoke
- final SpanQuery next = next(it, checkUnsupportedRule);
+ final SpanQuery next = next(it, throwExceptionOnUnsupportedRule);
if (next != null) {
list.add(next);
Modified: trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Searcher.java
===================================================================
--- trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Searcher.java
2012-06-02 00:36:52 UTC (rev 7151)
+++ trunk/JLanguageTool/src/dev/org/languagetool/dev/index/Searcher.java
2012-06-02 00:47:45 UTC (rev 7152)
@@ -27,6 +27,7 @@
import org.languagetool.JLanguageTool;
import org.languagetool.Language;
+import org.languagetool.rules.Rule;
import org.languagetool.rules.RuleMatch;
import org.apache.lucene.document.Document;
import org.apache.lucene.search.IndexSearcher;
@@ -46,32 +47,90 @@
*/
public class Searcher {
- private static final int MAX_HITS = 1000;
+ private static final int DEFAULT_MAX_HITS = 1000;
- public TopDocs run(PatternRule rule, IndexSearcher searcher, boolean
checkUnsupportedRule)
- throws IOException {
+ private int maxHits = DEFAULT_MAX_HITS;
+
+ public Searcher() {
+ }
+
+ public int getMaxHits() {
+ return maxHits;
+ }
+
+ public void setMaxHits(int maxHits) {
+ this.maxHits = maxHits;
+ }
+
+ public List<RuleMatch> findRuleMatchesOnIndex(PatternRule rule, Language
language, File indexDir) throws IOException {
+ final IndexSearcher indexSearcher = new
IndexSearcher(FSDirectory.open(indexDir));
+ try {
+ return findRuleMatchesOnIndex(rule, language, indexSearcher);
+ } finally {
+ indexSearcher.close();
+ }
+ }
+
+ public List<RuleMatch> findRuleMatchesOnIndex(PatternRule rule, Language
language, IndexSearcher indexSearcher) throws IOException {
+ final List<RuleMatch> matches = new ArrayList<RuleMatch>();
+ final Query query = createQuery(rule);
+ final TopDocs topDocs = indexSearcher.search(query, maxHits);
+ final JLanguageTool languageTool = getLanguageToolWithOneRule(language,
rule);
+ for (ScoreDoc match : topDocs.scoreDocs) {
+ final Document doc = indexSearcher.doc(match.doc);
+ final String sentence = doc.get(PatternRuleQueryBuilder.FIELD_NAME);
+ final List<RuleMatch> ruleMatches = languageTool.check(sentence);
+ matches.addAll(ruleMatches);
+ }
+ return matches;
+ }
+
+ private Query createQuery(PatternRule rule) {
final PatternRuleQueryBuilder patternRuleQueryBuilder = new
PatternRuleQueryBuilder();
- final Query query = patternRuleQueryBuilder.buildQuery(rule,
checkUnsupportedRule);
- //System.out.println("QUERY: " + query);
- return searcher.search(query, MAX_HITS);
+ Query query;
+ try {
+ query = patternRuleQueryBuilder.buildQuery(rule);
+ } catch (UnsupportedPatternRuleException e) {
+ query = patternRuleQueryBuilder.buildPossiblyRelaxedQuery(rule);
+ }
+ return query;
}
- public List<TopDocs> run(String ruleId, File xmlRuleFile, IndexSearcher
searcher,
- boolean checkUnsupportedRule) throws IOException {
- final List<TopDocs> topDocsList = new ArrayList<TopDocs>();
+ public TopDocs run(PatternRule rule, IndexSearcher searcher, boolean
throwExceptionOnUnsupportedRule)
+ throws IOException, UnsupportedPatternRuleException {
+ final PatternRuleQueryBuilder patternRuleQueryBuilder = new
PatternRuleQueryBuilder();
+ final Query query;
+ if (throwExceptionOnUnsupportedRule) {
+ query = patternRuleQueryBuilder.buildQuery(rule);
+ } else {
+ query = patternRuleQueryBuilder.buildPossiblyRelaxedQuery(rule);
+ }
+ return searcher.search(query, maxHits);
+ }
+
+ public TopDocs run(String ruleId, File xmlRuleFile, IndexSearcher searcher,
boolean checkUnsupportedRule) throws IOException,
UnsupportedPatternRuleException {
+ final PatternRule rule = getRuleById(ruleId, xmlRuleFile);
+ final TopDocs topDocs = run(rule, searcher, checkUnsupportedRule);
+ return topDocs;
+ }
+
+ private PatternRule getRuleById(String ruleId, File xmlRuleFile) throws
IOException {
final List<PatternRule> rules = loadRules(xmlRuleFile);
- boolean foundRule = false;
for (PatternRule rule : rules) {
if (rule.getId().equals(ruleId)) {
- final TopDocs topDocs = run(rule, searcher, checkUnsupportedRule);
- topDocsList.add(topDocs);
- foundRule = true;
+ return rule;
}
}
- if (!foundRule) {
- throw new PatternRuleNotFoundException(ruleId);
+ throw new PatternRuleNotFoundException(ruleId, xmlRuleFile);
+ }
+
+ private JLanguageTool getLanguageToolWithOneRule(Language lang, PatternRule
patternRule) throws IOException {
+ final JLanguageTool langTool = new JLanguageTool(lang);
+ for (Rule rule : langTool.getAllActiveRules()) {
+ langTool.disableRule(rule.getId());
}
- return topDocsList;
+ langTool.addRule(patternRule);
+ return langTool;
}
private List<PatternRule> loadRules(File xmlRuleFile) throws IOException {
@@ -83,9 +142,9 @@
xmlRulesStream.close();
}
}
-
+
private void run(String ruleId, File xmlRuleFile, File indexDir)
- throws IOException {
+ throws IOException, UnsupportedPatternRuleException {
if (!xmlRuleFile.exists() || !xmlRuleFile.canRead()) {
System.out.println("Rule XML file '" + xmlRuleFile.getAbsolutePath()
+ "' does not exist or is not readable, please check the path");
@@ -94,17 +153,13 @@
final IndexSearcher searcher = new
IndexSearcher(FSDirectory.open(indexDir));
try {
- final List<TopDocs> matchesList = run(ruleId, xmlRuleFile, searcher,
true);
- for (TopDocs matches : matchesList) {
- printResult(matches, searcher, null);
- }
+ final TopDocs topDocs = run(ruleId, xmlRuleFile, searcher, true);
+ printResult(topDocs, searcher, null);
} catch (UnsupportedPatternRuleException e) {
System.out.println(e.getMessage() + " Will run checking on potential
matches (this can be slow):");
- final List<TopDocs> potentialMatchesList = run(ruleId, xmlRuleFile,
searcher, false);
+ final TopDocs topDocs = run(ruleId, xmlRuleFile, searcher, false);
final JLanguageTool languageTool = getLanguageToolWithOneRule(ruleId,
xmlRuleFile);
- for (TopDocs potentialMatches : potentialMatchesList) {
- printResult(potentialMatches, searcher, languageTool);
- }
+ printResult(topDocs, searcher, languageTool);
}
searcher.close();
}
@@ -130,7 +185,7 @@
System.out.println("Search results: " + docs.totalHits);
}
- for (int i = 0; i < Math.min(docs.totalHits, MAX_HITS);) {
+ for (int i = 0; i < Math.min(docs.totalHits, maxHits);) {
final Document doc = searcher.doc(hits[i++].doc);
final String sentence = doc.get(PatternRuleQueryBuilder.FIELD_NAME);
if (languageTool != null) {
@@ -142,8 +197,8 @@
System.out.println(i + ": " + sentence);
}
}
- if (docs.totalHits > MAX_HITS) {
- System.out.println("NOTE: matches skipped due to maximum hit limit of "
+ MAX_HITS);
+ if (docs.totalHits > maxHits) {
+ System.out.println("NOTE: matches skipped due to maximum hit limit of "
+ maxHits);
}
}
@@ -152,7 +207,7 @@
System.err.println("Usage: Searcher <ruleId> <ruleXML> <indexDir>");
System.err.println("\truleId Id of the rule to search");
System.err.println("\truleXML path to a rule file, e.g. en/grammar.xml");
- System.err.println("\tindexDir path to a directory storing the index");
+ System.err.println("\tindexDir path to a directory containing the
index");
System.exit(1);
}
}
Modified:
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/UnsupportedPatternRuleException.java
===================================================================
---
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/UnsupportedPatternRuleException.java
2012-06-02 00:36:52 UTC (rev 7151)
+++
trunk/JLanguageTool/src/dev/org/languagetool/dev/index/UnsupportedPatternRuleException.java
2012-06-02 00:47:45 UTC (rev 7152)
@@ -18,10 +18,8 @@
*/
package org.languagetool.dev.index;
-import java.io.IOException;
+public class UnsupportedPatternRuleException extends Exception {
-public class UnsupportedPatternRuleException extends IOException {
-
private static final long serialVersionUID = -2346750825068970240L;
public UnsupportedPatternRuleException(String message) {
Modified:
trunk/JLanguageTool/src/test/org/languagetool/dev/index/IndexerSearcherTest.java
===================================================================
---
trunk/JLanguageTool/src/test/org/languagetool/dev/index/IndexerSearcherTest.java
2012-06-02 00:36:52 UTC (rev 7151)
+++
trunk/JLanguageTool/src/test/org/languagetool/dev/index/IndexerSearcherTest.java
2012-06-02 00:47:45 UTC (rev 7152)
@@ -18,60 +18,59 @@
*/
package org.languagetool.dev.index;
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.store.Directory;
import org.apache.lucene.util.LuceneTestCase;
-
import org.languagetool.Language;
+import org.languagetool.rules.RuleMatch;
+import org.languagetool.rules.patterns.Element;
+import org.languagetool.rules.patterns.PatternRule;
+import java.io.File;
+import java.util.Arrays;
+import java.util.List;
+
public class IndexerSearcherTest extends LuceneTestCase {
+
private IndexSearcher searcher;
-
private Directory directory;
@Override
public void setUp() throws Exception {
super.setUp();
directory = newDirectory();
-
}
@Override
public void tearDown() throws Exception {
- searcher.close();
+ if (searcher != null) {
+ searcher.close();
+ }
directory.close();
super.tearDown();
}
public void testIndexerSearcher() throws Exception {
// Note that the second sentence ends with "lid" instead of "lids" (the
inflated one)
- String content = "How to move back and fourth from linux to xmb? Calcium
deposits on eye lid.";
+ final String content = "How to move back and fourth from linux to xmb?
Calcium deposits on eye lid.";
Indexer.run(content, directory, Language.ENGLISH, false);
searcher = new IndexSearcher(directory);
- Searcher errorSearcher = new Searcher();
- File ruleFile = new File("src/rules/en/grammar.xml");
- List<TopDocs> topDocs = errorSearcher.run("BACK_AND_FOURTH", ruleFile,
searcher, true);
- assertEquals(1, topDocs.size());
- assertEquals(1, topDocs.get(0).totalHits);
-
+ final Searcher errorSearcher = new Searcher();
+ final File ruleFile = new File("src/rules/en/grammar.xml");
+ TopDocs topDocs = errorSearcher.run("BACK_AND_FOURTH", ruleFile, searcher,
true);
+ assertEquals(1, topDocs.totalHits);
+
topDocs = errorSearcher.run("BACK_AND_FOURTH", ruleFile, searcher, false);
- assertEquals(1, topDocs.size());
- assertEquals(1, topDocs.get(0).totalHits);
+ assertEquals(1, topDocs.totalHits);
topDocs = errorSearcher.run("ALL_OVER_THE_WORD", ruleFile, searcher, true);
- assertEquals(1, topDocs.size());
- assertEquals(0, topDocs.get(0).totalHits);
+ assertEquals(0, topDocs.totalHits);
topDocs = errorSearcher.run("ALL_OVER_THE_WORD", ruleFile, searcher,
false);
- assertEquals(1, topDocs.size());
- assertEquals(0, topDocs.get(0).totalHits);
+ assertEquals(0, topDocs.totalHits);
try {
errorSearcher.run("Invalid Rule Id", ruleFile, searcher, true);
@@ -86,21 +85,41 @@
try {
errorSearcher.run("EYE_BROW", ruleFile, searcher, true);
fail("Exception should be thrown for unsupported PatternRule");
- } catch (IOException e) {
- assertTrue(e instanceof UnsupportedPatternRuleException);
- topDocs = errorSearcher.run("EYE_BROW", ruleFile, searcher, false);
- assertEquals(1, topDocs.size());
- assertEquals(1, topDocs.get(0).totalHits);
- }
+ } catch (UnsupportedPatternRuleException expected) {}
+ topDocs = errorSearcher.run("EYE_BROW", ruleFile, searcher, false);
+ assertEquals(1, topDocs.totalHits);
+
+
try {
errorSearcher.run("ALL_FOR_NOT", ruleFile, searcher, true);
fail("Exception should be thrown for unsupported PatternRule");
} catch (UnsupportedPatternRuleException expected) {
topDocs = errorSearcher
.run("ALL_FOR_NOT", ruleFile, searcher, false);
- assertEquals(1, topDocs.size());
- assertEquals(0, topDocs.get(0).totalHits);
+ assertEquals(0, topDocs.totalHits);
}
}
+
+ public void testIndexerSearcher2() throws Exception {
+ final String content = "How to move back and fourth from linux to xmb?";
+
+ Indexer.run(content, directory, Language.ENGLISH, false);
+
+ final Searcher errorSearcher = new Searcher();
+ final List<Element> elements = Arrays.asList(
+ new Element("move", false, false, false),
+ new Element("back", false, false, false)
+ );
+ final PatternRule rule1 = new PatternRule("RULE1", Language.ENGLISH,
elements, "desc", "msg", "shortMsg");
+ final IndexSearcher indexSearcher = new IndexSearcher(directory);
+ try {
+ final List<RuleMatch> matches =
errorSearcher.findRuleMatchesOnIndex(rule1, Language.ENGLISH, indexSearcher);
+ assertEquals(1, matches.size());
+ assertEquals("RULE1", matches.get(0).getRule().getId());
+ } finally {
+ indexSearcher.close();
+ }
+ }
+
}
Modified:
trunk/JLanguageTool/src/test/org/languagetool/dev/index/PatternRuleQueryBuilderTest.java
===================================================================
---
trunk/JLanguageTool/src/test/org/languagetool/dev/index/PatternRuleQueryBuilderTest.java
2012-06-02 00:36:52 UTC (rev 7151)
+++
trunk/JLanguageTool/src/test/org/languagetool/dev/index/PatternRuleQueryBuilderTest.java
2012-06-02 00:47:45 UTC (rev 7152)
@@ -89,8 +89,8 @@
final List<PatternRule> rules = ruleLoader.getRules(input, "test.xml");
final PatternRuleQueryBuilder patternRuleQueryBuilder = new
PatternRuleQueryBuilder();
- final Query query1 = patternRuleQueryBuilder.buildQuery(rules.get(0),
true);
- final Query query2 = patternRuleQueryBuilder.buildQuery(rules.get(0),
false);
+ final Query query1 = patternRuleQueryBuilder.buildQuery(rules.get(0));
+ final Query query2 =
patternRuleQueryBuilder.buildPossiblyRelaxedQuery(rules.get(0));
assertEquals(query1, query2);
assertEquals(1, searcher.search(query1, null, 1000).totalHits);
assertEquals(1, searcher.search(query2, null, 1000).totalHits);
@@ -125,16 +125,16 @@
final List<PatternRule> rules = ruleLoader.getRules(input, "test.xml");
final PatternRuleQueryBuilder patternRuleQueryBuilder = new
PatternRuleQueryBuilder();
- Query query = patternRuleQueryBuilder.buildQuery(rules.get(0), true);
+ Query query = patternRuleQueryBuilder.buildQuery(rules.get(0));
assertEquals(1, searcher.search(query, null, 1000).totalHits);
- query = patternRuleQueryBuilder.buildQuery(rules.get(1), true);
+ query = patternRuleQueryBuilder.buildQuery(rules.get(1));
assertEquals(0, searcher.search(query, null, 1000).totalHits);
- query = patternRuleQueryBuilder.buildQuery(rules.get(2), true);
+ query = patternRuleQueryBuilder.buildQuery(rules.get(2));
assertEquals(1, searcher.search(query, null, 1000).totalHits);
- query = patternRuleQueryBuilder.buildQuery(rules.get(3), true);
+ query = patternRuleQueryBuilder.buildQuery(rules.get(3));
assertEquals(1, searcher.search(query, null, 1000).totalHits);
}
@@ -153,15 +153,12 @@
final PatternRuleQueryBuilder patternRuleQueryBuilder = new
PatternRuleQueryBuilder();
List<PatternRule> rules = ruleLoader.getRules(input, "test.xml");
try {
- patternRuleQueryBuilder.buildQuery(rules.get(0), true);
+ patternRuleQueryBuilder.buildQuery(rules.get(0));
fail("Exception should be thrown for unsupported PatternRule");
} catch (UnsupportedPatternRuleException expected) {}
- try {
- patternRuleQueryBuilder.buildQuery(rules.get(0), false);
- } catch (UnsupportedPatternRuleException e) {
- fail("Exception should not be thrown, if not checkUnsupportedRule");
- }
+ patternRuleQueryBuilder.buildPossiblyRelaxedQuery(rules.get(0));
+
sb = new StringBuilder();
sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?> <rules lang=\"en\">
<category name=\"Test\"> <rule id=\"TEST_RULE\" name=\"test\"> <pattern>");
@@ -172,49 +169,11 @@
rules = ruleLoader.getRules(input, "test.xml");
try {
- patternRuleQueryBuilder.buildQuery(rules.get(0), true);
+ patternRuleQueryBuilder.buildQuery(rules.get(0));
fail("Exception should be thrown for unsupported PatternRule");
} catch (UnsupportedPatternRuleException expected) {}
- try {
- patternRuleQueryBuilder.buildQuery(rules.get(0), false);
- } catch (UnsupportedPatternRuleException e) {
- fail("Exception should not be thrown, if not checkUnsupportedRule");
- }
-
+ patternRuleQueryBuilder.buildPossiblyRelaxedQuery(rules.get(0));
}
- /*
- * public void testAllPatternRules() throws IOException {
- * System.out.println("\nStatistics information for supported rule ratio of
each language:"); int
- * successAll = 0; int failAll = 0; HashMap<String, Integer> messagesAll =
new HashMap<String,
- * Integer>();
- *
- * for (Language language : Language.LANGUAGES) { final PatternRuleLoader
ruleLoader = new
- * PatternRuleLoader(); final String name = "/" + language.getShortName() +
"/grammar.xml"; final
- * List<PatternRule> rules =
ruleLoader.getRules(JLanguageTool.getDataBroker()
- * .getFromRulesDirAsStream(name), name); int success = 0; int fail = 0;
HashMap<String, Integer>
- * messages = new HashMap<String, Integer>();
- *
- * for (PatternRule rule : rules) {
- *
- * try { PatternRuleQueryBuilder.buildQuery((PatternRule) rule, true);
success++; } catch
- * (UnsupportedPatternRuleException e) { if (messages.get(e.getMessage()) ==
null) {
- * messages.put(e.getMessage(), 0); } messages.put(e.getMessage(),
messages.get(e.getMessage()) +
- * 1);
- *
- * fail++; }
- *
- * } System.out.println("\t" + language.getName() + " ratio: " + (float)
success / (success +
- * fail) + " (failure:" + fail + ")"); for (Entry<String, Integer> entry :
messages.entrySet()) {
- * System.out.println("\t\t" + entry.getKey() + ": " + entry.getValue()); }
- *
- * successAll += success; failAll += fail; } System.out.println("All
languages ratio: " + (float)
- * successAll / (successAll + failAll) + " (failure:" + failAll + ")");
- *
- * for (Entry<String, Integer> entry : messagesAll.entrySet()) {
System.out.println("\t" +
- * entry.getKey() + ": " + entry.getValue()); }
- *
- * }
- */
}
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and
threat landscape has changed and how IT managers can respond. Discussions
will include endpoint security, mobile security and the latest in malware
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
Languagetool-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/languagetool-cvs
