public IEnumerable <Token <T> > TypedShake(Token <T> target, TypedShakeCondition <T> cond, TypedShakeSelector <T> selector) { Token <T> prev = target; Tuple <Token <T>, Token <T>, Token <T> > curr = new Tuple <Token <T>, Token <T>, Token <T> >(null, null, target); do { curr = BasicTypedShakerFunction(curr.Item3, cond, selector); if (curr.Item1 != null) { if (!curr.Item1.IsBig) { curr.Item1.IsBig = true; } yield return(curr.Item1); } if (curr.Item2 != null) { yield return(curr.Item2); } if (curr.Item3.Equals((Hunk <T>)prev)) { if (curr.Item3.Length > 0) { if (!curr.Item3.IsBig) { curr.Item3.IsBig = true; } yield return(curr.Item3); } yield break; } prev = curr.Item3; } while (true); }
protected Tuple <Token <T>, Token <T>, Token <T> > BasicTypedShakerFunction( Token <T> target, TypedShakeCondition <T> cond, TypedShakeSelector <T> selector) { Func <TypedSegment, Token <T>, int> getRest = (seg, hunk) => (hunk.Length - (seg.Start + seg.Length)); Func <TypedSegment, int> getComputedStart = (seg) => seg.Start + seg.Length; TypedSegment result = cond(target); if (result == null) { return(new Tuple <Token <T>, Token <T>, Token <T> >(null, null, target)); } else { TypedSegment restSection = new TypedSegment(getRest(result, target), string.Empty, getComputedStart(result)); var matchTokens = selector(result, target); var before = matchTokens.Item1; var match = matchTokens.Item2; match.IsBig = false; var restTokens = selector(restSection, target); var rest = restTokens.Item2; rest.IsBig = true; return(new Tuple <Token <T>, Token <T>, Token <T> >(before, match, rest)); } }
public IEnumerable <Token <T> > TypedShake(Token <T> target, TypedShakeCondition <T> a, TypedShakeCondition <T> b) { foreach (var v in TypedShake(target, a)) { if (v.IsBig) { foreach (var q in TypedShake(v, b)) { yield return(q); } } else { yield return(v); } } }
public override TypedShakeCondition <string> AsTypedShakeCondition() { TypedShakeCondition <string> fn = null; if (RequiresEqualityCheck) { fn = LexicalExtensions.GenerateTypedCond <string>( (val, ind, len) => { bool condition = val.Equals(TargetWord); TypedSegment seg = new TypedSegment(TargetWord.Length, WordType, ind); return(new Tuple <bool, TypedSegment>(condition, seg)); }); } else { fn = LexicalExtensions.GenerateMultiCharacterTypedCond(TargetWord, TargetWord); } return((x) => { bool result = x.Value.Contains(TargetWord); return result ? fn(x) : null; }); }
public IEnumerable <Token <T> > TypedShake(Token <T> target, TypedShakeCondition <T> cond) { return(TypedShake(target, cond, Selector)); }
public Tuple <Token <T>, Token <T>, Token <T> > BasicTypedShakerFunction(Token <T> target, TypedShakeCondition <T> cond) { return(BasicTypedShakerFunction(target, cond, selector)); }
private IEnumerable <Token <T> > TypedShakeInternal(IEnumerable <Token <T> > outer, TypedShakeCondition <T> cond) { if (cond == null) { foreach (var v in outer) { yield return(v); } } else { foreach (var v in outer) { if (v.IsBig) { foreach (var q in TypedShake(v, cond)) { yield return(q); } } else { yield return(v); } } } }