private static ComparisonExpression ParseComparison(ExpressionReader reader, BooleanOperator booleanOperator)
{
var left = ParseValue(reader);
reader.SkipWhitespace();
var comparisonOperator = ParseOperator(reader);
reader.SkipWhitespace();
var right = ParseValue(reader);
return(new ComparisonExpression(left, right, comparisonOperator, booleanOperator));
}
private static string ParseDictionaryKey(ExpressionReader reader)
{
reader.Read(); //Skip {
var key = new StringBuilder();
while (reader.Peek() != -1 && reader.PeekChar() != '}')
{
key.Append(reader.ReadChar());
}
if (key.Length == 0)
{
throw reader.UnexpectedCharacterException();
}
if (reader.Read() != '}')
{
throw reader.UnexpectedCharacterException();
}
reader.SkipWhitespace();
return(key.ToString());
}
private static IReadOnlyCollection <IBooleanExpression> ParseGroup(ExpressionReader reader)
{
reader.Read(); //Skip (
reader.SkipWhitespace();
var result = ParseBooleanExpressions(reader, BooleanOperator.And).ToArray();
reader.SkipWhitespace();
var c = reader.ReadChar();
if (c != ')')
{
throw reader.UnexpectedCharacterException();
}
return(result);
}
public static VariableExpression ParseVariable(ExpressionReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (reader.ReadChar() != '$')
{
throw reader.UnexpectedCharacterException();
}
if (reader.ReadChar() != '(')
{
throw reader.UnexpectedCharacterException();
}
reader.SkipWhitespace();
var name = ParseVariableName(reader);
reader.SkipWhitespace();
VariableExpression variable;
if (reader.PeekChar() == '{')
{
var dictionaryKey = ParseDictionaryKey(reader);
var defaultValue = ParseDefaultValue(reader);
variable = new DictionaryVariableExpression(name, dictionaryKey, defaultValue);
}
else
{
var defaultValue = ParseDefaultValue(reader);
variable = new SimpleVariableExpression(name, defaultValue);
}
if (reader.ReadChar() != ')')
{
throw reader.UnexpectedCharacterException();
}
return(variable);
}
private static IEnumerable <IBooleanExpression> ParseBooleanExpressions(
ExpressionReader reader, BooleanOperator booleanOperator)
{
reader.SkipWhitespace();
yield return(ParseExpressionPart(reader, booleanOperator));
reader.SkipWhitespace();
if (reader.Peek() == -1)
{
yield break;
}
while (reader.Peek() != -1)
{
switch (reader.PeekChar())
{
case '|':
case '&':
var @operator = ParseBooleanOperator(reader);
reader.SkipWhitespace();
yield return(ParseExpressionPart(reader, @operator));
reader.SkipWhitespace();
break;
case ')':
yield break;
default:
throw reader.UnexpectedCharacterException();
}
}
if (reader.Peek() != -1)
{
throw reader.UnexpectedCharacterException();
}
}
private static IBooleanExpression ParseExpressionPart(ExpressionReader reader, BooleanOperator booleanOperator)
{
reader.SkipWhitespace();
if (reader.PeekChar() != '(')
{
return(ParseComparison(reader, booleanOperator));
}
var expressions = ParseGroup(reader);
if (expressions.Count == 1)
{
return(EnsureOperator(expressions.Single(), booleanOperator));
}
return(new GroupExpression(expressions, booleanOperator));
}
