public void OverrideGetHashCode()
{
// Arrange
var comparer = new TupleEqualityComparer <int, int>();
// Act
var actual = comparer.GetHashCode();
// Assert
Assert.True(actual > 0);
}
public void OverrideEquals(bool expected, int a1, int a2, int b1, int b2)
{
// Arrange
var comparer = new TupleEqualityComparer <int, int>();
var tupleA = new Tuple <int, int>(a1, a2);
var tupleB = new Tuple <int, int>(b1, b2);
// Act
var actual = comparer.Equals(tupleA, tupleB);
// Assert
Assert.Equal(expected, actual);
}
/// <inheritdoc/>
public string ToDot()
{
var writer = new DotWriter <TState>(this.StateComparer);
writer.WriteStart("NFA");
// Accepting states
writer.WriteAcceptingStates(this.AcceptingStates);
// Non-accepting states
writer.WriteStates(this.States.Except(this.AcceptingStates, this.StateComparer));
// Initial states
writer.WriteInitialStates(this.InitialStates);
// Transitions
var tupleComparer = new TupleEqualityComparer <TState, TState>(this.StateComparer, this.StateComparer);
var transitionsByState = this.Transitions.GroupBy(t => (t.Source, t.Destination), tupleComparer);
var remainingEpsilon = this.epsilonTransitions.EpsilonTransitionMap
.ToDictionary(kv => kv.Key, kv => kv.Value.ToHashSet(this.StateComparer), this.StateComparer);
foreach (var group in transitionsByState)
{
var from = group.Key.Item1;
var to = group.Key.Item2;
var on = string.Join(" U ", group.Select(g => g.Symbol));
if (this.EpsilonTransitions.Contains(new(from, to)))
{
remainingEpsilon[from].Remove(to);
on = $"{on}, ε";
}
writer.WriteTransition(from, on, to);
}
// Epsilon-transitions
foreach (var(from, toSet) in remainingEpsilon)
{
foreach (var to in toSet)
{
writer.WriteTransition(from, "ε", to);
}
}
writer.WriteEnd();
return(writer.Code.ToString());
}
public IntervalSet GetFollowSet(PreventContextType preventContextType)
{
if (_followSet != null && _followSet[(int)preventContextType] != null)
{
return(_followSet[(int)preventContextType]);
}
IntervalSet[] sets = _followSet ?? new IntervalSet[Enum.GetValues(typeof(PreventContextType)).Cast <int>().Max() + 1];
IntervalSet set = new IntervalSet();
var queue = new Queue <Tuple <Transition, PreventContextType> >(OutgoingTransitions.Select(i => Tuple.Create(i, preventContextType)));
var comparer = new TupleEqualityComparer <Transition, PreventContextType>(ObjectReferenceEqualityComparer <Transition> .Default, null);
var visited = new HashSet <Tuple <Transition, PreventContextType> >(queue, comparer);
while (queue.Count > 0)
{
var pair = queue.Dequeue();
Transition transition = pair.Item1;
PreventContextType nextPreventContextType = pair.Item2;
if (transition.IsContext)
{
switch (nextPreventContextType)
{
case PreventContextType.Pop:
if (!transition.IsRecursive && transition is PopContextTransition)
{
continue;
}
break;
case PreventContextType.PopRecursive:
if (transition.IsRecursive && (transition is PopContextTransition))
{
continue;
}
break;
case PreventContextType.Push:
if (!transition.IsRecursive && transition is PushContextTransition)
{
continue;
}
break;
case PreventContextType.PushRecursive:
if (transition.IsRecursive && (transition is PushContextTransition))
{
continue;
}
break;
default:
break;
}
}
if (transition.IsEpsilon || transition.IsContext)
{
// the preventContextType can only change if we're following a another context transition
if (transition.IsContext)
{
nextPreventContextType = PreventContextType.None;
if (transition.SourceState.IsOptimized)
{
if (transition is PushContextTransition)
{
nextPreventContextType = transition.IsRecursive ? PreventContextType.PushRecursive : PreventContextType.Push;
}
else if (transition is PopContextTransition)
{
nextPreventContextType = transition.IsRecursive ? PreventContextType.PopRecursive : PreventContextType.Pop;
}
}
}
if (transition.TargetState._followSet != null && transition.TargetState._followSet[(int)nextPreventContextType] != null)
{
set.UnionWith(transition.TargetState._followSet[(int)nextPreventContextType]);
}
else
{
foreach (var outgoing in transition.TargetState.OutgoingTransitions)
{
var nextPair = Tuple.Create(outgoing, nextPreventContextType);
if (visited.Add(nextPair))
{
queue.Enqueue(Tuple.Create(outgoing, nextPreventContextType));
}
}
}
}
else
{
set.UnionWith(transition.MatchSet);
}
}
_followSet = sets;
_followSet[(int)preventContextType] = set;
return(set);
}
