public Matcher(Pattern <TData, TOffset> pattern, MatcherSettings <TOffset> settings)
{
_settings = settings;
_settings.Freeze();
_matchComparer = AnonymousEqualityComparer.Create <Match <TData, TOffset> >(MatchEquals, MatchGetHashCode);
Compile(pattern);
}
public Matcher(SpanFactory <TOffset> spanFactory, Pattern <TData, TOffset> pattern, MatcherSettings <TOffset> settings)
{
_spanFactory = spanFactory;
_settings = settings;
_settings.ReadOnly = true;
_matchComparer = AnonymousEqualityComparer.Create <Match <TData, TOffset> >(MatchEquals, MatchGetHashCode);
Compile(pattern);
}
public void ThenByIsOnlyAppliedAsTieBreaker()
{
IEqualityComparer <Person> thenByComparer = new AnonymousEqualityComparer <Person>
{
Equals = (x, y) => { Assert.Fail(); return(false); },
};
var comparer = EqualityCompare <Person> .Default().ThenEquateBy(thenByComparer);
Assert.IsFalse(comparer.Equals(AbeAbrams, CaseyJohnson));
Assert.IsFalse(comparer.Equals(CaseyJohnson, AbeAbrams));
}
public override IEnumerable <FstResult <TData, TOffset> > Traverse(ref int annIndex, Register <TOffset>[,] initRegisters, IList <TagMapCommand> initCmds, ISet <int> initAnns)
{
Stack <NondeterministicFsaTraversalInstance <TData, TOffset> > instStack = InitializeStack(ref annIndex, initRegisters, initCmds, initAnns);
var curResults = new List <FstResult <TData, TOffset> >();
var traversed = new HashSet <Tuple <State <TData, TOffset>, int, Register <TOffset> [, ]> >(
AnonymousEqualityComparer.Create <Tuple <State <TData, TOffset>, int, Register <TOffset> [, ]> >(KeyEquals, KeyGetHashCode));
while (instStack.Count != 0)
{
NondeterministicFsaTraversalInstance <TData, TOffset> inst = instStack.Pop();
bool releaseInstance = true;
VariableBindings varBindings = null;
int i = 0;
foreach (Arc <TData, TOffset> arc in inst.State.Arcs)
{
bool isInstReusable = i == inst.State.Arcs.Count - 1;
if (arc.Input.IsEpsilon)
{
if (!inst.Visited.Contains(arc.Target))
{
NondeterministicFsaTraversalInstance <TData, TOffset> ti;
if (isInstReusable)
{
ti = inst;
}
else
{
ti = CopyInstance(inst);
if (inst.VariableBindings != null && varBindings == null)
{
varBindings = inst.VariableBindings.Clone();
}
ti.VariableBindings = varBindings;
}
ti.Visited.Add(arc.Target);
NondeterministicFsaTraversalInstance <TData, TOffset> newInst = EpsilonAdvance(ti, arc, curResults);
Tuple <State <TData, TOffset>, int, Register <TOffset> [, ]> key = Tuple.Create(newInst.State, newInst.AnnotationIndex, newInst.Registers);
if (!traversed.Contains(key))
{
instStack.Push(newInst);
traversed.Add(key);
}
if (isInstReusable)
{
releaseInstance = false;
}
varBindings = null;
}
}
else
{
if (inst.VariableBindings != null && varBindings == null)
{
varBindings = isInstReusable ? inst.VariableBindings : inst.VariableBindings.Clone();
}
if (CheckInputMatch(arc, inst.AnnotationIndex, varBindings))
{
NondeterministicFsaTraversalInstance <TData, TOffset> ti = isInstReusable ? inst : CopyInstance(inst);
foreach (NondeterministicFsaTraversalInstance <TData, TOffset> newInst in Advance(ti, varBindings, arc, curResults))
{
newInst.Visited.Clear();
Tuple <State <TData, TOffset>, int, Register <TOffset> [, ]> key = Tuple.Create(newInst.State, newInst.AnnotationIndex, newInst.Registers);
if (!traversed.Contains(key))
{
instStack.Push(newInst);
traversed.Add(key);
}
}
if (isInstReusable)
{
releaseInstance = false;
}
varBindings = null;
}
}
i++;
}
if (releaseInstance)
{
ReleaseInstance(inst);
}
}
return(curResults);
}
public override IEnumerable <FstResult <TData, TOffset> > Traverse(ref Annotation <TOffset> ann, NullableValue <TOffset>[,] initRegisters, IList <TagMapCommand> initCmds, ISet <Annotation <TOffset> > initAnns)
{
ConcurrentQueue <FsaInstance> from = InitializeQueue(ref ann, initRegisters, initCmds, initAnns);
var curResults = new ConcurrentBag <FstResult <TData, TOffset> >();
var traversed = new HashSet <Tuple <State <TData, TOffset>, Annotation <TOffset>, NullableValue <TOffset> [, ]> >(
AnonymousEqualityComparer.Create <Tuple <State <TData, TOffset>, Annotation <TOffset>, NullableValue <TOffset> [, ]> >(KeyEquals, KeyGetHashCode));
while (!from.IsEmpty)
{
var to = new ConcurrentQueue <FsaInstance>();
Parallel.ForEach(from, inst =>
{
if (inst.Annotation == null)
{
return;
}
var taskResults = new List <FstResult <TData, TOffset> >();
VariableBindings varBindings = null;
foreach (Arc <TData, TOffset> arc in inst.State.Arcs)
{
if (arc.Input.IsEpsilon)
{
if (!inst.Visited.Contains(arc.Target))
{
NullableValue <TOffset>[,] registers = inst.Registers;
ISet <State <TData, TOffset> > visited = inst.Visited;
if (IsInstanceReuseable(inst))
{
if (varBindings == null)
{
varBindings = inst.VariableBindings;
}
}
else
{
registers = (NullableValue <TOffset> [, ])inst.Registers.Clone();
if (varBindings == null)
{
varBindings = inst.VariableBindings.DeepClone();
}
visited = new HashSet <State <TData, TOffset> >(inst.Visited);
}
to.Enqueue(EpsilonAdvanceFsa(inst.Annotation, registers, varBindings, visited, arc, taskResults, inst.Priorities));
varBindings = null;
}
}
else
{
if (varBindings == null)
{
varBindings = IsInstanceReuseable(inst) ? inst.VariableBindings : inst.VariableBindings.DeepClone();
}
if (CheckInputMatch(arc, inst.Annotation, varBindings))
{
foreach (FsaInstance newInst in AdvanceFsa(inst.Annotation, inst.Registers, varBindings, arc,
taskResults, inst.Priorities))
{
to.Enqueue(newInst);
}
varBindings = null;
}
}
}
foreach (FstResult <TData, TOffset> res in taskResults)
{
curResults.Add(res);
}
});
from = new ConcurrentQueue <FsaInstance>();
foreach (FsaInstance inst in to)
{
Tuple <State <TData, TOffset>, Annotation <TOffset>, NullableValue <TOffset> [, ]> key = Tuple.Create(inst.State, inst.Annotation, inst.Registers);
if (!traversed.Contains(key))
{
from.Enqueue(inst);
traversed.Add(key);
}
}
}
return(curResults);
}
