pub fn build(b: *std.Build) !void {
    // ...
    // Add a reference to the package you've just fetched...
    const dep_lz4u = b.dependency("lz4u", .{
        .target = target,
        .optimize = optimize,
    });
    const mod_lz4u = dep_lz4u.module("lz4u");

    // ...then load its module into your own
    const your_module = b.addModule(.{
        // ...
        .imports = &.{
            .{ .name = "lz4u", .module = mod_lz4u },
        },
    }),
    // ...
}

const std = @import("std");
const lz4u = @import("lz4u");

pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const arena_alloc = arena.allocator();

    var in_file = try std.fs.cwd().openFile("compressed_file.txt.lz4", .{ .mode = .read_only });
    defer in_file.close();

    var out_file = try std.fs.cwd().createFile("decompresed_result.txt", .{});
    defer out_file.close();

    // there must be at least `queryInCapacity()` memory available for the reader to work 
    const reader_buf = try arena_alloc.alloc(u8, lz4u.Decompress.queryInCapacity());
    var reader = in_file.reader(reader_buf);

    // there must be at least `queryOutCapacity()` memory available for the writer to work 
    const writer_buf = try arena_alloc.alloc(u8, lz4u.Decompress.queryOutCapacity());
    var writer = out_file.writer(writer_buf);

    // `decompressor_buf` is optional, but it may boost performance by reducing syscalls.
    const decompressor_buf = try arena_alloc.alloc(u8, lz4u.min_indirect_buffer_len);
    var decompressor: lz4u.Decompress = .init(&reader.interface, decompressor_buf, .{ .verify_checksum = true });
    //var decompressor: lz4u.Decompress = .init(&reader.interface, &.{}, .{ .verify_checksum = true });

    defer writer.interface.flush() catch {};

    _ = decompressor.reader.streamRemaining(&writer.interface) catch |err| {
        if (decompressor.err) |dec_err| {
            // you can handle the decompressor specific error here
            return dec_err;
        } else {
            // or handle some std.Io error
            return err;
        }
    };
}

const std = @import("std");
const lz4u = @import("lz4u");

pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();
    const arena_alloc = arena.allocator();

    var in_file = try std.fs.cwd().openFile("my_uncompressed_tarball.tar", .{ .mode = .read_only });
    defer in_file.close();

    var out_file = try std.fs.cwd().createFile("out_compressed_tarball.tar.lz4", .{});
    defer out_file.close();

    // the compressor's options
    const compress_options: lz4u.Compress.Options = .{
        // a block's maximum memory size
        .max_block_size = .@"1MB",
        // if enabled, the decompressed data has its checksum verified
        .should_checksum_frame = true,
        // if enabled, blocks in compressed form have its checksum verified
        .should_checksum_block = false,
        // do blocks share the window buffer between them?
        .independent_blocks = true,
        // optional field that tells decompressors the exact size of the decompressed data
        .content_size_hint = null,
    };

    // reader's buffer may have any size, the compressor does not care.
    const reader_buf = try arena_alloc.alloc(u8, 8196);
    var reader = in_file.reader(reader_buf);

    // however, the writer's buffer must be at least `queryOutCapacity()` long`
    const writer_buf = try arena_alloc.alloc(u8, lz4u.Compress.queryOutCapacity(compress_options));
    var writer = out_file.writer(writer_buf);

    // a window buffer `lz4u.max_window_len` long must always be provided, regardless of block dependency
    const window_buf = try arena_alloc.alloc(u8, lz4u.max_window_len);

    var compressor: lz4u.Compress = try .init(&writer.interface, window_buf, compress_options);

    _ = try compressor.writer.sendFileAll(&reader, .unlimited);

    // you may flush the compressor's writer buffer at anytime,
    // however its resulting blocks may not be optimally compressed.
    try compressor.writer.flush();

    // tell the compressor you're done compressing data.
    // any new write will fail.
    // (if you wish to compress a new stream, you'll have to reinitialize the compressor.)
    try compressor.finish();

    try writer.interface.flush();
}