Reorganize

1 files changed, 197 insertions, 0 deletions

diff --git a/src/main/java/bjc/inflexion/IrregularNounInflection.java b/src/main/java/bjc/inflexion/IrregularNounInflection.java
new file mode 100644
index 0000000..6447db8
--- /dev/null
+++ b/src/main/java/bjc/inflexion/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;
+
+/**
+ * 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