Class: VibeZstd::CompressWriter

Inherits:

Object

• Object
• VibeZstd::CompressWriter

Defined in:

lib/vibe_zstd.rb,
ext/vibe_zstd/vibe_zstd.c

Class Method Summary

• .open(io, **options) ⇒ Object

  Block-based resource management Automatically calls finish when block completes.

Instance Method Summary

• #close ⇒ Object

  alias.

• #finish ⇒ Object
• #flush ⇒ Object
• #write(data) ⇒ Object

Class Method Details

.open(io, **options) ⇒ Object

Block-based resource management Automatically calls finish when block completes

# File 'lib/vibe_zstd.rb', line 190

def self.open(io, **options)
  writer = new(io, **options)
  return writer unless block_given?

  begin
    yield writer
  ensure
    writer.finish
  end
end

Instance Method Details

#close ⇒ Object

alias

# File 'ext/vibe_zstd/streaming.c', line 225

static VALUE
vibe_zstd_writer_finish(VALUE self) {
    vibe_zstd_cstream* cstream;
    TypedData_Get_Struct(self, vibe_zstd_cstream, &vibe_zstd_cstream_type, cstream);

    size_t outBufferSize = ZSTD_CStreamOutSize();
    VALUE outBuffer = cstream->output_buffer;

    ZSTD_inBuffer input = { NULL, 0, 0 };
    size_t remaining;

    // ZSTD_e_end: finalize frame with checksum and epilogue
    // Loop until remaining == 0 (frame complete)
    do {
        rb_str_modify(outBuffer);
        rb_str_resize(outBuffer, (long)outBufferSize);
        rb_str_set_len(outBuffer, 0);
        ZSTD_outBuffer output = {
            .dst = RSTRING_PTR(outBuffer),
            .size = outBufferSize,
            .pos = 0
        };

        // Return value > 0 means more epilogue data to write
        remaining = ZSTD_compressStream2((ZSTD_CCtx*)cstream->cstream, &output, &input, ZSTD_e_end);
        if (ZSTD_isError(remaining)) {
            rb_raise(rb_eRuntimeError, "Finish failed: %s", ZSTD_getErrorName(remaining));
        }

        if (output.pos > 0) {
            rb_str_set_len(outBuffer, output.pos);
            rb_funcall(cstream->io, id_write, 1, outBuffer);
        }
    } while (remaining > 0);

    return self;
}

#finish ⇒ Object

# File 'ext/vibe_zstd/streaming.c', line 225

static VALUE
vibe_zstd_writer_finish(VALUE self) {
    vibe_zstd_cstream* cstream;
    TypedData_Get_Struct(self, vibe_zstd_cstream, &vibe_zstd_cstream_type, cstream);

    size_t outBufferSize = ZSTD_CStreamOutSize();
    VALUE outBuffer = cstream->output_buffer;

    ZSTD_inBuffer input = { NULL, 0, 0 };
    size_t remaining;

    // ZSTD_e_end: finalize frame with checksum and epilogue
    // Loop until remaining == 0 (frame complete)
    do {
        rb_str_modify(outBuffer);
        rb_str_resize(outBuffer, (long)outBufferSize);
        rb_str_set_len(outBuffer, 0);
        ZSTD_outBuffer output = {
            .dst = RSTRING_PTR(outBuffer),
            .size = outBufferSize,
            .pos = 0
        };

        // Return value > 0 means more epilogue data to write
        remaining = ZSTD_compressStream2((ZSTD_CCtx*)cstream->cstream, &output, &input, ZSTD_e_end);
        if (ZSTD_isError(remaining)) {
            rb_raise(rb_eRuntimeError, "Finish failed: %s", ZSTD_getErrorName(remaining));
        }

        if (output.pos > 0) {
            rb_str_set_len(outBuffer, output.pos);
            rb_funcall(cstream->io, id_write, 1, outBuffer);
        }
    } while (remaining > 0);

    return self;
}

#flush ⇒ Object

# File 'ext/vibe_zstd/streaming.c', line 187

static VALUE
vibe_zstd_writer_flush(VALUE self) {
    vibe_zstd_cstream* cstream;
    TypedData_Get_Struct(self, vibe_zstd_cstream, &vibe_zstd_cstream_type, cstream);

    size_t outBufferSize = ZSTD_CStreamOutSize();
    VALUE outBuffer = cstream->output_buffer;

    ZSTD_inBuffer input = { NULL, 0, 0 };
    size_t remaining;

    // ZSTD_e_flush: flush internal buffers, making all data readable
    // Loop until remaining == 0 (flush complete)
    do {
        rb_str_modify(outBuffer);
        rb_str_resize(outBuffer, (long)outBufferSize);
        rb_str_set_len(outBuffer, 0);
        ZSTD_outBuffer output = {
            .dst = RSTRING_PTR(outBuffer),
            .size = outBufferSize,
            .pos = 0
        };

        // Return value > 0 means more flushing needed
        remaining = ZSTD_compressStream2((ZSTD_CCtx*)cstream->cstream, &output, &input, ZSTD_e_flush);
        if (ZSTD_isError(remaining)) {
            rb_raise(rb_eRuntimeError, "Flush failed: %s", ZSTD_getErrorName(remaining));
        }

        if (output.pos > 0) {
            rb_str_set_len(outBuffer, output.pos);
            rb_funcall(cstream->io, id_write, 1, outBuffer);
        }
    } while (remaining > 0);

    return self;
}

#write(data) ⇒ Object

# File 'ext/vibe_zstd/streaming.c', line 167

static VALUE
vibe_zstd_writer_write(VALUE self, VALUE data) {
    Check_Type(data, T_STRING);

    vibe_zstd_cstream* cstream;
    TypedData_Get_Struct(self, vibe_zstd_cstream, &vibe_zstd_cstream_type, cstream);

    // Lock data for the duration of the compress loop so that RSTRING_PTR(data)
    // stays valid even when io.write (called inside the loop) runs Ruby code that
    // could otherwise mutate or resize the string.  rb_str_locktmp raises if the
    // string is already locked; the ensure always unlocks it.
    rb_str_locktmp(data);

    vibe_zstd_write_state state = { cstream, data };
    rb_ensure(vibe_zstd_writer_write_body, (VALUE)&state,
              vibe_zstd_writer_write_unlock, data);

    return self;
}