tiny.tldr.LinkedImage

1pub const LinkedImage = struct {2    bytes: []u8,3    storage: Storage = .heap,4    manifest: incremental.Manifest,56    pub const Storage = union(enum) {7        heap,8        mapped_file: []align(std.heap.page_size_min) u8,910        pub const Allocation = struct {11            bytes: []u8,12            storage: Storage,1314            pub fn deinit(self: *Allocation, allocator: std.mem.Allocator) void {15                switch (self.storage) {16                    .heap => allocator.free(self.bytes),17                    .mapped_file => |mapping| sys.memory.unmap(mapping),18                }19                self.* = undefined;20            }2122            pub fn needsZeroFill(self: Allocation) bool {23                return switch (self.storage) {24                    .heap => true,25                    .mapped_file => false,26                };27            }28        };2930        pub fn allocate(31            allocator: std.mem.Allocator,32            len: usize,33            options: model.LinkOptions,34        ) model.Error!Allocation {35            if (options.mapped_output_file) |file| {36                if (len >= options.mapped_output_min_size) {37                    const file_len = std.math.cast(u64, len) orelse return error.OutputFileError;38                    file.setLength(sys.fs.debugIo(), 0) catch return error.OutputFileError;39                    file.setLength(sys.fs.debugIo(), file_len) catch return error.OutputFileError;40                    const mapping = sys.memory.mapSharedFile(file.handle, len, .{ .read = true, .write = true }, 0) catch |err| switch (err) {41                        error.UnsupportedPlatform => return heapAllocation(allocator, len),42                        else => return error.OutputFileError,43                    };44                    return .{45                        .bytes = mapping[0..len],46                        .storage = .{ .mapped_file = mapping },47                    };48                }49            }50            return heapAllocation(allocator, len);51        }5253        fn heapAllocation(allocator: std.mem.Allocator, len: usize) model.Error!Allocation {54            return .{55                .bytes = try allocator.alloc(u8, len),56                .storage = .heap,57            };58        }59    };6061    pub fn deinit(self: *LinkedImage, allocator: std.mem.Allocator) void {62        switch (self.storage) {63            .heap => allocator.free(self.bytes),64            .mapped_file => |mapping| sys.memory.unmap(mapping),65        }66        self.manifest.deinit(allocator);67        self.* = undefined;68    }6970    pub fn isMaterialized(self: LinkedImage) bool {71        return switch (self.storage) {72            .heap => false,73            .mapped_file => true,74        };75    }7677    pub fn prepareIncrementalState(78        self: *LinkedImage,79        allocator: std.mem.Allocator,80    ) std.mem.Allocator.Error!incremental.PreparedState {81        return try incremental.PreparedState.fromOwnedManifest(allocator, self.manifest.take());82    }83};

1pub const LinkedImage = object.LinkedImage;