public virtual AstNode VisitConditional(ConditionalNode n) { Visit(n.Condition); Visit(n.IfTrue); Visit(n.IfFalse); return(n); }
public void Transform(ConditionalNode item) { StripWhiteSpace(); foreach (var child in item.Children) { child.Transform(this); } }
public void Transform(ConditionalNode item) { TrimNewLine = true; foreach (var child in item.Children) { child.Transform(this); } }
public void Visit(ConditionalNode node) { if (!AnalyseExpression(node.Expression)) { this._isValid = false; } VisitChildren(node); }
//TODO use NodeType to categorize Types. public static BaseNode CreateNode(ActionNodeData aData) { if (aData.NodeType == null) { Debug.LogError("Type not set"); return(null); } aData.GUID = string.IsNullOrEmpty(aData.GUID) ? Guid.NewGuid().ToString() : aData.GUID; aData.OutputPortIDs = aData.OutputPortIDs ?? new List <string>(); //The copy prevent the node to modify the list in the ActionNodeData List <string> copy = new List <string>(); foreach (var outputPort in aData.OutputPortIDs) { copy.Add(outputPort); } BaseNode node; Type type = Type.GetType(aData.NodeType); if (type == typeof(ChangeSceneNode)) { node = ChangeSceneNode.Create("Change Scene", aData.Position, aData.GUID, copy); } else if (type == typeof(StartNode)) { node = StartNode.Create("Start Node", aData.Position, aData.GUID, copy); } else if (type == typeof(ConditionalNode)) { node = ConditionalNode.Create("Conditional", aData.Position, aData.GUID, copy); } else if (type == typeof(MultiNode)) { node = MultiNode.Create("Multi Output", aData.Position, aData.GUID, copy); } else if (type == typeof(ExitNode)) { node = ExitNode.Create("Exit Node", aData.Position, aData.GUID, copy); } else if (type == typeof(RandomNode)) { node = RandomNode.Create("Random Node", aData.Position, aData.GUID, copy); } else if (type == typeof(TakeObjectNode)) { node = TakeObjectNode.Create("Take Object", aData.Position, aData.GUID, copy); } else { throw new NotImplementedException($"Node type {type} not handled in NodeFactory"); } node?.SetSerializedScript(aData.SerializedScript); return(node); }
public AstNode VisitConditional(ConditionalNode n) { Visit(n.Condition); Append(" ? "); Visit(n.IfTrue); Append(" : "); Visit(n.IfFalse); return(n); }
public void Visit(ConditionalNode conditional) { conditional.Condition.Parent = conditional; conditional.Left.Parent = conditional; conditional.Right.Parent = conditional; conditional.Condition.Accept(this); conditional.Left.Accept(this); conditional.Right.Accept(this); }
/// <summary> /// Like an action node... but the function can return true/false and is mapped to success/failure. /// </summary> public BehaviorTreeBuilder If(Func <GameTime, bool> fn) { var conditionalNode = new ConditionalNode(rootNode, fn); parentNodeStack.Peek().AddChild(conditionalNode); parentNodeStack.Push(conditionalNode); return(this); }
override public Node Visit(ConditionalNode node) { if (_conditionalNodeExpectations.Count > 0) { _conditionalNodeExpectations.Dequeue().Invoke(node); } return(VisitChildren(node)); }
/// <summary> /// Transorms ConditionalNode into a boolean Expression /// </summary> /// <param name="conditionalNode">Node to parse</param> /// <returns>Boolean Expression</returns> public ExpressionBool GetCondition(ConditionalNode conditionalNode) { ExpressionValue expression = ParseExpressionNode(conditionalNode.Expression); if (expression.Type != typeof(bool)) { throw new InvalidOperationException(string.Format("Cannot use expression with type of {0} as a condition.", expression.Type)); } return(expression as ExpressionBool); }
public override Node VisitConditional(ConditionalContext context) { var conditional = new ConditionalNode(context.Start); conditional.AddChild(Visit(context.expression())); conditional.AddChild(Visit(context.ifBlock())); conditional.AddChild(Visit(context.elseBlock())); return(conditional); }
public override ASTN VisitIf([NotNull] IfContext context) { ConditionalNode node = new ConditionalNode(context) { If = VisitExpr(context.cond) as ExprNode, Then = VisitExpr(context.result) as ExprNode, Else = VisitExpr(context.@else) as ExprNode }; return(node); }
public override QLType Visit(ConditionalNode node) { foreach (Node child in node.ChildNodes) { QLType childType = child.Accept(this); if (childType != QLType.Boolean && childType != QLType.Undefined) { TypeErrors.Add(new ConditionalType(childType.ToString(), node.Token.Line)); } } return(QLType.Boolean); }
public void Visit(ConditionalNode node) { node.If.Accept(this); node.Then.Accept(this); node.Else.Accept(this); if (node.If.staticType.Text != "Bool") { errors.Add(ErrorSemantic.CannotConvert(node.If, node.If.staticType, scope.GetType("Bool"))); } node.staticType = SemanticAlgorithm.LowerCommonAncestor(node.Then.staticType, node.Else.staticType); }
/// <summary> /// Transorms ConditionalNode into a boolean Expression /// </summary> /// <param name="conditionalNode">Node to parse</param> /// <returns>Boolean Expression</returns> public ExpressionBool GetCondition(ConditionalNode conditionalNode) { ExpressionValue expression = ParseExpressionNode(conditionalNode.Expression); switch (expression) { case ExpressionBool boolExpression: return(boolExpression); default: throw new InvalidOperationException(string.Format("Cannot use expression with type of {0} as a condition.", expression.ExpressionType)); } }
protected override JSchema VisitConditionalNode(ConditionalNode node) { var schema = base.VisitConditionalNode(node); var parentSchema = _schemas.Peek(); //schema.Required = false; if (schema.Type == null) { schema.Type = JSchemaType.Boolean; } return(schema); }
public IEnumerable <ASTNode> Transform(ConditionalNode item) { yield return(item); foreach (var child in TransformAll(item.Expression)) { yield return(child); } foreach (var child in TransformAll(item.Children)) { yield return(child); } }
private bool GetClass(IDataRow row, ConditionalNode node, out string className) { className = node.Class; bool isValid = false; var rowValue = row[node.Attribute]; switch (node.Condition) { case PredicateCondition.Equal: if (row[node.Attribute].Equals(node.ThreshHold)) { isValid = true; } break; case PredicateCondition.LessThanOrEqual: if (rowValue == null) { return false; } if (Convert.ToDouble(rowValue) <= Convert.ToDouble(node.ThreshHold)) { isValid = true; } break; case PredicateCondition.GreaterThan: if (rowValue == null) { return false; } if (Convert.ToDouble(rowValue) > Convert.ToDouble(node.ThreshHold)) { isValid = true; } break; default: throw new ArgumentOutOfRangeException(); } if (isValid && node.Children != null) { foreach (var child in node.Children) { if (GetClass(row, child, out className)) { break; } } } return isValid; }
public IEnumerable <string> Transform(ConditionalNode item) { _EncounteredOutputStyleBlock = true; if (ShouldRender == false) { yield break; } foreach (var output in TransformAll(item.Children)) { yield return(output); } }
protected override IClientModel VisitConditionalNode(ConditionalNode node) { var result = this.VisitExpressionNode(node.Expression); _clientContext.BeginIf(result); this.VisitBlockNode(node.TrueBlock); if (node.FalseBlock != null) { _clientContext.ElseIf(); this.VisitBlockNode(node.FalseBlock); } _clientContext.EndIf(); return(null); }
public DomainId <IConditionalStatementNode> CreateConditional( string definition, DomainId <IBooleanLogicNode> predicate, IEnumerable <DomainId <IStatementNode> > consequent, IEnumerable <DomainId <IStatementNode> > alternative) { var condition = new ConditionalNode( m_ids.Next, definition, predicate, consequent, alternative); return(DomainItemRegistration <IConditionalStatementNode>(condition)); }
public void Visit(ConditionalNode node) { string tag = Code.Count.ToString(); node.If.Accept(this); Code.Add(new CondJumpCodeLine(VariableManager.PeekVariableCounter(), new LabelCodeLine("_else", tag))); node.Then.Accept(this); Code.Add(new GotoCodeLine(new LabelCodeLine("_endif", tag))); Code.Add(new LabelCodeLine("_else", tag)); node.Else.Accept(this); Code.Add(new LabelCodeLine("_endif", tag)); }
protected virtual TResult VisitConditionalNode(ConditionalNode node) { var expressionResult = this.VisitExpressionNode(node.Expression); if (node.TrueBlock != null) { this.VisitBlockNode(node.TrueBlock); } if (node.FalseBlock != null) { this.VisitBlockNode(node.FalseBlock); } return(expressionResult); }
public override Node Visit(ConditionalNode conditional) { Node expressionNode = conditional.ChildNodes[0]; var evaluatedNodeValue = _valueFactory.CreateValueFromString((expressionNode.Accept(this) as LiteralNode).Value, QLType.Boolean); if (evaluatedNodeValue.ToBoolean()) { var ifNode = conditional.ChildNodes[1]; return(ifNode.Accept(this)); } else if (conditional.ChildNodes.Count > 2) { var elseNode = conditional.ChildNodes[2]; return(elseNode.Accept(this)); } return(null); }
public void Initialize() { var firstQuestion = new QuestionNode(Location.Empty, "Q1", "Do you like puppies?", QValueType.Boolean); var secondQuestion = new QuestionNode(Location.Empty, "Q2", "Do you like kittens?", QValueType.Boolean); var thirdQuestion = new ConditionalNode(Location.Empty, null); thirdQuestion.AddNode(new FormNode(Location.Empty, "InvalidFormInLowerLayer")); var forthQuestion = new QuestionNode(Location.Empty, "Q4", "Is this the forthQuestion?", QValueType.Boolean); _validAST = new FormNode(Location.Empty, "TestForm"); _validAST.AddNode(firstQuestion); _validAST.AddNode(secondQuestion); _multipleFormAST = new FormNode(Location.Empty, "TestForm"); _multipleFormAST.AddNode(new FormNode(Location.Empty, "InvalidForm")); _multipleFormInLowerNodeAST = new FormNode(Location.Empty, "InvalidForm"); _multipleFormInLowerNodeAST.AddNode(thirdQuestion); }
private void EmitConditional(ConditionalNode node) { var hasTrueBlock = node.TrueBlock != null && node.TrueBlock.Nodes.Any(); var hasFalseBlock = node.FalseBlock != null && node.FalseBlock.Nodes.Any(); if (!hasTrueBlock && !hasFalseBlock) { throw new VeilCompilerException("Conditionals must have a True or False block"); } var done = emitter.DefineLabel(); EvaluateExpression(node.Expression); if (node.Expression.ResultType == typeof(object)) { emitter.CallMethod(boolifyMethod); } if (!hasTrueBlock) { emitter.BranchIfTrue(done); EmitNode(node.FalseBlock); } else if (!hasFalseBlock) { emitter.BranchIfFalse(done); EmitNode(node.TrueBlock); } else { var falseBlock = emitter.DefineLabel(); emitter.BranchIfFalse(falseBlock); EmitNode(node.TrueBlock); emitter.Branch(done); emitter.MarkLabel(falseBlock); EmitNode(node.FalseBlock); } emitter.MarkLabel(done); }
public static void PrintSection(ConditionalNode conditional) { Console.WriteLine("\n" + conditional); foreach (QLNode section in conditional.Children) { if (section.GetType() == typeof(QuestionNode)) { PrintSection(section as QuestionNode); } else if (section.GetType() == typeof(ComputedNode)) { PrintSection(section as ComputedNode); } else { PrintSection(section as ConditionalNode); } } }
/** * Recursive method which executes a node but the node method might execute its own nodes first */ private INode Execute(INode node) { try { return(node switch { DeclareIntVarNode declarerNode => declarerNode.Execute(declarerNode.Left as ReferenceNode, Execute(declarerNode.Right) as IntNode), IntOpNode opNode => opNode.Execute(Execute(opNode.Left) as IntNode, Execute(opNode.Right) as IntNode), ReferenceNode identity => new IntNode(identity.Value), FuncCallNode call => ExecuteFunctionCall(call), IntNode intNode => intNode, MethodNode method => ExecuteDeclareMethod(method), LoopNode loop => ExecuteLoopNode(loop), ConditionalNode conditional => ExecuteConditional(conditional), _ => new IntNode(-1) }); }
private Expression HandleConditional(ConditionalNode node) { var hasTrueBlock = node.TrueBlock != null && node.TrueBlock.Nodes.Any(); var hasFalseBlock = node.FalseBlock != null && node.FalseBlock.Nodes.Any(); if (!hasTrueBlock && !hasFalseBlock) { throw new VeilCompilerException("Conditionals must have a True or False block", node); } var valueToCheck = ParseExpression(node.Expression); var booleanCheck = BoolifyExpression(valueToCheck); //var returnTarget = Expression.Label(typeof(Task)); //var labelExpression = Expression.Label(returnTarget, Expression.Constant(null, typeof(Task))); if (!hasFalseBlock) { return(Expression.IfThen(booleanCheck, HandleAsync(HandleNode(node.TrueBlock)))); //return Expression.Block( // Expression.IfThen( // booleanCheck, // Expression.Return(returnTarget, HandleNode(node.TrueBlock))), // labelExpression); } else if (!hasTrueBlock) { return(Expression.IfThen(Expression.IsFalse(booleanCheck), HandleAsync(HandleNode(node.FalseBlock)))); //return Expression.Block( // Expression.IfThen( // Expression.IsFalse(booleanCheck), // Expression.Return(returnTarget, HandleNode(node.FalseBlock))), // labelExpression); } return(Expression.IfThenElse(booleanCheck, HandleAsync(HandleNode(node.TrueBlock)), HandleAsync(HandleNode(node.FalseBlock)))); //return Expression.Block( // Expression.IfThenElse(booleanCheck, // Expression.Return(returnTarget, HandleNode(node.TrueBlock)), // Expression.Return(returnTarget, HandleNode(node.FalseBlock))), // labelExpression); }
public void ParseConditional() { bool b = false; Expression <Func <int> > f = () => b ? 1 : 2; var node = NaturalExpressionParser.Parse(f.Body); var expected = new ConditionalNode { Condition = new ConstantNode { Text = "b", Value = "False" }, TrueValue = new ConstantNode { Text = "1" }, FalseValue = new ConstantNode { Text = "2" }, }; Assert.AreEqual(expected, node); }
/// <summary> /// Add a Continue Condition node to the end of the chain. /// </summary> /// <param name="continueCondition">The condition required in order to continue</param> /// <param name="nodeName"></param> /// <param name="triggerOverrides">Triggers to use for transitions out of this node in liu of the configured machine-wide triggers.</param> protected void AddContinueCondition(IUmlConstraint continueCondition, string nodeName, params IUmlTrigger[] triggerOverrides) { if (!_isEditable) { throw new ActivityMachineException("Assembly can only be done while the machine is in an edit mode."); } WaitCount++; // Resulting Continue Guard: (DefaultContinueConstraint && condition) // Resulting Quit Guard: (DefaultQuitConstraint) //TODO: use smarter way of sensing when previous node was a WAIT and therefore has to be followed by a constraint guarded transition var conditionalNode = new ConditionalNode(nodeName, Name, continueCondition) { LogType = LogType }; // Give the node any overriding triggers. These will be the triggers that evaluate the conditional node's // constraint because the constraint becomes the Guard of the Continue Transition out of the new node. conditionalNode.OverridingTriggers.AddRange(triggerOverrides); AddNode(conditionalNode); }
private int ParseConditional(CompilationContext compilationContext, List<Token> tokens, int index, ref IActionNode currentParent) { Token currentToken; currentToken = tokens[++index]; // Open Bracket AssertExpectedTokenValue(currentToken, "(", "Expected Open Bracket"); currentToken = tokens[++index]; // Parameters // Parse logical expression Expression expression; int skipTokens = ParseExpression(index - 1, tokens, compilationContext, out expression); index += (skipTokens - 2); currentToken = tokens[index]; // Close Bracket AssertExpectedTokenValue(currentToken, ")", "Expected Close Bracket"); // Obtain consequence block var blockStream = new List<Token>(); skipTokens = GetInnerBlock(index, tokens, ref blockStream); // Compile consequence IActionNode consequnce = Compile(blockStream, compilationContext); // Jump ahead in the Token stream index += skipTokens; if (index >= tokens.Count) throw new GossipScriptException("Unexpected end of input"); currentToken = tokens[index]; // Obtain Else consequence IActionNode elseConsequnce = null; if (tokens[index + 1].Value == "else") { var elseBlockStream = new List<Token>(); skipTokens = GetInnerBlock(index + 1, tokens, ref elseBlockStream); elseConsequnce = Compile(elseBlockStream, compilationContext); // Jump ahead in the Token stream index += (skipTokens + 1); currentToken = tokens[index]; } var conditionalCommand = new ConditionalNode(expression, consequnce, elseConsequnce); currentParent.Next = conditionalCommand; currentParent = currentParent.Next; return index; }