Module: LZ4Native::LZ4

Defined in:
ext/lz4_native/lz4_native.c

Constant Summary collapse

MAX_INPUT_SIZE =

Constants

INT2NUM(LZ4_MAX_INPUT_SIZE)

Class Method Summary collapse

Class Method Details

.compress_bound(input_size) ⇒ Object

Returns maximum compressed size for given input size.



105
106
107
108
109
110
111
112
 
# File 'ext/lz4_native/lz4_native.c', line 105

static VALUE
lz4_compress_bound_wrapper(VALUE self, VALUE input_size)
{
    Check_Type(input_size, T_FIXNUM);
    int size = NUM2INT(input_size);
    int bound = LZ4_compressBound(size);
    return INT2NUM(bound);
}

.compress_default(source) ⇒ Object

Compresses source data using default LZ4 compression. Returns compressed data as a binary string.



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'ext/lz4_native/lz4_native.c', line 35

static VALUE
lz4_compress_default_wrapper(VALUE self, VALUE source)
{
    Check_Type(source, T_STRING);

    const char* src = RSTRING_PTR(source);
    int src_size = (int)RSTRING_LEN(source);

    if (src_size > LZ4_MAX_INPUT_SIZE) {
        rb_raise(eLZ4CompressionError, "Input size exceeds LZ4_MAX_INPUT_SIZE");
    }

    int max_dst_size = LZ4_compressBound(src_size);
    if (max_dst_size == 0) {
        rb_raise(eLZ4CompressionError, "Invalid input size");
    }

    VALUE result = rb_str_buf_new(max_dst_size);
    char* dst = RSTRING_PTR(result);

    int compressed_size = LZ4_compress_default(src, dst, src_size, max_dst_size);

    if (compressed_size <= 0) {
        rb_raise(eLZ4CompressionError, "Compression failed");
    }

    rb_str_set_len(result, compressed_size);
    return result;
}

.compress_fast(source, acceleration) ⇒ Object

Compresses with acceleration factor (higher = faster, less compression).



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'ext/lz4_native/lz4_native.c', line 120

static VALUE
lz4_compress_fast_wrapper(VALUE self, VALUE source, VALUE acceleration)
{
    Check_Type(source, T_STRING);
    Check_Type(acceleration, T_FIXNUM);

    const char* src = RSTRING_PTR(source);
    int src_size = (int)RSTRING_LEN(source);
    int accel = NUM2INT(acceleration);

    int max_dst_size = LZ4_compressBound(src_size);
    VALUE result = rb_str_buf_new(max_dst_size);
    char* dst = RSTRING_PTR(result);

    int compressed_size = LZ4_compress_fast(src, dst, src_size, max_dst_size, accel);

    if (compressed_size <= 0) {
        rb_raise(eLZ4CompressionError, "Compression failed");
    }

    rb_str_set_len(result, compressed_size);
    return result;
}

.decompress_safe(source, max_size) ⇒ Object

Decompresses LZ4 compressed data safely. max_size must be >= actual decompressed size.



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'ext/lz4_native/lz4_native.c', line 72

static VALUE
lz4_decompress_safe_wrapper(VALUE self, VALUE source, VALUE max_size)
{
    Check_Type(source, T_STRING);
    Check_Type(max_size, T_FIXNUM);

    const char* src = RSTRING_PTR(source);
    int src_size = (int)RSTRING_LEN(source);
    int dst_capacity = NUM2INT(max_size);

    if (dst_capacity <= 0) {
        rb_raise(eLZ4DecompressionError, "Invalid max_size");
    }

    VALUE result = rb_str_buf_new(dst_capacity);
    char* dst = RSTRING_PTR(result);

    int decompressed_size = LZ4_decompress_safe(src, dst, src_size, dst_capacity);

    if (decompressed_size < 0) {
        rb_raise(eLZ4DecompressionError, "Decompression failed - possibly corrupt data");
    }

    rb_str_set_len(result, decompressed_size);
    return result;
}

.version_number ⇒ Integer

Returns the LZ4 library version number.

Returns:

  • (Integer) 


150
151
152
153
154
 
# File 'ext/lz4_native/lz4_native.c', line 150

static VALUE
lz4_version_number_wrapper(VALUE self)
{
    return INT2NUM(LZ4_versionNumber());
}

.version_string ⇒ String

Returns the LZ4 library version string.

Returns:

  • (String) 


162
163
164
165
166
 
# File 'ext/lz4_native/lz4_native.c', line 162

static VALUE
lz4_version_string_wrapper(VALUE self)
{
    return rb_str_new_cstr(LZ4_versionString());
}