public override Pair <FingerTree <T, M>, FingerTree <T, M> > SplitSequence(MeasurePredicate <M> predicate)
{
if (predicate(Size))
{
return(new Pair <FingerTree <T, M>, FingerTree <T, M> >(new Empty <T, M>(Measured), this));
}
return(new Pair <FingerTree <T, M>, FingerTree <T, M> >(this, new Empty <T, M>(Measured)));
}
public override Pair <FingerTree <T, M>, FingerTree <T, M> > SplitSequence(MeasurePredicate <M> predicate)
{
if (!predicate(Size))
{
return(new Pair <FingerTree <T, M>, FingerTree <T, M> >(this, _mk.Empty()));
}
Split <T, FingerTree <T, M>, M> split = Split(predicate, Measured.Identity);
return(new Pair <FingerTree <T, M>, FingerTree <T, M> >(split.Left, split.Right.AddLeft(split.Item)));
}
public Split <T, Digit <T, M>, M> Split(MeasurePredicate <M> predicate, M acc)
{
return(Match(one => new Split <T, Digit <T, M>, M>(null, one.V, null),
two =>
{
M value = _m.Append(acc, _m.Measure(two.V1));
if (predicate(value))
{
return new Split <T, Digit <T, M>, M>(null, two.V1, _mk.One(two.V2));
}
return new Split <T, Digit <T, M>, M>(_mk.One(two.V1), two.V2, null);
},
three =>
{
M value = _m.Append(acc, _m.Measure(three.V1));
if (predicate(value))
{
return new Split <T, Digit <T, M>, M>(null, three.V1, _mk.Two(three.V2, three.V3));
}
value = _m.Append(value, _m.Measure(three.V2));
if (predicate(value))
{
return new Split <T, Digit <T, M>, M>(_mk.One(three.V1), three.V2, _mk.One(three.V3));
}
throw new InvalidOperationException("Should not have split prefix if not in the middle");
},
four =>
{
M value = _m.Append(acc, _m.Measure(four.V1));
if (predicate(value))
{
return new Split <T, Digit <T, M>, M>(null, four.V1, _mk.Three(four.V2, four.V3, four.V4));
}
value = _m.Append(value, _m.Measure(four.V2));
if (predicate(value))
{
return new Split <T, Digit <T, M>, M>(_mk.One(four.V1), four.V2, _mk.Two(four.V3, four.V4));
}
value = _m.Append(value, _m.Measure(four.V3));
if (predicate(value))
{
return new Split <T, Digit <T, M>, M>(_mk.Two(four.V1, four.V2), four.V3, _mk.One(four.V4));
}
throw new InvalidOperationException("Should not have split prefix if not in the middle");
}));
}
public abstract Split <T, FingerTree <T, M>, M> Split(MeasurePredicate <M> predicate, M acc);
public abstract Pair <FingerTree <T, M>, FingerTree <T, M> > SplitSequence(MeasurePredicate <M> predicate);
public override Split <T, FingerTree <T, M>, M> Split(MeasurePredicate <M> predicate, M acc)
{
return(new Split <T, FingerTree <T, M>, M>(new Empty <T, M>(Measured), _item, new Empty <T, M>(Measured)));
}
public override Split <T, FingerTree <T, M>, M> Split(MeasurePredicate <M> predicate, M acc)
{
var mk = new MakeTree <Node <T, M>, M>(Measured.Node);
M prefixSize = Measured.Append(acc, _prefix.Size);
if (predicate(prefixSize))
{
Split <T, Digit <T, M>, M> split = _prefix.Split(predicate, acc);
FingerTree <T, M> leftTree = split.Left == null?_mk.Empty() : split.Left.ToTree();
FingerTree <T, M> rightTree;
if (split.Right != null)
{
rightTree = _mk.Deep(split.Right, _middle, _suffix);
}
else
{
rightTree = _middle.Match(e => _suffix.ToTree(),
s => _mk.Deep(s.Item.Match <Digit <T, M> >(x2 => _mk.Two(x2.V1, x2.V2),
x3 => _mk.Three(x3.V1, x3.V2, x3.V3)),
mk.Empty(), _suffix),
d =>
{
var leftView = _middle.Left;
return(_mk.Deep(leftView.Head.Match <Digit <T, M> >(x2 => _mk.Two(x2.V1, x2.V2),
x3 => _mk.Three(x3.V1, x3.V2, x3.V3)),
leftView.Tail, _suffix));
});
}
return(new Split <T, FingerTree <T, M>, M>(leftTree, split.Item, rightTree));
}
M middleSize = Measured.Append(prefixSize, _middle.Size);
if (predicate(middleSize))
{
Split <Node <T, M>, FingerTree <Node <T, M>, M>, M> split = _middle.Split(predicate, prefixSize);
Split <T, Digit <T, M>, M> splitMidLeft = split.Item
.Match <Digit <T, M> >(x2 => _mk.Two(x2.V1, x2.V2), x3 => _mk.Three(x3.V1, x3.V2, x3.V3))
.Split(predicate, Measured.Append(prefixSize, split.Left.Size));
FingerTree <T, M> leftTree = _mk.Deep(_prefix, split.Left, splitMidLeft.Left);
FingerTree <T, M> rightTree = _mk.Deep(splitMidLeft.Right, split.Right, _suffix);
return(new Split <T, FingerTree <T, M>, M>(leftTree, splitMidLeft.Item, rightTree));
}
Split <T, Digit <T, M>, M> splitSuffix = _suffix.Split(predicate, middleSize);
FingerTree <T, M> right = splitSuffix.Right == null?_mk.Empty() : splitSuffix.Right.ToTree();
FingerTree <T, M> left;
if (splitSuffix.Left != null)
{
left = _mk.Deep(_prefix, _middle, splitSuffix.Left);
}
else
{
left = _middle.Match(e => _prefix.ToTree(),
s => _mk.Deep(_prefix, mk.Empty(), s.Item.Match <Digit <T, M> >(x2 => _mk.Two(x2.V1, x2.V2),
x3 => _mk.Three(x3.V1, x3.V2, x3.V3))),
d =>
{
var rightView = _middle.Right;
return(_mk.Deep(_prefix, rightView.Tail, rightView.Head.Match <Digit <T, M> >(x2 => _mk.Two(x2.V1, x2.V2),
x3 => _mk.Three(x3.V1, x3.V2, x3.V3))));
});
}
return(new Split <T, FingerTree <T, M>, M>(left, splitSuffix.Item, right));
}
public override Pair <FingerTree <T, M>, FingerTree <T, M> > SplitSequence(MeasurePredicate <M> predicate)
{
return(Pair.New <FingerTree <T, M>, FingerTree <T, M> >(new Empty <T, M>(Measured), new Empty <T, M>(Measured)));
}
public override Split <T, FingerTree <T, M>, M> Split(MeasurePredicate <M> predicate, M acc)
{
throw new NotImplementedException("Tree is empty");
}
