/// <summary>
/// Singularizes the provided input considering irregular words
/// </summary>
/// <param name="word">Word to be singularized</param>
/// <param name="plurality">Normally you call Singularize on plural words; but if you're unsure call it with Plurality.CouldBeEither</param>
/// <returns></returns>
public static string Singularize(this string word, Plurality plurality = Plurality.Plural)
{
if (plurality == Plurality.Singular)
{
return(word);
}
var result = ApplyRules(Singulars, word);
if (plurality == Plurality.Plural)
{
return(result);
}
// the Plurality is unknown so we should check all possibilities
var asPlural = ApplyRules(Plurals, word);
var asPluralAsSingular = ApplyRules(Singulars, asPlural);
if (asPlural != word && word + "s" != asPlural && asPluralAsSingular == word && result != word)
{
return(word);
}
return(result ?? word);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,EmployeeId,PositionId")] Plurality plurality)
{
if (id != plurality.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(plurality);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PluralityExists(plurality.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeId"] = new SelectList(_context.Employees, "Id", "View", plurality.EmployeeId);
ViewData["PositionId"] = new SelectList(_context.Positions, "Id", "View", plurality.PositionId);
return(View(plurality));
}
public ServiceOperationHelper(string itemType, Plurality plurality, ServiceOperation serviceOperation, string targetName, string itemIdentifier = "")
{
ItemType = itemType;
Plurality = plurality;
ServiceOperation = serviceOperation;
TargetName = targetName;
ServiceOperationResult = new ServiceOperationResult();
ItemIdentifier = itemIdentifier;
}
public static string LogServiceOperation(Type itemType, Plurality plurality, ServiceOperation serviceOperation, ServiceOperationStatus serviceOperationStatus, string targetName, string itemIdentifier = "", string exceptionMessage = "")
{
var logMessageType = serviceOperationStatus == ServiceOperationStatus.Failed ? LogMessageType.Error : LogMessageType.Verbose;
var exceptionMessageSuffix = serviceOperationStatus == ServiceOperationStatus.Failed ? $"Error message: {exceptionMessage}" : string.Empty;
var identifier = plurality == Plurality.Single ? $"{itemType.Name} \"{itemIdentifier}\"" : GetPluralIdentifier(itemType);
var logMessage = $"{GetActionString(serviceOperation, serviceOperationStatus)} {identifier} {GetPrepositionString(serviceOperation)} the {targetName}. {exceptionMessageSuffix}";
AppInfo.BaseAppInfo.Log.QueueLogMessageAsync(logMessage, logMessageType);
return(logMessage);
}
public ExtendedType(Type clrType, Plurality plurality)
{
if (clrType == null)
throw new ArgumentNullException("clrType");
this.clrType = clrType;
this.plurality = plurality;
this.viewType = new Lazy<Type>(this.InitializeViewType);
}
public PdxSublist GetHistoryCountryFile(Vic2World world)
{
var data = new PdxSublist(null);
data.AddValue("capital", Capital.ToString());
data.AddValue("primary_culture", PrimaryCulture);
AcceptedCultures.ForEach(c => data.AddValue("culture", c));
data.AddValue("religion", Religion);
data.AddValue("government", Government);
data.AddValue("plurality", Plurality.ToString());
if (NationalValues != null)
{
data.AddValue("nationalvalue", NationalValues.Value);
}
data.AddValue("literacy", Literacy.ToString());
data.AddValue("civilized", IsCivilised ? "yes" : "no");
data.AddValue("prestige", Prestige.ToString());
if (Reforms != null)
{
Reforms.AddData(data);
}
if (Technologies != null)
{
Technologies.ForEach(t => data.AddValue(t, "1"));
}
data.AddValue("consciousness", Consciousness.ToString());
// todo
data.AddValue("nonstate_consciousness", (Consciousness / 3).ToString());
if (RulingParty != null)
{
data.AddValue("ruling_party", RulingParty.Name);
}
data.AddDate("last_election", LastElection);
if (UpperHouse != null)
{
data.AddSublist("upper_house", UpperHouse.GetData(data));
}
if (TechSchools != null)
{
data.AddValue("schools", Enum.GetName(typeof(TechSchool), TechSchools.TechSchool));
}
if (FemaleLeaders && (Reforms.vote_franschise == vote_franschise.universal_voting || Reforms.vote_franschise == vote_franschise.universal_weighted_voting))
{
var entry = new PdxSublist();
entry.AddValue("decision", "enact_female_suffrage");
data.AddSublist(world.StartDate, entry);
}
return(data);
}
public async Task <IActionResult> Create([Bind("Id,EmployeeId,PositionId")] Plurality plurality)
{
if (ModelState.IsValid)
{
_context.Add(plurality);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["EmployeeId"] = new SelectList(_context.Employees, "Id", "View", plurality.EmployeeId);
ViewData["PositionId"] = new SelectList(_context.Positions, "Id", "View", plurality.PositionId);
return(View(plurality));
}
private void InitializePlurality(float num, out Plurality val)
{
if (num <= 0.4f)
{
val = Plurality.Zero;
}
else if (num <= 1.4f)
{
val = Plurality.Singular;
}
else
{
val = Plurality.Multiple;
}
}
public static void LogServiceOperation(string itemType, Plurality plurality, ServiceOperation serviceOperation, ServiceOperationStatus serviceOperationStatus, string targetName, ServiceOperationResult serviceOperationResult, string itemIdentifier = "", string exceptionMessage = "")
{
var logMessageType = serviceOperationStatus == ServiceOperationStatus.Failed ? LogMessageType.Error : LogMessageType.Verbose;
var exceptionMessageSuffix = serviceOperationStatus == ServiceOperationStatus.Failed ? $"Error message: {exceptionMessage}" : string.Empty;
var identifier = plurality == Plurality.Single ? $"{itemType} \"{itemIdentifier}\"" : GetPluralIdentifier(itemType);
var operationMessage = $"{GetActionString(serviceOperation, serviceOperationStatus)} {identifier} {GetPrepositionString(serviceOperation)} the {targetName}.";
var logMessage = $"{operationMessage} {exceptionMessageSuffix}";
serviceOperationResult.Status = serviceOperationStatus;
AppInfo.BaseAppInfo.Log.QueueLogMessageAsync(logMessage, logMessageType);
if (serviceOperationStatus == ServiceOperationStatus.Failed)
{
serviceOperationResult.ErrorMessage = logMessage;
serviceOperationResult.UserFriendlyErrorMessage = operationMessage;
}
}
SimpleTermDefinition GetTerm(PluralTermDefinition definition, Plurality plurality)
{
if (definition.Pluralities.ContainsKey(plurality))
{
return(definition.Pluralities[plurality]);
}
if (definition.Pluralities.ContainsKey(Plurality.One))
{
return(definition.Pluralities[Plurality.One]);
}
if (definition.Pluralities.ContainsKey(Plurality.Two))
{
return(definition.Pluralities[Plurality.Two]);
}
if (definition.Pluralities.ContainsKey(Plurality.Few))
{
return(definition.Pluralities[Plurality.Few]);
}
if (definition.Pluralities.ContainsKey(Plurality.Many))
{
return(definition.Pluralities[Plurality.Many]);
}
if (definition.Pluralities.ContainsKey(Plurality.Other))
{
return(definition.Pluralities[Plurality.Other]);
}
if (definition.Pluralities.ContainsKey(Plurality.Zero))
{
return(definition.Pluralities[Plurality.Zero]);
}
// really stuck :/
return(null);
}
/// <summary>
/// Pluralizes the provided input considering irregular words
/// </summary>
/// <param name="word">Word to be pluralized</param>
/// <param name="plurality">Normally you call Pluralize on singular words; but if you're unsure call it with Plurality.CouldBeEither</param>
/// <returns></returns>
public static string Pluralize(this string word, Plurality plurality = Plurality.Singular)
{
if (plurality == Plurality.Plural)
{
return(word);
}
var result = ApplyRules(Plurals, word);
if (plurality == Plurality.Singular)
{
return(result);
}
var asSingular = ApplyRules(Singulars, word);
var asSingularAsPlural = ApplyRules(Plurals, asSingular);
if (asSingular != null && asSingular != word && asSingular + "s" != word && asSingularAsPlural == word && result != word)
{
return(word);
}
return(result);
}
public string Pluralize(string word, Plurality plurality)
{
return plurality == Plurality.Plural ? word : Pluralize(word, inputIsKnownToBeSingular: false);
}
public string Singularize(string word, Plurality plurality)
{
return plurality == Plurality.Singular ? word : Singularize(word, inputIsKnownToBePlural: false);
}
/// <summary>
/// Singularizes the provided input considering irregular words
/// </summary>
/// <param name="word">Word to be singularized</param>
/// <param name="plurality">Normally you call Singularize on plural words; but if you're unsure call it with Plurality.CouldBeEither</param>
/// <returns></returns>
public static string Singularize(this string word, Plurality plurality = Plurality.Plural)
{
if (plurality == Plurality.Singular)
return word;
var result = ApplyRules(Singulars, word);
if (plurality == Plurality.Plural)
return result;
// the Plurality is unknown so we should check all possibilities
var asPlural = ApplyRules(Plurals, word);
var asPluralAsSingular = ApplyRules(Singulars, asPlural);
if (asPlural != word && word + "s" != asPlural && asPluralAsSingular == word && result != word)
return word;
return result ?? word;
}
public static string Singularize(this string word, Plurality plurality)
{
return(plurality == Plurality.Singular ? word : word.Singularize(inputIsKnownToBePlural: false));
}
/// <summary>
/// Pluralizes the provided input considering irregular words
/// </summary>
/// <param name="word">Word to be pluralized</param>
/// <param name="plurality">Normally you call Pluralize on singular words; but if you're unsure call it with Plurality.CouldBeEither</param>
/// <returns></returns>
public static string Pluralize(this string word, Plurality plurality = Plurality.Singular)
{
if (plurality == Plurality.Plural)
return word;
var result = ApplyRules(Plurals, word);
if (plurality == Plurality.Singular)
return result;
var asSingular = ApplyRules(Singulars, word);
var asSingularAsPlural = ApplyRules(Plurals, asSingular);
if (asSingular != null && asSingular != word && asSingular + "s" != word && asSingularAsPlural == word && result != word)
return word;
return result;
}
public string Localize(string key, Plurality plurality, CultureInfo startCulture, object tokens = null)
{
return(this.Localize(string.Join(".", key, plurality), startCulture, tokens));
}
public static string Pluralize(this string word, Plurality plurality)
{
return(plurality == Plurality.Plural ? word : word.Pluralize(inputIsKnownToBeSingular: false));
}
public static string Singularize(this string word, Plurality plurality)
{
return plurality == Plurality.Singular ? word : word.Singularize(inputIsKnownToBePlural: false);
}
public static string Pluralize(this string word, Plurality plurality)
{
return plurality == Plurality.Plural ? word : word.Pluralize(inputIsKnownToBeSingular: false);
}
private static Type CreateViewType(Type type, Plurality plurality)
{
return plurality != Plurality.Singular ? type.MakeArrayType() : type;
}
public string Singularize(string word, Plurality plurality)
{
return(plurality == Plurality.Singular ? word : Singularize(word, inputIsKnownToBePlural: false));
}
public string Pluralize(string word, Plurality plurality)
{
return(plurality == Plurality.Plural ? word : Pluralize(word, inputIsKnownToBeSingular: false));
}
