/// <summary>Apply the <see cref="InputArguments.ContainsKey"/> argument.</summary>
/// <param name="values">The underlying values to modify.</param>
/// <param name="argValue">The argument value.</param>
private IInvariantSet ApplyContains(IEnumerable <string> values, IInputArgumentValue argValue)
{
// skip empty search
if (string.IsNullOrWhiteSpace(argValue.Raw))
{
return(InvariantSets.False);
}
// get search values
string[] search = argValue.Parsed;
if (this.NormalizeValue != null)
{
for (int i = 0; i < search.Length; i++)
{
search[i] = this.NormalizeValue(search[i]);
}
}
// get result
bool found = values is IInvariantSet set
? set.Overlaps(search)
: InvariantSets.From(search).Overlaps(values);
return(InvariantSets.FromValue(found));
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
public RandomValueProvider()
: base(ConditionType.Random, mayReturnMultipleValuesForRoot: false)
{
this.EnableInputArguments(required: true, mayReturnMultipleValues: false, maxPositionalArgs: null);
this.ValidNamedArguments = InvariantSets.FromValue("key");
this.BaseSeed = this.GenerateBaseSeed();
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
// get translation
string?key = input.GetFirstPositionalArg();
if (string.IsNullOrWhiteSpace(key))
{
return(InvariantSets.Empty);
}
Translation translation = this.TranslationHelper.Get(key);
// add tokens
if (input.HasNamedArgs)
{
translation = translation.Tokens(input
.NamedArgs
.ToDictionary(p => p.Key, p => this.Stringify(p.Value))
);
}
// add default value
if (input.NamedArgs.TryGetValue("default", out IInputArgumentValue? defaultValue))
{
translation = translation
.Default(this.Stringify(defaultValue))
.UsePlaceholder(false); // allow setting a blank default
}
return(InvariantSets.FromValue(translation));
}
/// <inheritdoc />
public override bool HasBoundedValues(IInputArguments input, [NotNullWhen(true)] out IInvariantSet?allowedValues)
{
if (this.TryParseAndRound(input, out decimal value, out _))
{
allowedValues = InvariantSets.FromValue(value.ToString(CultureInfo.InvariantCulture));
return(true);
}
/// <inheritdoc />
public override bool HasBoundedValues(IInputArguments input, [NotNullWhen(true)] out IInvariantSet?allowedValues)
{
allowedValues = !input.IsMutable
? InvariantSets.From(input.PositionalArgs)
: null;
return(allowedValues != null);
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="type">The condition type.</param>
/// <param name="values">Get the current values.</param>
/// <param name="isValidInContext">Get whether the value provider is applicable in the current context, or <c>null</c> if it's always applicable.</param>
/// <param name="mayReturnMultipleValues">Whether the root may contain multiple values.</param>
/// <param name="allowedValues">The allowed values (or <c>null</c> if any value is allowed).</param>
public ConditionTypeValueProvider(ConditionType type, Func <IEnumerable <string> > values, Func <bool>?isValidInContext = null, bool mayReturnMultipleValues = false, IEnumerable <string>?allowedValues = null)
: base(type, mayReturnMultipleValues)
{
this.IsValidInContextImpl = isValidInContext;
this.AllowedRootValues = allowedValues != null?InvariantSets.From(allowedValues) : null;
this.FetchValues = () => InvariantSets.From(values());
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
return(InvariantSets.FromValue(
this.GetPathExists(input.GetPositionalSegment())
));
}
/// <inheritdoc />
public override bool UpdateContext(IContext context)
{
return(this.IsChanged(this.Values, () =>
{
return this.Values = this.MarkReady(this.IsValidInContextImpl == null || this.IsValidInContextImpl())
? InvariantSets.From(this.FetchValues())
: InvariantSets.Empty;
}));
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="type">The condition type.</param>
/// <param name="values">Get the current values.</param>
/// <param name="saveReader">Handles reading info from the current save.</param>
/// <param name="mayReturnMultipleValues">Whether the root may contain multiple values.</param>
/// <param name="allowedValues">The allowed values (or <c>null</c> if any value is allowed).</param>
public PerPlayerValueProvider(ConditionType type, Func <Farmer, IEnumerable <string> > values, TokenSaveReader saveReader, bool mayReturnMultipleValues = false, IEnumerable <string>?allowedValues = null)
: base(type, mayReturnMultipleValues)
{
this.SaveReader = saveReader;
this.AllowedRootValues = allowedValues != null?InvariantSets.From(allowedValues) : null;
this.FetchValues = player => InvariantSets.From(values(player));
this.EnableInputArguments(required: false, mayReturnMultipleValues: mayReturnMultipleValues, maxPositionalArgs: null);
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
string?path = input.GetPositionalSegment();
return(!string.IsNullOrWhiteSpace(path)
? InvariantSets.FromValue(this.GetInternalAssetKey(path).Name)
: InvariantSets.Empty);
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
string?path = this.GetAbsolutePath(input.GetPositionalSegment());
return(path != null
? InvariantSets.FromValue(path)
: InvariantSets.Empty);
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
return(InvariantSets.From(
input.PositionalArgs
.Where(this.GetPathExists)
.Take(1)
));
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
if (!this.TryGetPart(input.PositionalArgs[0], input.PositionalArgs[1], out string?part, out string?error))
{
throw new InvalidOperationException(error); // shouldn't happen since we check the input in TryValidateInput
}
return(part != null
? InvariantSets.FromValue(part)
: InvariantSets.Empty);
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
var values = this
.GetContextsFor(input)
.Select(context => this.Values.TryGetValue(context, out Weather weather)
? weather.ToString()
: Weather.Sun.ToString() // the game treats an invalid context (e.g. MAX) as always sunny
);
return(InvariantSets.From(values));
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
string?output = this.Type switch
{
ConditionType.Lowercase => input.TokenString?.Value?.ToLowerInvariant(),
ConditionType.Uppercase => input.TokenString?.Value?.ToUpperInvariant(),
_ => throw new NotSupportedException($"Unimplemented letter case type '{this.Type}'.") // should never happen
};
return(InvariantSets.FromValue(output ?? string.Empty));
}
}
/// <inheritdoc />
public override bool UpdateContext(IContext context)
{
return(this.IsChanged(this.Values, () =>
{
IEnumerable <string>?raw = this.GetValueImpl();
this.Values = raw != null
? InvariantSets.From(raw)
: InvariantSets.Empty;
this.MarkReady(this.Values.Any());
return this.Values;
}));
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
// validate
this.AssertInput(input);
if (!input.HasPositionalArgs)
{
return(InvariantSets.Empty);
}
// get random number for input
string seedString = input.GetRawArgumentValue("key") ?? input.TokenString !.Path;
int randomNumber = new Random(unchecked (this.BaseSeed + this.GetDeterministicHashCode(seedString))).Next();
// choose value
return(InvariantSets.FromValue(input.PositionalArgs[randomNumber % input.PositionalArgs.Length]));
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
string?path = input.GetPositionalSegment();
if (!string.IsNullOrWhiteSpace(path))
{
path = PathUtilities.NormalizeAssetName(path);
if (input.NamedArgs.TryGetValue("separator", out IInputArgumentValue? separator))
{
path = path.Replace(PathUtilities.PreferredAssetSeparator.ToString(), separator.Parsed.FirstOrDefault());
}
return(InvariantSets.FromValue(path));
}
return(InvariantSets.Empty);
}
static void Main(string[] args)
{
// BishopMove o = new BishopMove();
// Console.WriteLine(o.howManyMoves(4,
//6,
//7,
//4
// ));
//BracketExpressions o = new BracketExpressions();
//Console.WriteLine(o.ifPossible(
// "([]X()[()]XX}[])X{{}}]"
// ));
InvariantSets o = new InvariantSets();
Console.WriteLine(o.countSets(new int[]
{ 1, 0, 0, 0 }
));
Console.ReadLine();
}
/// <summary>Apply the <see cref="InputArguments.ValueAtKey"/> argument.</summary>
/// <param name="values">The underlying values to modify.</param>
/// <param name="argValue">The argument value.</param>
private IInvariantSet ApplyValueAt(IEnumerable <string> values, IInputArgumentValue argValue)
{
// parse index
if (!int.TryParse(argValue.Raw, out int index))
{
throw new FormatException($"Invalid '{InputArguments.ValueAtKey}' index '{argValue.Raw}', must be a numeric index."); // should never happen since it's validated before this point
}
// get list
if (values is not IList <string> list)
{
list = values.ToArray();
}
// get value at index (negative index = from end)
if (Math.Abs(index) >= list.Count)
{
return(InvariantSets.Empty);
}
return(InvariantSets.FromValue(index >= 0
? list[index]
: list[list.Count + index]
));
}
/// <inheritdoc />
public virtual IInvariantSet GetValues(IInputArguments input)
{
// default logic
IEnumerable <string> values = this.Values.GetValues(input);
// apply global input arguments
if (input.ReservedArgs.Any())
{
foreach ((string name, IInputArgumentValue value) in input.ReservedArgsList)
{
if (InputArguments.ContainsKey.EqualsIgnoreCase(name))
{
values = this.ApplyContains(values, value);
}
else if (InputArguments.ValueAtKey.EqualsIgnoreCase(name))
{
values = this.ApplyValueAt(values, value);
}
}
}
return(InvariantSets.From(values));
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
return(InvariantSets.FromValue(input.PositionalArgs.Length));
}
/// <inheritdoc />
public override IEnumerable <string> GetValues(IInputArguments input)
{
this.AssertInput(input);
return(InvariantSets.FromValue(input.TokenString?.Value ?? string.Empty));
}
/// <inheritdoc />
public override bool HasBoundedValues(IInputArguments input, out IInvariantSet allowedValues)
{
allowedValues = InvariantSets.From(this.GetValues(input));
return(true);
}
/// <summary>Get an immutable token whose value never changes.</summary>
/// <param name="name">The token name.</param>
/// <param name="values">The token values.</param>
private IToken GetImmutableToken(string name, params string[] values)
{
IValueProvider valueProvider = new ImmutableValueProvider(name, InvariantSets.From(values));
return(new Token(valueProvider));
}
/// <inheritdoc />
public override bool HasBoundedValues(IInputArguments input, out IInvariantSet allowedValues)
{
allowedValues = InvariantSets.From(input.PositionalArgs);
return(true);
}
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
public FormatAssetNameValueProvider()
: base(ConditionType.FormatAssetName, mayReturnMultipleValuesForRoot: false)
{
this.EnableInputArguments(required: true, mayReturnMultipleValues: false, maxPositionalArgs: null);
this.ValidNamedArguments = InvariantSets.FromValue("separator");
}
