private bool IsUninflective(string word)
{
//EDesignUtil.CheckArgumentNull<string>(word, "word");
if (!PluralizationServiceUtil.DoesWordContainSuffix(word, _uninflectiveSuffixList, _culture) && (word.ToLower(_culture).Equals(word) || !word.EndsWith("ese", false, _culture)) && !_uninflectiveWordList.Contains <string>(word.ToLowerInvariant()))
{
return(false);
}
return(true);
}
// *******************************************************************
/// <summary>
/// This method performs an action if a word contains a specific suffix.
/// </summary>
/// <param name="word">The word to use for the operation.</param>
/// <param name="suffixes">A list of suffixes to check for.</param>
/// <param name="operationOnWord">The action to be performed.</param>
/// <param name="culture">A culture to use for the operation.</param>
/// <param name="newWord">The results of the operation.</param>
/// <returns>True if the operation succeeded; false otherwise.</returns>
public static bool TryInflectOnSuffixInWord(
string word,
IEnumerable <string> suffixes,
Func <string, string> operationOnWord,
CultureInfo culture,
out string newWord
)
{
newWord = null;
if (!PluralizationServiceUtil.DoesWordContainSuffix(word, suffixes, culture))
{
return(false);
}
newWord = operationOnWord(word);
return(true);
}
private string InternalSingularize(string word)
{
string str;
string str1;
if (_userDictionary.ExistsInSecond(word))
{
return(_userDictionary.GetFirstValue(word));
}
if (IsNoOpWord(word))
{
return(word);
}
string suffixWord = GetSuffixWord(word, out str);
if (IsNoOpWord(suffixWord))
{
return(string.Concat(str, suffixWord));
}
if (IsUninflective(suffixWord))
{
return(string.Concat(str, suffixWord));
}
if (_knownSingluarWords.Contains(suffixWord.ToLowerInvariant()))
{
return(string.Concat(str, suffixWord));
}
if (_irregularVerbPluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _irregularVerbPluralizationService.GetFirstValue(suffixWord)));
}
if (_irregularPluralsPluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _irregularPluralsPluralizationService.GetFirstValue(suffixWord)));
}
if (_wordsEndingWithSisPluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _wordsEndingWithSisPluralizationService.GetFirstValue(suffixWord)));
}
if (_wordsEndingWithSePluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _wordsEndingWithSePluralizationService.GetFirstValue(suffixWord)));
}
if (_wordsEndingWithSusPluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _wordsEndingWithSusPluralizationService.GetFirstValue(suffixWord)));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"men"
}, (string s) => string.Concat(s.Remove(s.Length - 2, 2), "an"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"lice",
"mice"
}, (string s) => string.Concat(s.Remove(s.Length - 3, 3), "ouse"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"teeth"
}, (string s) => string.Concat(s.Remove(s.Length - 4, 4), "ooth"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"geese"
}, (string s) => string.Concat(s.Remove(s.Length - 4, 4), "oose"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"feet"
}, (string s) => string.Concat(s.Remove(s.Length - 3, 3), "oot"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"zoa"
}, (string s) => string.Concat(s.Remove(s.Length - 2, 2), "oon"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"ches",
"shes",
"sses"
}, (string s) => s.Remove(s.Length - 2, 2), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (_assimilatedClassicalInflectionPluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _assimilatedClassicalInflectionPluralizationService.GetFirstValue(suffixWord)));
}
if (_classicalInflectionPluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _classicalInflectionPluralizationService.GetFirstValue(suffixWord)));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"trices"
}, (string s) => string.Concat(s.Remove(s.Length - 3, 3), "x"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"eaux",
"ieux"
}, (string s) => s.Remove(s.Length - 1, 1), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (_wordsEndingWithInxAnxYnxPluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _wordsEndingWithInxAnxYnxPluralizationService.GetFirstValue(suffixWord)));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"alves",
"elves",
"olves",
"eaves",
"arves"
}, (string s) => string.Concat(s.Remove(s.Length - 3, 3), "f"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"nives",
"lives",
"wives"
}, (string s) => string.Concat(s.Remove(s.Length - 3, 3), "fe"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"ays",
"eys",
"iys",
"oys",
"uys"
}, (string s) => s.Remove(s.Length - 1, 1), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (suffixWord.EndsWith("ies", true, _culture))
{
return(string.Concat(str, suffixWord.Remove(suffixWord.Length - 3, 3), "y"));
}
if (_oSuffixPluralizationService.ExistsInSecond(suffixWord))
{
return(string.Concat(str, _oSuffixPluralizationService.GetFirstValue(suffixWord)));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"aos",
"eos",
"ios",
"oos",
"uos"
}, (string s) => suffixWord.Remove(suffixWord.Length - 1, 1), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"ces"
}, (string s) => s.Remove(s.Length - 1, 1), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"ces",
"ses",
"xes"
}, (string s) => s.Remove(s.Length - 2, 2), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (suffixWord.EndsWith("oes", true, _culture))
{
return(string.Concat(str, suffixWord.Remove(suffixWord.Length - 2, 2)));
}
if (suffixWord.EndsWith("ss", true, _culture))
{
return(string.Concat(str, suffixWord));
}
if (!suffixWord.EndsWith("s", true, _culture))
{
return(string.Concat(str, suffixWord));
}
return(string.Concat(str, suffixWord.Remove(suffixWord.Length - 1, 1)));
}
private string InternalPluralize(string word)
{
string str;
string str1;
if (_userDictionary.ExistsInFirst(word))
{
return(_userDictionary.GetSecondValue(word));
}
if (IsNoOpWord(word))
{
return(word);
}
string suffixWord = GetSuffixWord(word, out str);
if (IsNoOpWord(suffixWord))
{
return(string.Concat(str, suffixWord));
}
if (IsUninflective(suffixWord))
{
return(string.Concat(str, suffixWord));
}
if (_knownPluralWords.Contains(suffixWord.ToLowerInvariant()) || IsPlural(suffixWord))
{
return(string.Concat(str, suffixWord));
}
if (_irregularPluralsPluralizationService.ExistsInFirst(suffixWord))
{
return(string.Concat(str, _irregularPluralsPluralizationService.GetSecondValue(suffixWord)));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"man"
}, (string s) => string.Concat(s.Remove(s.Length - 2, 2), "en"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"louse",
"mouse"
}, (string s) => string.Concat(s.Remove(s.Length - 4, 4), "ice"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"tooth"
}, (string s) => string.Concat(s.Remove(s.Length - 4, 4), "eeth"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"goose"
}, (string s) => string.Concat(s.Remove(s.Length - 4, 4), "eese"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"foot"
}, (string s) => string.Concat(s.Remove(s.Length - 3, 3), "eet"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"zoon"
}, (string s) => string.Concat(s.Remove(s.Length - 3, 3), "oa"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"cis",
"sis",
"xis"
}, (string s) => string.Concat(s.Remove(s.Length - 2, 2), "es"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (_assimilatedClassicalInflectionPluralizationService.ExistsInFirst(suffixWord))
{
return(string.Concat(str, _assimilatedClassicalInflectionPluralizationService.GetSecondValue(suffixWord)));
}
if (_classicalInflectionPluralizationService.ExistsInFirst(suffixWord))
{
return(string.Concat(str, _classicalInflectionPluralizationService.GetSecondValue(suffixWord)));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"trix"
}, (string s) => string.Concat(s.Remove(s.Length - 1, 1), "ces"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"eau",
"ieu"
}, (string s) => string.Concat(s, "x"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (_wordsEndingWithInxAnxYnxPluralizationService.ExistsInFirst(suffixWord))
{
return(string.Concat(str, _wordsEndingWithInxAnxYnxPluralizationService.GetSecondValue(suffixWord)));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"ch",
"sh",
"ss"
}, (string s) => string.Concat(s, "es"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"alf",
"elf",
"olf",
"eaf",
"arf"
}, (string s) => {
if (s.EndsWith("deaf", true, _culture))
{
return(s);
}
return(string.Concat(s.Remove(s.Length - 1, 1), "ves"));
}, _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"nife",
"life",
"wife"
}, (string s) => string.Concat(s.Remove(s.Length - 2, 2), "ves"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"ay",
"ey",
"iy",
"oy",
"uy"
}, (string s) => string.Concat(s, "s"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (suffixWord.EndsWith("y", true, _culture))
{
return(string.Concat(str, suffixWord.Remove(suffixWord.Length - 1, 1), "ies"));
}
if (_oSuffixPluralizationService.ExistsInFirst(suffixWord))
{
return(string.Concat(str, _oSuffixPluralizationService.GetSecondValue(suffixWord)));
}
if (PluralizationServiceUtil.TryInflectOnSuffixInWord(suffixWord, new List <string>()
{
"ao",
"eo",
"io",
"oo",
"uo"
}, (string s) => string.Concat(s, "s"), _culture, out str1))
{
return(string.Concat(str, str1));
}
if (suffixWord.EndsWith("o", true, _culture) || suffixWord.EndsWith("s", true, _culture))
{
return(string.Concat(str, suffixWord, "es"));
}
if (suffixWord.EndsWith("x", true, _culture))
{
return(string.Concat(str, suffixWord, "es"));
}
return(string.Concat(str, suffixWord, "s"));
}
