tiny.smg.EdgeFindingPlan

1pub const EdgeFindingPlan = struct {2    pub const Limits = struct {3        edges: usize,4    };56    pub const Capacity = struct {7        edges: usize,8        bytes: usize,910        pub fn derive(limits: Limits) error{CapacityOverflow}!Capacity {11            return .{12                .edges = limits.edges,13                .bytes = std.math.mul(14                    usize,15                    limits.edges,16                    @sizeOf(model.Edge),17                ) catch return error.CapacityOverflow,18            };19        }20    };2122    pub const InitError = std.mem.Allocator.Error || error{CapacityOverflow};2324    pub const claim: alloc_phase.capacity.Declaration = .{25        .source = .{26            .id = "smg.edge_finding_plan",27            .kind = .phase_static,28            .limit_source = .caller,29            .storage = .{30                .covered = &.{31                    .{32                        .id = "exact_edge_finding_result",33                        .lifetime = .transferred,34                        .detail = "exact edge finding result",35                    },36                },37                .excluded = &.{38                    "borrowed graph nodes edges indexes and model strings",39                    "parsed rule fields and finding message text",40                    "rule aggregation rendering and terminal output",41                },42            },43            .capacity = .{44                .inputs = &.{45                    alloc_phase.capacity.bindInput(Limits, "edges", "edges"),46                },47                .type_selectors = &.{48                    alloc_phase.capacity.bindType(model.Edge, "edge"),49                },50                .nodes = &.{51                    .{ .input = 0 },52                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },53                },54                .assertions = &.{.{55                    .scope = .closure_total,56                    .measure = .retained,57                    .relation = .exact,58                    .expression = 1,59                }},60            },61            .overload = .{62                .kind = .reject_before_seal,63                .detail = "checked survey arithmetic and exact acquisition reject before fill",64            },65            .risks = .{66                .transitive = .{67                    .status = .witnessed,68                    .detail = "sealed fill and in-place ordering call no allocator-backed child",69                },70                .foreign = .{71                    .status = .excluded,72                    .detail = "rule matching and result production perform no foreign effects",73                },74            },75            .obligations = &.{76                .{ .key = "smg_edge_finding_plan_capacity_capacity_model", .role = .capacity_model },77                .{ .key = "smg_edge_finding_plan_capacity_overload", .role = .overload },78                .{ .key = "smg_edge_finding_plan_oom", .role = .overload },79                .{ .key = "smg_edge_finding_plan_sealed", .role = .transitive_risk },80                .{ .key = "smg_edge_finding_plan_integration", .role = .foreign_risk },81            },82        },83        .bindings = .{84            .owner = @This(),85            .seal = .{86                .family = alloc_phase.capacity.selector(@This().activate),87                .premise = .{88                    .class = .checked_semantic_fact,89                    .authority = .checker,90                },91            },92            .teardown = .{93                .family = alloc_phase.capacity.selector(@This().deinit),94                .premise = .{95                    .class = .checked_semantic_fact,96                    .authority = .checker,97                },98            },99        },100    };101102    phase: alloc_phase.capacity.Phase,103    capacity: Capacity,104    edges: []model.Edge,105    filled: usize = 0,106107    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!EdgeFindingPlan {108        const capacity = try Capacity.derive(limits);109        return .{110            .phase = .initialization,111            .capacity = capacity,112            .edges = try allocFindingEdges(allocator, capacity.edges),113        };114    }115116    pub fn activate(self: *EdgeFindingPlan) void {117        std.debug.assert(self.phase == .initialization);118        std.debug.assert(self.filled == 0);119        self.phase = .steady;120    }121122    pub fn append(self: *EdgeFindingPlan, edge: model.Edge) void {123        std.debug.assert(self.phase == .steady);124        std.debug.assert(self.filled < self.edges.len);125        self.edges[self.filled] = edge;126        self.filled += 1;127    }128129    pub fn sort(self: *EdgeFindingPlan) void {130        std.debug.assert(self.phase == .steady);131        std.debug.assert(self.filled == self.edges.len);132        view.sortEdges(self.edges);133    }134135    pub fn transfer(self: *EdgeFindingPlan) []const model.Edge {136        std.debug.assert(self.phase == .steady);137        std.debug.assert(self.filled == self.edges.len);138        const edges = self.edges;139        self.phase = .teardown;140        self.edges = @constCast((&[_]model.Edge{})[0..]);141        self.filled = 0;142        return edges;143    }144145    pub fn deinit(self: *EdgeFindingPlan, allocator: std.mem.Allocator) void {146        std.debug.assert(self.phase != .teardown);147        self.phase = .teardown;148        freeFindingEdges(allocator, self.edges);149        self.* = undefined;150    }151};

1pub const EdgeFindingPlan = @import("rules.zig").EdgeFindingPlan;