Module: ZstdNative

Defined in:
lib/zstd_native.rb,
lib/zstd_native/version.rb,
ext/zstd_native/zstd_native.c

Defined Under Namespace

Classes: CCtx, CDict, CStream, DCtx, DDict, DStream, Error

Constant Summary collapse

VERSION = 
"1.0.2"

Class Method Summary collapse

Class Method Details

.compress(*args) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'ext/zstd_native/zstd_native.c', line 38

static VALUE zstd_compress(int argc, VALUE *argv, VALUE self) {
    VALUE data, level_val;
    rb_scan_args(argc, argv, "11", &data, &level_val);

    Check_Type(data, T_STRING);
    int level = NIL_P(level_val) ? ZSTD_CLEVEL_DEFAULT : NUM2INT(level_val);

    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);

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

    size_t compressed_size = ZSTD_compress(dst, dst_capacity, src, src_size, level);
    check_zstd_error(compressed_size, "Compression failed");

    rb_str_set_len(result, compressed_size);
    return result;
}

.compress_bound(size_val) ⇒ Object 



84
85
86
87
 
# File 'ext/zstd_native/zstd_native.c', line 84

static VALUE zstd_compress_bound(VALUE self, VALUE size_val) {
    size_t src_size = NUM2SIZET(size_val);
    return SIZET2NUM(ZSTD_compressBound(src_size));
}

.compress_using_cdict(data, cdict_val) ⇒ Object 



695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
 
# File 'ext/zstd_native/zstd_native.c', line 695

static VALUE zstd_compress_using_cdict(VALUE self, VALUE data, VALUE cdict_val) {
    Check_Type(data, T_STRING);

    ZSTD_CDict *cdict;
    TypedData_Get_Struct(cdict_val, ZSTD_CDict, &cdict_type, cdict);

    ZSTD_CCtx *ctx = ZSTD_createCCtx();
    if (!ctx) {
        rb_raise(eZstdError, "Failed to create compression context");
    }

    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);

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

    size_t compressed_size = ZSTD_compress_usingCDict(ctx, dst, dst_capacity, src, src_size, cdict);
    ZSTD_freeCCtx(ctx);
    check_zstd_error(compressed_size, "CDict compression failed");

    rb_str_set_len(result, compressed_size);
    return result;
}

.compress_using_dict(*args) ⇒ Object

Dictionary helper functions



629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
 
# File 'ext/zstd_native/zstd_native.c', line 629

static VALUE zstd_compress_using_dict(int argc, VALUE *argv, VALUE self) {
    VALUE data, dict, level_val;
    rb_scan_args(argc, argv, "21", &data, &dict, &level_val);

    Check_Type(data, T_STRING);
    Check_Type(dict, T_STRING);
    int level = NIL_P(level_val) ? ZSTD_CLEVEL_DEFAULT : NUM2INT(level_val);

    ZSTD_CCtx *ctx = ZSTD_createCCtx();
    if (!ctx) {
        rb_raise(eZstdError, "Failed to create compression context");
    }

    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);
    const char *dict_data = RSTRING_PTR(dict);
    size_t dict_size = RSTRING_LEN(dict);

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

    size_t compressed_size = ZSTD_compress_usingDict(ctx, dst, dst_capacity, src, src_size, dict_data, dict_size, level);
    ZSTD_freeCCtx(ctx);
    check_zstd_error(compressed_size, "Dictionary compression failed");

    rb_str_set_len(result, compressed_size);
    return result;
}

.decompress(data) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'ext/zstd_native/zstd_native.c', line 59

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

    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);

    unsigned long long const dst_capacity = ZSTD_getFrameContentSize(src, src_size);

    if (dst_capacity == ZSTD_CONTENTSIZE_ERROR) {
        rb_raise(eZstdError, "Invalid compressed data");
    }
    if (dst_capacity == ZSTD_CONTENTSIZE_UNKNOWN) {
        rb_raise(eZstdError, "Content size unknown");
    }

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

    size_t decompressed_size = ZSTD_decompress(dst, dst_capacity, src, src_size);
    check_zstd_error(decompressed_size, "Decompression failed");

    rb_str_set_len(result, decompressed_size);
    return result;
}

.decompress_using_ddict(data, ddict_val) ⇒ Object 



721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
 
# File 'ext/zstd_native/zstd_native.c', line 721

static VALUE zstd_decompress_using_ddict(VALUE self, VALUE data, VALUE ddict_val) {
    Check_Type(data, T_STRING);

    ZSTD_DDict *ddict;
    TypedData_Get_Struct(ddict_val, ZSTD_DDict, &ddict_type, ddict);

    ZSTD_DCtx *ctx = ZSTD_createDCtx();
    if (!ctx) {
        rb_raise(eZstdError, "Failed to create decompression context");
    }

    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);

    unsigned long long const dst_capacity = ZSTD_getFrameContentSize(src, src_size);

    if (dst_capacity == ZSTD_CONTENTSIZE_ERROR) {
        ZSTD_freeDCtx(ctx);
        rb_raise(eZstdError, "Invalid compressed data");
    }
    if (dst_capacity == ZSTD_CONTENTSIZE_UNKNOWN) {
        ZSTD_freeDCtx(ctx);
        rb_raise(eZstdError, "Content size unknown");
    }

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

    size_t decompressed_size = ZSTD_decompress_usingDDict(ctx, dst, dst_capacity, src, src_size, ddict);
    ZSTD_freeDCtx(ctx);
    check_zstd_error(decompressed_size, "DDict decompression failed");

    rb_str_set_len(result, decompressed_size);
    return result;
}

