PersistentMap/PersistentOrderedMap/BaseOrderedMap.cs

using System.Collections;

namespace PersistentOrderedMap;

public abstract class BaseOrderedMap<TK, TV, TStrategy> : IEnumerable<KeyValuePair<TK, TV>> where TStrategy : IKeyStrategy<TK>
{
    internal Node<TK> Root;
    internal readonly TStrategy Strategy;
    
    public int Count { get; protected set; }

    protected BaseOrderedMap(Node<TK> root, TStrategy strategy, int count)
    {
        Root = root ?? throw new ArgumentNullException(nameof(root));
        Strategy = strategy ?? throw new ArgumentNullException(nameof(strategy));
        Count = count;

    }

    // ---------------------------------------------------------
    // Read Operations (Shared)
    // ---------------------------------------------------------

    public bool TryGetValue(TK key, out TV value)
    {
        return BTreeFunctions.TryGetValue(Root, key, Strategy, out value);
    }

    public bool ContainsKey(TK key)
    {
        return BTreeFunctions.TryGetValue<TK,TV, TStrategy>(Root, key, Strategy, out _);
    }
    
    

    // ---------------------------------------------------------
    // Bootstrap / Factory Helpers
    // ---------------------------------------------------------
        
    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<TK, TV>(OwnerId.None, strategy.UsesPrefixes);
        return new PersistentOrderedMap<TK, TV, TStrategy>(emptyRoot, strategy, 0);
    }

    public static TransientOrderedMap<TK, TV, TStrategy> CreateTransient(TStrategy strategy)
    {
        var emptyRoot = new LeafNode<TK, TV>(OwnerId.None, strategy.UsesPrefixes);
        return new TransientOrderedMap<TK, TV, TStrategy>(emptyRoot, strategy,0);
    }
    
    
    public BTreeEnumerator<TK, TV, TStrategy> GetEnumerator()
    {
        return AsEnumerable().GetEnumerator();
    }

    IEnumerator<KeyValuePair<TK, TV>> IEnumerable<KeyValuePair<TK, TV>>.GetEnumerator()
    {
        return GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    
    // 1. Full Scan
    public BTreeEnumerable<TK, TV, TStrategy> AsEnumerable() 
        => new(Root, Strategy, false, default!, false, default!);

// 2. Exact Range
    public BTreeEnumerable<TK, TV, TStrategy> Range(TK min, TK max) 
        => new(Root, Strategy, true, min, true, max);

// 3. Start From (Open Ended)
    public BTreeEnumerable<TK, TV, TStrategy> From(TK min) => new(Root, Strategy, true, min, false, default!);

// 4. Until (Start at beginning)
    public BTreeEnumerable<TK, TV, TStrategy> Until(TK max) 
        => new(Root, Strategy, false, default!, true, max);



    // ---------------------------------------------------------
// Navigation Operations
// ---------------------------------------------------------

public bool TryGetMin(out TK key, out TV value) => BTreeFunctions.TryGetMin(Root, out key, out value);

public bool TryGetMax(out TK key, out TV value) => BTreeFunctions.TryGetMax(Root, out key, out value);

public bool TryGetSuccessor(TK key, out TK nextKey, out TV nextValue) => BTreeFunctions.TryGetSuccessor(Root, key, Strategy, out nextKey, out nextValue);

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<TK, TV>> Intersect(BaseOrderedMap<TK, TV, TStrategy> other)
{
    using var enum1 = this.GetEnumerator();
    using var enum2 = other.GetEnumerator();
    
    bool has1 = enum1.MoveNext();
    bool has2 = enum2.MoveNext();

    while (has1 && has2)
    {
        int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
        if (cmp == 0)
        {
            yield return enum1.Current;
            has1 = enum1.MoveNext();
            has2 = enum2.MoveNext();
        }
        else if (cmp < 0) has1 = enum1.MoveNext();
        else has2 = enum2.MoveNext();
    }
}

public IEnumerable<KeyValuePair<TK, TV>> Except(BaseOrderedMap<TK, TV, TStrategy> other)
{
    using var enum1 = this.GetEnumerator();
    using var enum2 = other.GetEnumerator();
    
    bool has1 = enum1.MoveNext();
    bool has2 = enum2.MoveNext();

    while (has1 && has2)
    {
        int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
        if (cmp == 0)
        {
            has1 = enum1.MoveNext();
            has2 = enum2.MoveNext();
        }
        else if (cmp < 0)
        {
            yield return enum1.Current;
            has1 = enum1.MoveNext();
        }
        else
        {
            has2 = enum2.MoveNext();
        }
    }

    while (has1)
    {
        yield return enum1.Current;
        has1 = enum1.MoveNext();
    }
}

public IEnumerable<KeyValuePair<TK, TV>> SymmetricExcept(BaseOrderedMap<TK, TV, TStrategy> other)
{
    using var enum1 = this.GetEnumerator();
    using var enum2 = other.GetEnumerator();
    
    bool has1 = enum1.MoveNext();
    bool has2 = enum2.MoveNext();

    while (has1 && has2)
    {
        int cmp = Strategy.Compare(enum1.Current.Key, enum2.Current.Key);
        if (cmp == 0)
        {
            has1 = enum1.MoveNext();
            has2 = enum2.MoveNext();
        }
        else if (cmp < 0)
        {
            yield return enum1.Current;
            has1 = enum1.MoveNext();
        }
        else
        {
            yield return enum2.Current;
            has2 = enum2.MoveNext();
        }
    }

    while (has1)
    {
        yield return enum1.Current;
        has1 = enum1.MoveNext();
    }
    while (has2)
    {
        yield return enum2.Current;
        has2 = enum2.MoveNext();
    }
}
}