Rename because it is ordered
This commit is contained in:
parent
b5b363ae9f
commit
e3cec3423b
28 changed files with 104 additions and 104 deletions
864
PersistentOrderedMap/BTreeFunctions.cs
Normal file
864
PersistentOrderedMap/BTreeFunctions.cs
Normal file
|
|
@ -0,0 +1,864 @@
|
|||
using System.Numerics;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace PersistentOrderedMap
|
||||
{
|
||||
public static class BTreeFunctions
|
||||
{
|
||||
// ---------------------------------------------------------
|
||||
// Public API
|
||||
// ---------------------------------------------------------
|
||||
|
||||
/// <summary>TryGetValue tries to get the value at mapping key. If it finds the key it sets th
|
||||
/// out var to value and returns true. </summary>
|
||||
public static bool TryGetValue<K, V, TStrategy>(Node<K> root, K key, TStrategy strategy, out V value)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
// We always get a strategy to avoid branching already here
|
||||
long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
|
||||
|
||||
Node<K> current = root;
|
||||
while (true)
|
||||
{
|
||||
if (current.IsLeaf)
|
||||
{
|
||||
var leaf = current.AsLeaf<V>();
|
||||
int index = FindIndex(leaf, key, keyPrefix, strategy);
|
||||
if (index < leaf.Header.Count && strategy.Compare(leaf.Keys[index], key) == 0)
|
||||
{
|
||||
value = leaf.Values[index];
|
||||
return true;
|
||||
}
|
||||
value = default!;
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
var internalNode = current.AsInternal();
|
||||
int index = FindRoutingIndex(internalNode, key, keyPrefix, strategy);
|
||||
current = internalNode.Children[index]!;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static Node<K> Set<K, V>(Node<K> root, K key, V value, IKeyStrategy<K> strategy, OwnerId owner, out bool countChanged)
|
||||
{
|
||||
root = root.EnsureEditable(owner);
|
||||
|
||||
// Todo, this should really be made a tuple return value to not stress the GC
|
||||
var splitResult = InsertRecursive(root, key, value, strategy, owner, out countChanged);
|
||||
|
||||
if (splitResult != null)
|
||||
{
|
||||
var newRoot = strategy.UsesPrefixes
|
||||
? new PrefixInternalNode<K>(owner)
|
||||
: new InternalNode<K>(owner);
|
||||
|
||||
newRoot.Keys[0] = splitResult.Separator;
|
||||
newRoot.Children[0] = root;
|
||||
newRoot.Children[1] = splitResult.NewNode;
|
||||
newRoot.SetCount(1);
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
newRoot.AllPrefixes[0] = strategy.GetPrefix(splitResult.Separator);
|
||||
}
|
||||
|
||||
return newRoot;
|
||||
}
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
private static SplitResult<K>? InsertRecursive<K, V>(Node<K> node, K key, V value, IKeyStrategy<K> strategy, OwnerId owner, out bool added)
|
||||
{
|
||||
long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
|
||||
|
||||
if (node.IsLeaf)
|
||||
{
|
||||
var leaf = node.AsLeaf<V>();
|
||||
int index = FindIndex(leaf, key, keyPrefix, strategy);
|
||||
|
||||
if (index < leaf.Header.Count && strategy.Compare(leaf.Keys[index], key) == 0)
|
||||
{
|
||||
leaf.Values[index] = value;
|
||||
added = false;
|
||||
return null;
|
||||
}
|
||||
|
||||
added = true;
|
||||
if (leaf.Header.Count < LeafNode<K, V>.Capacity)
|
||||
{
|
||||
InsertIntoLeaf(leaf, index, key, value, strategy);
|
||||
return null;
|
||||
}
|
||||
else
|
||||
{
|
||||
return SplitLeaf(leaf, index, key, value, strategy, owner);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
var internalNode = node.AsInternal();
|
||||
int index = FindRoutingIndex(internalNode, key, keyPrefix, strategy);
|
||||
|
||||
var child = internalNode.Children[index]!.EnsureEditable(owner);
|
||||
internalNode.Children[index] = child;
|
||||
|
||||
var split = InsertRecursive(child, key, value, strategy, owner, out added);
|
||||
|
||||
if (split != null)
|
||||
{
|
||||
if (internalNode.Header.Count < InternalNode<K>.Capacity - 1)
|
||||
{
|
||||
InsertIntoInternal(internalNode, index, split.Separator, split.NewNode, strategy);
|
||||
return null;
|
||||
}
|
||||
else
|
||||
{
|
||||
return SplitInternal(internalNode, index, split.Separator, split.NewNode, strategy, owner);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public static Node<K> Remove<K, V, TStrategy>(Node<K> root, K key, TStrategy strategy, OwnerId owner, out bool countChanged)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
root = root.EnsureEditable(owner);
|
||||
|
||||
bool rebalanceNeeded = RemoveRecursive<K, V, TStrategy>(root, key, strategy, owner, out countChanged);
|
||||
|
||||
if (rebalanceNeeded)
|
||||
{
|
||||
if (!root.IsLeaf)
|
||||
{
|
||||
var internalRoot = root.AsInternal();
|
||||
if (internalRoot.Header.Count == 0)
|
||||
{
|
||||
return internalRoot.Children[0]!;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return root;
|
||||
}
|
||||
|
||||
private static bool RemoveRecursive<K, V, TStrategy>(Node<K> node, K key, TStrategy strategy, OwnerId owner, out bool removed)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
|
||||
|
||||
if (node.IsLeaf)
|
||||
{
|
||||
var leaf = node.AsLeaf<V>();
|
||||
int index = FindIndex(leaf, key, keyPrefix, strategy);
|
||||
|
||||
if (index < leaf.Header.Count && strategy.Compare(leaf.Keys[index], key) == 0)
|
||||
{
|
||||
RemoveFromLeaf(leaf, index, strategy);
|
||||
removed = true;
|
||||
return leaf.Header.Count < LeafNode<K, V>.MergeThreshold;
|
||||
}
|
||||
|
||||
removed = false;
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
var internalNode = node.AsInternal();
|
||||
int index = FindRoutingIndex(internalNode, key, keyPrefix, strategy);
|
||||
|
||||
var child = internalNode.Children[index]!.EnsureEditable(owner);
|
||||
internalNode.Children[index] = child;
|
||||
|
||||
bool childUnderflow = RemoveRecursive<K, V, TStrategy>(child, key, strategy, owner, out removed);
|
||||
|
||||
if (removed && childUnderflow)
|
||||
{
|
||||
return HandleUnderflow<K, V, TStrategy>(internalNode, index, strategy, owner);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------
|
||||
// Internal Helpers: Search
|
||||
// ---------------------------------------------------------
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
internal static int FindIndex<K, TStrategy>(Node<K> node, K key, long keyPrefix, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
if (typeof(K) == typeof(int))
|
||||
{
|
||||
Span<K> keys = node.GetKeys();
|
||||
ref K firstKeyRef = ref MemoryMarshal.GetReference(keys);
|
||||
ref int firstIntRef = ref Unsafe.As<K, int>(ref firstKeyRef);
|
||||
ReadOnlySpan<int> intKeys = MemoryMarshal.CreateReadOnlySpan(ref firstIntRef, keys.Length);
|
||||
int intKey = Unsafe.As<K, int>(ref key);
|
||||
return IntScanner.FindFirstGreaterOrEqual(intKeys, intKey);
|
||||
}
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
int index = PrefixScanner.FindFirstGreaterOrEqual(node.Prefixes, keyPrefix);
|
||||
return RefineSearch(index, node.GetKeys(), key, strategy);
|
||||
}
|
||||
|
||||
return FallbackSearchKeys(node.GetKeys(), key, strategy);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
internal static int FindRoutingIndex<K, TStrategy>(InternalNode<K> node, K key, long keyPrefix, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
|
||||
if (typeof(K) == typeof(int))
|
||||
{
|
||||
Span<K> keys = node.GetKeys();
|
||||
ref K firstKeyRef = ref MemoryMarshal.GetReference(keys);
|
||||
ref int firstIntRef = ref Unsafe.As<K, int>(ref firstKeyRef);
|
||||
ReadOnlySpan<int> intKeys = MemoryMarshal.CreateReadOnlySpan(ref firstIntRef, keys.Length);
|
||||
int intKey = Unsafe.As<K, int>(ref key);
|
||||
return IntScanner.FindFirstGreater(intKeys, intKey);
|
||||
}
|
||||
if (!strategy.UsesPrefixes)
|
||||
{
|
||||
return FallbackRoutingKeys(node.GetKeys(), key, strategy);
|
||||
}
|
||||
|
||||
int index = PrefixScanner.FindFirstGreaterOrEqual(node.Prefixes, keyPrefix);
|
||||
return RefineRouting(index, node.GetKeys(), key, strategy);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static int RefineSearch<K, TStrategy>(int startIndex, ReadOnlySpan<K> keys, K key, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int i = startIndex;
|
||||
while (i < keys.Length && strategy.Compare(keys[i], key) < 0) i++;
|
||||
return i;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static int RefineRouting<K, TStrategy>(int startIndex, ReadOnlySpan<K> keys, K key, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int i = startIndex;
|
||||
while (i < keys.Length && strategy.Compare(keys[i], key) <= 0) i++;
|
||||
return i;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static int FallbackSearchKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
return strategy.UseBinarySearch
|
||||
? BinarySearchKeys(keys, key, strategy)
|
||||
: LinearSearchKeys(keys, key, strategy);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static int FallbackRoutingKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
return strategy.UseBinarySearch
|
||||
? BinaryRoutingKeys(keys, key, strategy)
|
||||
: LinearRoutingKeys(keys, key, strategy);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static int LinearSearchKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int i = 0;
|
||||
while (i < keys.Length && strategy.Compare(keys[i], key) < 0) i++;
|
||||
return i;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static int LinearRoutingKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int i = 0;
|
||||
while (i < keys.Length && strategy.Compare(keys[i], key) <= 0) i++;
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static int BinarySearchKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int low = 0;
|
||||
int high = keys.Length - 1;
|
||||
ref K keysRef = ref MemoryMarshal.GetReference(keys);
|
||||
|
||||
while (low <= high)
|
||||
{
|
||||
int mid = low + ((high - low) >> 1);
|
||||
K midKey = Unsafe.Add(ref keysRef, mid);
|
||||
int cmp = strategy.Compare(midKey, key);
|
||||
|
||||
if (cmp == 0) return mid;
|
||||
if (cmp < 0) low = mid + 1;
|
||||
else high = mid - 1;
|
||||
}
|
||||
return low;
|
||||
}
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
private static int BinaryRoutingKeys<K, TStrategy>(ReadOnlySpan<K> keys, K key, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int low = 0;
|
||||
int high = keys.Length - 1;
|
||||
ref K keysRef = ref MemoryMarshal.GetReference(keys);
|
||||
|
||||
while (low <= high)
|
||||
{
|
||||
int mid = low + ((high - low) >> 1);
|
||||
K midKey = Unsafe.Add(ref keysRef, mid);
|
||||
int cmp = strategy.Compare(midKey, key);
|
||||
|
||||
if (cmp <= 0) low = mid + 1;
|
||||
else high = mid - 1;
|
||||
}
|
||||
return low;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------
|
||||
// Insertion Logic
|
||||
// ---------------------------------------------------------
|
||||
|
||||
private class SplitResult<K>
|
||||
{
|
||||
public Node<K> NewNode;
|
||||
public K Separator;
|
||||
public SplitResult(Node<K> newNode, K separator)
|
||||
{
|
||||
NewNode = newNode;
|
||||
Separator = separator;
|
||||
}
|
||||
}
|
||||
|
||||
private static void InsertIntoLeaf<K, V, TStrategy>(LeafNode<K, V> leaf, int index, K key, V value, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int count = leaf.Header.Count;
|
||||
if (index < count)
|
||||
{
|
||||
int moveCount = count - index;
|
||||
leaf.Keys.AsSpan(index, moveCount).CopyTo(leaf.Keys.AsSpan(index + 1));
|
||||
leaf.Values.AsSpan(index, moveCount).CopyTo(leaf.Values.AsSpan(index + 1));
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
leaf.AllPrefixes.Slice(index, moveCount).CopyTo(leaf.AllPrefixes.Slice(index + 1));
|
||||
}
|
||||
}
|
||||
|
||||
leaf.Keys[index] = key;
|
||||
leaf.Values[index] = value;
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
leaf.AllPrefixes[index] = strategy.GetPrefix(key);
|
||||
}
|
||||
|
||||
leaf.SetCount(count + 1);
|
||||
}
|
||||
|
||||
private static SplitResult<K> SplitLeaf<K, V, TStrategy>(LeafNode<K, V> left, int insertIndex, K key, V value, TStrategy strategy, OwnerId owner)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
var right = new LeafNode<K, V>(owner, strategy.UsesPrefixes);
|
||||
int totalCount = left.Header.Count;
|
||||
|
||||
int splitPoint = (insertIndex == totalCount) ? totalCount : (insertIndex == 0 ? 0 : totalCount / 2);
|
||||
int moveCount = totalCount - splitPoint;
|
||||
|
||||
if (moveCount > 0)
|
||||
{
|
||||
left.Keys.AsSpan(splitPoint, moveCount).CopyTo(right.Keys.AsSpan(0));
|
||||
left.Values.AsSpan(splitPoint, moveCount).CopyTo(right.Values.AsSpan(0));
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
left.AllPrefixes.Slice(splitPoint, moveCount).CopyTo(right.AllPrefixes);
|
||||
}
|
||||
}
|
||||
|
||||
left.SetCount(splitPoint);
|
||||
right.SetCount(moveCount);
|
||||
|
||||
if (insertIndex < splitPoint || (splitPoint == 0 && insertIndex == 0))
|
||||
{
|
||||
InsertIntoLeaf(left, insertIndex, key, value, strategy);
|
||||
}
|
||||
else
|
||||
{
|
||||
InsertIntoLeaf(right, insertIndex - splitPoint, key, value, strategy);
|
||||
}
|
||||
|
||||
return new SplitResult<K>(right, right.Keys[0]);
|
||||
}
|
||||
|
||||
private static void InsertIntoInternal<K, TStrategy>(InternalNode<K> node, int index, K separator, Node<K> newChild, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int count = node.Header.Count;
|
||||
|
||||
if (index < count)
|
||||
{
|
||||
int moveCount = count - index;
|
||||
Span<K> keysSpan = node.Keys;
|
||||
keysSpan.Slice(index, moveCount).CopyTo(keysSpan.Slice(index + 1));
|
||||
|
||||
Span<Node<K>> childrenSpan = node.Children;
|
||||
childrenSpan.Slice(index + 1, moveCount).CopyTo(childrenSpan.Slice(index + 2));
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
node.AllPrefixes.Slice(index, moveCount).CopyTo(node.AllPrefixes.Slice(index + 1));
|
||||
}
|
||||
}
|
||||
|
||||
node.Keys[index] = separator;
|
||||
node.Children[index + 1] = newChild;
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
node.AllPrefixes[index] = strategy.GetPrefix(separator);
|
||||
}
|
||||
|
||||
node.SetCount(count + 1);
|
||||
}
|
||||
|
||||
private static SplitResult<K> SplitInternal<K, TStrategy>(InternalNode<K> left, int insertIndex, K separator, Node<K> newChild, TStrategy strategy, OwnerId owner)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
var right = strategy.UsesPrefixes
|
||||
? new PrefixInternalNode<K>(owner)
|
||||
: new InternalNode<K>(owner);
|
||||
|
||||
int count = left.Header.Count;
|
||||
int splitPoint = count / 2;
|
||||
K upKey = left.Keys[splitPoint];
|
||||
int moveCount = count - splitPoint - 1;
|
||||
|
||||
if (moveCount > 0)
|
||||
{
|
||||
Span<K> leftKeys = left.Keys;
|
||||
Span<K> rightKeys = right.Keys;
|
||||
leftKeys.Slice(splitPoint + 1, moveCount).CopyTo(rightKeys);
|
||||
|
||||
Span<Node<K>> leftChildren = left.Children;
|
||||
Span<Node<K>> rightChildren = right.Children;
|
||||
leftChildren.Slice(splitPoint + 1, moveCount + 1).CopyTo(rightChildren);
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
left.AllPrefixes.Slice(splitPoint + 1, moveCount).CopyTo(right.AllPrefixes);
|
||||
}
|
||||
}
|
||||
|
||||
left.SetCount(splitPoint);
|
||||
right.SetCount(moveCount);
|
||||
|
||||
if (insertIndex <= splitPoint)
|
||||
{
|
||||
InsertIntoInternal(left, insertIndex, separator, newChild, strategy);
|
||||
}
|
||||
else
|
||||
{
|
||||
InsertIntoInternal(right, insertIndex - (splitPoint + 1), separator, newChild, strategy);
|
||||
}
|
||||
|
||||
return new SplitResult<K>(right, upKey);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------
|
||||
// Removal Logic
|
||||
// ---------------------------------------------------------
|
||||
|
||||
private static void RemoveFromLeaf<K, V, TStrategy>(LeafNode<K, V> leaf, int index, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
int count = leaf.Header.Count;
|
||||
int moveCount = count - index - 1;
|
||||
|
||||
if (moveCount > 0)
|
||||
{
|
||||
leaf.Keys.AsSpan(index + 1, moveCount).CopyTo(leaf.Keys.AsSpan(index));
|
||||
leaf.Values.AsSpan(index + 1, moveCount).CopyTo(leaf.Values.AsSpan(index));
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
leaf.AllPrefixes.Slice(index + 1, moveCount).CopyTo(leaf.AllPrefixes.Slice(index));
|
||||
}
|
||||
}
|
||||
|
||||
leaf.SetCount(count - 1);
|
||||
}
|
||||
|
||||
private static bool HandleUnderflow<K, V, TStrategy>(InternalNode<K> parent, int childIndex, TStrategy strategy, OwnerId owner)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
if (childIndex < parent.Header.Count)
|
||||
{
|
||||
var rightSibling = parent.Children[childIndex + 1]!.EnsureEditable(owner);
|
||||
parent.Children[childIndex + 1] = rightSibling;
|
||||
var leftChild = parent.Children[childIndex]!;
|
||||
|
||||
if (CanBorrow(rightSibling))
|
||||
{
|
||||
RotateLeft<K, V, TStrategy>(parent, childIndex, leftChild, rightSibling, strategy);
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
Merge<K, V, TStrategy>(parent, childIndex, leftChild, rightSibling, strategy);
|
||||
return parent.Header.Count < LeafNode<K, V>.MergeThreshold;
|
||||
}
|
||||
}
|
||||
else if (childIndex > 0)
|
||||
{
|
||||
var leftSibling = parent.Children[childIndex - 1]!.EnsureEditable(owner);
|
||||
parent.Children[childIndex - 1] = leftSibling;
|
||||
var rightChild = parent.Children[childIndex]!;
|
||||
|
||||
if (CanBorrow(leftSibling))
|
||||
{
|
||||
RotateRight<K, V, TStrategy>(parent, childIndex - 1, leftSibling, rightChild, strategy);
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
Merge<K, V, TStrategy>(parent, childIndex - 1, leftSibling, rightChild, strategy);
|
||||
return parent.Header.Count < LeafNode<K, V>.MergeThreshold;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private static bool CanBorrow<K>(Node<K> node)
|
||||
{
|
||||
return node.Header.Count > 8 + 1;
|
||||
}
|
||||
|
||||
private static void Merge<K, V, TStrategy>(InternalNode<K> parent, int separatorIndex, Node<K> left, Node<K> right, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
if (left.IsLeaf)
|
||||
{
|
||||
var leftLeaf = left.AsLeaf<V>();
|
||||
var rightLeaf = right.AsLeaf<V>();
|
||||
|
||||
int lCount = leftLeaf.Header.Count;
|
||||
int rCount = rightLeaf.Header.Count;
|
||||
|
||||
rightLeaf.Keys.AsSpan(0, rCount).CopyTo(leftLeaf.Keys.AsSpan(lCount));
|
||||
rightLeaf.Values.AsSpan(0, rCount).CopyTo(leftLeaf.Values.AsSpan(lCount));
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
rightLeaf.AllPrefixes.Slice(0, rCount).CopyTo(leftLeaf.AllPrefixes.Slice(lCount));
|
||||
}
|
||||
|
||||
leftLeaf.SetCount(lCount + rCount);
|
||||
}
|
||||
else
|
||||
{
|
||||
var leftInternal = left.AsInternal();
|
||||
var rightInternal = right.AsInternal();
|
||||
|
||||
K separator = parent.Keys[separatorIndex];
|
||||
|
||||
int lCount = leftInternal.Header.Count;
|
||||
leftInternal.Keys[lCount] = separator;
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
leftInternal.AllPrefixes[lCount] = strategy.GetPrefix(separator);
|
||||
}
|
||||
|
||||
int rCount = rightInternal.Header.Count;
|
||||
Span<K> rightKeys = rightInternal.Keys;
|
||||
Span<K> leftKeys = leftInternal.Keys;
|
||||
rightKeys.Slice(0, rCount).CopyTo(leftKeys.Slice(lCount + 1));
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
rightInternal.AllPrefixes.Slice(0, rCount).CopyTo(leftInternal.AllPrefixes.Slice(lCount + 1));
|
||||
}
|
||||
|
||||
Span<Node<K>> rightChildren = rightInternal.Children;
|
||||
Span<Node<K>> leftChildren = leftInternal.Children;
|
||||
rightChildren.Slice(0, rCount + 1).CopyTo(leftChildren.Slice(lCount + 1));
|
||||
|
||||
leftInternal.SetCount(lCount + 1 + rCount);
|
||||
}
|
||||
|
||||
int pCount = parent.Header.Count;
|
||||
int moveCount = pCount - separatorIndex - 1;
|
||||
|
||||
if (moveCount > 0)
|
||||
{
|
||||
Span<K> parentKeys = parent.Keys;
|
||||
parentKeys.Slice(separatorIndex + 1, moveCount).CopyTo(parentKeys.Slice(separatorIndex));
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
parent.AllPrefixes.Slice(separatorIndex + 1, moveCount).CopyTo(parent.AllPrefixes.Slice(separatorIndex));
|
||||
}
|
||||
|
||||
Span<Node<K>> parentChildren = parent.Children;
|
||||
parentChildren.Slice(separatorIndex + 2, moveCount).CopyTo(parentChildren.Slice(separatorIndex + 1));
|
||||
}
|
||||
|
||||
parent.SetCount(pCount - 1);
|
||||
}
|
||||
|
||||
private static void RotateLeft<K, V, TStrategy>(InternalNode<K> parent, int separatorIndex, Node<K> left, Node<K> right, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
if (left.IsLeaf)
|
||||
{
|
||||
var leftLeaf = left.AsLeaf<V>();
|
||||
var rightLeaf = right.AsLeaf<V>();
|
||||
|
||||
InsertIntoLeaf(leftLeaf, leftLeaf.Header.Count, rightLeaf.Keys[0], rightLeaf.Values[0], strategy);
|
||||
RemoveFromLeaf(rightLeaf, 0, strategy);
|
||||
|
||||
parent.Keys[separatorIndex] = rightLeaf.Keys[0];
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(rightLeaf.Keys[0]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
var leftInternal = left.AsInternal();
|
||||
var rightInternal = right.AsInternal();
|
||||
|
||||
K sep = parent.Keys[separatorIndex];
|
||||
InsertIntoInternal(leftInternal, leftInternal.Header.Count, sep, rightInternal.Children[0]!, strategy);
|
||||
|
||||
parent.Keys[separatorIndex] = rightInternal.Keys[0];
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(rightInternal.Keys[0]);
|
||||
}
|
||||
|
||||
int rCount = rightInternal.Header.Count;
|
||||
|
||||
Span<Node<K>> rightChildren = rightInternal.Children;
|
||||
rightChildren.Slice(1, rCount).CopyTo(rightChildren);
|
||||
|
||||
if (rCount > 1)
|
||||
{
|
||||
Span<K> rightKeys = rightInternal.Keys;
|
||||
rightKeys.Slice(1, rCount - 1).CopyTo(rightKeys);
|
||||
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
rightInternal.AllPrefixes.Slice(1, rCount - 1).CopyTo(rightInternal.AllPrefixes);
|
||||
}
|
||||
}
|
||||
|
||||
rightInternal.SetCount(rCount - 1);
|
||||
}
|
||||
}
|
||||
|
||||
private static void RotateRight<K, V, TStrategy>(InternalNode<K> parent, int separatorIndex, Node<K> left, Node<K> right, TStrategy strategy)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
if (left.IsLeaf)
|
||||
{
|
||||
var leftLeaf = left.AsLeaf<V>();
|
||||
var rightLeaf = right.AsLeaf<V>();
|
||||
int last = leftLeaf.Header.Count - 1;
|
||||
|
||||
InsertIntoLeaf(rightLeaf, 0, leftLeaf.Keys[last], leftLeaf.Values[last], strategy);
|
||||
RemoveFromLeaf(leftLeaf, last, strategy);
|
||||
|
||||
parent.Keys[separatorIndex] = rightLeaf.Keys[0];
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(rightLeaf.Keys[0]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
var leftInternal = left.AsInternal();
|
||||
var rightInternal = right.AsInternal();
|
||||
int last = leftInternal.Header.Count - 1;
|
||||
|
||||
K sep = parent.Keys[separatorIndex];
|
||||
InsertIntoInternal(rightInternal, 0, sep, leftInternal.Children[last + 1]!, strategy);
|
||||
|
||||
parent.Keys[separatorIndex] = leftInternal.Keys[last];
|
||||
if (strategy.UsesPrefixes)
|
||||
{
|
||||
parent.AllPrefixes[separatorIndex] = strategy.GetPrefix(leftInternal.Keys[last]);
|
||||
}
|
||||
|
||||
leftInternal.SetCount(last);
|
||||
}
|
||||
}
|
||||
|
||||
public static bool TryGetMin<K, V>(Node<K> root, out K key, out V value)
|
||||
{
|
||||
var current = root;
|
||||
while (!current.IsLeaf)
|
||||
{
|
||||
current = current.AsInternal().Children[0]!;
|
||||
}
|
||||
|
||||
var leaf = current.AsLeaf<V>();
|
||||
if (leaf.Header.Count == 0)
|
||||
{
|
||||
key = default!;
|
||||
value = default!;
|
||||
return false;
|
||||
}
|
||||
|
||||
key = leaf.Keys[0];
|
||||
value = leaf.Values[0];
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool TryGetMax<K, V>(Node<K> root, out K key, out V value)
|
||||
{
|
||||
var current = root;
|
||||
while (!current.IsLeaf)
|
||||
{
|
||||
var internalNode = current.AsInternal();
|
||||
current = internalNode.Children[internalNode.Header.Count]!;
|
||||
}
|
||||
|
||||
var leaf = current.AsLeaf<V>();
|
||||
if (leaf.Header.Count == 0)
|
||||
{
|
||||
key = default!;
|
||||
value = default!;
|
||||
return false;
|
||||
}
|
||||
|
||||
int last = leaf.Header.Count - 1;
|
||||
key = leaf.Keys[last];
|
||||
value = leaf.Values[last];
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool TryGetSuccessor<K, V, TStrategy>(Node<K> root, K key, TStrategy strategy, out K nextKey, out V nextValue)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
InternalNode<K>[] path = new InternalNode<K>[32];
|
||||
int[] indices = new int[32];
|
||||
int depth = 0;
|
||||
long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
|
||||
|
||||
var current = root;
|
||||
while (!current.IsLeaf)
|
||||
{
|
||||
var internalNode = current.AsInternal();
|
||||
int idx = FindRoutingIndex(internalNode, key, keyPrefix, strategy);
|
||||
path[depth] = internalNode;
|
||||
indices[depth] = idx;
|
||||
depth++;
|
||||
current = internalNode.Children[idx]!;
|
||||
}
|
||||
|
||||
var leaf = current.AsLeaf<V>();
|
||||
int index = FindIndex(leaf, key, keyPrefix, strategy);
|
||||
|
||||
if (index < leaf.Header.Count && strategy.Compare(leaf.Keys[index], key) == 0) index++;
|
||||
|
||||
if (index < leaf.Header.Count)
|
||||
{
|
||||
nextKey = leaf.Keys[index];
|
||||
nextValue = leaf.Values[index];
|
||||
return true;
|
||||
}
|
||||
|
||||
for (int i = depth - 1; i >= 0; i--)
|
||||
{
|
||||
if (indices[i] < path[i].Header.Count)
|
||||
{
|
||||
current = path[i].Children[indices[i] + 1]!;
|
||||
while (!current.IsLeaf)
|
||||
{
|
||||
current = current.AsInternal().Children[0]!;
|
||||
}
|
||||
|
||||
var targetLeaf = current.AsLeaf<V>();
|
||||
nextKey = targetLeaf.Keys[0];
|
||||
nextValue = targetLeaf.Values[0];
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
nextKey = default!;
|
||||
nextValue = default!;
|
||||
return false;
|
||||
}
|
||||
|
||||
public static bool TryGetPredecessor<K, V, TStrategy>(Node<K> root, K key, TStrategy strategy, out K prevKey, out V prevValue)
|
||||
where TStrategy : IKeyStrategy<K>
|
||||
{
|
||||
InternalNode<K>[] path = new InternalNode<K>[32];
|
||||
int[] indices = new int[32];
|
||||
int depth = 0;
|
||||
long keyPrefix = strategy.UsesPrefixes ? strategy.GetPrefix(key) : 0;
|
||||
|
||||
var current = root;
|
||||
while (!current.IsLeaf)
|
||||
{
|
||||
var internalNode = current.AsInternal();
|
||||
int idx = FindRoutingIndex(internalNode, key, keyPrefix, strategy);
|
||||
path[depth] = internalNode;
|
||||
indices[depth] = idx;
|
||||
depth++;
|
||||
current = internalNode.Children[idx]!;
|
||||
}
|
||||
|
||||
var leaf = current.AsLeaf<V>();
|
||||
int index = FindIndex(leaf, key, keyPrefix, strategy);
|
||||
|
||||
if (index > 0)
|
||||
{
|
||||
prevKey = leaf.Keys[index - 1];
|
||||
prevValue = leaf.Values[index - 1];
|
||||
return true;
|
||||
}
|
||||
|
||||
for (int i = depth - 1; i >= 0; i--)
|
||||
{
|
||||
if (indices[i] > 0)
|
||||
{
|
||||
current = path[i].Children[indices[i] - 1]!;
|
||||
while (!current.IsLeaf)
|
||||
{
|
||||
var internalNode = current.AsInternal();
|
||||
current = internalNode.Children[internalNode.Header.Count]!;
|
||||
}
|
||||
|
||||
var targetLeaf = current.AsLeaf<V>();
|
||||
int last = targetLeaf.Header.Count - 1;
|
||||
prevKey = targetLeaf.Keys[last];
|
||||
prevValue = targetLeaf.Values[last];
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
prevKey = default!;
|
||||
prevValue = default!;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue