internal void InsertAsRight(TextAnchorNode node, TextAnchorNode newNode)
{
Debug.Assert(node.Right == null);
node.Right = newNode;
newNode.Parent = node;
UpdateTotalLength(node);
FixTree4Insertion(newNode);
}
internal void SwapNode(TextAnchorNode node1, TextAnchorNode node2)
{
TextAnchor tmp = node1.Anchor;
node1.Anchor = node2.Anchor;
node1.Anchor._node = node1;
node2.Anchor = tmp;
node2.Anchor._node = node2;
}
internal NodeColor GetNodeColor(TextAnchorNode node)
{
if (node == null)
{
// NIL节点均视为黑色
return(NodeColor.BLACK);
}
return(node.Color);
}
private void PushBlack(TextAnchorNode node)
{
Debug.Assert(node.Left != null && node.Right != null);
node.Color = node.Color - 1;
TextAnchorNode left = node.Left;
TextAnchorNode right = node.Right;
left.Color = left.Color + 1;
right.Color = right.Color + 1;
}
internal void MoveRight(TextAnchorNode node, Int32 length)
{
Debug.Assert(_doc.Length - node.Anchor.Offset >= length);
var nodesNeedUpdate = new List <TextAnchorNode>();
Boolean firstSwap = true;
do
{
TextAnchorNode successor = node.Successor;
if (successor == null || successor.Length > length)
{
break;
}
length -= successor.Length;
if (firstSwap)
{
// 只有第一次交换的后继节点需要更新
firstSwap = false;
successor.Length += node.Length;
nodesNeedUpdate.Add(node);
}
SwapNode(node, successor);
node.Length = successor.Length;
node = successor;
node.Length = 0;
} while (true);
// 所有节点交换完毕
node.Length += length;
nodesNeedUpdate.Add(node);
// 交换完毕后如果存在后继节点，则需要更新Length
TextAnchorNode lastSuccessor = node.Successor;
if (lastSuccessor != null)
{
lastSuccessor.Length -= Math.Min(node.Length, length);
nodesNeedUpdate.Add(lastSuccessor);
}
// 更新所有需要更新的节点
foreach (var nodeNeedUpdate in nodesNeedUpdate)
{
UpdateTotalLength(nodeNeedUpdate);
}
#if DEBUG
VerifySelf();
#endif
}
internal void MoveLeft(TextAnchorNode node, Int32 length)
{
Debug.Assert(node.Anchor.Offset >= length);
var nodesNeedUpdate = new List <TextAnchorNode>();
// 交换前如果存在后继节点，则更新后继节点的Length
TextAnchorNode successor = node.Successor;
if (successor != null)
{
successor.Length += Math.Min(node.Length, length);
nodesNeedUpdate.Add(successor);
}
// 记录最后一次交换的节点
TextAnchorNode lastPredecessor = null;
while (length > node.Length)
{
length -= node.Length;
// 向前交换前驱节点
TextAnchorNode predecessor = node.Predecessor;
Debug.Assert(predecessor != null);
SwapNode(node, predecessor);
lastPredecessor = node;
lastPredecessor.Length = predecessor.Length;
node = predecessor;
}
// 所有节点交换完毕
if (lastPredecessor != null)
{
lastPredecessor.Length = length;
nodesNeedUpdate.Add(lastPredecessor);
}
node.Length -= length;
nodesNeedUpdate.Add(node);
// 更新所有需要更新的节点
foreach (var nodeNeedUpdate in nodesNeedUpdate)
{
UpdateTotalLength(nodeNeedUpdate);
}
#if DEBUG
VerifySelf();
#endif
}
/// <summary>
/// 寻找node下offset处的后置锚点，offset会被修改为该节点的相对偏移
/// </summary>
/// <param name="offset"></param>
/// <returns></returns>
internal TextAnchorNode FindNode(TextAnchorNode node, ref Int32 offset)
{
while (true)
{
// 如果存在左侧锚点
if (node.Left != null)
{
// offset在左锚点覆盖范围内
if (offset < node.Left.TotalLength)
{
// 继续判断offset是否在更左侧
node = node.Left;
continue;
}
// offset在右锚点覆盖范围内
else
{
// 转为相对该锚点的偏移
offset -= node.Left.TotalLength;
}
}
// 如果相对的offset已经在当前锚点的左侧，那么该节点就是要找的节点（因为当前锚点的右锚点都在更后面）
//Debug.Assert(offset != node.Length);
if (offset <= node.Length)
{
return(node);
}
// 在当前节点右侧，则继续转成相对右锚点的相对偏移
offset -= node.Length;
if (node.Right != null)
{
// 在右锚点覆盖范围内，继续寻找
node = node.Right;
}
else
{
// 如果没有右锚点了，说明不存在该offset的后置锚点
return(null);
}
}
}
internal TextAnchor CreateAnchor(Int32 offset)
{
var anchor = new TextAnchor(_doc);
anchor._node = new TextAnchorNode(anchor);
if (_root == null)
{
// 第一个锚点
_root = anchor._node;
_root.TotalLength = _root.Length = offset;
FixTree4Insertion(_root);
}
else if (offset >= _root.TotalLength)
{
// 超过了整棵树覆盖的范围，所以直接加入尾部
anchor._node.TotalLength = anchor._node.Length = offset - _root.TotalLength;
InsertAsRight(_root.RightMost, anchor._node);
}
else
{
// 锚点在整棵树覆盖的范围内，先找到该offset靠后的最近锚点
TextAnchorNode nearestAfter = FindNode(_root, ref offset);
// 找不到后置锚点的情况已经在前面一个分支处理过了
Debug.Assert(nearestAfter != null);
anchor._node.TotalLength = anchor._node.Length = offset;
nearestAfter.Length -= offset;
// 在后置锚点前插入这个锚点，该锚点就是后置锚点的前驱
if (nearestAfter.Left == null)
{
InsertAsLeft(nearestAfter, anchor._node);
}
else
{
InsertAsRight(nearestAfter.Predecessor, anchor._node);
}
}
#if DEBUG
VerifySelf();
#endif
return(anchor);
}
internal void RotateRight(TextAnchorNode node)
{
/* 右旋
* N L
* / \ / \
* L R ===> T1 N
* / \ / \
* T1 T T R
*/
TextAnchorNode left = node.Left;
TextAnchorNode right = node.Right;
TextAnchorNode t = left.Right;
TextAnchorNode parent = node.Parent;
left.Parent = parent;
if (node.IsLeft)
{
parent.Left = left;
}
else if (node.IsRight)
{
parent.Right = left;
}
node.Parent = left;
left.Right = node;
node.Left = t;
if (t != null)
{
t.Parent = node;
}
// 是否需要更换根节点
if (parent == null)
{
_root = left;
}
// 更新锚点覆盖范围
UpdateTotalLength(node);
UpdateTotalLength(left);
}
internal void UpdateTotalLength(TextAnchorNode node)
{
Int32 totalLength = node.Length;
if (node.Left != null)
{
totalLength += node.Left.TotalLength;
}
if (node.Right != null)
{
totalLength += node.Right.TotalLength;
}
if (node.TotalLength != totalLength)
{
// 如果总长度发生变化，则不断更新父节点的总长度
node.TotalLength = totalLength;
if (node.Parent != null)
{
UpdateTotalLength(node.Parent);
}
}
}
internal void RotateLeft(TextAnchorNode node)
{
/* 左旋
* N R
* / \ / \
* L R ===> N T1
* / \ / \
* T T1 L T
*/
TextAnchorNode left = node.Left;
TextAnchorNode right = node.Right;
TextAnchorNode t = right.Left;
TextAnchorNode parent = node.Parent;
right.Parent = parent;
if (node.IsLeft)
{
parent.Left = right;
}
else if (node.IsRight)
{
parent.Right = right;
}
node.Parent = right;
right.Left = node;
node.Right = t;
if (t != null)
{
t.Parent = node;
}
// 是否需要更换根节点
if (parent == null)
{
_root = right;
}
// 更新锚点覆盖范围
UpdateTotalLength(node);
UpdateTotalLength(right);
}
internal TextAnchorNode FindNodeToReplace(TextAnchorNode node)
{
Debug.Assert(node.Left == null || node.Right == null);
// 如果是根节点直接用nil节点替换
if (node.Parent == null && node.IsLeaf)
{
return(null);
}
// node只需要考虑两种情况
// 1. node为叶子节点
// 2. node为左孩子或右孩子
// 不需要考虑node有两个孩子的情况是因为这个时候只需要找到node的后继节点替换，而后继节点只可能有一个右孩子
if (node.Color == NodeColor.RED)
{
// 如果删除的是红色节点，直接用nil节点替换即可
return(null);
}
if (node.IsLeaf)
{
// 删除后是一个Double-Black节点，需要修复
return(TextAnchorNode.DoubleBlackNilNode);
}
else
{
TextAnchorNode ret = null;
// 子节点只可能是红色节点，并且一定是叶子节点，直接涂黑替换即可
if (node.Left != null)
{
ret = node.Left;
}
else
{
ret = node.Right;
}
ret.Color = NodeColor.BLACK;
return(ret);
}
}
internal TextAnchorNode ReplaceNode(TextAnchorNode orig, TextAnchorNode dest)
{
Debug.Assert(orig != dest);
TextAnchorNode parent = orig.Parent;
if (dest == null)
{
if (parent == null)
{
_root = dest;
}
else if (orig.IsLeft)
{
parent.Left = dest;
}
else
{
parent.Right = dest;
}
return(dest);
}
else
{
orig.Left = dest.Left;
orig.Right = dest.Right;
orig.Color = dest.Color;
orig.Anchor = dest.Anchor;
if (orig.Anchor != null)
{
// dest可能为双黑节点，双黑节点没有anchor
orig.Anchor._node = orig;
}
orig.Length = dest.Length;
orig.TotalLength = dest.TotalLength;
return(orig);
}
}
internal void RemoveText(Int32 offset, Int32 length)
{
// 空树或者不在插入范围内则不作处理
if (length <= 0 || _root == null || offset >= _root.TotalLength)
{
return;
}
TextAnchorNode nearestAfter = FindNode(_root, ref offset);
Debug.Assert(nearestAfter != null);
if (offset == 0)
{
// 踩点的锚点不做处理
while (nearestAfter.Length == 0 && nearestAfter.Successor != null)
{
nearestAfter = nearestAfter.Successor;
}
}
// 删除锚点
var nodes4removal = new List <TextAnchorNode>();
TextAnchorNode curNode = nearestAfter;
while (length > curNode.Length)
{
nodes4removal.Add(curNode);
curNode.Anchor.Alive = false;
length -= curNode.Length;
curNode = curNode.Successor;
}
// 必须要倒着删除
for (int i = nodes4removal.Count - 1; i >= 0; --i)
{
RemoveNode(nodes4removal[i]);
}
curNode.Length -= length;
UpdateTotalLength(curNode);
}
internal void RemoveNode(TextAnchorNode node)
{
TextAnchorNode toReplace = null;
TextAnchorNode replaced = null;
TextAnchorNode successor = node.Successor;
TextAnchorNode updateNode = null;
Int32 nodeLength = node.Length;
if (node.Left != null && node.Right != null)
{
// 用后继节点替换
node.Anchor = successor.Anchor;
node.Anchor._node = node;
node.Length = successor.Length;
node.TotalLength = successor.TotalLength;
updateNode = successor.Parent;
// 转换为删除successor
toReplace = FindNodeToReplace(successor);
replaced = ReplaceNode(successor, toReplace);
successor = node;
}
else
{
toReplace = FindNodeToReplace(node);
replaced = ReplaceNode(node, toReplace);
if (toReplace == null)
{
updateNode = node.Parent;
}
else
{
if (toReplace == successor)
{
updateNode = node;
successor = node;
}
else
{
updateNode = node.Parent;
}
}
}
// 后继节点长度增加
if (successor != null)
{
successor.Length += nodeLength;
}
if (updateNode != null)
{
UpdateTotalLength(updateNode);
}
// 如果替换的节点是双黑节点，则需要修复
if (replaced != null && replaced.Color == NodeColor.DOUBLE_BLACK)
{
FixTree4Deletion(replaced);
}
if (_root != null)
{
_root.Color = NodeColor.BLACK;
}
#if DEBUG
VerifySelf();
#endif
}
internal void FixTree4Deletion(TextAnchorNode node, Boolean remove = true)
{
// 其他情况已经在FindNodeToReplace中正确处理
if (node.Color != NodeColor.DOUBLE_BLACK)
{
// 只可能是递归修复的时候，遇到父节点pull为黑色，这个时候已经修复完成
return;
}
TextAnchorNode parent = node.Parent;
if (parent == null)
{
// 如果根节点是双黑节点，变黑即可
node.Color = NodeColor.BLACK;
return;
}
TextAnchorNode sibling = node.IsLeft ? parent.Right : parent.Left;
NodeColor siblingLeftColor = GetNodeColor(sibling.Left);
NodeColor siblingRightColor = GetNodeColor(sibling.Right);
if (sibling.Color == NodeColor.BLACK)
{
if (siblingLeftColor == NodeColor.BLACK && siblingRightColor == NodeColor.BLACK)
{
// 如果sibling的孩子均为黑色
PullBlack(parent);
FixTree4Deletion(parent, false);
}
else
{
// sibling的孩子至少有一个红色
PullBlack(parent);
if (node.IsLeft && siblingLeftColor == NodeColor.RED)
{
// sibling只有左孩子，先对sibling右旋，再对parent左旋
RotateRight(sibling);
// sibling变更
sibling = sibling.Parent;
RotateLeft(parent);
SwapColor(parent, sibling);
}
else if (node.IsLeft && siblingRightColor == NodeColor.RED)
{
// sibling只有右孩子，直接左旋parent
RotateLeft(parent);
SwapColor(parent, sibling);
}
else if (node.IsRight && siblingRightColor == NodeColor.RED)
{
RotateLeft(sibling);
sibling = sibling.Parent;
RotateRight(parent);
SwapColor(parent, sibling);
}
else
{
RotateRight(parent);
SwapColor(parent, sibling);
}
// 平衡颜色
PushBlack(sibling);
}
}
else
{
// 我们需要想办法转到sibling为黑色的情况继续修复
if (node.IsLeft)
{
RotateLeft(parent);
SwapColor(parent, sibling);
}
else
{
RotateRight(parent);
SwapColor(parent, sibling);
}
FixTree4Deletion(node, false);
}
if (remove)
{
// 将辅助用的双黑节点置空
ReplaceNode(node, null);
}
}
internal void FixTree4Insertion(TextAnchorNode node)
{
Debug.Assert(node.Color == NodeColor.RED);
if (node.Parent == null)
{
// 根节点必须为黑色
node.Color = NodeColor.BLACK;
return;
}
TextAnchorNode parent = node.Parent;
if (parent.Color == NodeColor.BLACK)
{
// 父节点为黑色则不需要修复
return;
}
TextAnchorNode grandParent = parent.Parent;
TextAnchorNode uncle = parent.IsLeft ? grandParent.Right : grandParent.Left;
NodeColor uncleColor = GetNodeColor(uncle);
if (uncleColor == NodeColor.RED)
{
// 如果uncle节点为红色，则只需要重新着色即可
parent.Color = NodeColor.BLACK;
uncle.Color = NodeColor.BLACK;
// 多了一个黑色，将grandparent置为红色以平衡
grandParent.Color = NodeColor.RED;
// 继续修复grandParent
FixTree4Insertion(grandParent);
}
else
{
// 如果uncle节点为黑色，此时grandParent一定为黑色
// 1. node为左孩子，parent为左孩子，右旋grandParent
if (node.IsLeft && parent.IsLeft)
{
RotateRight(grandParent);
// 交换parent和grandParent的颜色
SwapColor(parent, grandParent);
}
// 2. node为左孩子，parent为右孩子，先右旋parent再左旋grandParent
else if (node.IsLeft && parent.IsRight)
{
RotateRight(parent);
// 变成右右的情况，parent和node变更
node = parent;
parent = node.Parent;
RotateLeft(grandParent);
SwapColor(parent, grandParent);
}
// 3. node为右孩子，parent为左孩子，先左旋parent再右旋grandParent
else if (node.IsRight && parent.IsLeft)
{
RotateLeft(parent);
// 变成左左的情况，parent和node变更
node = parent;
parent = node.Parent;
RotateRight(grandParent);
SwapColor(parent, grandParent);
}
// 4. node为右孩子，parent为右孩子，左旋grandParent
else
{
RotateLeft(grandParent);
// 交换parent和grandParent的颜色
SwapColor(parent, grandParent);
}
// 根节点一定为黑色
_root.Color = NodeColor.BLACK;
}
}
