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)); }