iteration.nct

//! Semantic Map iterators projected from private table cursors.

see ./index.nct
see ./storage.nct

use /hash.Hash
use /internal/table.{TableIntoIter, TableIter, TableIterMut}
use /iter.{ExactSizeIterator, Iterator}

struct MapIter<K, V> {
    source: TableIter<K, V>
}

struct MapIterMut<K, V> {
    source: TableIterMut<K, V>
}

struct MapIntoIter<K, V> {
    source: TableIntoIter<K, V>
}

instance Map<K, V> where K impl Hash {
    operator (...&self): MapIter<K, V> {
        return MapIter<K, V> { source: self.table.iter() }
    }

    operator (...&+self): MapIterMut<K, V> {
        return MapIterMut<K, V> { source: self.table.iter_mut() }
    }

    operator (...self): MapIntoIter<K, V> {
        return MapIntoIter<K, V> { source: self.table.into_iter() }
    }
}

instance MapIter<K, V> {
    method &self.remaining_len(): usize {
        return self.source.remaining()
    }

    method &+self.next(): MapEntryRef<K, V>? {
        let entry = self.source.advance() otherwise { return none }
        return MapEntryRef<K, V> { key: entry.key, value: entry.value }
    }
}

instance MapIterMut<K, V> {
    method &self.remaining_len(): usize {
        return self.source.remaining()
    }

    method &+self.next(): MapEntryMut<K, V>? {
        let entry = self.source.advance() otherwise { return none }
        return MapEntryMut<K, V> { key: entry.key, value: entry.value }
    }
}

instance MapIntoIter<K, V> {
    method &self.remaining_len(): usize {
        return self.source.remaining()
    }

    method &+self.next(): MapEntry<K, V>? {
        let entry = self.source.advance() otherwise { return none }
        return MapEntry<K, V> { key: move entry.key, value: move entry.value }
    }
}