protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IExpressionNode) Password = (IExpressionNode) node; return base.OnChildNode(node); }
public override void SetUp () { base.SetUp(); _unresolvedLambda = ExpressionHelper.CreateLambdaExpression<int, bool> (i => i > 5); _currentNode = new TestMethodCallExpressionNode (CreateParseInfo (), null); _expressionResolver = new ExpressionResolver (_currentNode); }
private QueryModel ApplyAllNodes(IExpressionNode node, ClauseGenerationContext clauseGenerationContext) { QueryModel queryModel = null; if (node.Source != null) queryModel = ApplyAllNodes(node.Source, clauseGenerationContext); return node.Apply(queryModel, clauseGenerationContext); }
protected override void Deserialize(StringReader reader) { base.Deserialize(reader); Left = PExpressionUtility.DeserializeNode(reader); Right = PExpressionUtility.DeserializeNode(reader); }
protected virtual void Deserialize(StringReader reader) { Children = new IExpressionNode[int.Parse(reader.ReadLine())]; for (int i = 0; i < Children.Length; i++) Children[i] = PExpressionUtility.DeserializeNode(reader); }
public static SqlExpression Build(IExpressionNode node) { if (node is SqlVariableRefExpressionNode) return VisitVariableRefExpression((SqlVariableRefExpressionNode) node); if (node is SqlExpressionTupleNode) return VisitTupleExpression((SqlExpressionTupleNode) node); if (node is SqlQueryExpressionNode) return VisitQueryExpression((SqlQueryExpressionNode) node); if (node is SqlCaseExpressionNode) return VisitCaseExpression((SqlCaseExpressionNode) node); if (node is SqlConstantExpressionNode) return VisitConstantExpression((SqlConstantExpressionNode) node); if (node is SqlFunctionCallExpressionNode) return VisitFunctionCall((SqlFunctionCallExpressionNode) node); if (node is SqlReferenceExpressionNode) return VisitReferenceExpression((SqlReferenceExpressionNode) node); if (node is SqlBinaryExpressionNode) return VisitBinaryExpression((SqlBinaryExpressionNode) node); if (node is SqlUnaryExpressionNode) return VisitUnaryExpression((SqlUnaryExpressionNode) node); if (node is SqlBetweenExpressionNode) return VisitBetweenExpression((SqlBetweenExpressionNode) node); throw new NotSupportedException(); }
public MemberExpressionNode(IExpressionNode target, [NotNull] string member) : base(ExpressionNodeType.Member) { Should.NotBeNull(member, nameof(member)); _target = target; _member = member; }
public UnaryExressionNode([NotNull] IExpressionNode operand, TokenType token) : base(ExpressionNodeType.Unary) { Should.NotBeNull(operand, "operand"); _operand = operand; _token = token; }
protected MethodCallExpressionNodeBase (MethodCallExpressionParseInfo parseInfo) { if (parseInfo.AssociatedIdentifier == null) throw new ArgumentException ("Unitialized struct.", "parseInfo"); _associatedIdentifier = parseInfo.AssociatedIdentifier; _source = parseInfo.Source; _nodeResultType = parseInfo.ParsedExpression.Type; }
protected override void AcceptInternal(IExpressionVisitor visitor) { if (Target != null) _target = AcceptWithCheck(visitor, Target, false); for (int index = 0; index < _arguments.Count; index++) { _arguments[index] = AcceptWithCheck(visitor, _arguments[index], true); } }
/// <summary> /// Initializes a new instance of the <see cref="BinaryExpressionNode" /> class. /// </summary> public BinaryExpressionNode([NotNull] IExpressionNode left, [NotNull] IExpressionNode right, TokenType token) : base(ExpressionNodeType.Binary) { Should.NotBeNull(left, "left"); Should.NotBeNull(right, "right"); _left = left; _right = right; _token = token; }
public static void SerializeNode(IExpressionNode node, StringWriter writer) { if (node == null) writer.WriteLine((int)ExpressionTypes.Null); else { writer.WriteLine((int)node.Type); writer.WriteLine(JsonUtility.ToJson(node)); } }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "sql_expression_list") { GetGroupExpressions(node); } else if (node.NodeName == "having_clause_opt") { HavingExpression = node.ChildNodes.FirstOrDefault() as IExpressionNode; } return base.OnChildNode(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IdentifierNode) { ColumnName = ((IdentifierNode) node).Text; } else if (node is IExpressionNode) { Expression = (IExpressionNode) node; } return base.OnChildNode(node); }
public LambdaExpressionNode([NotNull] IExpressionNode expression, [CanBeNull] IEnumerable<string> parameters) : base(ExpressionNodeType.Lambda) { Should.NotBeNull(expression, "expression"); _expression = expression; _parameters = parameters == null ? Empty.Array<string>() : parameters.ToArray(); BindingExtensions.CheckDuplicateLambdaParameter(Parameters); }
public ArgumentData(IExpressionNode node, Expression expression, Type type, bool isTypeAccess) { Should.NotBeNull(node, "node"); _node = node; _expression = expression; if (type == null && expression != null) type = expression.Type; _type = type; _isTypeAccess = isTypeAccess; }
public static SelectManyExpressionNode CreateSelectMany (IExpressionNode source) { var p1 = Expression.Parameter (typeof (Cook), "s"); var p2 = Expression.Parameter (typeof (Kitchen), "sd"); var resultSelector = Expression.Lambda (Expression.Constant (null), p1, p2); var collectionSelector = Expression.Lambda (Expression.Constant (null), p1); var parseInfo = new MethodCallExpressionParseInfo ("trans", source, ExpressionHelper.CreateMethodCallExpression<Cook> ()); return new SelectManyExpressionNode (parseInfo, collectionSelector, resultSelector); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("label_opt")) { Label = node.FindNode<IdentifierNode>().Text; } else if (node.NodeName.Equals("when_opt")) { WhenExpression = node.FindNode<IExpressionNode>(); } return base.OnChildNode(node); }
public object GetContextInfo (IExpressionNode node) { ArgumentUtility.CheckNotNull ("node", node); object contextInfo; if (!_lookup.TryGetValue (node, out contextInfo)) throw new KeyNotFoundException ("Node has no associated context info."); return contextInfo; }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName.Equals("label_opt")) { Label = node.FindNode<StringLiteralNode>().Value; } else if (node.NodeName.Equals("when_opt")) { WhenExpression = node.FindNode<IExpressionNode>(); } return base.OnChildNode(node); }
public IExpressionNode Parse ( string associatedIdentifier, IExpressionNode source, IEnumerable<Expression> arguments, MethodCallExpression expressionToParse) { ArgumentUtility.CheckNotNull ("expressionToParse", expressionToParse); Type nodeType = GetNodeType (expressionToParse); var additionalConstructorParameters = arguments.Select (expr => ProcessArgumentExpression (expr)).ToArray(); var parseInfo = new MethodCallExpressionParseInfo (associatedIdentifier, source, expressionToParse); return CreateExpressionNode (nodeType, parseInfo, additionalConstructorParameters); }
/// <summary> /// Initializes a new instance of the <see cref="ConditionExpressionNode" /> class. /// </summary> public ConditionExpressionNode([NotNull] IExpressionNode condition, [NotNull] IExpressionNode ifTrue, [NotNull] IExpressionNode ifFalse) : base(ExpressionNodeType.Condition) { Should.NotBeNull(condition, "condition"); Should.NotBeNull(ifTrue, "ifTrue"); Should.NotBeNull(ifFalse, "ifFalse"); _condition = condition; _ifTrue = ifTrue; _ifFalse = ifFalse; }
public MethodCallExpressionParseInfo (string associatedIdentifier, IExpressionNode source, MethodCallExpression parsedExpression) : this() { ArgumentUtility.CheckNotNullOrEmpty ("associatedIdentifier", associatedIdentifier); ArgumentUtility.CheckNotNull ("source", source); ArgumentUtility.CheckNotNull ("parsedExpression", parsedExpression); AssociatedIdentifier = associatedIdentifier; Source = source; ParsedExpression = parsedExpression; }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node.NodeName == "sql_reference_expression") { Expression = (IExpressionNode) node; } else if (node.NodeName == "sql_expression") { Expression = (IExpressionNode) node; } else if (node.NodeName == "sort_order") { GetOrder(node); } return base.OnChildNode(node); }
public MethodCallExpressionNode(IExpressionNode target, [NotNull] string methodName, [CanBeNull] IList<IExpressionNode> args, [CanBeNull] IList<string> typeArgs) : base(ExpressionNodeType.MethodCall) { Should.NotBeNull(methodName, nameof(methodName)); _target = target; _method = methodName; _typeArgs = typeArgs == null ? Empty.Array<string>() : typeArgs.ToArrayEx(); _arguments = args == null ? Empty.Array<IExpressionNode>() : args.ToArrayEx(); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is IExpressionNode) { if (VariableReference == null) { VariableReference = (IExpressionNode) node; } else { ValueExpression = (IExpressionNode) node; } } return base.OnChildNode(node); }
/// <inheritdoc/> protected override ISqlNode OnChildNode(ISqlNode node) { if (node is SqlKeyNode && ((SqlKeyNode) node).Text == "WHEN") { whenFound = true; } else if (node is IExpressionNode) { if (whenFound) { WhenExpression = (IExpressionNode) node; } else { ThenExpression = (IExpressionNode) node; } } return base.OnChildNode(node); }
public void AddContextInfo (IExpressionNode node, object contextInfo) { ArgumentUtility.CheckNotNull ("node", node); ArgumentUtility.CheckNotNull ("contextInfo", contextInfo); try { _lookup.Add (node, contextInfo); } catch (ArgumentException) { throw new InvalidOperationException ("Node already has associated context info."); } }
public IExpressionNode Visit(IExpressionNode node) { var lambdaNode = node as ILambdaExpressionNode; if (lambdaNode != null && !_ignoreLambda) return VisitLambda(lambdaNode); var methodCall = node as IMethodCallExpressionNode; if (methodCall != null) return VisitMethodCall(methodCall); var relativeSource = node as IRelativeSourceExpressionNode; if (relativeSource != null) return VisitRelativeSource(relativeSource); return VisitExpression(node); }
protected override ISqlNode OnChildNode(ISqlNode node) { if (node is ObjectNameNode) { TableName = ((ObjectNameNode) node).Name; } else if (node.NodeName == "column_set_list") { Columns = node.FindNodes<UpdateColumnNode>(); } else if (node.NodeName == "update_where") { WhereExpression = node.FindNode<IExpressionNode>(); } else if (node.NodeName == "limit_opt") { var child = node.FindNode<IntegerLiteralNode>(); if (child != null) Limit = (int) child.Value; } return base.OnChildNode(node); }
protected MethodCallExpressionParseInfo CreateParseInfo(IExpressionNode source) { return(CreateParseInfo(source, "x")); }
public CompareInequalityBinOpNode(IExpressionNode lhs, IExpressionNode rhs) : base(lhs, rhs) { }
public ReturnNode(IExpressionNode rhs) { RHS = rhs; }
public void VisitUnknown(IExpressionNode node) { UnknownVisitor?.Visit(node); }
/// <summary> /// Gets the evaluation of an expression. /// </summary> /// <returns>The evaluation.</returns> /// <param name="expressions">Expressions.</param> private IProperty getEvaluation(IExpressionNode expression) { IProperty evaluatedType = expression.Accept(this).asProperty(); return(evaluatedType); }
/// <summary> /// Creates a new if command node /// </summary> /// <param name="expression">The condition expression</param> /// <param name="thenCommand">The then branch command</param> /// <param name="position">The position in the code where the content associated with the node begins</param> public IfCommandNode(IExpressionNode expression, ICommandNode thenCommand, Position position) { Expression = expression; ThenCommand = thenCommand; Position = position; }
public int GetCount([NotNull] IExpressionNode node) { _count = 0; node.Accept(this); return(_count); }
protected MethodCallExpressionParseInfo CreateParseInfo(IExpressionNode source, string associatedIdentifier) { return(new MethodCallExpressionParseInfo(associatedIdentifier, source, ExpressionHelper.CreateMethodCallExpression <Cook>())); }
public ExpressionResolver(IExpressionNode currentNode) { ArgumentUtility.CheckNotNull("currentNode", currentNode); CurrentNode = currentNode; }
public TextNode(IExpressionNode parent, string buff) : base(parent) { _buff.Append(buff); }
public UnaryExpression(IExpressionNode rhs, Func <double, double> operation) { _rhs = rhs; _operation = operation; }
public Equation(string id, IExpressionNode expression, VariableSource outputVariableSource) { OutputVariableSource = outputVariableSource; Id = id; Expression = expression; }
public BerLengthNode(IExpressionNode parent) : base(parent) { }
/// <summary> /// Dispatches the expression. /// </summary> /// <param name="node">The expression to visit.</param> /// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns> IExpressionNode IExpressionVisitor.Visit(IExpressionNode node) { _count++; return(node); }
public GoNode(IExpressionNode expression) { this.expression = expression; }
public void SetUp() { _source = ExpressionNodeObjectMother.CreateMainSource(); _parseInfo = new MethodCallExpressionParseInfo("foo", _source, ExpressionHelper.CreateMethodCallExpression <Cook>()); }
private IExpressionNode makeComparison(IExpressionNode leftSide, string operatorSymbol, IExpressionNode rightSide, double tolerance) { IExpressionNode result = new Constant(double.NaN); switch (operatorSymbol) { case "=": result = new Equality(leftSide, rightSide, tolerance); break; case "<>": case "≠": result = new Inequality(leftSide, rightSide, tolerance); break; case "<": result = new LessThen(leftSide, rightSide, tolerance, true); break; case "<=": case "≤": result = new LessThen(leftSide, rightSide, tolerance, false); break; case ">": result = new GreaterThen(leftSide, rightSide, tolerance, true); break; case ">=": case "≥": result = new GreaterThen(leftSide, rightSide, tolerance, false); break; } return(result.Simplified()); }
protected override void AcceptInternal(IExpressionVisitor visitor) { _operand = AcceptWithCheck(visitor, Operand, true); }
private void InsertCastNode(IExpressionNode binaryNode, int child) { CastFromIntegerExpression cast = new CastFromIntegerExpression(binaryNode.Children[child], 0, 0); binaryNode.Children[child] = cast; }
protected override void AcceptInternal(IExpressionVisitor visitor) { _condition = AcceptWithCheck(visitor, Condition, true); _ifTrue = AcceptWithCheck(visitor, IfTrue, true); _ifFalse = AcceptWithCheck(visitor, IfFalse, true); }
public virtual void visit(IExpressionNode value) { }
public IfNode(IStatementNode statement, IExpressionNode expression, IStatementNode thenNode) : this(statement, expression, thenNode, null) { }
public VariableNode(IExpressionNode parent, Func <string, string> resolver) : base(parent) { _resolver = resolver; }
public IfNode(IExpressionNode expression, IStatementNode block) : this(null, expression, block) { }
public VarNode(string name, TypeInfo typeinfo, IExpressionNode expression) : base(name, typeinfo, expression) { }
public void LinkExpressionToLocalBuilder(IExpressionNode expr, LocalBuilder lb) { memoized_exprs[expr] = lb; }
public LocalBuilder GetLocalBuilderForExpression(IExpressionNode expr) { return(memoized_exprs[expr] as LocalBuilder); }
public AddExpression(IExpressionNode leftExpression, IExpressionNode rightExpression) { _leftExpression = leftExpression; _rightExpression = rightExpression; }
public TextNode(IExpressionNode parent) : base(parent) { }
internal static Exception UnexpectedExpressionNode(IExpressionNode node) { return(new InvalidOperationException($"Unexpected expression node type: '{node.NodeType}', node: '{node}'")); }