class Zlib::GzipWriter
Zlib::GzipWriter ist eine Klasse zum Schreiben von gzippten Dateien. GzipWriter sollte mit einer Instanz von IO oder einem IO-ähnlichen Objekt verwendet werden.
Die folgenden beiden Beispiele erzeugen dasselbe Ergebnis.
Zlib::GzipWriter.open('hoge.gz') do |gz| gz.write 'jugemu jugemu gokou no surikire...' end File.open('hoge.gz', 'w') do |f| gz = Zlib::GzipWriter.new(f) gz.write 'jugemu jugemu gokou no surikire...' gz.close end
Um wie gzip(1) zu verfahren, führen Sie Folgendes aus
orig = 'hoge.txt' Zlib::GzipWriter.open('hoge.gz') do |gz| gz.mtime = File.mtime(orig) gz.orig_name = orig gz.write IO.binread(orig) end
HINWEIS: Aufgrund der Einschränkung des Ruby-Finalizers müssen Sie GzipWriter-Objekte explizit über Zlib::GzipWriter#close usw. schließen. Andernfalls kann GzipWriter nicht den gzip-Footer schreiben und generiert eine beschädigte gzip-Datei.
Öffentliche Klassenmethoden
Source
static VALUE
rb_gzwriter_initialize(int argc, VALUE *argv, VALUE obj)
{
struct gzfile *gz;
VALUE io, level, strategy, opt = Qnil;
int err;
if (argc > 1) {
opt = rb_check_convert_type(argv[argc-1], T_HASH, "Hash", "to_hash");
if (!NIL_P(opt)) argc--;
}
rb_scan_args(argc, argv, "12", &io, &level, &strategy);
TypedData_Get_Struct(obj, struct gzfile, &gzfile_data_type, gz);
/* this is undocumented feature of zlib */
gz->level = ARG_LEVEL(level);
err = deflateInit2(&gz->z.stream, gz->level, Z_DEFLATED,
-MAX_WBITS, DEF_MEM_LEVEL, ARG_STRATEGY(strategy));
if (err != Z_OK) {
raise_zlib_error(err, gz->z.stream.msg);
}
gz->io = io;
ZSTREAM_READY(&gz->z);
rb_gzfile_ecopts(gz, opt);
if (rb_respond_to(io, id_path)) {
/* File#path may raise IOError in case when a path is unavailable */
rb_rescue2(gzfile_initialize_path_partial, obj, NULL, Qnil, rb_eIOError, (VALUE)0);
}
return obj;
}
Erstellt ein GzipWriter-Objekt, das mit io verbunden ist. level und strategy sollten dieselben sein wie die Argumente von Zlib::Deflate.new. Das GzipWriter-Objekt schreibt gzippte Daten in io. io muss die Methode write unterstützen, die sich genauso verhält wie IO#write.
Der options-Hash kann verwendet werden, um die Kodierung der Daten festzulegen. :external_encoding, :internal_encoding und :encoding können wie in IO::new festgelegt werden.
Source
static VALUE
rb_gzwriter_s_open(int argc, VALUE *argv, VALUE klass)
{
return gzfile_s_open(argc, argv, klass, "wb");
}
Öffnet eine Datei, die durch filename angegeben ist, zum Schreiben von gzip-komprimierten Daten und gibt ein GzipWriter-Objekt zurück, das mit dieser Datei verbunden ist. Weitere Details zu dieser Methode finden Sie unter Zlib::GzipWriter.new und Zlib::GzipFile.wrap.
Öffentliche Instanzmethoden
Source
static VALUE
rb_gzfile_set_comment(VALUE obj, VALUE str)
{
struct gzfile *gz = get_gzfile(obj);
VALUE s;
char *p;
if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
rb_raise(cGzError, "header is already written");
}
s = rb_str_dup(rb_str_to_str(str));
p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
if (p) {
rb_str_resize(s, p - RSTRING_PTR(s));
}
gz->comment = s;
return str;
}
Gibt den Kommentar (str) im gzip-Header an.
Source
static VALUE
rb_gzwriter_flush(int argc, VALUE *argv, VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
VALUE v_flush;
int flush;
rb_scan_args(argc, argv, "01", &v_flush);
flush = FIXNUMARG(v_flush, Z_SYNC_FLUSH);
if (flush != Z_NO_FLUSH) { /* prevent Z_BUF_ERROR */
zstream_run(&gz->z, (Bytef*)"", 0, flush);
}
gzfile_write_raw(gz);
if (rb_respond_to(gz->io, id_flush)) {
rb_funcall(gz->io, id_flush, 0);
}
return obj;
}
Leert alle internen Puffer des GzipWriter-Objekts. Die Bedeutung von flush ist dieselbe wie in Zlib::Deflate#deflate. Zlib::SYNC_FLUSH wird verwendet, wenn flush weggelassen wird. Es ist nutzlos, flush Zlib::NO_FLUSH zu geben.
Source
static VALUE
rb_gzfile_set_mtime(VALUE obj, VALUE mtime)
{
struct gzfile *gz = get_gzfile(obj);
VALUE val;
if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
rb_raise(cGzError, "header is already written");
}
val = rb_Integer(mtime);
gz->mtime = NUM2UINT(val);
gz->z.flags |= GZFILE_FLAG_MTIME_IS_SET;
return mtime;
}
Gibt die Änderungszeit (mtime) im gzip-Header an. Verwenden Sie einen Integer.
Das Setzen der mtime im gzip-Header hat keinen Einfluss auf die mtime der generierten Datei. Verschiedene Dienstprogramme, die gzippte Dateien erweitern, können die mtime im Header verwenden. Zum Beispiel kann das gunzip-Dienstprogramm die Option `-N` verwenden, die die mtime der resultierenden Datei auf den Wert im Header setzt. Standardmäßig setzen viele Tools die mtime der erweiterten Datei auf die mtime der gzippten Datei, nicht auf die mtime im Header.
Wenn Sie keine mtime festlegen, ist der Standardwert die Zeit, zu der die Komprimierung gestartet wurde. Ein Wert von 0 bedeutet, dass kein Zeitstempel verfügbar ist.
Source
static VALUE
rb_gzfile_set_orig_name(VALUE obj, VALUE str)
{
struct gzfile *gz = get_gzfile(obj);
VALUE s;
char *p;
if (gz->z.flags & GZFILE_FLAG_HEADER_FINISHED) {
rb_raise(cGzError, "header is already written");
}
s = rb_str_dup(rb_str_to_str(str));
p = memchr(RSTRING_PTR(s), '\0', RSTRING_LEN(s));
if (p) {
rb_str_resize(s, p - RSTRING_PTR(s));
}
gz->orig_name = s;
return str;
}
Gibt den ursprünglichen Namen (str) im gzip-Header an.
Source
static VALUE
rb_gzfile_total_in(VALUE obj)
{
return rb_uint2inum(get_gzfile(obj)->z.stream.total_in);
}
Gesamtzahl der bisher gelesenen Eingabe-Bytes.
Source
static VALUE
rb_gzwriter_putc(VALUE obj, VALUE ch)
{
struct gzfile *gz = get_gzfile(obj);
char c = NUM2CHR(ch);
gzfile_write(gz, (Bytef*)&c, 1);
return ch;
}
Entspricht IO.
Source
static VALUE
rb_gzwriter_write(int argc, VALUE *argv, VALUE obj)
{
struct gzfile *gz = get_gzfile(obj);
size_t total = 0;
while (argc-- > 0) {
VALUE str = *argv++;
if (!RB_TYPE_P(str, T_STRING))
str = rb_obj_as_string(str);
if (gz->enc2 && gz->enc2 != rb_ascii8bit_encoding()) {
str = rb_str_conv_enc(str, rb_enc_get(str), gz->enc2);
}
gzfile_write(gz, (Bytef*)RSTRING_PTR(str), RSTRING_LEN(str));
total += RSTRING_LEN(str);
RB_GC_GUARD(str);
}
return SIZET2NUM(total);
}
Entspricht IO.