tiny.syn.SpanCapacity

1/// The sizes that follow from one `Limits` value, computed without allocating. A caller derives it2/// before allocating, to learn the exact bytes span storage will take, and the storage keeps its3/// own copy.4pub const Capacity = struct {5    /// The limits the sizes were derived from, as given.6    limits: Limits,7    /// The span capacity: how many spans the storage holds, equal to `limits.max_text_bytes`. A8    /// line within the limit never needs more, because each kept span covers at least one byte and9    /// no two overlap.10    span_capacity: usize,11    /// The bytes those spans take: `span_capacity` times the size of one `Span`.12    span_bytes: usize,13    /// The bytes `Storage.init` allocates, in one region, equal to `span_bytes`. `Storage.status`14    /// reports the same number, and the README example checks that the two agree. The byte count is15    /// zero when the limit is zero, and then `Storage.init` allocates nothing.16    storage_bytes: usize,1718    /// Returns the sizes for `limits`. A caller computes the storage size ahead of time, for19    /// example to check a memory budget, and `Storage.init` calls it too. `Capacity.derive` fails20    /// with `error.CapacityOverflow` when `max_text_bytes` times the size of one `Span` overflows a21    /// `usize`. The call allocates nothing and reads nothing but its argument.22    pub fn derive(limits: Limits) DeriveError!Capacity {23        const span_bytes = std.math.mul(24            usize,25            limits.max_text_bytes,26            @sizeOf(model.Span),27        ) catch return error.CapacityOverflow;28        return .{29            .limits = limits,30            .span_capacity = limits.max_text_bytes,31            .span_bytes = span_bytes,32            .storage_bytes = span_bytes,33        };34    }35};

1pub const SpanCapacity = span.Capacity;