Struct hashtable_nodes 

pub struct hashtable_nodes<T> { /* private fields */ }

Port of the node-storage half of struct hashtable (Src/zsh.h:1175-1235: HashNode *nodes; int hsize; int ct;) as Src/hashtable.c actually drives it — an OPEN-HASHED BUCKET ARRAY:

• bucket index is ht->hash(nam) % ht->hsize (c:176/236/260/280);
• a new key goes to the FRONT of its chain (c:194-196 for an empty bucket, c:214-215 otherwise);
• replacing an existing key keeps that key’s POSITION in the chain (c:187-203 replacing: — hn->next = hp->next);
• once ct >= hsize * 2 the table quadruples and every node is re-added in old-traversal order (c:183/219 → expandhashtable c:458-482);
• an unsorted scan walks bucket 0..hsize-1, each chain head→tail (scanmatchtable c:420-434).

That walk order is OBSERVABLE: ${(k)functions} / ${(k)commands} / compadd -k <assoc> all emit it verbatim (Src/Modules/parameter.c:480-481 loops shfunctab->nodes[i] directly), and join_clines is a non-commutative fold, so the order matches are added in decides the common prefix compadd -k produces.

The port previously stood a std::collections::HashMap in for the bucket array. That is not merely a different order — RandomState re-seeds per process, so print -rl -- ${(k)functions} returned a DIFFERENT order on every run of the same binary against the same 46761-function table, and any completion enumerating the table was nondeterministic.

!!! WARNING: RUST-ONLY HELPER !!! C reaches these fields through one polymorphic struct hashtable with hash/cmpnodes/addnode/getnode function pointers. Rust has no equivalent of the HashNode-as-first-member downcast, so the storage is a generic struct and the typed wrappers below embed it. Every method is named for the Src/hashtable.c function it ports.

Implementations

impl<T> hashtable_nodes<T>

pub fn newhashtable(size: usize) -> Self

Port of newhashtable(int size, …) from Src/hashtable.c:100 — zshcalloc(size * sizeof(HashNode)) + hsize = size + ct = 0.

pub fn addhashnode2(&mut self, nam: &str, nodeptr: T) -> Option<T>

Port of addhashnode2(HashTable ht, char *nam, void *nodeptr) from Src/hashtable.c:168 — inserts, returning the displaced node.

pub fn gethashnode2(&self, nam: &str) -> Option<&T>

Port of gethashnode2(HashTable ht, const char *nam) from Src/hashtable.c:255 — lookup WITHOUT the DISABLED filter.

pub fn get_mut(&mut self, nam: &str) -> Option<&mut T>

Mutable companion of hashtable_nodes::gethashnode2. C mutates straight through the returned HashNode pointer; Rust needs the separate borrow.

pub fn removehashnode(&mut self, nam: &str) -> Option<T>

Port of removehashnode(HashTable ht, const char *nam) from Src/hashtable.c:275 — unlinks the node from its chain and decrements ct.

pub fn emptyhashtable(&mut self)

Port of emptyhashtable(HashTable ht) from Src/hashtable.c:517 (resizehashtable(ht, ht->hsize)) — frees every node, keeps hsize.

pub fn len(&self) -> usize

C’s ht->ct (Src/zsh.h:1181).

pub fn is_empty(&self) -> bool

ht->ct == 0.

pub fn iter(&self) -> impl Iterator<Item = (&String, &T)>

The unsorted scan order of scanmatchtable (Src/hashtable.c:420-434): bucket 0..hsize-1, each chain head→tail. This IS the order zsh’s ${(k)assoc} / compadd -k emit.

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&String, &mut T)>

Mutable companion of hashtable_nodes::iter — same scanmatchtable walk (Src/hashtable.c:420-434); C hands the scan function a writable HashNode, Rust needs the separate borrow.

pub fn keys(&self) -> impl Iterator<Item = &String>

The names in scanmatchtable order (Src/hashtable.c:420-434) — C’s scan reads hn->nam off each node in the same walk.

pub fn values(&self) -> impl Iterator<Item = &T>

The nodes in scanmatchtable order (Src/hashtable.c:420-434).

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut T>

Mutable companion of hashtable_nodes::values (Src/hashtable.c:420-434).

pub fn get(&self, nam: &str) -> Option<&T>

ht->getnode2(ht, nam) (Src/hashtable.c:255 gethashnode2) — map-shaped alias so tables converted from a HashMap keep their call sites. Same O(1) bucket hash + short-chain walk as C.

pub fn contains_key(&self, nam: &str) -> bool

ht->getnode2(ht, nam) != NULL (Src/hashtable.c:255).

pub fn insert(&mut self, nam: String, nodeptr: T) -> Option<T>

ht->addnode(ht, ztrdup(nam), node) (Src/hashtable.c:157 addhashnode → addhashnode2 at c:168) — returns the displaced node instead of running freenode.

pub fn remove(&mut self, nam: &str) -> Option<T>

ht->removenode(ht, nam) (Src/hashtable.c:275 removehashnode).

pub fn clear(&mut self)

ht->emptytable(ht) (Src/hashtable.c:517 emptyhashtable).

pub fn retain<F: FnMut(&String, &mut T) -> bool>(&mut self, f: F)

The scanmatchtable walk (Src/hashtable.c:420-434) with the C freenode arm taken for every node the predicate rejects. Chain order of the survivors is preserved exactly, which is what makes this different from rebuilding the table.

Trait Implementations

impl<T: Clone> Clone for hashtable_nodes<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for hashtable_nodes<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for hashtable_nodes<T>

fn default() -> Self

newparamtable/newmoduletable fall back to size = 17 when handed 0 (Src/params.c:541-542, and Src/module.c:1602 creates 17-bucket sub-tables); use that as the neutral default for #[derive(Default)] containers.

impl<T, Q: ?Sized + Borrow<str>> Index<&Q> for hashtable_nodes<T>

fn index(&self, nam: &Q) -> &T

ht->getnode2(ht, nam) with C’s “caller already checked” contract (Src/hashtable.c:255) — panics on a missing name, like the HashMap indexing it replaces.

type Output = T

The returned type after indexing.

impl<'a, T> IntoIterator for &'a hashtable_nodes<T>

fn into_iter(self) -> Self::IntoIter

for (k, v) in &table — the scanmatchtable walk (Src/hashtable.c:420-434).

type Item = (&'a String, &'a T)

The type of the elements being iterated over.

type IntoIter = Map<Flatten<Iter<'a, Vec<(String, T)>>>, fn(&'a (String, T)) -> (&'a String, &'a T)>

Which kind of iterator are we turning this into?