/// <summary>
/// Adds an outgoing transition to the place. This is usually called when you add a <see cref="Transition"/> to the net.
/// </summary>
/// <param Name="transition">The outgoing transition.</param>
public void AppendOutgoingTransition(Transition transition)
{
if (!OutgoingTransitions.Contains(transition))
{
OutgoingTransitions.Add(transition);
}
}
public void RemoveTransition(Transition transition, StateOptimizer optimizer = null)
{
Requires.NotNull(transition, nameof(transition));
Requires.Argument(transition.SourceState == this, nameof(transition), "The transition source state must be the current instance.");
Verify.Operation(OutgoingTransitions.Contains(transition), "Expected the state to contain the transition.");
RemoveTransitionInternal(transition, optimizer);
}
public void AddTransition(Transition transition, StateOptimizer optimizer = null)
{
Contract.Requires <ArgumentNullException>(transition != null, "transition");
Contract.Requires <InvalidOperationException>(transition.SourceState == null);
Contract.Requires <InvalidOperationException>(!OutgoingTransitions.Contains(transition));
Contract.Requires <InvalidOperationException>(!transition.TargetState.IncomingTransitions.Contains(transition));
AddTransitionInternal(transition, optimizer);
}
public void AddTransition(Transition transition, StateOptimizer optimizer = null)
{
Requires.NotNull(transition, nameof(transition));
Verify.Operation(transition.SourceState == null, "Expected the transition to not be associated with a source state.");
Verify.Operation(!OutgoingTransitions.Contains(transition), "Expected the state to not already contain the transition.");
Verify.Operation(!transition.TargetState.IncomingTransitions.Contains(transition), "Expected the target state to not already contain the incoming transition.");
AddTransitionInternal(transition, optimizer);
}
public void RemoveTransition(Transition transition, StateOptimizer optimizer = null)
{
Contract.Requires <ArgumentNullException>(transition != null, "transition");
Contract.Requires <ArgumentException>(transition.SourceState == this);
Contract.Requires <InvalidOperationException>(OutgoingTransitions.Contains(transition));
Contract.Ensures(transition.SourceState == null);
Contract.Ensures(!Contract.OldValue(transition.SourceState).OutgoingTransitions.Contains(transition));
Contract.Ensures(!transition.TargetState.IncomingTransitions.Contains(transition));
RemoveTransitionInternal(transition, optimizer);
}
internal void RemoveTransitionInternal(Transition transition, StateOptimizer optimizer)
{
Contract.Requires(transition != null, "transition");
Contract.Requires(transition.SourceState == this);
#if ALL_CHECKS
Contract.Requires(OutgoingTransitions.Contains(transition));
#endif
Contract.Ensures(transition.SourceState == null);
#if ALL_CHECKS
Contract.Ensures(!Contract.OldValue(transition.SourceState).OutgoingTransitions.Contains(transition));
Contract.Ensures(!transition.TargetState.IncomingTransitions.Contains(transition));
Contract.Assert(transition.TargetState.IncomingTransitions.Contains(transition));
#endif
//PopContextTransition popContextTransition = transition as PopContextTransition;
//if (popContextTransition != null)
//{
// foreach (var pushTransition in popContextTransition.PushTransitions)
// {
// Contract.Assert(pushTransition.PopTransitions.Contains(transition));
// pushTransition.PopTransitions.Remove(popContextTransition);
// }
//}
//PushContextTransition pushContextTransition = transition as PushContextTransition;
//if (pushContextTransition != null)
//{
// foreach (var popTransition in pushContextTransition.PopTransitions)
// {
// Contract.Assert(popTransition.PushTransitions.Contains(transition));
// popTransition.PushTransitions.Remove(pushContextTransition);
// }
//}
if (optimizer != null)
{
optimizer.RemoveTransition(transition);
}
OutgoingTransitions.Remove(transition);
transition.TargetState.IncomingTransitions.Remove(transition);
_followSet = null;
_isForwardRecursive = null;
transition.TargetState._sourceSet = null;
transition.TargetState._isBackwardRecursive = null;
transition.SourceState = null;
}
internal void AddTransitionInternal(Transition transition, StateOptimizer optimizer)
{
Contract.Requires(transition != null);
Contract.Requires(transition.SourceState == null);
#if ALL_CHECKS
Contract.Requires(!OutgoingTransitions.Contains(transition));
Contract.Requires(!transition.TargetState.IncomingTransitions.Contains(transition));
#endif
if (IsRecursiveAnalysisComplete && !transition.IsMatch && transition.TargetState == this && !transition.IsRecursive)
{
throw new InvalidOperationException();
}
PopContextTransition popContextTransition = transition as PopContextTransition;
PushContextTransition pushContextTransition = transition as PushContextTransition;
#if false
if (popContextTransition != null && !transition.IsRecursive)
{
foreach (var recursive in OutgoingTransitions.OfType <PopContextTransition>().Where(i => i.IsRecursive))
{
if (popContextTransition.ContextIdentifiers.Take(recursive.ContextIdentifiers.Count).SequenceEqual(recursive.ContextIdentifiers))
{
if (popContextTransition.ContextIdentifiers.Count > recursive.ContextIdentifiers.Count)
{
throw new InvalidOperationException();
}
}
}
}
#endif
if (_outgoingTransitions.Count > 10 && !(_outgoingTransitions is ISet <Transition>))
{
_outgoingTransitions = new HashSet <Transition>(_outgoingTransitions, ObjectReferenceEqualityComparer <Transition> .Default);
}
#if false
if (transition.IsContext && transition.IsRecursive)
{
PopContextTransition first = transition as PopContextTransition;
if (first != null)
{
foreach (var existing in OutgoingTransitions.OfType <PopContextTransition>().ToArray())
{
if (existing.TargetState != transition.TargetState)
{
continue;
}
if (first.ContextIdentifiers.Take(existing.ContextIdentifiers.Count).SequenceEqual(existing.ContextIdentifiers))
{
RemoveTransitionInternal(existing, optimizer);
}
}
}
PushContextTransition second = transition as PushContextTransition;
if (second != null)
{
foreach (var existing in OutgoingTransitions.OfType <PushContextTransition>().ToArray())
{
if (existing.TargetState != transition.TargetState)
{
continue;
}
if (second.ContextIdentifiers.Take(existing.ContextIdentifiers.Count).SequenceEqual(existing.ContextIdentifiers))
{
RemoveTransitionInternal(existing, optimizer);
}
}
}
}
#endif
OutgoingTransitions.Add(transition);
if (transition.TargetState.IncomingTransitions.Count > 10 && !(transition.TargetState.IncomingTransitions is ISet <Transition>))
{
transition.TargetState._incomingTransitions = new HashSet <Transition>(transition.TargetState._incomingTransitions, ObjectReferenceEqualityComparer <Transition> .Default);
}
transition.TargetState.IncomingTransitions.Add(transition);
transition.SourceState = this;
if (optimizer != null)
{
optimizer.AddTransition(transition);
}
if (popContextTransition != null)
{
//if (optimizer != null)
// popContextTransition.PushTransitions.UnionWith(optimizer.GetPushContextTransitions(popContextTransition.ContextIdentifiers.Last()));
//foreach (var pushTransition in popContextTransition.PushTransitions)
//{
// Contract.Assert(pushTransition.ContextIdentifiers.First() == popContextTransition.ContextIdentifiers.Last());
// Contract.Assert(pushTransition.SourceState != null);
// pushTransition.PopTransitions.Add(popContextTransition);
//}
#if ALL_CHECKS
Contract.Assert(Contract.ForAll(OutgoingTransitions.OfType <PushContextTransition>(), i => i.ContextIdentifiers.Last() != popContextTransition.ContextIdentifiers.First() || popContextTransition.PushTransitions.Contains(i)));
#endif
}
else if (pushContextTransition != null)
{
//if (optimizer != null)
// pushContextTransition.PopTransitions.UnionWith(optimizer.GetPopContextTransitions(pushContextTransition.ContextIdentifiers[0]));
//foreach (var popTransition in pushContextTransition.PopTransitions)
//{
// Contract.Assert(popTransition.ContextIdentifiers.Last() == pushContextTransition.ContextIdentifiers.First());
// Contract.Assert(popTransition.SourceState != null);
// popTransition.PushTransitions.Add(pushContextTransition);
//}
#if ALL_CHECKS
Contract.Assert(Contract.ForAll(OutgoingTransitions.OfType <PopContextTransition>(), i => i.ContextIdentifiers.Last() != pushContextTransition.ContextIdentifiers.First() || pushContextTransition.PopTransitions.Contains(i)));
#endif
}
_followSet = null;
_isForwardRecursive = null;
transition.TargetState._sourceSet = null;
transition.TargetState._isBackwardRecursive = null;
}
