bjoli/PersistentMap
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

surpressed all style warnings from the LSP server.

Browse source
This commit is contained in:
Linus Björnstam 2026-05-21 13:13:22 +02:00
parent 7ee2238248
commit 23c4ac299e
13 changed files with 346 additions and 371 deletions
Download patch file Download diff file Expand all files Collapse all files

70
PersistentOrderedMap/BaseOrderedMap.cs
View file

@ -2,17 +2,17 @@ using System.Collections;
namespace PersistentOrderedMap;
public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair<K, V>> where TStrategy : IKeyStrategy<K>
public abstract class BaseOrderedMap<TK, TV, TStrategy> : IEnumerable<KeyValuePair<TK, TV>> where TStrategy : IKeyStrategy<TK>
{
internal Node<K> _root;
internal readonly TStrategy _strategy;
internal Node<TK> Root;
internal readonly TStrategy Strategy;
public int Count { get; protected set; }
protected BaseOrderedMap(Node<K> root, TStrategy strategy, int count)
protected BaseOrderedMap(Node<TK> root, TStrategy strategy, int count)
{
_root = root ?? throw new ArgumentNullException(nameof(root));
_strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
Root = root ?? throw new ArgumentNullException(nameof(root));
Strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
Count = count;
}
@ -21,14 +21,14 @@ public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair
// Read Operations (Shared)
// ---------------------------------------------------------
public bool TryGetValue(K key, out V value)
public bool TryGetValue(TK key, out TV value)
{
return BTreeFunctions.TryGetValue(_root, key, _strategy, out value);
return BTreeFunctions.TryGetValue(Root, key, Strategy, out value);
}
public bool ContainsKey(K key)
public bool ContainsKey(TK key)
{
return BTreeFunctions.TryGetValue<K,V, TStrategy>(_root, key, _strategy, out _);
return BTreeFunctions.TryGetValue<TK,TV, TStrategy>(Root, key, Strategy, out _);
}
@ -37,26 +37,26 @@ public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair
// Bootstrap / Factory Helpers
// ---------------------------------------------------------
public static PersistentOrderedMap<K, V, TStrategy> Create(TStrategy strategy)
public static PersistentOrderedMap<TK, TV, TStrategy> Create(TStrategy strategy)
{
// Start with an empty leaf owned by None so the first write triggers CoW.
var emptyRoot = new LeafNode<K, V>(OwnerId.None, strategy.UsesPrefixes);
return new PersistentOrderedMap<K, V, TStrategy>(emptyRoot, strategy, 0);
var emptyRoot = new LeafNode<TK, TV>(OwnerId.None, strategy.UsesPrefixes);
return new PersistentOrderedMap<TK, TV, TStrategy>(emptyRoot, strategy, 0);
}
public static TransientOrderedMap<K, V, TStrategy> CreateTransient(TStrategy strategy)
public static TransientOrderedMap<TK, TV, TStrategy> CreateTransient(TStrategy strategy)
{
var emptyRoot = new LeafNode<K, V>(OwnerId.None, strategy.UsesPrefixes);
return new TransientOrderedMap<K, V, TStrategy>(emptyRoot, strategy,0);
var emptyRoot = new LeafNode<TK, TV>(OwnerId.None, strategy.UsesPrefixes);
return new TransientOrderedMap<TK, TV, TStrategy>(emptyRoot, strategy,0);
}
public BTreeEnumerator<K, V, TStrategy> GetEnumerator()
public BTreeEnumerator<TK, TV, TStrategy> GetEnumerator()
{
return AsEnumerable().GetEnumerator();
}
IEnumerator<KeyValuePair<K, V>> IEnumerable<KeyValuePair<K, V>>.GetEnumerator()
IEnumerator<KeyValuePair<TK, TV>> IEnumerable<KeyValuePair<TK, TV>>.GetEnumerator()
{
return GetEnumerator();
}
@ -67,19 +67,19 @@ public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair
}
// 1. Full Scan
public BTreeEnumerable<K, V, TStrategy> AsEnumerable()
=> new(_root, _strategy, false, default, false, default);
public BTreeEnumerable<TK, TV, TStrategy> AsEnumerable()
=> new(Root, Strategy, false, default!, false, default!);
// 2. Exact Range
public BTreeEnumerable<K, V, TStrategy> Range(K min, K max)
=> new(_root, _strategy, true, min, true, max);
public BTreeEnumerable<TK, TV, TStrategy> Range(TK min, TK max)
=> new(Root, Strategy, true, min, true, max);
// 3. Start From (Open Ended)
public BTreeEnumerable<K, V, TStrategy> From(K min) => new(_root, _strategy, true, min, false, default);
public BTreeEnumerable<TK, TV, TStrategy> From(TK min) => new(Root, Strategy, true, min, false, default!);
// 4. Until (Start at beginning)
public BTreeEnumerable<K, V, TStrategy> Until(K max)
=> new(_root, _strategy, false, default, true, max);
public BTreeEnumerable<TK, TV, TStrategy> Until(TK max)
=> new(Root, Strategy, false, default!, true, max);
@ -87,19 +87,19 @@ public abstract class BaseOrderedMap<K, V, TStrategy> : IEnumerable<KeyValuePair
// Navigation Operations
// ---------------------------------------------------------
public bool TryGetMin(out K key, out V value) => BTreeFunctions.TryGetMin(_root, out key, out value);
public bool TryGetMin(out TK key, out TV value) => BTreeFunctions.TryGetMin(Root, out key, out value);
public bool TryGetMax(out K key, out V value) => BTreeFunctions.TryGetMax(_root, out key, out value);
public bool TryGetMax(out TK key, out TV value) => BTreeFunctions.TryGetMax(Root, out key, out value);
public bool TryGetSuccessor(K key, out K nextKey, out V nextValue) => BTreeFunctions.TryGetSuccessor(_root, key, _strategy, out nextKey, out nextValue);
public bool TryGetSuccessor(TK key, out TK nextKey, out TV nextValue) => BTreeFunctions.TryGetSuccessor(Root, key, Strategy, out nextKey, out nextValue);
public bool TryGetPredecessor(K key, out K prevKey, out V prevValue) => BTreeFunctions.TryGetPredecessor(_root, key, _strategy, out prevKey, out prevValue);
public bool TryGetPredecessor(TK key, out TK prevKey, out TV prevValue) => BTreeFunctions.TryGetPredecessor(Root, key, Strategy, out prevKey, out prevValue);
// ---------------------------------------------------------
// Set Operations (Linear Merge O(N+M))
// ---------------------------------------------------------
public IEnumerable<KeyValuePair<K, V>> Intersect(BaseOrderedMap<K, V, TStrategy> other)
public IEnumerable<KeyValuePair<TK, TV>> Intersect(BaseOrderedMap<TK, TV, TStrategy> other)
{
using var enum1 = this.GetEnumerator();
using var enum2 = other.GetEnumerator();
@ -109,7 +109,7 @@ public IEnumerable<KeyValuePair<K, V>> Intersect(BaseOrderedMap<K, V, TStrategy>
while (has1 && has2)
{
int cmp = _strategy.Compare(enum1.Current.Key, enum2.Current.Key);
int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
if (cmp == 0)
{
yield return enum1.Current;
@ -121,7 +121,7 @@ public IEnumerable<KeyValuePair<K, V>> Intersect(BaseOrderedMap<K, V, TStrategy>
}
}
public IEnumerable<KeyValuePair<K, V>> Except(BaseOrderedMap<K, V, TStrategy> other)
public IEnumerable<KeyValuePair<TK, TV>> Except(BaseOrderedMap<TK, TV, TStrategy> other)
{
using var enum1 = this.GetEnumerator();
using var enum2 = other.GetEnumerator();
@ -131,7 +131,7 @@ public IEnumerable<KeyValuePair<K, V>> Except(BaseOrderedMap<K, V, TStrategy> ot
while (has1 && has2)
{
int cmp = _strategy.Compare(enum1.Current.Key, enum2.Current.Key);
int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
if (cmp == 0)
{
has1 = enum1.MoveNext();
@ -155,7 +155,7 @@ public IEnumerable<KeyValuePair<K, V>> Except(BaseOrderedMap<K, V, TStrategy> ot
}
}
public IEnumerable<KeyValuePair<K, V>> SymmetricExcept(BaseOrderedMap<K, V, TStrategy> other)
public IEnumerable<KeyValuePair<TK, TV>> SymmetricExcept(BaseOrderedMap<TK, TV, TStrategy> other)
{
using var enum1 = this.GetEnumerator();
using var enum2 = other.GetEnumerator();
@ -165,7 +165,7 @@ public IEnumerable<KeyValuePair<K, V>> SymmetricExcept(BaseOrderedMap<K, V, TStr
while (has1 && has2)
{
int cmp = _strategy.Compare(enum1.Current.Key, enum2.Current.Key);
int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
if (cmp == 0)
{
has1 = enum1.MoveNext();