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