public static IEnumerable <SearchItem> Last(SearchExpressionContext c)
{
SearchExpressionValidator.ValidateExpressionArguments(c, new[]
{
new SearchExpressionValidator.Signature().AddArgument(SearchExpressionType.Iterable, true, false),
new SearchExpressionValidator.Signature().AddArgument(SearchExpressionType.Number).AddArgument(SearchExpressionType.Iterable, true, false)
});
var argIndex = 0;
var takeNumber = 1;
if (c.args[0].types.HasFlag(SearchExpressionType.Number))
{
++argIndex;
takeNumber = Math.Max((int)(c.args[0].GetNumberValue(takeNumber)), 0);
}
var queue = new Queue <SearchItem>(takeNumber);
return(c.ForEachArgument((context, e) =>
{
queue.Clear();
if (takeNumber == 0)
{
context.Break();
}
}, argIndex).AggregateResults(queue, (context, item, aggregator) =>
{
if (queue.Count == takeNumber)
{
queue.Dequeue();
}
queue.Enqueue(item);
}));
}
internal static SearchExpression NamedParser(SearchExpressionParserArgs args)
{
var text = ParserUtils.SimplifyExpression(args.text);
if (text.IsNullOrEmpty())
{
return(null);
}
var match = ParserUtils.namedExpressionStartRegex.Match(text.ToString());
if (!match.Success || match.Index != 0 || match.Groups["name"].Length == 0)
{
return(null);
}
var expressionsStartAndLength = ParserUtils.GetExpressionsStartAndLength(text, out _);
if (expressionsStartAndLength.Length != 1)
{
return(null);
}
var expressionName = match.Groups["name"].Value;
if ((expressionName.Length + expressionsStartAndLength[0].length) != text.length)
{
return(null);
}
var evaluator = EvaluatorManager.GetEvaluatorByNameDuringParsing(expressionName, text.Substring(0, expressionName.Length));
var parametersText = text.Substring(expressionName.Length, text.length - expressionName.Length);
var parametersPositions = ParserUtils.ExtractArguments(parametersText, expressionName);
var parameters = new List <SearchExpression>();
var argsWith = SearchExpressionParserFlags.None;
var argsWithout = SearchExpressionParserFlags.ImplicitLiterals;
ApplyEvaluatorHints(evaluator.hints, ref argsWith, ref argsWithout);
foreach (var paramText in parametersPositions)
{
parameters.Add(ParserManager.Parse(args.With(paramText, argsWith).Without(argsWithout)));
}
if (!evaluator.hints.HasFlag(SearchExpressionEvaluationHints.DoNotValidateSignature) &&
args.HasOption(SearchExpressionParserFlags.ValidateSignature))
{
var signatures = EvaluatorManager.GetSignaturesByName(expressionName);
if (signatures != null)
{
SearchExpressionValidator.ValidateExpressionArguments(evaluator, parameters.ToArray(), signatures, text);
}
}
var expressionText = ParserUtils.SimplifyExpression(expressionsStartAndLength[0].Substring(1, expressionsStartAndLength[0].length - 2));
return(new SearchExpression(SearchExpressionType.Function, args.text, expressionText, evaluator, parameters.ToArray()));
}
public static void AddSignature(string name, SearchExpressionValidator.Signature signature)
{
name = name.ToLowerInvariant();
string error = "";
if (!SearchExpressionValidator.ValidateSignature(name, signature, ref error))
{
Debug.LogError($"Invalid signature for {name}({signature}) : {error}");
return;
}
if (!evaluatorSignatures.TryGetValue(name.ToLowerInvariant(), out var signatures))
{
signatures = new List <SearchExpressionValidator.Signature>();
evaluatorSignatures.Add(name, signatures);
}
evaluatorSignatures[name].Add(signature);
}
