diff options
Diffstat (limited to 'src/main/java/bjc/inflexion/v2/IrregularNounInflection.java')
| -rw-r--r-- | src/main/java/bjc/inflexion/v2/IrregularNounInflection.java | 197 |
1 files changed, 197 insertions, 0 deletions
diff --git a/src/main/java/bjc/inflexion/v2/IrregularNounInflection.java b/src/main/java/bjc/inflexion/v2/IrregularNounInflection.java new file mode 100644 index 0000000..294c6a3 --- /dev/null +++ b/src/main/java/bjc/inflexion/v2/IrregularNounInflection.java @@ -0,0 +1,197 @@ +/** + * (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 irregular nouns. + * + * @author EVE + * + */ +public class IrregularNounInflection implements NounInflection { + private static final String TOSTRING_FMT = "IrregularNounInflection [singular=%s, modernPlural=%s," + + " classicalPlural=%s, preferClassical=%s]"; + + private String singular; + + private String modernPlural; + private String classicalPlural; + + private boolean preferClassical; + + /** + * Create a new irregular noun inflection. + * + * @param singlar + * The singular form of the noun. + * + * @param modrnPlural + * The modern plural of the noun. + * + * @param classiclPlural + * The classical plural of the noun. + * + * @param prefrClassical + * Whether the classical form should be preferred if it + * is available. + */ + public IrregularNounInflection(String singlar, String modrnPlural, String classiclPlural, + boolean prefrClassical) { + if(singlar == null) throw new NullPointerException("Singular form must not be null"); + 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(noun.equalsIgnoreCase(singular)) + return true; + else if(noun.equalsIgnoreCase(modernPlural)) + return true; + else if(noun.equalsIgnoreCase(classicalPlural)) + return true; + else + return false; + } + + @Override + public boolean isSingular(String noun) { + if(noun.equalsIgnoreCase(singular)) + return true; + else if(matchesPlural(noun)) + return false; + else { + String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", noun, this); + + throw new InflectionException(msg); + } + } + + @Override + public boolean isPlural(String noun) { + if(noun.equalsIgnoreCase(singular)) + return false; + else if(matchesPlural(noun)) + return true; + else { + String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", noun, this); + + throw new InflectionException(msg); + } + } + + @Override + public String singularize(String plural) { + if(plural.equalsIgnoreCase(singular)) + return singular; + else if(matchesPlural(plural)) + return singular; + else { + String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", plural, this); + + throw new InflectionException(msg); + } + } + + @Override + public String pluralize(String singular) { + if(singular.equalsIgnoreCase(singular)) + return getPlural(); + else if(matchesPlural(singular)) + return getPlural(); + else { + String msg = String.format("Noun '%s' doesn't belong to this inflection '%s'", singular, this); + + throw new InflectionException(msg); + } + } + + private String getPlural() { + if(preferClassical) { + if(classicalPlural == null) + return modernPlural; + else + return classicalPlural; + } else if(modernPlural == null) { + return classicalPlural; + } else { + return modernPlural; + } + } + + private boolean matchesPlural(String noun) { + return noun.equalsIgnoreCase(modernPlural) || noun.equalsIgnoreCase(classicalPlural); + } + + @Override + public String toString() { + return String.format(TOSTRING_FMT, singular, modernPlural, classicalPlural, preferClassical); + } + + @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()); + result = prime * result + ((singular == null) ? 0 : singular.hashCode()); + + return result; + } + + @Override + public boolean equals(Object obj) { + if(this == obj) return true; + if(obj == null) return false; + if(!(obj instanceof IrregularNounInflection)) return false; + + IrregularNounInflection other = (IrregularNounInflection) obj; + + if(singular == null) { + if(other.singular != null) return false; + } else if(!singular.equals(other.singular)) return false; + + 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 singular) { + if(modernPlural == null) return pluralizeClassical(singular); + + return modernPlural; + } + + @Override + public String pluralizeClassical(String singular) { + if(classicalPlural == null) return pluralizeModern(singular); + + return classicalPlural; + } +}
\ No newline at end of file |