Files
mesh-sdk/go/views/held_writer.go
T
jschoubben adf7392651 G A-29: views.HeldWriter, the writer of a part whose findings are raised as they happen, observes the findings it holds
Seeded from the state's keys before it starts, held under a lock of its own, its Observe answers them; Write and Clear keep the
held set. The watchman's copy moves here.

Builds: design 47 G A-29, §686
Claude-Session: https://claude.ai/code/session_01JG73KEq4zoDfM9WtYpcQgZ
2026-11-11 22:02:02 +01:00

91 lines
2.8 KiB
Go

package views
import (
"context"
"encoding/json"
"errors"
"sync"
)
// HeldWriter is the finding writer of a part whose findings are raised as they happen, not judged afresh (design 47 G A-29,
// §686): it holds the findings it has written, seeded from the keys of its state `findings` before it starts, under a lock of
// its own (never the part's: the writer calls Observe under its own lock while the part writes under its), and its Observe
// answers them, so a statement says exactly what the part holds. Write and Clear update the held set and then the writer's.
// It is a Writer[F, C, S, A] with that Observe, so no part writes the adapter.
type HeldWriter[F, C, S, A any] struct {
*Writer[F, C, S, A]
mu sync.Mutex
held map[string]F
}
// NewHeldWriter makes the writer for cfg, whose Observe is none (a given Observe is refused): the findings that stand in
// cfg.State are read at once, each key's value as the writer kept it (a value that is no finding of F is left to the next
// statement, which deletes its key when it is of a kind the writer owns).
func NewHeldWriter[F, C, S, A any](cfg WriterConfig[F, C, S, A]) (*HeldWriter[F, C, S, A], error) {
if cfg.Observe != nil {
return nil, errors.New("a held finding writer observes what it holds: it takes no Observe")
}
if cfg.State == nil {
return nil, errors.New("a finding writer needs the state `findings`")
}
h := &HeldWriter[F, C, S, A]{held: map[string]F{}}
keys, err := cfg.State.Keys()
if err != nil {
return nil, err
}
for _, k := range keys {
e, err := cfg.State.Get(k)
if err != nil {
return nil, err
}
var f F
if e == nil || json.Unmarshal(e.Value, &f) != nil {
continue
}
if m, err := wireOf(&f); err == nil && keyOf(m) == k {
h.held[k] = f
}
}
cfg.Observe = func(context.Context) (Observed[F], error) {
h.mu.Lock()
defer h.mu.Unlock()
var o Observed[F]
for _, f := range h.held {
o.Findings = append(o.Findings, f)
}
return o, nil
}
w, err := NewWriter(cfg)
if err != nil {
return nil, err
}
h.Writer = w
return h, nil
}
// Write holds the finding and writes it through the writer.
func (h *HeldWriter[F, C, S, A]) Write(ctx context.Context, finding F) error {
m, err := wireOf(&finding)
if err != nil {
return err
}
if err := CheckFinding(m); err != nil {
return err
}
if !h.Writer.owns(str(m, "kind")) {
return h.Writer.Write(ctx, finding) // refused by the writer, naming the kind, and held no more than it is
}
h.mu.Lock()
h.held[keyOf(m)] = finding
h.mu.Unlock()
return h.Writer.Write(ctx, finding)
}
// Clear stops holding the finding of scope, id and kind and clears it through the writer.
func (h *HeldWriter[F, C, S, A]) Clear(ctx context.Context, scope, id, kind, why string) error {
h.mu.Lock()
delete(h.held, FindingKey(scope, id, kind))
h.mu.Unlock()
return h.Writer.Clear(ctx, scope, id, kind, why)
}