.decompress_using_dict(data, dict) ⇒ Object 



659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
 
# File 'ext/zstd_native/zstd_native.c', line 659

static VALUE zstd_decompress_using_dict(VALUE self, VALUE data, VALUE dict) {
    Check_Type(data, T_STRING);
    Check_Type(dict, T_STRING);

    ZSTD_DCtx *ctx = ZSTD_createDCtx();
    if (!ctx) {
        rb_raise(eZstdError, "Failed to create decompression context");
    }

    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);
    const char *dict_data = RSTRING_PTR(dict);
    size_t dict_size = RSTRING_LEN(dict);

    unsigned long long const dst_capacity = ZSTD_getFrameContentSize(src, src_size);

    if (dst_capacity == ZSTD_CONTENTSIZE_ERROR) {
        ZSTD_freeDCtx(ctx);
        rb_raise(eZstdError, "Invalid compressed data");
    }
    if (dst_capacity == ZSTD_CONTENTSIZE_UNKNOWN) {
        ZSTD_freeDCtx(ctx);
        rb_raise(eZstdError, "Content size unknown");
    }

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

    size_t decompressed_size = ZSTD_decompress_usingDict(ctx, dst, dst_capacity, src, src_size, dict_data, dict_size);
    ZSTD_freeDCtx(ctx);
    check_zstd_error(decompressed_size, "Dictionary decompression failed");

    rb_str_set_len(result, decompressed_size);
    return result;
}

.default_clevel ⇒ Object 



122
123
124
 
# File 'ext/zstd_native/zstd_native.c', line 122

static VALUE zstd_default_clevel(VALUE self) {
    return INT2NUM(ZSTD_defaultCLevel());
}

.dict_id_from_cdict(cdict_val) ⇒ Object 



757
758
759
760
761
 
# File 'ext/zstd_native/zstd_native.c', line 757

static VALUE zstd_dict_id_from_cdict(VALUE self, VALUE cdict_val) {
    ZSTD_CDict *cdict;
    TypedData_Get_Struct(cdict_val, ZSTD_CDict, &cdict_type, cdict);
    return UINT2NUM(ZSTD_getDictID_fromCDict(cdict));
}

.dict_id_from_ddict(ddict_val) ⇒ Object 



763
764
765
766
767
 
# File 'ext/zstd_native/zstd_native.c', line 763

static VALUE zstd_dict_id_from_ddict(VALUE self, VALUE ddict_val) {
    ZSTD_DDict *ddict;
    TypedData_Get_Struct(ddict_val, ZSTD_DDict, &ddict_type, ddict);
    return UINT2NUM(ZSTD_getDictID_fromDDict(ddict));
}

.dict_id_from_frame(data) ⇒ Object 



769
770
771
772
773
774
 
# File 'ext/zstd_native/zstd_native.c', line 769

static VALUE zstd_dict_id_from_frame(VALUE self, VALUE data) {
    Check_Type(data, T_STRING);
    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);
    return UINT2NUM(ZSTD_getDictID_fromFrame(src, src_size));
}

.find_frame_compressed_size(data) ⇒ Object 



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

static VALUE zstd_find_frame_compressed_size(VALUE self, VALUE data) {
    Check_Type(data, T_STRING);
    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);

    size_t size = ZSTD_findFrameCompressedSize(src, src_size);
    check_zstd_error(size, "Failed to find frame size");
    return SIZET2NUM(size);
}

.frame_content_size(data) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'ext/zstd_native/zstd_native.c', line 89

static VALUE zstd_frame_content_size(VALUE self, VALUE data) {
    Check_Type(data, T_STRING);
    const char *src = RSTRING_PTR(data);
    size_t src_size = RSTRING_LEN(data);

    unsigned long long size = ZSTD_getFrameContentSize(src, src_size);
    if (size == ZSTD_CONTENTSIZE_ERROR) {
        rb_raise(eZstdError, "Invalid frame");
    }
    if (size == ZSTD_CONTENTSIZE_UNKNOWN) {
        return Qnil;
    }
    return ULL2NUM(size);
}

.max_clevel ⇒ Object 



118
119
120
 
# File 'ext/zstd_native/zstd_native.c', line 118

static VALUE zstd_max_clevel(VALUE self) {
    return INT2NUM(ZSTD_maxCLevel());
}

.min_clevel ⇒ Object 



114
115
116
 
# File 'ext/zstd_native/zstd_native.c', line 114

static VALUE zstd_min_clevel(VALUE self) {
    return INT2NUM(ZSTD_minCLevel());
}

.version_number ⇒ Object

Module methods



30
31
32
 
# File 'ext/zstd_native/zstd_native.c', line 30

static VALUE zstd_version_number(VALUE self) {
    return UINT2NUM(ZSTD_versionNumber());
}

.version_string ⇒ Object 



34
35
36
 
# File 'ext/zstd_native/zstd_native.c', line 34

static VALUE zstd_version_string(VALUE self) {
    return rb_str_new_cstr(ZSTD_versionString());
}