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); }