From d6e49b472bcf023d86a7c236b57d6eef0ad9bb3f Mon Sep 17 00:00:00 2001 From: bjculkin Date: Tue, 4 Apr 2017 16:02:16 -0400 Subject: Implement bulk of inflector --- .../inflexion/v2/CategoricalNounInflection.java | 204 +++++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java (limited to 'src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java') diff --git a/src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java b/src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java new file mode 100644 index 0000000..597b2a3 --- /dev/null +++ b/src/main/java/bjc/inflexion/v2/CategoricalNounInflection.java @@ -0,0 +1,204 @@ +/** + * (C) Copyright 2017 Benjamin Culkin. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package bjc.inflexion.v2; + +/** + * Implementation of {@link NounInflection} for nouns matched by a regular + * expression. + * + * @author EVE + * + */ +public class CategoricalNounInflection implements NounInflection { + private static final String TOSTRING_FMT = "CategoricalNounInflection [singular=%s, modernPlural=%s," + + " classicalPlural=%s]"; + + private InflectionAffix singular; + + private InflectionAffix modernPlural; + private InflectionAffix classicalPlural; + + private boolean preferClassical; + + /** + * Create a new categorical inflection. + * + * @param singlar + * The affix for the singular form. + * @param modrnPlural + * The affix for the modern plural. + * @param classiclPlural + * The affix for the classical plural. + * @param prefrClassical + * Whether or not the classical plural should be + * preferred. + */ + public CategoricalNounInflection(InflectionAffix singlar, InflectionAffix modrnPlural, + InflectionAffix classiclPlural, boolean prefrClassical) { + if(singlar == null) + throw new NullPointerException("Singular form must not be null"); + else if(modrnPlural == null && classiclPlural == null) + throw new NullPointerException("One of modern/classical plural forms must not be null"); + + singular = singlar; + modernPlural = modrnPlural; + classicalPlural = classiclPlural; + preferClassical = prefrClassical; + } + + @Override + public boolean matches(String noun) { + if(singular.hasAffix(noun)) + return true; + else if(modernPlural != null && modernPlural.hasAffix(noun)) + return true; + else if(classicalPlural != null && classicalPlural.hasAffix(noun)) + return true; + else + return false; + } + + @Override + public boolean isSingular(String noun) { + if(singular.hasAffix(noun)) + return true; + else if(matchesPlural(noun)) + return false; + else { + String msg = String.format("Noun '%s' doesn't belong to this inflection", noun, this); + + throw new InflectionException(msg); + } + } + + @Override + public boolean isPlural(String noun) { + if(singular.hasAffix(noun)) + return false; + else if(matchesPlural(noun)) + return true; + else { + String msg = String.format("Noun '%s' doesn't belong to this inflection", noun, this); + + throw new InflectionException(msg); + } + } + + @Override + public String singularize(String plural) { + if(singular.hasAffix(plural)) + return plural; + else if(modernPlural != null && modernPlural.hasAffix(plural)) + return singular.affix(modernPlural.deaffix(plural)); + else if(classicalPlural != null && classicalPlural.hasAffix(plural)) + return singular.affix(classicalPlural.deaffix(plural)); + else { + String msg = String.format("Noun '%s' doesn't belong to this inflection", plural, this); + + throw new InflectionException(msg); + } + } + + @Override + public String pluralize(String singlar) { + if(singular.hasAffix(singlar)) { + if(preferClassical) { + if(classicalPlural == null) { + return modernPlural.affix(singular.deaffix(singlar)); + } else { + return classicalPlural.affix(singular.deaffix(singlar)); + } + } else { + if(modernPlural == null) { + return classicalPlural.affix(singular.deaffix(singlar)); + } else { + return modernPlural.affix(singular.deaffix(singlar)); + } + } + } else if(matchesPlural(singlar)) { + return singlar; + } else { + String msg = String.format("Noun '%s' doesn't belong to this inflection", singlar, this); + + throw new InflectionException(msg); + } + } + + private boolean matchesPlural(String noun) { + boolean hasModernPlural = modernPlural != null && modernPlural.hasAffix(noun); + + return hasModernPlural || (classicalPlural != null && classicalPlural.hasAffix(noun)); + } + + @Override + public String toString() { + return String.format(TOSTRING_FMT, singular, modernPlural, classicalPlural); + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + + result = prime * result + ((classicalPlural == null) ? 0 : classicalPlural.hashCode()); + result = prime * result + ((modernPlural == null) ? 0 : modernPlural.hashCode()); + + return result; + } + + @Override + public boolean equals(Object obj) { + if(this == obj) return true; + if(obj == null) return false; + if(!(obj instanceof CategoricalNounInflection)) return false; + + CategoricalNounInflection other = (CategoricalNounInflection) obj; + + if(classicalPlural == null) { + if(other.classicalPlural != null) return false; + } else if(!classicalPlural.equals(other.classicalPlural)) return false; + + if(modernPlural == null) { + if(other.modernPlural != null) return false; + } else if(!modernPlural.equals(other.modernPlural)) return false; + + return true; + } + + @Override + public String pluralizeModern(String singlar) { + if(modernPlural == null) return pluralizeClassical(singlar); + + String actSinglar = singlar; + if(isPlural(singlar)) { + actSinglar = singularize(singlar); + } + + return modernPlural.affix(singular.deaffix(actSinglar)); + } + + @Override + public String pluralizeClassical(String singlar) { + if(classicalPlural == null) return pluralizeModern(singlar); + + String actSinglar = singlar; + if(isPlural(singlar)) { + actSinglar = singularize(singlar); + } + + return classicalPlural.affix(singular.deaffix(actSinglar)); + } +} \ No newline at end of file -- cgit v1.2.3