tiny.smg.NodeFindingPlan

1pub const NodeFindingPlan = struct {2    pub const Limits = struct {3        nodes: usize,4    };56    pub const Capacity = struct {7        nodes: usize,8        bytes: usize,910        pub fn derive(limits: Limits) error{CapacityOverflow}!Capacity {11            return .{12                .nodes = limits.nodes,13                .bytes = std.math.mul(14                    usize,15                    limits.nodes,16                    @sizeOf([]const u8),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.node_finding_plan",27            .kind = .phase_static,28            .limit_source = .caller,29            .storage = .{30                .covered = &.{31                    .{32                        .id = "exact_node_finding_result",33                        .lifetime = .transferred,34                        .detail = "exact node finding result",35                    },36                },37                .excluded = &.{38                    "borrowed graph nodes 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, "nodes", "nodes"),46                },47                .type_selectors = &.{48                    alloc_phase.capacity.bindType([]const u8, "const_u8"),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_node_finding_plan_capacity_capacity_model", .role = .capacity_model },77                .{ .key = "smg_node_finding_plan_capacity_overload", .role = .overload },78                .{ .key = "smg_node_finding_plan_oom", .role = .overload },79                .{ .key = "smg_node_finding_plan_sealed", .role = .transitive_risk },80                .{ .key = "smg_node_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    nodes: [][]const u8,105    filled: usize = 0,106107    pub fn init(allocator: std.mem.Allocator, limits: Limits) InitError!NodeFindingPlan {108        const capacity = try Capacity.derive(limits);109        return .{110            .phase = .initialization,111            .capacity = capacity,112            .nodes = try allocFindingNodes(allocator, capacity.nodes),113        };114    }115116    pub fn activate(self: *NodeFindingPlan) 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: *NodeFindingPlan, node: []const u8) void {123        std.debug.assert(self.phase == .steady);124        std.debug.assert(self.filled < self.nodes.len);125        self.nodes[self.filled] = node;126        self.filled += 1;127    }128129    pub fn sort(self: *NodeFindingPlan) void {130        std.debug.assert(self.phase == .steady);131        std.debug.assert(self.filled == self.nodes.len);132        std.mem.sort([]const u8, self.nodes, {}, cmpString);133    }134135    pub fn transfer(self: *NodeFindingPlan) []const []const u8 {136        std.debug.assert(self.phase == .steady);137        std.debug.assert(self.filled == self.nodes.len);138        const nodes = self.nodes;139        self.phase = .teardown;140        self.nodes = @constCast((&[_][]const u8{})[0..]);141        self.filled = 0;142        return nodes;143    }144145    pub fn deinit(self: *NodeFindingPlan, allocator: std.mem.Allocator) void {146        std.debug.assert(self.phase != .teardown);147        self.phase = .teardown;148        freeFindingNodes(allocator, self.nodes);149        self.* = undefined;150    }151};

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