public static IList <KeyValuePair <IFreeValueDefinition, FreeValue> > TransformFreeValues(
IList <KeyValuePair <IFreeValueDefinition, string> > rawFreeValues)
{
if (rawFreeValues == null)
{
return(Array.Empty <KeyValuePair <IFreeValueDefinition, FreeValue> >());
}
return(rawFreeValues.Select(fv =>
{
IFreeValueDefinition freeValueDefinition = fv.Key;
ValueTransformer transformer = freeValueDefinition.Transformer;
try
{
IList <object> transformed = transformer.Transform(fv.Value);
return new KeyValuePair <IFreeValueDefinition, FreeValue>(
freeValueDefinition,
new FreeValue(fv.Value, transformed));
}
catch (ArgParsingException)
{
throw;
}
catch
{
throw new ArgParsingException(
ArgsParsingErrorCode.TransformValueFailed,
fv.Value);
}
})
.ToArray());
}
public bool IsConflict(IFreeValueDefinition freeValueDefinition)
{
if (freeValueDefinition == null)
{
throw new ArgumentNullException(nameof(freeValueDefinition));
}
return(Name.Equals(freeValueDefinition.Name, StringComparison.OrdinalIgnoreCase));
}
public bool Equals(IFreeValueDefinition other)
{
if (other == null)
{
return(false);
}
return(Id == other.Id);
}
void CheckConflict(IFreeValueDefinition freeValue)
{
IFreeValueDefinition conflictFreeValueDefinition =
freeValues.FirstOrDefault(f => f.IsConflict(freeValue));
if (conflictFreeValueDefinition == null)
{
return;
}
throw new ArgumentException(
$"The free value definition '{freeValue}' conflicts with '{conflictFreeValueDefinition}'");
}
void ValidateRequiredFreeValues()
{
IFreeValueDefinition notPresentedRequiredFreeValue = command.GetRegisteredFreeValues()
.Where(fv => fv.IsRequired)
.FirstOrDefault(fv => !freeValues.Any(f => f.Key.Equals(fv)));
if (notPresentedRequiredFreeValue != null)
{
throw new ArgParsingException(
ArgsParsingErrorCode.RequiredFreeValueNotPresent,
$"<{notPresentedRequiredFreeValue.Name}>");
}
}
void CheckRequiredCompatibility(IFreeValueDefinition freeValue)
{
if (!freeValue.IsRequired)
{
return;
}
IFreeValueDefinition firstNonRequiredFreeValueDefinition =
freeValues.FirstOrDefault(fv => !fv.IsRequired);
if (firstNonRequiredFreeValueDefinition == null)
{
return;
}
throw new InvalidOperationException(
$"The definition for <{freeValue.Name}> is required nut a definition [{firstNonRequiredFreeValueDefinition.Name}] before it is not required.");
}
public bool IsConflict(IFreeValueDefinition freeValueDefinition)
{
// always return true to avoid registration.
return(true);
}
public void RegisterFreeValue(IFreeValueDefinition freeValue)
{
CheckConflict(freeValue);
CheckRequiredCompatibility(freeValue);
freeValues.Add(freeValue);
}
