/// <summary>
/// Fills out this argument with the remainder of the provided command
/// line.
/// </summary>
/// <param name="restOfLine">Remainder of the command-line tokens.</param>
/// <returns>true on success; false otherwise.</returns>
public bool TrySetRestOfLine(IEnumerable <string> restOfLine)
{
Debug.Assert(restOfLine != null);
Debug.Assert(!SeenValue);
SeenValue = true;
if (Argument.IsCollection)
{
foreach (var arg in restOfLine)
{
CollectionValues.Add(arg);
}
}
else if (IsObjectPresent(DestinationObject))
{
var restOfLineAsList = restOfLine.ToList();
if (!TrySetValue(DestinationObject,
CreateCommandLine(restOfLineAsList),
string.Join(" ", restOfLineAsList)))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Parses the provided value string using this object's value type.
/// </summary>
/// <param name="setParseState">Current parse state for containing arg set.</param>
/// <param name="value">The string to parse.</param>
/// <param name="parsedValue">On success, receives the parsed value.
/// </param>
/// <returns>True on success; false otherwise.</returns>
public bool TryParseAndStore(ArgumentSetParser setParseState, string value, out object parsedValue)
{
// Check for disallowed duplicate arguments.
if (SeenValue && !Argument.AllowMultiple)
{
ReportDuplicateArgumentValue(value);
parsedValue = null;
return(false);
}
// Check for conflicting arguments that have already been specified.
bool conflictsDetected = false;
foreach (var arg in Argument.ConflictingArgs.Where(setParseState.HasSeenValueFor))
{
ReportConflictingArgument(value, arg);
conflictsDetected = true;
}
if (conflictsDetected)
{
parsedValue = null;
return(false);
}
// Note that we've now seen a value for this argument so we can
// catch disallowed duplicates later.
SeenValue = true;
// Parse the string version of the value.
if (!ParseValue(value, out object newValue))
{
parsedValue = null;
return(false);
}
if (!TryValidateValue(newValue, new ArgumentValidationContext(ParseContext.FileSystemReader)))
{
parsedValue = null;
return(false);
}
if (Argument.IsCollection)
{
var newValues = Argument.CollectionArgumentType.ToEnumerable(newValue).Cast <object>();
// Check for disallowed duplicate values in this argument. Note that the
// duplication could either be between existing values and the new values,
// or within the new value collection itself.
if (Argument.Unique)
{
var allValues = newValues.Concat(CollectionValues.Cast <object>()).ToList();
// TODO: Allow providing alternate notion of equality for uniqueness.
if (allValues.Count != allValues.Distinct().Count())
{
ReportDuplicateArgumentValue(value);
parsedValue = null;
return(false);
}
}
// Add the value to the collection.
foreach (var newValueItem in newValues)
{
CollectionValues.Add(newValueItem);
}
}
else if (IsObjectPresent(DestinationObject))
{
if (!TrySetValue(DestinationObject, newValue, value))
{
parsedValue = null;
return(false);
}
}
parsedValue = newValue;
return(true);
}
