public SearchExpression(IToken startToken, string expressionString, ISearchExpressionContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_tokens = new List <IToken> {
startToken
};
_isValid = true;
_asString = AsString();
Parse(expressionString, _context);
}
public virtual IArgumentToken Parse(string expressionString, ISearchExpressionContext items)
{
var isArgumentValid = GetArgumentValue(expressionString, items, out var argumentValue);
var argumentToken = (ArgumentToken)GetInstance(GetType());
argumentToken._isValid = isArgumentValid && ValidateAttributeValue(argumentValue);
argumentToken._id = argumentValue.Id;
argumentToken._data = argumentValue.Data;
argumentToken._value = argumentValue.DisplayValue;
argumentToken.UpdateTokenContext(argumentToken._context);
return(argumentToken);
}
private int GetPresetArgumentLength(string expressionString, ISearchExpressionContext context, out IPresetItem validItem)
{
var presetItems = GetPresetItems(context);
var presetArgumentLength = -1;
validItem = null;
foreach (var item in presetItems)
{
var itemValue = context.IsInvariantCulture ? item.Id : item.DisplayValue;
if (itemValue == null)
{
continue;
}
if (expressionString.StartsWith(itemValue, StringComparison.InvariantCultureIgnoreCase) && itemValue.Length > presetArgumentLength)
{
if (expressionString.Length == itemValue.Length)
{
presetArgumentLength = itemValue.Length;
validItem = item;
}
else
{
foreach (var validTail in ValidNexts.OfType <IKeywordToken>())
{
var keywordAlias = context.IsInvariantCulture
? validTail.SerializationAlias
: validTail.Alias;
var validTailIndex = expressionString.IndexOf(keywordAlias, itemValue.Length, StringComparison.InvariantCultureIgnoreCase);
if (validTailIndex == itemValue.Length)
{
presetArgumentLength = itemValue.Length;
validItem = item;
break;
}
}
if (presetArgumentLength == -1)
{
presetArgumentLength = itemValue.Length;
validItem = item;
}
}
}
}
return(presetArgumentLength);
}
protected virtual bool GetArgumentValue(string expressionString, ISearchExpressionContext context, out IPresetItem value)
{
IPresetItem validItem;
var presetArgumentLength = GetPresetArgumentLength(expressionString, context, out validItem);
if (presetArgumentLength > 0)
{
value = validItem;
return(true);
}
value = new PresetItem(null, expressionString.Substring(0, GetArgumentLegth(expressionString, AllowCustomValues)));
return(AllowCustomValues);
}
private void Parse(string expressionString, ISearchExpressionContext searchExpressionContext)
{
if (string.IsNullOrWhiteSpace(expressionString))
{
return;
}
while (!string.IsNullOrEmpty(expressionString))
{
var prevExpressionString = expressionString;
if (TryParseAsKeyword(ref expressionString, this))
{
continue;
}
if (TryParseAsArgument(ref expressionString, this, searchExpressionContext))
{
continue;
}
if (prevExpressionString == expressionString)
{
var unexpectedString = expressionString.Substring(0, 1);
expressionString = expressionString.Remove(0, 1);
var unexpectedToken = LastToken as UnexpectedToken;
if (unexpectedToken != null)
{
var newValue = unexpectedToken.Value + unexpectedString;
unexpectedToken.SetValue(new PresetItem(newValue, newValue));
}
else
{
unexpectedToken = new UnexpectedToken();
unexpectedToken.SetValue(new PresetItem(unexpectedString, unexpectedString));
AddToken(unexpectedToken);
}
_isValid = false;
}
_isValid = false;
}
_asString = AsString();
}
public ISearchExpression Parse(string expressionString, ISearchExpressionContext items)
{
return(new SearchExpression(new NextTaskWhitespaceToken(), expressionString, items));
}
public IEnumerable <IPresetItem> GetPresetItems(ISearchExpressionContext context)
{
return(context != null
? context.GetPresetItems(this)
: new List <IPresetItem>());
}
private static int GetValueLength(ISearchExpressionContext items, IArgumentToken token)
{
return(items.IsInvariantCulture && token.Id != null
? token.Id.Length
: token.Value.Length);
}
private static bool TryParseAsArgument(ref string expressionString, SearchExpression expression, ISearchExpressionContext items)
{
var nextArgumentTokens = expression.GetValidNexts().OfType <IArgumentToken>().OrderBy(x => !x.GetPresetItems(items).Any()).ToList();
var validCases = new List <IArgumentToken>();
for (var index = 0; index < nextArgumentTokens.Count; index++)
{
var isLastToken = index == nextArgumentTokens.Count - 1;
var token = nextArgumentTokens[index];
var newArgumentToken = token.Parse(expressionString, items);
if (!newArgumentToken.IsValid && !isLastToken)
{
continue;
}
if (newArgumentToken.IsValid || !validCases.Any())
{
validCases.Add(newArgumentToken);
}
}
if (!validCases.Any())
{
return(false);
}
validCases = validCases.OrderBy(x => GetValueLength(items, x)).ToList();
var bestCaseToken = validCases.Last();
var valueLength = GetValueLength(items, bestCaseToken);
expressionString = expressionString.Remove(0, valueLength);
expression.AddToken(bestCaseToken);
return(bestCaseToken.IsValid);
}
public override IArgumentToken Parse(string expressionString, ISearchExpressionContext items)
{
var argumentToken = (SearchPhraseToken)base.Parse(expressionString, items);
return(argumentToken);
}
