graph

func (*Mapper[N]) Intern ¶

func (m *Mapper[N]) Intern(k N) NodeID

Intern returns the NodeID associated with k, allocating a new one on first encounter. Subsequent calls with the same value return the same NodeID. The fast path (k already interned) takes a read lock only and performs no heap allocation.

func (*Mapper[N]) Len ¶

func (m *Mapper[N]) Len() int

Len returns the total number of values currently interned across every shard. The returned count is a consistent snapshot per shard but may not reflect concurrent inserts in other shards.

func (*Mapper[N]) LoadFrom ¶

func (m *Mapper[N]) LoadFrom(entries []MapperEntry[N]) error

LoadFrom rebuilds m's internal state from a snapshot's entries. It is intended for one-shot recovery initialisation against a fresh (zero-state) Mapper.

The pre-conditions enforced are:

1. m must be empty in every shard (ErrMapperNotEmpty otherwise).
2. Each entry's NodeID, when unpacked, must yield a shard index equal to mapperShardFor(entry.Key). The writer guarantees this because it composes NodeIDs via [packNodeID] from the same hash.
3. After grouping entries by shard and sorting by intra-index, intra-indexes must form the contiguous sequence 0..N-1. Any gap surfaces as ErrMapperEntryCorrupted.
4. Within a shard, no two entries may collide on the natural key.

Post-condition: subsequent Mapper.Intern calls with a previously seeded key return the original NodeID; new keys get fresh slots after the seeded ones (the next intra-index is len(reverse)).

LoadFrom is safe for concurrent goroutines only with respect to other LoadFrom calls (which would all fail with ErrMapperNotEmpty after the first); it must not run concurrently with any Intern/Lookup/Resolve/Walk call on the same Mapper.

func (*Mapper[N]) Lookup ¶

func (m *Mapper[N]) Lookup(k N) (NodeID, bool)

Lookup returns the NodeID previously assigned to k and true, or the zero NodeID and false when k has not been interned. The fast path holds a read lock only and performs no heap allocation. Unlike Mapper.Intern, Lookup never mutates the Mapper, which makes it the right primitive for read-only operations (HasEdge, Neighbours, existence checks) on backends layered above the Mapper.

package main

import (
	"fmt"

	"github.com/FlavioCFOliveira/GoGraph/graph"
)

func main() {
	m := graph.NewMapper[string]()
	m.Intern("alice")

	_, known := m.Lookup("alice")
	_, unknown := m.Lookup("carol")

	fmt.Println("alice known:", known)
	fmt.Println("carol known:", unknown)
}

Output:
alice known: true
carol known: false

func (*Mapper[N]) MaxNodeID ¶

func (m *Mapper[N]) MaxNodeID() NodeID

MaxNodeID returns one more than the largest NodeID that has been assigned by this Mapper. It is the natural size for an array indexed directly by NodeID (e.g. a CSR offsets array). Returns 0 when no value has been interned.

func (*Mapper[N]) Resolve ¶

func (m *Mapper[N]) Resolve(id NodeID) (N, bool)

Resolve returns the value previously interned under id, or the zero value of N and false when id was not produced by this Mapper.

func (*Mapper[N]) Walk ¶

func (m *Mapper[N]) Walk(fn func(NodeID, N) bool)

Walk invokes fn for every interned (NodeID, value) pair, taking each shard's RLock once for the whole iteration instead of once per Resolve call. Returns early when fn returns false.

Concurrency: Walk holds each shard's RLock while iterating that shard, so concurrent Intern calls on the same shard block until Walk advances past it. Concurrent Resolve calls on the same shard also block (the read lock is held for the duration of the inner loop). Use Walk for bulk export where many Resolves would otherwise dominate; prefer Resolve for individual lookups.

package main

import (
	"fmt"
	"sort"

	"github.com/FlavioCFOliveira/GoGraph/graph"
)

func main() {
	m := graph.NewMapper[string]()
	m.Intern("alice")
	m.Intern("bob")
	m.Intern("carol")

	var keys []string
	m.Walk(func(_ graph.NodeID, key string) bool {
		keys = append(keys, key)
		return true // returning false would stop the walk early
	})
	sort.Strings(keys)

	fmt.Println(keys)
}

Output:
[alice bob carol]