tiny.http.ResponseStorage

1pub const Storage = struct {2    phase: alloc_phase.capacity.Phase,3    capacity: StorageCapacity,4    bytes: []align(@alignOf(Header)) u8,56    pub const Limits: type = StorageLimits;7    pub const Capacity: type = StorageCapacity;8    pub const Exhaustion: type = StorageExhaustion;9    pub const InitError = std.mem.Allocator.Error || error{CapacityOverflow};1011    pub const claim: alloc_phase.capacity.Declaration = .{12        .source = .{13            .id = "http.response_storage",14            .kind = .phase_static,15            .limit_source = .caller,16            .storage = .{17                .covered = &.{18                    .{19                        .id = "fixed_response_header_entry_region_for_every_response_slot",20                        .lifetime = .steady,21                        .detail = "fixed response-header entry region for every response slot",22                    },23                    .{24                        .id = "fixed_serialized_response_head_byte_region_for_ever_e148bf132b18",25                        .lifetime = .steady,26                        .detail = "fixed serialized response-head byte region for every response slot",27                    },28                },29                .excluded = &.{30                    "borrowed or transferred response body bytes and release callbacks",31                    "connection input, socket and kernel queues, clients, TLS, and protocol sessions",32                },33            },34            .capacity = .{35                .inputs = &.{36                    alloc_phase.capacity.bindInput(StorageLimits, "response_count", "response_count"),37                    alloc_phase.capacity.bindInput(StorageLimits, "header_count_per_response", "header_count_per_response"),38                    alloc_phase.capacity.bindInput(StorageLimits, "head_bytes_per_response", "head_bytes_per_response"),39                },40                .type_selectors = &.{41                    alloc_phase.capacity.bindType(Header, "header"),42                },43                .nodes = &.{44                    .{ .input = 0 },45                    .{ .input = 1 },46                    .{ .product = .{ .left = 0, .right = 1 } },47                    .{ .constant = 1 },48                    .{ .scale = .{ .node = 3, .coefficient = .{ .size_of_concrete_type = 0 } } },49                    .{ .product = .{ .left = 2, .right = 4 } },50                    .{ .input = 2 },51                    .{ .product = .{ .left = 0, .right = 6 } },52                    .{ .add = .{ .left = 5, .right = 7 } },53                },54                .assertions = &.{.{55                    .scope = .closure_total,56                    .measure = .retained,57                    .relation = .exact,58                    .expression = 8,59                }},60            },61            .overload = .{62                .kind = .reject_before_mutation,63                .detail = "header and serialized-head max plus one preserve prior storage",64            },65            .risks = .{66                .transitive = .{67                    .status = .witnessed,68                    .detail = "response mutation and serialization allocate no storage after activation",69                },70                .foreign = .{71                    .status = .excluded,72                    .detail = "serialization transforms borrowed values without performing I/O",73                },74            },75            .obligations = &.{76                .{ .key = "http_response_capacity", .role = .capacity_model },77                .{ .key = "http_response_oom_retry", .role = .custom },78                .{ .key = "http_response_partition", .role = .custom },79                .{ .key = "http_response_sealed", .role = .transitive_risk },80                .{ .key = "http_response_atomic_overload", .role = .overload },81                .{ .key = "http_response_atomic_foreign_risk", .role = .foreign_risk },82                .{ .key = "http_response_boundary", .role = .custom },83                .{ .key = "http_response_router", .role = .custom },84            },85        },86        .bindings = .{87            .owner = @This(),88            .seal = .{89                .family = alloc_phase.capacity.selector(@This().activate),90                .premise = .{91                    .class = .checked_semantic_fact,92                    .authority = .checker,93                },94            },95            .teardown = .{96                .family = alloc_phase.capacity.selector(@This().deinit),97                .premise = .{98                    .class = .checked_semantic_fact,99                    .authority = .checker,100                },101            },102        },103    };104105    pub fn init(allocator: std.mem.Allocator, limits: StorageLimits) InitError!Storage {106        const capacity = try StorageCapacity.derive(limits);107        const bytes = if (capacity.storage_bytes == 0)108            @as([]align(@alignOf(Header)) u8, &.{})109        else110            try allocator.alignedAlloc(u8, .of(Header), capacity.storage_bytes);111        return .{112            .phase = .initialization,113            .capacity = capacity,114            .bytes = bytes,115        };116    }117118    pub fn activate(self: *Storage) void {119        std.debug.assert(self.phase == .initialization);120        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);121        self.phase = .steady;122    }123124    pub fn response(self: *Storage, index: usize) Exhaustion!Scratch {125        std.debug.assert(self.phase == .steady);126        if (index >= self.capacity.response_count) return error.ResponseCapacityExceeded;127        const all_headers = std.mem.bytesAsSlice(128            Header,129            self.bytes[0..self.capacity.header_bytes],130        );131        const header_start = index * self.capacity.header_count_per_response;132        const head_start = self.capacity.header_bytes +133            index * self.capacity.head_bytes_per_response;134        return .{135            .headers = all_headers[header_start..][0..self.capacity.header_count_per_response],136            .head = self.bytes[head_start..][0..self.capacity.head_bytes_per_response],137        };138    }139140    pub fn deinit(self: *Storage, allocator: std.mem.Allocator) void {141        std.debug.assert(self.phase != .teardown);142        std.debug.assert(self.bytes.len == self.capacity.storage_bytes);143        self.phase = .teardown;144        if (self.bytes.len != 0) allocator.free(self.bytes);145        self.bytes = &.{};146    }147};

1pub const ResponseStorage = response.Storage;