summaryrefslogtreecommitdiff
path: root/src/main/java/bjc/inflexion/nouns/Nouns.java
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/java/bjc/inflexion/nouns/Nouns.java')
-rw-r--r--src/main/java/bjc/inflexion/nouns/Nouns.java307
1 files changed, 184 insertions, 123 deletions
diff --git a/src/main/java/bjc/inflexion/nouns/Nouns.java b/src/main/java/bjc/inflexion/nouns/Nouns.java
index d63b704..aeb2f2f 100644
--- a/src/main/java/bjc/inflexion/nouns/Nouns.java
+++ b/src/main/java/bjc/inflexion/nouns/Nouns.java
@@ -28,34 +28,41 @@ import java.util.Scanner;
import java.util.regex.Pattern;
/**
- * @author EVE
+ * Utilities for doing things with nouns.
*
+ * @author EVE
*/
public class Nouns {
+ /* The default inflection. */
private static final DefaultNounInflection DEFAULT_INFLECTION = new
- DefaultNounInflection();
+ DefaultNounInflection();
+ /* Database of prepositions. */
private final Prepositions prepositionDB;
-
+
+ /* User defined irregular inflections. */
private final Map<String, NounInflection> userIrregulars;
+ /* User defined categorical inflections. */
private final List<NounInflection> userInflections;
+ /* Predefined irregular inflections. */
private final Map<String, NounInflection> predefinedIrregulars;
+ /* Predefined categorical inflections. */
private final List<NounInflection> predefinedInflections;
/**
* Create a new empty noun DB.
*
* @param prepDB
- * The source for prepositions.
+ * The source for prepositions.
*/
public Nouns(final Prepositions prepDB) {
prepositionDB = prepDB;
- userIrregulars = new HashMap<>();
+ userIrregulars = new HashMap<>();
userInflections = new LinkedList<>();
- predefinedIrregulars = new HashMap<>();
+ predefinedIrregulars = new HashMap<>();
predefinedInflections = new LinkedList<>();
}
@@ -63,12 +70,13 @@ public class Nouns {
* Retrieve a noun with its inflection from the database of inflections.
*
* @param noun
- * The noun to retrieve.
+ * The noun to retrieve.
*
- * @return The noun with its inflection.
+ * @return
+ * The noun with its inflection.
*
* @throws InflectionException
- * If the noun matched no inflection.
+ * If the noun matched no inflection.
*/
public Noun getNoun(final String noun) {
if (userIrregulars.containsKey(noun)) return new Noun(noun, userIrregulars.get(noun));
@@ -77,8 +85,9 @@ public class Nouns {
if (inflect.matches(noun)) return new Noun(noun, inflect);
}
- if (predefinedIrregulars.containsKey(noun)) return new Noun(noun,
- predefinedIrregulars.get(noun));
+ if (predefinedIrregulars.containsKey(noun)) {
+ return new Noun(noun, predefinedIrregulars.get(noun));
+ }
for (final NounInflection inflect : predefinedInflections) {
if (inflect.matches(noun)) return new Noun(noun, inflect);
@@ -91,24 +100,19 @@ public class Nouns {
* Load the contents of the stream into this DB.
*
* @param stream
- * The stream to load from.
+ * The stream to load from.
*/
public void loadFromStream(final InputStream stream) {
try (Scanner scn = new Scanner(stream)) {
while (scn.hasNextLine()) {
final String ln = scn.nextLine().trim();
- /*
- * Ignore comments and blank lines.
- */
- if (ln.startsWith("#")) {
- continue;
- }
-
- if (ln.equals("")) {
+ /* Ignore comments and blank lines. */
+ if (ln.startsWith("#") || ln.equals("")) {
continue;
}
+ /* Handle being able to replace -'s with spaces. */
if (ln.contains("-")) {
handleLine(ln);
handleLine(ln.replace('-', ' '));
@@ -119,6 +123,7 @@ public class Nouns {
}
}
+ /* Handle a line from a noun database. */
private void handleLine(final String ln) {
final String[] parts = ln.split(Pattern.quote("=>"));
@@ -129,9 +134,9 @@ public class Nouns {
}
final String singular = parts[0].trim();
- final String plural = parts[1].trim();
+ final String plural = parts[1].trim();
- String modernPlural = "";
+ String modernPlural = "";
String classicalPlural = "";
if (plural.contains("|")) {
@@ -140,7 +145,7 @@ public class Nouns {
if (plurals.length == 1) {
modernPlural = plurals[0].trim();
} else {
- modernPlural = plurals[0].trim();
+ modernPlural = plurals[0].trim();
classicalPlural = plurals[1].trim();
}
@@ -152,7 +157,7 @@ public class Nouns {
classicalPlural = null;
}
} else {
- modernPlural = plural;
+ modernPlural = plural;
classicalPlural = null;
}
@@ -167,31 +172,41 @@ public class Nouns {
}
}
+ /*
+ * Handle a compound inflection.
+ */
private void handleCompoundPlural(final String singular, final String modernPlural,
final String classicalPlural) {
- String actSingular = singular;
- String actModern = modernPlural == null ? "" : modernPlural;
+ String actSingular = singular;
+ String actModern = modernPlural == null ? "" : modernPlural;
String actClassical = classicalPlural == null ? "" : classicalPlural;
- final String singularPatt = actSingular.replaceAll(Pattern.quote("(SING)"),
- "(?<noun>\\\\w+)");
- final String modernPatt = actModern.replaceAll(Pattern.quote("(PL)"), "(?<noun>\\\\w+)");
- final String classicalPatt = actClassical.replaceAll(Pattern.quote("(PL)"),
- "(?<noun>\\\\w+)");
+ final String singularPatt =
+ actSingular.replaceAll(Pattern.quote("(SING)"),
+ "(?<noun>\\\\w+)");
+
+ final String modernPatt =
+ actModern.replaceAll(Pattern.quote("(PL)"),
+ "(?<noun>\\\\w+)");
+
+ final String classicalPatt =
+ actClassical.replaceAll(Pattern.quote("(PL)"),
+ "(?<noun>\\\\w+)");
- actSingular = actSingular.replaceAll(Pattern.quote("(SING)"), "%1\\$s");
- actModern = actModern.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
+ actSingular = actSingular.replaceAll(Pattern.quote("(SING)"), "%1\\$s");
+ actModern = actModern.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
actClassical = actClassical.replaceAll(Pattern.quote("(PL)"), "%1\\$s");
final List<CompoundNounInflection> inflections = new ArrayList<>(3);
if (singular.contains("(PREP)")) {
- handleCompoundPreposition(actSingular, actModern, actClassical, singularPatt, modernPatt,
- classicalPatt, inflections);
+ handleCompoundPreposition(actSingular, actModern,
+ actClassical, singularPatt, modernPatt,
+ classicalPatt, inflections);
} else {
- handleCompound(actSingular, actModern, actClassical, singularPatt, modernPatt,
- classicalPatt,
- inflections);
+ handleCompound(actSingular, actModern, actClassical,
+ singularPatt, modernPatt, classicalPatt,
+ inflections);
}
for (final NounInflection inf : inflections) {
@@ -199,129 +214,173 @@ public class Nouns {
}
}
- private void handleCompound(final String actSinglar, final String actModrn,
- final String actClasscal,
- final String singularPtt, final String modernPtt, final String classicalPtt,
- final List<CompoundNounInflection> inflections) {
+ /*
+ * Handle a compound inflection.
+ */
+ private void handleCompound(final String actSinglar, final String
+ actModrn, final String actClasscal, final String
+ singularPtt, final String modernPtt, final String
+ classicalPtt, final List<CompoundNounInflection>
+ inflections) {
if (singularPtt.contains("*")) {
- final String singularPatt = singularPtt.replaceAll(Pattern.quote("*"),
- "(?<scratch>\\\\w+)");
- final String modernPatt = modernPtt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
- final String classicalPatt = classicalPtt.replaceAll(Pattern.quote("*"),
- "(?<scratch>\\\\w+)");
-
- final String actSingular = actSinglar.replaceAll(Pattern.quote("*"), "%2\\$s");
- final String actModern = actModrn.replaceAll(Pattern.quote("*"), "%2\\$s");
+ final String singularPatt =
+ singularPtt.replaceAll(Pattern.quote("*"),
+ "(?<scratch>\\\\w+)");
+
+ final String modernPatt =
+ modernPtt.replaceAll(Pattern.quote("*"),
+ "(?<scratch>\\\\w+)");
+
+ final String classicalPatt =
+ classicalPtt.replaceAll(Pattern.quote("*"),
+ "(?<scratch>\\\\w+)");
+
+ final String actSingular = actSinglar.replaceAll(Pattern.quote("*"), "%2\\$s");
+ final String actModern = actModrn.replaceAll(Pattern.quote("*"), "%2\\$s");
final String actClassical = actClasscal.replaceAll(Pattern.quote("*"), "%2\\$s");
- handleNonpluralCompound(actSingular, actModern, actClassical, singularPatt, modernPatt,
- classicalPatt, inflections, true);
+ handleNonpluralCompound(actSingular, actModern,
+ actClassical, singularPatt, modernPatt,
+ classicalPatt, inflections, true);
} else {
- handleNonpluralCompound(actSinglar, actModrn, actClasscal, singularPtt, modernPtt,
- classicalPtt,
- inflections, false);
+ handleNonpluralCompound(actSinglar, actModrn,
+ actClasscal, singularPtt, modernPtt,
+ classicalPtt, inflections, false);
}
}
- private void handleNonpluralCompound(final String actSinglar, final String actModrn,
- final String actClasscal,
- final String singularPatt, final String modernPatt, final String classicalPatt,
- final List<CompoundNounInflection> inflections, final boolean hasScratch) {
- final String actModern = actModrn.equals("") ? null : actModrn;
+ /* Handle a non-plural compound inflection. */
+ private void handleNonpluralCompound(final String actSinglar, final
+ String actModrn, final String actClasscal, final String
+ singularPatt, final String modernPatt, final String
+ classicalPatt, final List<CompoundNounInflection>
+ inflections, final boolean hasScratch) {
+ final String actModern = actModrn.equals("") ? null : actModrn;
final String actClassical = actClasscal.equals("") ? null : actClasscal;
- final CompoundNounInflection singularInflection = new CompoundNounInflection(this,
- prepositionDB,
- Pattern.compile(singularPatt), actSinglar, actModern, actClassical, false, hasScratch);
+ final Pattern singPt = Pattern.compile(singularPatt);
+
+ final CompoundNounInflection singularInflection = new
+ CompoundNounInflection(this, prepositionDB, singPt,
+ actSinglar, actModern, actClassical,
+ false, hasScratch);
inflections.add(singularInflection);
if (!modernPatt.equals("")) {
- final CompoundNounInflection modernInflection = new CompoundNounInflection(this,
- prepositionDB,
- Pattern.compile(modernPatt), actSinglar, actModern, actClassical, false,
- hasScratch);
+ final Pattern modPt = Pattern.compile(modernPatt);
+
+ final CompoundNounInflection modernInflection = new
+ CompoundNounInflection(this, prepositionDB,
+ modPt, actSinglar, actModern,
+ actClassical, false,
+ hasScratch);
inflections.add(modernInflection);
}
if (!classicalPatt.equals("")) {
- final CompoundNounInflection classicalInflection = new CompoundNounInflection(this,
- prepositionDB, Pattern.compile(classicalPatt), actSinglar, actModern,
- actClassical, false, hasScratch);
+ final Pattern clasPt = Pattern.compile(classicalPatt);
+
+ final CompoundNounInflection classicalInflection = new
+ CompoundNounInflection(this, prepositionDB,
+ clasPt, actSinglar, actModern,
+ actClassical, false,
+ hasScratch);
inflections.add(classicalInflection);
}
}
- private void handleCompoundPreposition(final String actSinglar, final String actModrn,
- final String actClasscal,
- final String singularPtt, final String modernPtt, final String classicalPtt,
- final List<CompoundNounInflection> inflections) {
- String singularPatt = singularPtt.replaceAll(Pattern.quote("(PREP)"),
- "(?<preposition>\\\\w+)");
- String modernPatt = modernPtt.replaceAll(Pattern.quote("(PREP)"),
- "(?<preposition>\\\\w+)");
- String classicalPatt = classicalPtt.replaceAll(Pattern.quote("(PREP)"),
- "(?<preposition>\\\\w+)");
-
- String actSingular = actSinglar.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
- String actModern = actModrn.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+ /*
+ * Handle a compound plural with a preposition. */
+ private void handleCompoundPreposition(final String actSinglar, final
+ String actModrn, final String actClasscal, final String
+ singularPtt, final String modernPtt, final String
+ classicalPtt, final List<CompoundNounInflection>
+ inflections) {
+ String singularPatt =
+ singularPtt.replaceAll(Pattern.quote("(PREP)"),
+ "(?<preposition>\\\\w+)");
+
+ String modernPatt =
+ modernPtt.replaceAll(Pattern.quote("(PREP)"),
+ "(?<preposition>\\\\w+)");
+
+ String classicalPatt =
+ classicalPtt.replaceAll(Pattern.quote("(PREP)"),
+ "(?<preposition>\\\\w+)");
+
+ String actSingular = actSinglar.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
+ String actModern = actModrn.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
String actClassical = actClasscal.replaceAll(Pattern.quote("(PREP)"), "%2\\$s");
if (singularPatt.contains("*")) {
- singularPatt = singularPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
- modernPatt = modernPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
+ singularPatt = singularPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
+ modernPatt = modernPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
classicalPatt = classicalPatt.replaceAll(Pattern.quote("*"), "(?<scratch>\\\\w+)");
- actSingular = actSingular.replaceAll(Pattern.quote("*"), "%3\\$s");
- actModern = actModern.replaceAll(Pattern.quote("*"), "%3\\$s");
+ actSingular = actSingular.replaceAll(Pattern.quote("*"), "%3\\$s");
+ actModern = actModern.replaceAll(Pattern.quote("*"), "%3\\$s");
actClassical = actClassical.replaceAll(Pattern.quote("*"), "%3\\$s");
- actModern = actModern.equals("") ? null : actModern;
+ actModern = actModern.equals("") ? null : actModern;
actClassical = actClassical.equals("") ? null : actClassical;
- addCompoundInflections(actSingular, actModern, actClassical, singularPatt, modernPatt,
- classicalPatt, inflections, true);
+ addCompoundInflections(actSingular, actModern,
+ actClassical, singularPatt, modernPatt,
+ classicalPatt, inflections, true);
} else {
- addCompoundInflections(actSingular, actModern, actClassical, singularPatt, modernPatt,
- classicalPatt, inflections, false);
+ addCompoundInflections(actSingular, actModern,
+ actClassical, singularPatt, modernPatt,
+ classicalPatt, inflections, false);
}
}
- private void addCompoundInflections(final String actSingular, final String actModern,
- final String actClassical,
- final String singularPatt, final String modernPatt, final String classicalPatt,
- final List<CompoundNounInflection> inflections, final boolean hasScratch) {
- final CompoundNounInflection singularInflection = new CompoundNounInflection(this,
- prepositionDB,
- Pattern.compile(singularPatt), actSingular, actModern, actClassical, true, hasScratch);
+ /* Do adding a compound inflection. */
+ private void addCompoundInflections(final String actSingular, final
+ String actModern, final String actClassical, final
+ String singularPatt, final String modernPatt, final
+ String classicalPatt, final List<CompoundNounInflection>
+ inflections, final boolean hasScratch) {
+ Pattern singPt = Pattern.compile(singularPatt);
+
+ final CompoundNounInflection singularInflection = new
+ CompoundNounInflection(this, prepositionDB, singPt,
+ actSingular, actModern, actClassical,
+ true, hasScratch);
inflections.add(singularInflection);
if (!modernPatt.equals("")) {
- final CompoundNounInflection modernInflection = new CompoundNounInflection(this,
- prepositionDB,
- Pattern.compile(modernPatt), actSingular, actModern, actClassical, true,
- hasScratch);
+ Pattern modPt = Pattern.compile(modernPatt);
+
+ final CompoundNounInflection modernInflection = new
+ CompoundNounInflection(this, prepositionDB,
+ modPt, actSingular, actModern,
+ actClassical, true, hasScratch);
inflections.add(modernInflection);
}
if (!classicalPatt.equals("")) {
- final CompoundNounInflection classicalInflection = new CompoundNounInflection(this,
- prepositionDB, Pattern.compile(classicalPatt), actSingular, actModern,
- actClassical, true, hasScratch);
+ Pattern clasPt = Pattern.compile(classicalPatt);
+
+ final CompoundNounInflection classicalInflection = new
+ CompoundNounInflection(this, prepositionDB,
+ clasPt, actSingular, actModern,
+ actClassical, true, hasScratch);
inflections.add(classicalInflection);
}
}
- private void handleIncompletePlural(final String singular, final String modernPlural,
- final String classicalPlural) {
+ /* Handle an incomplete plural. */
+ private void handleIncompletePlural(final String singular, final String
+ modernPlural, final String classicalPlural) {
final InflectionAffix singularAffix = incomplete(singular.substring(1));
- InflectionAffix modernAffix = null;
+ InflectionAffix modernAffix = null;
InflectionAffix classicalAffix = null;
if (modernPlural != null) {
@@ -332,18 +391,19 @@ public class Nouns {
classicalAffix = incomplete(classicalPlural.substring(1));
}
- final CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix,
- modernAffix,
- classicalAffix);
+ final CategoricalNounInflection inflection = new
+ CategoricalNounInflection(singularAffix, modernAffix,
+ classicalAffix);
predefinedInflections.add(inflection);
}
- private void handleCompletePlural(final String singular, final String modernPlural,
- final String classicalPlural) {
+ /* Handle a complete plural. */
+ private void handleCompletePlural(final String singular, final String
+ modernPlural, final String classicalPlural) {
final InflectionAffix singularAffix = complete(singular.substring(1));
- InflectionAffix modernAffix = null;
+ InflectionAffix modernAffix = null;
InflectionAffix classicalAffix = null;
if (modernPlural != null) {
@@ -354,18 +414,19 @@ public class Nouns {
classicalAffix = complete(classicalPlural.substring(1));
}
- final CategoricalNounInflection inflection = new CategoricalNounInflection(singularAffix,
- modernAffix,
- classicalAffix);
+ final CategoricalNounInflection inflection = new
+ CategoricalNounInflection(singularAffix, modernAffix,
+ classicalAffix);
predefinedInflections.add(inflection);
}
- private void handleIrregularPlural(final String singular, final String modernPlural,
- final String classicalPlural) {
- final IrregularNounInflection inflection = new IrregularNounInflection(singular,
- modernPlural,
- classicalPlural, false);
+ /* Handle an irregular plural. */
+ private void handleIrregularPlural(final String singular, final String
+ modernPlural, final String classicalPlural) {
+ final IrregularNounInflection inflection = new
+ IrregularNounInflection(singular, modernPlural,
+ classicalPlural, false);
if (!predefinedIrregulars.containsKey(singular)) {
predefinedIrregulars.put(singular, inflection);
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-10 04:07:11 +0000