Documentation
¶
Index ¶
- type EdgeItem
- type EdgeKey
- type GraphCache
- func (c *GraphCache[S, T]) AddEdge(tail, head S, w float32)
- func (c *GraphCache[S, T]) AddEdgeWithExpiration(tail, head S, w float32, expiration time.Time)
- func (c *GraphCache[S, T]) AddEdgeWithTTL(tail, head S, w float32, ttl time.Duration)
- func (c *GraphCache[S, T]) AddEdgesWithExpiration(items []EdgeItem[S])
- func (c *GraphCache[S, T]) AddVertexWithExpiration(key S, value T, expiration time.Time)
- func (c *GraphCache[S, T]) AddVertexWithTTL(key S, value T, ttl time.Duration)
- func (c *GraphCache[S, T]) AddVerticesWithExpiration(items []VertexItem[S, T])
- func (c *GraphCache[S, T]) DeleteEdge(tail, head S) bool
- func (c *GraphCache[S, T]) DeleteEdges(keys []EdgeKey[S]) int
- func (c *GraphCache[S, T]) DeleteVertex(key S) bool
- func (c *GraphCache[S, T]) DeleteVertices(keys []S) int
- func (c *GraphCache[S, T]) GetEdgeDetail(tail, head S) (float32, time.Time, bool)
- func (c *GraphCache[S, T]) GetVertex(key S) (T, bool)
- func (c *GraphCache[S, T]) GetWeight(tail, head S) (float32, bool)
- func (c *GraphCache[S, T]) Neighbor(seed S, step int, k int, tfidf bool) *graph.Graph[S, T]
- func (c *GraphCache[S, T]) NeighborContext(ctx context.Context, seed S, step int, k int, tfidf bool) (*graph.Graph[S, T], error)
- func (c *GraphCache[S, T]) NeighborWithExpirationsContext(ctx context.Context, seed S, step int, k int, tfidf bool) (*graph.Graph[S, T], map[S]map[S]time.Time, error)
- func (c *GraphCache[S, T]) PutEdgeWithExpiration(tail, head S, w float32, expiration time.Time)
- func (c *GraphCache[S, T]) PutEdgesWithExpiration(items []EdgeItem[S])
- func (c *GraphCache[S, T]) PutVertex(key S, value T)
- func (c *GraphCache[S, T]) Watch(ctx context.Context, interval time.Duration)
- type VertexItem
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type EdgeItem ¶
type EdgeItem[S comparable] struct { Tail S Head S Weight float32 Expiration time.Time }
EdgeItem is a single (tail, head, weight, expiration) tuple supplied to AddEdgesWithExpiration / PutEdgesWithExpiration.
type EdgeKey ¶
type EdgeKey[S comparable] struct { Tail S Head S }
EdgeKey identifies a directed edge for batch deletion via DeleteEdges.
type GraphCache ¶
type GraphCache[S comparable, T any] struct { // contains filtered or unexported fields }
func NewGraphCache ¶
func NewGraphCache[S comparable, T any](defaultTTL time.Duration) *GraphCache[S, T]
func (*GraphCache[S, T]) AddEdge ¶
func (c *GraphCache[S, T]) AddEdge(tail, head S, w float32)
func (*GraphCache[S, T]) AddEdgeWithExpiration ¶
func (c *GraphCache[S, T]) AddEdgeWithExpiration(tail, head S, w float32, expiration time.Time)
func (*GraphCache[S, T]) AddEdgeWithTTL ¶
func (c *GraphCache[S, T]) AddEdgeWithTTL(tail, head S, w float32, ttl time.Duration)
func (*GraphCache[S, T]) AddEdgesWithExpiration ¶
func (c *GraphCache[S, T]) AddEdgesWithExpiration(items []EdgeItem[S])
AddEdgesWithExpiration additively writes every supplied edge under a single write lock, auto-creating endpoint vertices on demand (matching the per-edge AddEdgeWithExpiration invariant). Concurrent readers see either the pre-batch or the post-batch state.
func (*GraphCache[S, T]) AddVertexWithExpiration ¶
func (c *GraphCache[S, T]) AddVertexWithExpiration(key S, value T, expiration time.Time)
func (*GraphCache[S, T]) AddVertexWithTTL ¶
func (c *GraphCache[S, T]) AddVertexWithTTL(key S, value T, ttl time.Duration)
func (*GraphCache[S, T]) AddVerticesWithExpiration ¶
func (c *GraphCache[S, T]) AddVerticesWithExpiration(items []VertexItem[S, T])
AddVerticesWithExpiration writes every supplied vertex under a single write lock. Concurrent readers observe either the pre-batch or the post-batch state — never an intermediate snapshot where some keys are present and others are not.
func (*GraphCache[S, T]) DeleteEdge ¶
func (c *GraphCache[S, T]) DeleteEdge(tail, head S) bool
DeleteEdge removes the (tail, head) edge and returns whether it was present.
func (*GraphCache[S, T]) DeleteEdges ¶
func (c *GraphCache[S, T]) DeleteEdges(keys []EdgeKey[S]) int
DeleteEdges removes every supplied edge under a single write lock and returns the count of edges that were actually present. Concurrent readers observe either the pre-batch or the post-batch state.
func (*GraphCache[S, T]) DeleteVertex ¶
func (c *GraphCache[S, T]) DeleteVertex(key S) bool
DeleteVertex removes the vertex (by key) and returns whether it was present.
func (*GraphCache[S, T]) DeleteVertices ¶
func (c *GraphCache[S, T]) DeleteVertices(keys []S) int
DeleteVertices removes every supplied vertex under a single write lock and returns the count of keys that were actually present (and therefore deleted). Concurrent readers observe either the pre-batch or the post-batch state.
func (*GraphCache[S, T]) GetEdgeDetail ¶
func (c *GraphCache[S, T]) GetEdgeDetail(tail, head S) (float32, time.Time, bool)
GetEdgeDetail returns the current edge weight together with the latest contribution expiration. The expiration is the moment after which the edge is guaranteed to have decayed to zero. When no edge exists, ok is false.
func (*GraphCache[S, T]) GetVertex ¶
func (c *GraphCache[S, T]) GetVertex(key S) (T, bool)
func (*GraphCache[S, T]) GetWeight ¶
func (c *GraphCache[S, T]) GetWeight(tail, head S) (float32, bool)
func (*GraphCache[S, T]) NeighborContext ¶
func (c *GraphCache[S, T]) NeighborContext(ctx context.Context, seed S, step int, k int, tfidf bool) (*graph.Graph[S, T], error)
NeighborContext is the context-aware variant of Neighbor. It returns ctx.Err() as soon as the context is cancelled or its deadline has expired — checked between BFS expansion steps — so handlers can short-circuit large traversals when the caller has given up.
func (*GraphCache[S, T]) NeighborWithExpirationsContext ¶
func (c *GraphCache[S, T]) NeighborWithExpirationsContext(ctx context.Context, seed S, step int, k int, tfidf bool) (*graph.Graph[S, T], map[S]map[S]time.Time, error)
NeighborWithExpirationsContext returns the same subgraph as NeighborContext together with a parallel expirations map keyed by (tail, head). Both are computed under a single RLock so handlers can compose responses without re-acquiring the cache lock per edge.
The expirations map only contains entries for edges that ended up in the returned graph; a missing or zero value means the edge has no known expiration.
func (*GraphCache[S, T]) PutEdgeWithExpiration ¶
func (c *GraphCache[S, T]) PutEdgeWithExpiration(tail, head S, w float32, expiration time.Time)
PutEdgeWithExpiration atomically replaces the (tail, head) edge weight. AddEdgeWithExpiration is additive (Add semantics) so a naive "DeleteEdge + AddEdgeWithExpiration" sequence performed by callers exposes a window in which concurrent GetEdge readers observe a spurious NotFound. PutEdgeWithExpiration takes the write lock once and performs the delete + add under the same lock, restoring atomicity for the idempotent Put semantics.
func (*GraphCache[S, T]) PutEdgesWithExpiration ¶
func (c *GraphCache[S, T]) PutEdgesWithExpiration(items []EdgeItem[S])
PutEdgesWithExpiration replaces every supplied edge atomically under a single write lock. Each (tail, head) pair is deleted and re-added so the resulting weight is exactly the supplied weight — matching PutEdgeWithExpiration semantics for each item in the batch.
func (*GraphCache[S, T]) PutVertex ¶
func (c *GraphCache[S, T]) PutVertex(key S, value T)
type VertexItem ¶
type VertexItem[S comparable, T any] struct { Key S Value T Expiration time.Time }
VertexItem is a single (key, value, expiration) tuple supplied to AddVerticesWithExpiration.
Source Files
Directories