public virtual bool Equals(TokenValue other)
{
if (other == null)
{
return(false);
}
if (object.ReferenceEquals(this, other))
{
return(true);
}
if (!object.Equals(this.Syntax, other.Syntax))
{
return(false);
}
if (!object.Equals(this.Token, other.Token))
{
return(false);
}
if (!string.Equals(this.Value, other.Value, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (!Enumerable.SequenceEqual(this.Children, other.Children))
{
return(false);
}
return(true);
}
protected virtual bool TryParse(StringReader reader, Syntax syntax, Token token, out TokenValue result)
{
if (token.IsEmpty)
{
result = new TokenValue(syntax, token, string.Empty);
return(true);
}
if (token.Flags.HasFlag(TokenFlags.Literal))
{
return(this.TryParseLiteral(reader, syntax, token, out result));
}
if (token.Flags.HasFlag(TokenFlags.Identifier))
{
return(this.TryParseIdentifier(reader, syntax, token, out result));
}
if (token.Flags.HasFlag(TokenFlags.Boolean))
{
return(this.TryParseBoolean(reader, syntax, token, out result));
}
if (token.Flags.HasFlag(TokenFlags.Number))
{
return(this.TryParseNumber(reader, syntax, token, out result));
}
if (token.Flags.HasFlag(TokenFlags.String))
{
return(this.TryParseString(reader, syntax, token, out result));
}
throw new NotImplementedException();
}
protected virtual bool TryParseIdentifier(StringReader reader, Syntax syntax, Token token, out TokenValue result)
{
reader.Begin();
reader.Align();
var builder = new StringBuilder();
while (!reader.EOF)
{
if (!char.IsLetter(reader.Peek()))
{
break;
}
builder.Append(reader.Read());
while (!reader.EOF)
{
if (!char.IsLetterOrDigit(reader.Peek()))
{
break;
}
builder.Append(reader.Read());
}
reader.Complete();
result = new TokenValue(syntax, token, builder.ToString());
return(true);
}
reader.Rollback();
result = default(TokenValue);
return(false);
}
public static TokenValue ForChannel(this TokenValue value, TokenChannel channel)
{
if (value.Token != null)
{
if (value.Token.Channel == channel)
{
return(value);
}
else
{
return(null);
}
}
else if (value.Children != null)
{
return(new TokenValue(
value.Syntax,
value.Children
.Select(child => child.ForChannel(channel))
.Where(child => child != null)
.ToArray()
));
}
throw new NotImplementedException();
}
public static CallExpression Call(TokenValue value)
{
var args = Expressions(value.Children);
var name = Ensure <LiteralExpression>(args.OfType <LiteralExpression>().FirstOrDefault());
var arguments = args.Except(new[] { name });
return(new CallExpression(name, arguments));
}
public static ConditionExpression Condition(TokenValue value)
{
var args = Expressions(value.Children);
var identifier = args.OfType <IdentifierExpression>().FirstOrDefault();
var expressions = args.OfType <BinaryExpression>();
Validate(value, args, new Expression[] { identifier }.Concat(expressions));
return(new ConditionExpression(identifier, expressions));
}
public static IssueExpression Issue(TokenValue value)
{
var args = Expressions(value.Children);
var issuance = Ensure <LiteralExpression>(args.OfType <LiteralExpression>().FirstOrDefault());
var expressions = args.OfType <BinaryExpression>();
Validate(value, args, new Expression[] { issuance }.Concat(expressions));
return(new IssueExpression(issuance, expressions));
}
public static RuleExpression Rule(TokenValue value)
{
var args = Expressions(value.Children);
var conditions = args.OfType <ConditionExpression>();
var issue = Ensure <IssueExpression>(args.OfType <IssueExpression>().FirstOrDefault());
Validate(value, args, new Expression[] { issue }.Concat(conditions));
return(new RuleExpression(conditions, issue));
}
public virtual bool TryParse(StringReader reader, Syntax syntax, out TokenValue result)
{
if (syntax.Flags.HasFlag(SyntaxFlags.Repeat))
{
return(this.TryParseMultiple(reader, syntax, out result));
}
else
{
return(this.TryParseSingle(reader, syntax, out result));
}
}
public static ConditionPropertyExpression ConditionProperty(TokenValue value)
{
var args = Expressions(value.Children);
var identifier = Ensure <IdentifierExpression>(args.OfType <IdentifierExpression>().FirstOrDefault());
var property = Ensure <ClaimPropertyExpression>(args.OfType <ClaimPropertyExpression>().FirstOrDefault());
Validate(value, args, identifier, property);
return(new ConditionPropertyExpression(
identifier,
property
));
}
public static IEnumerable <TokenValue> Find(this TokenValue value, IEnumerable <Syntax> syntax)
{
if (syntax.Contains(value.Syntax))
{
return(new[] { value });
}
else if (value.Children != null)
{
return(value.Children
.SelectMany(child => child.Find(syntax))
.Where(child => child != null)
.ToArray());
}
return(Enumerable.Empty <TokenValue>());
}
private static void Validate(TokenValue value, IEnumerable <Expression> expected, IEnumerable <Expression> actual)
{
foreach (var expression in expected)
{
if (!actual.Contains(expression))
{
throw new ExpressionFactoryException(
string.Format(
"Expression of type \"{0}\" was not handled: {1}",
expression.GetType().Name,
expression.ToString()
)
);
}
}
}
public static AggregateConditionExpression AggregateCondition(TokenValue value)
{
var args = Expressions(value.Children);
var identifier = args.OfType <IdentifierExpression>().FirstOrDefault();
var literals = args.OfType <LiteralExpression>().ToArray();
var expressions = args.OfType <BinaryExpression>();
Validate(value, args, new Expression[] { identifier }.Concat(literals).Concat(expressions));
switch (literals.Length)
{
case 1:
return(new AggregateConditionExpression(identifier, literals[0], expressions));
case 3:
return(new AggregateConditionExpression(identifier, literals[0], expressions, literals[1], literals[2]));
}
throw new ExpressionFactoryException(string.Format("Failed to create aggregate condition expression: Expected 1 or 3 literals but found {0}.", literals.Length));
}
public static BinaryExpression Binary(TokenValue value)
{
var result = default(BinaryExpression);
var args = new Queue <Expression>(Expressions(value.Children));
while (args.Count > 0)
{
if (result == null)
{
if (args.Count >= 3)
{
result = new BinaryExpression(
args.Dequeue(),
Ensure <LiteralExpression>(args.Dequeue()),
args.Dequeue()
);
}
else
{
throw new ExpressionFactoryException(string.Format("Failed to create binary expression: Expected 3 expressions but found {0}.", args.Count));
}
}
else
{
if (args.Count >= 2)
{
result = new BinaryExpression(
result.Left,
result.Operator,
new BinaryExpression(
result.Right,
Ensure <LiteralExpression>(args.Dequeue()),
args.Dequeue()
)
);
}
else
{
throw new ExpressionFactoryException(string.Format("Failed to combine binary expression: Expected 2 expressions but found {0}.", args.Count));
}
}
}
return(result);
}
protected virtual bool TryParseNumber(StringReader reader, Syntax syntax, Token token, out TokenValue result)
{
reader.Begin();
reader.Align();
if (char.IsNumber(reader.Peek()))
{
var builder = new StringBuilder();
do
{
builder.Append(reader.Read());
} while (char.IsNumber(reader.Peek()));
reader.Complete();
result = new TokenValue(syntax, token, builder.ToString());
return(true);
}
reader.Rollback();
result = default(TokenValue);
return(false);
}
protected virtual bool TryParseSingle(StringReader reader, Syntax syntax, out TokenValue result)
{
if (syntax.Token != null)
{
return(this.TryParse(reader, syntax, syntax.Token, out result));
}
else if (syntax.Children != null)
{
if (syntax.Flags.HasFlag(SyntaxFlags.Any))
{
return(this.TryParseAny(reader, syntax, syntax.Children, out result));
}
if (syntax.Flags.HasFlag(SyntaxFlags.All))
{
return(this.TryParseAll(reader, syntax, syntax.Children, out result));
}
}
throw new NotImplementedException();
}
protected virtual bool TryParseLiteral(StringReader reader, Syntax syntax, Token token, out TokenValue result)
{
reader.Begin();
reader.Align();
var builder = new StringBuilder();
while (!reader.EOF)
{
builder.Append(reader.Read());
if (string.Equals(builder.ToString(), token.Value, StringComparison.OrdinalIgnoreCase))
{
reader.Complete();
result = new TokenValue(syntax, token, token.Value);
return(true);
}
}
reader.Rollback();
result = default(TokenValue);
return(false);
}
protected virtual bool TryParseAll(StringReader reader, Syntax syntax, IEnumerable <Syntax> children, out TokenValue result)
{
reader.Begin();
reader.Align();
var values = new List <TokenValue>();
foreach (var child in children)
{
if (this.TryParse(reader, child, out result))
{
values.Add(result);
}
else
{
reader.Rollback();
result = default(TokenValue);
return(false);
}
}
reader.Complete();
result = new TokenValue(syntax, values);
return(true);
}
protected virtual bool TryParseMultiple(StringReader reader, Syntax syntax, out TokenValue result)
{
var values = new List <TokenValue>();
while (this.TryParseSingle(reader, syntax, out result))
{
values.Add(result);
}
switch (values.Count)
{
case 0:
result = default(TokenValue);
return(false);
case 1:
result = values[0];
return(true);
default:
result = new TokenValue(syntax, values);
return(true);
}
}
protected virtual bool TryParseString(StringReader reader, Syntax syntax, Token token, out TokenValue result)
{
reader.Begin();
reader.Align();
if (reader.Read() == '"')
{
var builder = new StringBuilder();
while (!reader.EOF)
{
var character = reader.Read();
if (character == '"')
{
reader.Complete();
result = new TokenValue(syntax, token, builder.ToString());
return(true);
}
builder.Append(character);
}
}
reader.Rollback();
result = default(TokenValue);
return(false);
}
protected virtual bool TryParseAny(StringReader reader, Syntax syntax, IEnumerable <Syntax> children, out TokenValue result)
{
foreach (var child in children)
{
if (this.TryParse(reader, child, out result))
{
return(true);
}
}
result = default(TokenValue);
return(false);
}
public static IdentifierExpression Identifier(TokenValue value)
{
return(new IdentifierExpression(value.Value));
}
protected virtual bool TryParseBoolean(StringReader reader, Syntax syntax, Token token, out TokenValue result)
{
//TODO: Implement me.
result = default(TokenValue);
return(false);
}
public static LiteralExpression Literal(TokenValue value)
{
return(new LiteralExpression(value.Value));
}
private static void Validate(TokenValue value, IEnumerable <Expression> expected, params Expression[] actual)
{
Validate(value, expected, actual.AsEnumerable());
}
public void Add(TokenValue value)
{
this.Children = this.Children.Concat(
new[] { value }
).ToArray();
}
public static IEnumerable <TokenValue> Find(this TokenValue value, params Syntax[] syntax)
{
return(value.Find(syntax.AsEnumerable()));
}
public static ClaimPropertyExpression ClaimProperty(TokenValue value)
{
return(new ClaimPropertyExpression(value.Value));
}
