/// <summary> /// Refreshes the state depending on the state of the predecessors and /// successors, using the associated <see cref="StateComposer"/>. /// </summary> /// <devdoc> /// We save this calculation of the node state in the current graph location /// (WRT predecessors) as an optimization for the PropertyChanged event. /// We want to prevent a case where an already blocked node (i.e. a join) /// raises the changed event when one of its predecessors changes to Blocked. /// In this case, the predecessor would have changed its state, but the /// join itself would not, as it was already blocked. This optimization /// would benefit the entire tree spanning from that join, potentially /// reducing quite importantly the refresh rates of the graph UI. /// This is important for all kinds of nodes, and is virtual because /// different ones have different calculation of their state WRT /// to the predecessors. /// </devdoc> protected virtual void ComposeState(StateChangeSource changeSource) { var calculatedState = this.StateComposer.ComposeState(this, changeSource); if (this.State != calculatedState) { this.State = calculatedState; this.OnStateChanged(); } }
public NodeState ComposeState(INode node, StateChangeSource changeSource) { var final = node.Successors.Traverse <INode>(s => s.Successors).OfType <IFinal>().FirstOrDefault(); if (final == null) { return(node.State); } return(final.State == NodeState.Completed ? NodeState.Completed : NodeState.Enabled); }
public NodeState ComposeState(INode node, StateChangeSource changeSource) { #if ImplicitPredecessorsCompleteCondition if (changeSource == StateChangeSource.Predecessor && node.Predecessors.Any()) { return(node.Predecessors.All(n => n.State == NodeState.Completed) ? NodeState.Unknown : NodeState.Blocked); } #endif // Ignores successor changes. return(node.State); }
public NodeState ComposeState(INode node, StateChangeSource changeSource) { Guard.NotNull(() => node, node); #if ImplicitPredecessorsCompleteCondition if (changeSource == StateChangeSource.Predecessor && node.Predecessors.Any()) { return node.Predecessors.All(n => n.State == NodeState.Completed) ? NodeState.Completed : NodeState.Blocked; } #endif // Ignores successor changes. return node.State; }
/// <summary> /// Refreshes the state depending on the state of the predecessors and successors. /// </summary> protected override void ComposeState(StateChangeSource changeSource) { var state = this.StateComposer.ComposeState(this, changeSource); if (this.State != state) { var previouslyHadPredecessorBlocking = this.hasBlockingPredecessor; this.hasBlockingPredecessor = state == NodeState.Blocked; if (base.State != NodeState.Blocked && (this.hasBlockingPredecessor || previouslyHadPredecessorBlocking)) { this.OnStateChanged(); } } }
public NodeState ComposeState(INode node, StateChangeSource changeSource) { return(node.Successors.Any() && node.Predecessors.Any() ? NodeState.Completed : NodeState.Unknown); }
public NodeState ComposeState(INode node, StateChangeSource changeSource) { return node.Successors.Any() && node.Predecessors.Any() ? NodeState.Completed : NodeState.Unknown; }
public NodeState ComposeState(INode node, StateChangeSource changeSource) { var final = node.Successors.Traverse<INode>(s => s.Successors).OfType<IFinal>().FirstOrDefault(); if (final == null) return node.State; return final.State == NodeState.Completed ? NodeState.Completed : NodeState.Enabled; }