src/com/hughes/android/dictionary/parser/wiktionary/EnFunctionCallbacks.java

   1 // Copyright 2012 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 package com.hughes.android.dictionary.parser.wiktionary;
  16
  17 import java.util.Arrays;
  18 import java.util.LinkedHashMap;
  19 import java.util.LinkedHashSet;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.Set;
  23 import java.util.concurrent.atomic.AtomicInteger;
  24
  25 import com.hughes.android.dictionary.engine.EntryTypeName;
  26 import com.hughes.android.dictionary.engine.IndexBuilder;
  27 import com.hughes.android.dictionary.parser.WikiTokenizer;
  28 import com.hughes.android.dictionary.parser.wiktionary.AbstractWiktionaryParser.AppendAndIndexWikiCallback;
  29 import com.hughes.android.dictionary.parser.wiktionary.AbstractWiktionaryParser.NameAndArgs;
  30 import com.hughes.util.ListUtil;
  31
  32 class EnFunctionCallbacks {
  33
  34   static final Map<String,FunctionCallback<EnParser>> DEFAULT = new LinkedHashMap<String, FunctionCallback<EnParser>>();
  35
  36   static {
  37     FunctionCallback<EnParser> callback = new TranslationCallback<EnParser>();
  38     DEFAULT.put("t", callback);
  39     DEFAULT.put("t+", callback);
  40     DEFAULT.put("t-", callback);
  41     DEFAULT.put("tø", callback);
  42     DEFAULT.put("apdx-t", callback);
  43
  44     callback = new EncodingCallback();
  45     Set<String> encodings = new LinkedHashSet<String>(Arrays.asList(
  46         "zh-ts", "zh-tsp",
  47         "sd-Arab", "ku-Arab", "Arab", "unicode", "Laoo", "ur-Arab", "Thai",
  48         "fa-Arab", "Khmr", "Cyrl", "IPAchar", "ug-Arab", "ko-inline",
  49         "Jpan", "Kore", "Hebr", "rfscript", "Beng", "Mong", "Knda", "Cyrs",
  50         "yue-tsj", "Mlym", "Tfng", "Grek", "yue-yue-j"));
  51     for (final String encoding : encodings) {
  52       DEFAULT.put(encoding, callback);
  53     }
  54
  55     callback = new l_term();
  56     DEFAULT.put("l", callback);
  57     DEFAULT.put("term", callback);
  58
  59     callback = new Gender();
  60     DEFAULT.put("m", callback);
  61     DEFAULT.put("f", callback);
  62     DEFAULT.put("n", callback);
  63     DEFAULT.put("p", callback);
  64     DEFAULT.put("g", callback);
  65
  66     callback = new AppendArg0();
  67
  68     callback = new Ignore();
  69     DEFAULT.put("trreq", callback);
  70     DEFAULT.put("t-image", callback);
  71     DEFAULT.put("defn", callback);
  72     DEFAULT.put("rfdef", callback);
  73     DEFAULT.put("rfdate", callback);
  74     DEFAULT.put("rfex", callback);
  75     DEFAULT.put("rfquote", callback);
  76     DEFAULT.put("attention", callback);
  77     DEFAULT.put("zh-attention", callback);
  78
  79
  80     callback = new FormOf();
  81     DEFAULT.put("form of", callback);
  82     DEFAULT.put("conjugation of", callback);
  83     DEFAULT.put("participle of", callback);
  84     DEFAULT.put("present participle of", callback);
  85     DEFAULT.put("past participle of", callback);
  86     DEFAULT.put("feminine past participle of", callback);
  87     DEFAULT.put("gerund of", callback);
  88     DEFAULT.put("feminine of", callback);
  89     DEFAULT.put("plural of", callback);
  90     DEFAULT.put("feminine plural of", callback);
  91     DEFAULT.put("inflected form of", callback);
  92     DEFAULT.put("alternative form of", callback);
  93     DEFAULT.put("dated form of", callback);
  94     DEFAULT.put("apocopic form of", callback);
  95
  96     callback = new InflOrHead();
  97     DEFAULT.put("infl", callback);
  98     DEFAULT.put("head", callback);
  99
 100     callback = new AppendName();
 101     DEFAULT.put("...", callback);
 102
 103     DEFAULT.put("qualifier", new QualifierCallback());
 104     DEFAULT.put("italbrac", new italbrac());
 105     DEFAULT.put("gloss", new gloss());
 106     DEFAULT.put("not used", new not_used());
 107     DEFAULT.put("wikipedia", new wikipedia());
 108   }
 109
 110   static final NameAndArgs<EnParser> NAME_AND_ARGS = new NameAndArgs<EnParser>();
 111
 112   // ------------------------------------------------------------------
 113
 114   static final class TranslationCallback<T extends AbstractWiktionaryParser> implements FunctionCallback<T> {
 115     @Override
 116     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 117         final Map<String, String> namedArgs, final T parser,
 118         final AppendAndIndexWikiCallback<T> appendAndIndexWikiCallback) {
 119
 120       final String transliteration = namedArgs.remove("tr");
 121       final String alt = namedArgs.remove("alt");
 122       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 123       if (args.size() < 2) {
 124         if (!name.equals("ttbc")) {
 125           EnParser.LOG.warning("{{t...}} with wrong args: title=" + parser.title + ", " + wikiTokenizer.token());
 126         }
 127         return false;
 128       }
 129       final String langCode = ListUtil.get(args, 0);
 130       if (!appendAndIndexWikiCallback.langCodeToTCount.containsKey(langCode)) {
 131         appendAndIndexWikiCallback.langCodeToTCount.put(langCode, new AtomicInteger());
 132       }
 133       appendAndIndexWikiCallback.langCodeToTCount.get(langCode).incrementAndGet();
 134       final String word = ListUtil.get(args, 1);
 135       appendAndIndexWikiCallback.dispatch(alt != null ? alt : word, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 136
 137       // Genders...
 138       if (args.size() > 2) {
 139         appendAndIndexWikiCallback.builder.append(" {");
 140         for (int i = 2; i < args.size(); ++i) {
 141           if (i > 2) {
 142             appendAndIndexWikiCallback.builder.append("|");
 143           }
 144           appendAndIndexWikiCallback.builder.append(args.get(i));
 145         }
 146         appendAndIndexWikiCallback.builder.append("}");
 147       }
 148
 149       if (transliteration != null) {
 150         appendAndIndexWikiCallback.builder.append(" (");
 151         appendAndIndexWikiCallback.dispatch(transliteration, EntryTypeName.WIKTIONARY_TRANSLITERATION);
 152         appendAndIndexWikiCallback.builder.append(")");
 153       }
 154
 155       if (alt != null) {
 156         // If alt wasn't null, we appended alt instead of the actual word
 157         // we're filing under..
 158         appendAndIndexWikiCallback.builder.append(" (");
 159         appendAndIndexWikiCallback.dispatch(word, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 160         appendAndIndexWikiCallback.builder.append(")");
 161       }
 162
 163       // Catch-all for anything else...
 164       if (!namedArgs.isEmpty()) {
 165         appendAndIndexWikiCallback.builder.append(" {");
 166         EnParser.appendNamedArgs(namedArgs, appendAndIndexWikiCallback);
 167         appendAndIndexWikiCallback.builder.append("}");
 168       }
 169
 170       return true;
 171     }
 172   }
 173
 174   // ------------------------------------------------------------------
 175
 176   static final class QualifierCallback implements FunctionCallback<EnParser> {
 177     @Override
 178     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 179         final Map<String, String> namedArgs,
 180         final EnParser parser,
 181         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 182       if (args.size() != 1 || !namedArgs.isEmpty()) {
 183         EnParser.LOG.warning("weird qualifier: ");
 184         return false;
 185       }
 186       String qualifier = args.get(0);
 187       appendAndIndexWikiCallback.builder.append("(");
 188       appendAndIndexWikiCallback.dispatch(qualifier, null);
 189       appendAndIndexWikiCallback.builder.append(")");
 190       return true;
 191     }
 192   }
 193
 194   // ------------------------------------------------------------------
 195
 196   static final class EncodingCallback implements FunctionCallback<EnParser> {
 197     @Override
 198     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 199         final Map<String, String> namedArgs,
 200         final EnParser parser,
 201         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 202       if (!namedArgs.isEmpty()) {
 203         EnParser.LOG.warning("weird encoding: " + wikiTokenizer.token());
 204       }
 205       if (args.size() == 0) {
 206         // Things like "{{Jpan}}" exist.
 207         return true;
 208       }
 209
 210       for (int i = 0; i < args.size(); ++i) {
 211         if (i > 0) {
 212           appendAndIndexWikiCallback.builder.append(", ");
 213         }
 214         final String arg = args.get(i);
 215 //        if (arg.equals(parser.title)) {
 216 //          parser.titleAppended = true;
 217 //        }
 218         appendAndIndexWikiCallback.dispatch(arg, appendAndIndexWikiCallback.entryTypeName);
 219       }
 220
 221       return true;
 222     }
 223   }
 224
 225   // ------------------------------------------------------------------
 226
 227   static final class Gender implements FunctionCallback<EnParser> {
 228     @Override
 229     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 230         final Map<String, String> namedArgs,
 231         final EnParser parser,
 232         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 233       if (!namedArgs.isEmpty()) {
 234         return false;
 235       }
 236       appendAndIndexWikiCallback.builder.append("{");
 237       appendAndIndexWikiCallback.builder.append(name);
 238       for (int i = 0; i < args.size(); ++i) {
 239         appendAndIndexWikiCallback.builder.append("|").append(args.get(i));
 240       }
 241       appendAndIndexWikiCallback.builder.append("}");
 242       return true;
 243     }
 244   }
 245
 246   // ------------------------------------------------------------------
 247
 248   static final class l_term implements FunctionCallback<EnParser> {
 249     @Override
 250     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 251         final Map<String, String> namedArgs,
 252         final EnParser parser,
 253         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 254
 255       // for {{l}}, lang is arg 0, but not for {{term}}
 256       if (name.equals("term")) {
 257         args.add(0, "");
 258       }
 259
 260       final EntryTypeName entryTypeName;
 261       switch (parser.state) {
 262       case TRANSLATION_LINE: entryTypeName = EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT; break;
 263       case ENGLISH_DEF_OF_FOREIGN: entryTypeName = EntryTypeName.WIKTIONARY_ENGLISH_DEF_WIKI_LINK; break;
 264       default: throw new IllegalStateException("Invalid enum value: " + parser.state);
 265       }
 266
 267       final String langCode = args.get(0);
 268       final IndexBuilder indexBuilder;
 269       if ("".equals(langCode)) {
 270         indexBuilder = parser.foreignIndexBuilder;
 271       } else if ("en".equals(langCode)) {
 272         indexBuilder = parser.enIndexBuilder;
 273       } else {
 274         indexBuilder = parser.foreignIndexBuilder;
 275       }
 276
 277       String displayText = ListUtil.get(args, 2, "");
 278       if (displayText.equals("")) {
 279         displayText = ListUtil.get(args, 1, null);
 280       }
 281
 282       if (displayText != null) {
 283         appendAndIndexWikiCallback.dispatch(displayText, indexBuilder, entryTypeName);
 284       } else {
 285         EnParser.LOG.warning("no display text: " + wikiTokenizer.token());
 286       }
 287
 288       final String tr = namedArgs.remove("tr");
 289       if (tr != null) {
 290         appendAndIndexWikiCallback.builder.append(" (");
 291         appendAndIndexWikiCallback.dispatch(tr, indexBuilder, EntryTypeName.WIKTIONARY_TRANSLITERATION);
 292         appendAndIndexWikiCallback.builder.append(")");
 293       }
 294
 295       final String gloss = ListUtil.get(args, 3, "");
 296       if (!gloss.equals("")) {
 297         appendAndIndexWikiCallback.builder.append(" (");
 298         appendAndIndexWikiCallback.dispatch(gloss, parser.enIndexBuilder, EntryTypeName.WIKTIONARY_ENGLISH_DEF);
 299         appendAndIndexWikiCallback.builder.append(")");
 300       }
 301
 302       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 303       if (!namedArgs.isEmpty()) {
 304         appendAndIndexWikiCallback.builder.append(" {").append(name);
 305         EnParser.appendNamedArgs(namedArgs, appendAndIndexWikiCallback);
 306         appendAndIndexWikiCallback.builder.append("}");
 307       }
 308
 309       return true;
 310     }
 311   }
 312
 313   // ------------------------------------------------------------------
 314
 315   static final class AppendArg0 implements FunctionCallback<EnParser> {
 316     @Override
 317     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 318         final Map<String, String> namedArgs,
 319         final EnParser parser,
 320         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 321       if (args.size() != 1 || !namedArgs.isEmpty()) {
 322         return false;
 323       }
 324       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 325
 326       final String tr = namedArgs.remove("tr");
 327       if (tr != null) {
 328         appendAndIndexWikiCallback.builder.append(" (");
 329         appendAndIndexWikiCallback.dispatch(tr, EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 330         appendAndIndexWikiCallback.builder.append(")");
 331         parser.wordForms.add(tr);
 332       }
 333
 334       return true;
 335     }
 336   }
 337
 338   // ------------------------------------------------------------------
 339
 340   static final class italbrac implements FunctionCallback<EnParser> {
 341     @Override
 342     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 343         final Map<String, String> namedArgs,
 344         final EnParser parser,
 345         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 346       if (args.size() != 1 || !namedArgs.isEmpty()) {
 347         return false;
 348       }
 349       appendAndIndexWikiCallback.builder.append("(");
 350       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 351       appendAndIndexWikiCallback.builder.append(")");
 352       return true;
 353     }
 354   }
 355
 356   // ------------------------------------------------------------------
 357
 358   static final class gloss implements FunctionCallback<EnParser> {
 359     @Override
 360     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 361         final Map<String, String> namedArgs,
 362         final EnParser parser,
 363         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 364       if (args.size() != 1 || !namedArgs.isEmpty()) {
 365         return false;
 366       }
 367       appendAndIndexWikiCallback.builder.append("(");
 368       appendAndIndexWikiCallback.dispatch(args.get(0), EntryTypeName.WIKTIONARY_TRANSLATION_OTHER_TEXT);
 369       appendAndIndexWikiCallback.builder.append(")");
 370       return true;
 371     }
 372   }
 373
 374   // ------------------------------------------------------------------
 375
 376   static final class Ignore implements FunctionCallback<EnParser> {
 377     @Override
 378     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 379         final Map<String, String> namedArgs,
 380         final EnParser parser,
 381         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 382       return true;
 383     }
 384   }
 385
 386   // ------------------------------------------------------------------
 387
 388   static final class not_used implements FunctionCallback<EnParser> {
 389     @Override
 390     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 391         final Map<String, String> namedArgs,
 392         final EnParser parser,
 393         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 394       appendAndIndexWikiCallback.builder.append("(not used)");
 395       return true;
 396     }
 397   }
 398
 399
 400   // ------------------------------------------------------------------
 401
 402   static final class AppendName implements FunctionCallback<EnParser> {
 403     @Override
 404     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 405         final Map<String, String> namedArgs,
 406         final EnParser parser,
 407         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 408       if (!args.isEmpty() || !namedArgs.isEmpty()) {
 409         return false;
 410       }
 411       appendAndIndexWikiCallback.builder.append(name);
 412       return true;
 413     }
 414   }
 415
 416   // --------------------------------------------------------------------
 417   // --------------------------------------------------------------------
 418
 419
 420   static final class FormOf implements FunctionCallback<EnParser> {
 421     @Override
 422     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 423         final Map<String, String> namedArgs,
 424         final EnParser parser,
 425         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 426       parser.entryIsFormOfSomething = true;
 427       String formName = name;
 428       if (name.equals("form of")) {
 429         formName = ListUtil.remove(args, 0, null);
 430       }
 431       if (formName == null) {
 432         EnParser.LOG.warning("Missing form name: " + parser.title);
 433         formName = "form of";
 434       }
 435       String baseForm = ListUtil.get(args, 1, "");
 436       if ("".equals(baseForm)) {
 437         baseForm = ListUtil.get(args, 0, null);
 438         ListUtil.remove(args, 1, "");
 439       } else {
 440         ListUtil.remove(args, 0, null);
 441       }
 442       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 443
 444       appendAndIndexWikiCallback.builder.append("{");
 445       NAME_AND_ARGS.onWikiFunction(wikiTokenizer, formName, args, namedArgs, parser, appendAndIndexWikiCallback);
 446       appendAndIndexWikiCallback.builder.append("}");
 447       if (baseForm != null && appendAndIndexWikiCallback.indexedEntry != null) {
 448         parser.foreignIndexBuilder.addEntryWithString(appendAndIndexWikiCallback.indexedEntry, baseForm, EntryTypeName.WIKTIONARY_BASE_FORM_MULTI);
 449       } else {
 450         // null baseForm happens in Danish.
 451         EnParser.LOG.warning("Null baseform: " + parser.title);
 452       }
 453       return true;
 454     }
 455   }
 456
 457   static final EnFunctionCallbacks.FormOf FORM_OF = new FormOf();
 458
 459
 460   // --------------------------------------------------------------------
 461   // --------------------------------------------------------------------
 462
 463   static final class wikipedia implements FunctionCallback<EnParser> {
 464     @Override
 465     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 466         final Map<String, String> namedArgs,
 467         final EnParser parser,
 468         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 469       namedArgs.remove("lang");
 470       if (args.size() > 1 || !namedArgs.isEmpty()) {
 471         // Unindexed!
 472         return false;
 473       } else if (args.size() == 1) {
 474         return false;
 475       } else {
 476         return true;
 477       }
 478     }
 479   }
 480
 481   static final class InflOrHead implements FunctionCallback<EnParser> {
 482     @Override
 483     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 484         final Map<String, String> namedArgs,
 485         final EnParser parser,
 486         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 487       // See: http://en.wiktionary.org/wiki/Template:infl
 488       // TODO: Actually these functions should start a new WordPOS:
 489       // See: http://en.wiktionary.org/wiki/quattro
 490       final String langCode = ListUtil.get(args, 0);
 491       String head = namedArgs.remove("head");
 492       if (head == null) {
 493         head = namedArgs.remove("title"); // Bug
 494       }
 495       if (head == null) {
 496         head = parser.title;
 497       }
 498
 499       namedArgs.keySet().removeAll(EnParser.USELESS_WIKI_ARGS);
 500
 501       final String tr = namedArgs.remove("tr");
 502       String g = namedArgs.remove("g");
 503       if (g == null) {
 504         g = namedArgs.remove("gender");
 505       }
 506       final String g2 = namedArgs.remove("g2");
 507       final String g3 = namedArgs.remove("g3");
 508
 509       // We might have already taken care of this in a generic way...
 510       if (!parser.titleAppended) {
 511         appendAndIndexWikiCallback.dispatch(head, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 512         parser.titleAppended = true;
 513       }
 514
 515       if (g != null) {
 516         appendAndIndexWikiCallback.builder.append(" {").append(g);
 517         if (g2 != null) {
 518           appendAndIndexWikiCallback.builder.append("|").append(g2);
 519         }
 520         if (g3 != null) {
 521           appendAndIndexWikiCallback.builder.append("|").append(g3);
 522         }
 523         appendAndIndexWikiCallback.builder.append("}");
 524       }
 525
 526       if (tr != null) {
 527         appendAndIndexWikiCallback.builder.append(" (");
 528         appendAndIndexWikiCallback.dispatch(tr, EntryTypeName.WIKTIONARY_TITLE_MULTI);
 529         appendAndIndexWikiCallback.builder.append(")");
 530         parser.wordForms.add(tr);
 531       }
 532
 533       final String pos = ListUtil.get(args, 1);
 534       if (pos != null) {
 535         appendAndIndexWikiCallback.builder.append(" (").append(pos).append(")");
 536       }
 537       for (int i = 2; i < args.size(); i += 2) {
 538         final String inflName = ListUtil.get(args, i);
 539         final String inflValue = ListUtil.get(args, i + 1);
 540         appendAndIndexWikiCallback.builder.append(", ");
 541         appendAndIndexWikiCallback.dispatch(inflName, null, null);
 542         if (inflValue != null && inflValue.length() > 0) {
 543           appendAndIndexWikiCallback.builder.append(": ");
 544           appendAndIndexWikiCallback.dispatch(inflValue, null, null);
 545           parser.wordForms.add(inflValue);
 546         }
 547       }
 548       for (final String key : namedArgs.keySet()) {
 549         final String value = WikiTokenizer.toPlainText(namedArgs.get(key));
 550         appendAndIndexWikiCallback.builder.append(" ");
 551         appendAndIndexWikiCallback.dispatch(key, null, null);
 552         appendAndIndexWikiCallback.builder.append("=");
 553         appendAndIndexWikiCallback.dispatch(value, null, null);
 554         parser.wordForms.add(value);
 555       }
 556       return true;
 557     }
 558   }
 559
 560
 561   static {
 562     DEFAULT.put("it-noun", new it_noun());
 563   }
 564   static final class it_noun implements FunctionCallback<EnParser> {
 565     @Override
 566     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 567         final Map<String, String> namedArgs,
 568         final EnParser parser,
 569         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 570       parser.titleAppended = true;
 571       final String base = ListUtil.get(args, 0);
 572       final String gender = ListUtil.get(args, 1);
 573       final String singular = base + ListUtil.get(args, 2, null);
 574       final String plural = base + ListUtil.get(args, 3, null);
 575       appendAndIndexWikiCallback.builder.append(" ");
 576       appendAndIndexWikiCallback.dispatch(singular, null, null);
 577       appendAndIndexWikiCallback.builder.append(" {").append(gender).append("}, ");
 578       appendAndIndexWikiCallback.dispatch(plural, null, null);
 579       appendAndIndexWikiCallback.builder.append(" {pl}");
 580       parser.wordForms.add(singular);
 581       parser.wordForms.add(plural);
 582       if (!namedArgs.isEmpty() || args.size() > 4) {
 583         EnParser.LOG.warning("Invalid it-noun: " + wikiTokenizer.token());
 584       }
 585       return true;
 586     }
 587   }
 588
 589   static {
 590     DEFAULT.put("it-proper noun", new it_proper_noun());
 591   }
 592   static final class it_proper_noun implements FunctionCallback<EnParser> {
 593     @Override
 594     public boolean onWikiFunction(final WikiTokenizer wikiTokenizer, final String name, final List<String> args,
 595         final Map<String, String> namedArgs,
 596         final EnParser parser,
 597         final AppendAndIndexWikiCallback<EnParser> appendAndIndexWikiCallback) {
 598       return false;
 599     }
 600   }
 601
 602   }