public MatchPoint(int state, Link <T> link, int index, Backtrack <T> backtrack = default)
{
State = state;
Link = link;
Index = index;
Backtrack = backtrack;
}
public virtual bool TryMatch(T[] input, int index, out int end, ref Backtrack <T> backtrack)
{
var match = Match(input, index, out end, ref backtrack);
if (!Consume)
{
end = index;
}
return(match);
}
public void New()
{
var dot = new AnySingleCharacter();
var a1 = new Backtrack(dot);
Assert.AreEqual(dot, a1.Pattern);
Assert.IsNull(a1.Name);
Assert.IsFalse(a1.Memoized);
var a2 = new Backtrack(dot, "bt");
Assert.AreEqual("bt", a2.Name);
Assert.IsTrue(a2.Memoized);
}
public void Memoize()
{
var dot = new Backtrack(new AnySingleCharacter());
var dot2 = dot.Memoize() as Backtrack;
Assert.IsNotNull(dot2);
Assert.IsTrue(dot2.Memoized);
Assert.AreEqual("", dot2.Name);
var dot3 = dot2.Memoize();
Assert.AreEqual(dot2, dot3);
var dot4 = dot2.Memoize("Test") as Backtrack;
Assert.IsNotNull(dot4);
Assert.IsTrue(dot4.Memoized);
Assert.AreEqual("Test", dot4.Name);
}
public void Match()
{
var ap = new Backtrack(new AnySingleCharacter());
var str = "x";
var node = ap.Match(str) as ParseNode;
Assert.IsNotNull(node);
Assert.AreEqual(0, node.Children.Count);
Assert.AreEqual(0, node.Length);
Assert.AreEqual(new Position(str), node.Position);
Assert.AreEqual(new Position(str), node.NextPosition);
Assert.AreEqual("", node.Value);
var err = ap.Match("") as ParsingError;
Assert.IsNotNull(err);
Assert.AreEqual(ap, err.Pattern);
Assert.AreEqual(new Position(""), err.Position);
Assert.IsNull(err.InnerError);
Assert.AreEqual($"Couldn't match pattern .", err.Message);
}
protected abstract bool Match(T[] input, int index, out int end, ref Backtrack <T> backtrack);
protected override bool Match(T[] input, int index, out int end, ref Backtrack <T> backtrack)
{
var match = Machine.Match(input, out var path, ref backtrack, index);
end = path[^ 1].index;
protected override bool Match(T[] input, int index, out int end, ref Backtrack <T> backtrack)
{
end = index + 1;
return(index < input.Length && !Values.Any(t => Equals(input[index], t)));
}
protected override bool Match(T[] input, int index, out int end, ref Backtrack <T> backtrack)
{
end = index;
return(index < input.Length && !Link.TryMatch(input, index, out end, ref backtrack));
}
protected override bool Match(T[] input, int index, out int end, ref Backtrack <T> backtrack)
{
end = index + 1;
return(index < input.Length && Matcher(input[index]));
}
public MatchPoint <T> WithBacktrack(Backtrack <T> backtrack)
{
return(new(State, Link, Index, backtrack));
}
public IEnumerable <Operator> GetBacktrack()
{
AbstractSearch searcher = new Backtrack(30);
return(searcher.Search());
}
public new void ToString()
{
var ap = new Backtrack(new Range('a', 'z'));
Assert.AreEqual("&[a-z]", ap.ToString());
}
public void NewException()
{
var a = new Backtrack(null);
}
public override bool TryMatch(T[] input, int index, out int end, ref Backtrack <T> backtrack)
{
end = index;
return(true);
}
protected override bool Match(T[] input, int index, out int end, ref Backtrack <T> backtrack)
{
end = index;
return(index == input.Length);
}
public FillBusinessLogic(ViewModel VM, Grid gameGrid)
{
this.VM = VM;
this.gameGrid = gameGrid;
fillBacktrack = new Backtrack();
}
