Spec-Zone.ru › Ruby 2.3

класс StringIO

Родитель:
Данные
Включенные модули:
Enumerable, IO::generic_readable, IO::generic_writable

Псевдо-ввод/вывод для объекта String.

Часто используется для имитации `$stdio` или `$stderr`

Примеры

require 'stringio'

io = StringIO.new
io.puts "Hello World"
io.string #=> "Hello World\n"

Общедоступные методы класса

new(string=""[, mode]) Показать исходный код 
static VALUE
strio_initialize(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = check_strio(self);

    if (!ptr) {
        DATA_PTR(self) = ptr = strio_alloc();
    }
    rb_call_super(0, 0);
    strio_init(argc, argv, ptr, self);
    return self;
}

Создаёт новый экземпляр StringIO из string и mode.

open(string=""[, mode]) {|strio| ...} Показать исходный код 
static VALUE
strio_s_open(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj = rb_class_new_instance(argc, argv, klass);
    if (!rb_block_given_p()) return obj;
    return rb_ensure(rb_yield, obj, strio_finalize, obj);
}

Эквивалентно ::new, за исключением того, что при вызове с блоком, он передаёт новый экземпляр и закрывает его, а возвращает результат, возвращённый блоком.

Публичные методы экземпляра

binmode() Show source 
static VALUE
strio_binmode(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    rb_encoding *enc = rb_ascii8bit_encoding();

    ptr->enc = enc;
    if (WRITABLE(self)) {
        rb_enc_associate(ptr->string, enc);
    }
    return self;
}
bytes() Show source 
static VALUE
strio_bytes(VALUE self)
{
    rb_warn("StringIO#bytes is deprecated; use #each_byte instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_byte")), 0, 0);
    return strio_each_byte(self);
}

Это устаревшее псевдоним для each_byte.

chars() Show source 
static VALUE
strio_chars(VALUE self)
{
    rb_warn("StringIO#chars is deprecated; use #each_char instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_char")), 0, 0);
    return strio_each_char(self);
}

Это устаревшее псевдоним для each_char.

close → nil Show source 
static VALUE
strio_close(VALUE self)
{
    StringIO(self);
    RBASIC(self)->flags &= ~STRIO_READWRITE;
    return Qnil;
}

Закрывает strio. strio недоступен для дальнейших операций с данными; IOError генерируется, если такая попытка будет предпринята.

close_read → nil Show source 
static VALUE
strio_close_read(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (!(ptr->flags & FMODE_READABLE)) {
        rb_raise(rb_eIOError, "closing non-duplex IO for reading");
    }
    RBASIC(self)->flags &= ~STRIO_READABLE;
    return Qnil;
}

Закрывает входной поток StringIO. Вызовет IOError, если strio не является читаемым.

close_write → nil Show source 
static VALUE
strio_close_write(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (!(ptr->flags & FMODE_WRITABLE)) {
        rb_raise(rb_eIOError, "closing non-duplex IO for writing");
    }
    RBASIC(self)->flags &= ~STRIO_WRITABLE;
    return Qnil;
}

Закрывает выходной поток StringIO. Вызовет IOError, если strio не является записываемым.

closed? → true or false Show source 
static VALUE
strio_closed(VALUE self)
{
    StringIO(self);
    if (!CLOSED(self)) return Qfalse;
    return Qtrue;
}

Возвращает true, если strio полностью закрыт, false в противном случае.

closed_read? → true or false Show source 
static VALUE
strio_closed_read(VALUE self)
{
    StringIO(self);
    if (READABLE(self)) return Qfalse;
    return Qtrue;
}

Возвращает true, если strio не является читаемым, false в противном случае.

closed_write? → true or false Show source 
static VALUE
strio_closed_write(VALUE self)
{
    StringIO(self);
    if (WRITABLE(self)) return Qfalse;
    return Qtrue;
}

Возвращает true, если strio не является записываемым, false в противном случае.

codepoints() Show source 
static VALUE
strio_codepoints(VALUE self)
{
    rb_warn("StringIO#codepoints is deprecated; use #each_codepoint instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_codepoint")), 0, 0);
    return strio_each_codepoint(self);
}

Это устаревшее псевдоним для each_codepoint.

each(sep=$/) {|line| block } → strio Show source
each(limit) {|line| block } → strio
each(sep, limit) {|line| block } → strio
each(...) → anEnumerator
each_line(sep=$/) {|line| block } → strio
each_line(limit) {|line| block } → strio
each_line(sep,limit) {|line| block } → strio
each_line(...) → anEnumerator 
static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    VALUE line;

    StringIO(self);
    RETURN_ENUMERATOR(self, argc, argv);

    if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) &&
        NUM2LONG(argv[argc-1]) == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
    }

    while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) {
        rb_yield(line);
    }
    return self;
}

См. IO#each.

each_byte {|byte| block } → strio Show source
each_byte → anEnumerator 
static VALUE
strio_each_byte(VALUE self)
{
    struct StringIO *ptr = readable(self);

    RETURN_ENUMERATOR(self, 0, 0);

    while (ptr->pos < RSTRING_LEN(ptr->string)) {
        char c = RSTRING_PTR(ptr->string)[ptr->pos++];
        rb_yield(CHR2FIX(c));
    }
    return self;
}

См. IO#each_byte.

each_char {|char| block } → strio Show source
each_char → anEnumerator 
static VALUE
strio_each_char(VALUE self)
{
    VALUE c;

    RETURN_ENUMERATOR(self, 0, 0);

    while (!NIL_P(c = strio_getc(self))) {
        rb_yield(c);
    }
    return self;
}

См. IO#each_char.

each_codepoint {|c| block } → strio Show source
each_codepoint → anEnumerator 
static VALUE
strio_each_codepoint(VALUE self)
{
    struct StringIO *ptr;
    rb_encoding *enc;
    unsigned int c;
    int n;

    RETURN_ENUMERATOR(self, 0, 0);

    ptr = readable(self);
    enc = get_enc(ptr);
    for (;;) {
        if (ptr->pos >= RSTRING_LEN(ptr->string)) {
            return self;
        }

        c = rb_enc_codepoint_len(RSTRING_PTR(ptr->string)+ptr->pos,
                                 RSTRING_END(ptr->string), &n, enc);
        rb_yield(UINT2NUM(c));
        ptr->pos += n;
    }
    return self;
}

См. IO#each_codepoint.

each_line(sep=$/) {|line| block } → strio Show source
each_line(limit) {|line| block } → strio
each_line(sep,limit) {|line| block } → strio
each_line(...) → anEnumerator 
static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    VALUE line;

    StringIO(self);
    RETURN_ENUMERATOR(self, argc, argv);

    if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) &&
        NUM2LONG(argv[argc-1]) == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
    }

    while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) {
        rb_yield(line);
    }
    return self;
}

См. IO#each.

eof → true or false Show source
eof? → true or false 
static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(self);
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}

Возвращает true, если strio находится в конце файла. Stringio должен быть открыт для чтения, иначе будет выброшено исключение IOError.

eof? → true or false Show source 
static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(self);
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}

Возвращает true, если strio находится в конце файла. Stringio должен быть открыт для чтения, иначе будет выброшено исключение IOError.

external_encoding → encoding Show source 
static VALUE
strio_external_encoding(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    return rb_enc_from_encoding(get_enc(ptr));
}

Возвращает объект Encoding, представляющий кодировку файла. Если strio находится в режиме записи и кодировка не указана, возвращает nil.

fcntl(*args) Show source 
static VALUE
strio_unimpl(int argc, VALUE *argv, VALUE self)
{
    StringIO(self);
    rb_notimplement();

    UNREACHABLE;
}

Вызывает NotImplementedError.

fileno() Show source 
static VALUE
strio_nil(VALUE self)
{
    StringIO(self);
    return Qnil;
}

Возвращает nil. Только для совместимости с IO.

flush() Show source 
static VALUE
strio_self(VALUE self)
{
    StringIO(self);
    return self;
}

Возвращает сам strio. Только для совместимости с IO.

fsync() Show source 
static VALUE
strio_0(VALUE self)
{
    StringIO(self);
    return INT2FIX(0);
}

Возвращает 0. Только для совместимости с IO.

getbyte → fixnum or nil Show source 
static VALUE
strio_getbyte(VALUE self)
{
    struct StringIO *ptr = readable(self);
    int c;
    if (ptr->pos >= RSTRING_LEN(ptr->string)) {
        return Qnil;
    }
    c = RSTRING_PTR(ptr->string)[ptr->pos++];
    return CHR2FIX(c);
}

См. IO#getbyte.

getc → string или nil Показать исходный код 
static VALUE
strio_getc(VALUE self)
{
    struct StringIO *ptr = readable(self);
    rb_encoding *enc = get_enc(ptr);
    int len;
    char *p;

    if (ptr->pos >= RSTRING_LEN(ptr->string)) {
        return Qnil;
    }
    p = RSTRING_PTR(ptr->string)+ptr->pos;
    len = rb_enc_mbclen(p, RSTRING_END(ptr->string), enc);
    ptr->pos += len;
    return rb_enc_str_new(p, len, enc);
}

См. IO#getc.

gets(sep=$/) → string или nil Показать исходный код
gets(limit) → string или nil
gets(sep, limit) → string или nil 
static VALUE
strio_gets(int argc, VALUE *argv, VALUE self)
{
    VALUE str = strio_getline(argc, argv, readable(self));

    rb_lastline_set(str);
    return str;
}

См. IO#gets.

internal_encoding → encoding Показать исходный код 
static VALUE
strio_internal_encoding(VALUE self)
{
     return Qnil;
}

Возвращает Encoding внутренней строки, если указано преобразование. В противном случае возвращает nil.

isatty() Показать исходный код 
static VALUE
strio_false(VALUE self)
{
    StringIO(self);
    return Qfalse;
}

Возвращает false. Только для совместимости с IO.

length → integer Показать исходный код 
static VALUE
strio_size(VALUE self)
{
    VALUE string = StringIO(self)->string;
    if (NIL_P(string)) {
        rb_raise(rb_eIOError, "not opened");
    }
    return ULONG2NUM(RSTRING_LEN(string));
}

Возвращает размер буферной строки.

lineno → integer Показать исходный код 
static VALUE
strio_get_lineno(VALUE self)
{
    return LONG2NUM(StringIO(self)->lineno);
}

Возвращает текущий номер строки в strio. Строка strio должна быть открыта для чтения. lineno считает количество вызовов gets, а не количество встреченных символов новой строки. Эти два значения будут отличаться, если gets вызывается с разделителем, отличным от символа новой строки. См. также переменную $..

lineno = integer → integer Показать исходный код 
static VALUE
strio_set_lineno(VALUE self, VALUE lineno)
{
    StringIO(self)->lineno = NUM2LONG(lineno);
    return lineno;
}

Вручную устанавливает текущий номер строки на заданное значение. $. обновляется только при следующем чтении.

lines(*args) Показать исходный код 
static VALUE
strio_lines(int argc, VALUE *argv, VALUE self)
{
    rb_warn("StringIO#lines is deprecated; use #each_line instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_line")), argc, argv);
    return strio_each(argc, argv, self);
}

Это устаревшее псевдоним для each_line.

pid() Показать исходный код 
static VALUE
strio_nil(VALUE self)
{
    StringIO(self);
    return Qnil;
}

Возвращает nil. Только для совместимости с IO.

pos → integer Показать исходный код
tell → integer 
static VALUE
strio_get_pos(VALUE self)
{
    return LONG2NUM(StringIO(self)->pos);
}

Возвращает текущий смещение (в байтах) strio.

pos = integer → integer Показать исходный код 
static VALUE
strio_set_pos(VALUE self, VALUE pos)
{
    struct StringIO *ptr = StringIO(self);
    long p = NUM2LONG(pos);
    if (p < 0) {
        error_inval(0);
    }
    ptr->pos = p;
    return pos;
}

Перемещается к заданной позиции (в байтах) в strio.

putc(obj) → obj Показать исходный код 
static VALUE
strio_putc(VALUE self, VALUE ch)
{
    struct StringIO *ptr = writable(self);
    VALUE str;

    check_modifiable(ptr);
    if (RB_TYPE_P(ch, T_STRING)) {
        str = rb_str_substr(ch, 0, 1);
    }
    else {
        char c = NUM2CHR(ch);
        str = rb_str_new(&c, 1);
    }
    strio_write(self, str);
    return ch;
}

См. IO#putc.

read([length [, outbuf]]) → string, outbuf, или nil Показать исходный код 
static VALUE
strio_read(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = readable(self);
    VALUE str = Qnil;
    long len;
    int binary = 0;

    rb_check_arity(argc, 0, 2);
    switch (argc) {
      case 2:
        str = argv[1];
        if (!NIL_P(str)) {
            StringValue(str);
            rb_str_modify(str);
        }
      case 1:
        if (!NIL_P(argv[0])) {
            len = NUM2LONG(argv[0]);
            if (len < 0) {
                rb_raise(rb_eArgError, "negative length %ld given", len);
            }
            if (len > 0 && ptr->pos >= RSTRING_LEN(ptr->string)) {
                if (!NIL_P(str)) rb_str_resize(str, 0);
                return Qnil;
            }
            binary = 1;
            break;
        }
        /* fall through */
      case 0:
        len = RSTRING_LEN(ptr->string);
        if (len <= ptr->pos) {
            if (NIL_P(str)) {
                str = rb_str_new(0, 0);
            }
            else {
                rb_str_resize(str, 0);
            }
            return str;
        }
        else {
            len -= ptr->pos;
        }
        break;
    }
    if (NIL_P(str)) {
        str = strio_substr(ptr, ptr->pos, len);
        if (binary) rb_enc_associate(str, rb_ascii8bit_encoding());
    }
    else {
        long rest = RSTRING_LEN(ptr->string) - ptr->pos;
        if (len > rest) len = rest;
        rb_str_resize(str, len);
        MEMCPY(RSTRING_PTR(str), RSTRING_PTR(ptr->string) + ptr->pos, char, len);
        if (binary)
            rb_enc_associate(str, rb_ascii8bit_encoding());
        else
            rb_enc_copy(str, ptr->string);
    }
    ptr->pos += RSTRING_LEN(str);
    return str;
}

См. IO#read.

readlines(sep=$/) → array Показать исходный код
readlines(limit) → array
readlines(sep,limit) → array 
static VALUE
strio_readlines(int argc, VALUE *argv, VALUE self)
{
    VALUE ary, line;

    StringIO(self);
    ary = rb_ary_new();
    if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) &&
        NUM2LONG(argv[argc-1]) == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for readlines");
    }

    while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) {
        rb_ary_push(ary, line);
    }
    return ary;
}

См. IO#readlines.

reopen(other_StrIO) → strio Показать исходный код
reopen(string, mode) → strio 
static VALUE
strio_reopen(int argc, VALUE *argv, VALUE self)
{
    rb_io_taint_check(self);
    if (argc == 1 && !RB_TYPE_P(*argv, T_STRING)) {
        return strio_copy(self, *argv);
    }
    strio_init(argc, argv, StringIO(self), self);
    return self;
}

Переинициализирует strio с заданным other_StrIO или string и mode (см. StringIO#new).

rewind → 0 Показать исходный код 
static VALUE
strio_rewind(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    ptr->pos = 0;
    ptr->lineno = 0;
    return INT2FIX(0);
}

Позиционирует strio в начало ввода, сбрасывая lineno в ноль.

seek(amount, whence=SEEK_SET) → 0 Показать исходный код 
static VALUE
strio_seek(int argc, VALUE *argv, VALUE self)
{
    VALUE whence;
    struct StringIO *ptr = StringIO(self);
    long offset;

    rb_scan_args(argc, argv, "11", NULL, &whence);
    offset = NUM2LONG(argv[0]);
    if (CLOSED(self)) {
        rb_raise(rb_eIOError, "closed stream");
    }
    switch (NIL_P(whence) ? 0 : NUM2LONG(whence)) {
      case 0:
        break;
      case 1:
        offset += ptr->pos;
        break;
      case 2:
        offset += RSTRING_LEN(ptr->string);
        break;
      default:
        error_inval("invalid whence");
    }
    if (offset < 0) {
        error_inval(0);
    }
    ptr->pos = offset;
    return INT2FIX(0);
}

Перемещается к заданному смещению amount в потоке в соответствии со значением whence (см. IO#seek).

set_encoding(ext_enc, [int_enc[, opt]]) → strio Показать исходный код 
static VALUE
strio_set_encoding(int argc, VALUE *argv, VALUE self)
{
    rb_encoding* enc;
    struct StringIO *ptr = StringIO(self);
    VALUE ext_enc, int_enc, opt;

    argc = rb_scan_args(argc, argv, "11:", &ext_enc, &int_enc, &opt);

    if (NIL_P(ext_enc)) {
        enc = rb_default_external_encoding();
    }
    else {
        enc = rb_to_encoding(ext_enc);
    }
    ptr->enc = enc;
    if (WRITABLE(self)) {
        rb_enc_associate(ptr->string, enc);
    }

    return self;
}

Указывает кодировку StringIO как ext_enc. Использует кодировку по умолчанию, если ext_enc равно nil. 2-й аргумент int_enc и необязательный аргумент хеша opt игнорируются; они предназначены для совместимости API с IO.

size → integer Показать исходный код 
static VALUE
strio_size(VALUE self)
{
    VALUE string = StringIO(self)->string;
    if (NIL_P(string)) {
        rb_raise(rb_eIOError, "not opened");
    }
    return ULONG2NUM(RSTRING_LEN(string));
}

Возвращает размер буферной строки.

string → string Показать исходный код 
static VALUE
strio_get_string(VALUE self)
{
    return StringIO(self)->string;
}

Возвращает основной объект String, объект IO.

string = string → string Показать исходный код 
static VALUE
strio_set_string(VALUE self, VALUE string)
{
    struct StringIO *ptr = StringIO(self);

    rb_io_taint_check(self);
    ptr->flags &= ~FMODE_READWRITE;
    StringValue(string);
    ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE;
    ptr->pos = 0;
    ptr->lineno = 0;
    return ptr->string = string;
}

Изменяет основной объект String, объект IO.

sync → true Показать исходный код 
static VALUE
strio_get_sync(VALUE self)
{
    StringIO(self);
    return Qtrue;
}

Всегда возвращает true.

sync=(p1) Показать исходный код 
static VALUE
strio_first(VALUE self, VALUE arg)
{
    StringIO(self);
    return arg;
}

Возвращает аргумент без изменений. Только для совместимости с IO.

pos → integer Показать исходный код
tell → integer 
static VALUE
strio_get_pos(VALUE self)
{
    return LONG2NUM(StringIO(self)->pos);
}

Возвращает текущий смещение (в байтах) strio.

truncate(integer) → 0 Показать исходный код 
static VALUE
strio_truncate(VALUE self, VALUE len)
{
    VALUE string = writable(self)->string;
    long l = NUM2LONG(len);
    long plen = RSTRING_LEN(string);
    if (l < 0) {
        error_inval("negative length");
    }
    rb_str_resize(string, l);
    if (plen < l) {
        MEMZERO(RSTRING_PTR(string) + plen, char, l - plen);
    }
    return len;
}

Усекает буферную строку максимум до integer байт. strio должен быть открыт для записи.

tty?() Показать исходный код 
static VALUE
strio_false(VALUE self)
{
    StringIO(self);
    return Qfalse;
}

Возвращает false. Только для совместимости с IO.

ungetbyte(fixnum) → nil Показать исходный код 
static VALUE
strio_ungetbyte(VALUE self, VALUE c)
{
    struct StringIO *ptr = readable(self);
    char buf[1], *cp = buf;
    long cl = 1;

    check_modifiable(ptr);
    if (NIL_P(c)) return Qnil;
    if (FIXNUM_P(c)) {
        buf[0] = (char)FIX2INT(c);
        return strio_unget_bytes(ptr, buf, 1);
    }
    else {
        SafeStringValue(c);
        cp = RSTRING_PTR(c);
        cl = RSTRING_LEN(c);
        if (cl == 0) return Qnil;
        strio_unget_bytes(ptr, cp, cl);
        RB_GC_GUARD(c);
        return Qnil;
    }
}

См. IO#ungetbyte

ungetc(string) → nil Показать исходный код 
static VALUE
strio_ungetc(VALUE self, VALUE c)
{
    struct StringIO *ptr = readable(self);
    rb_encoding *enc, *enc2;

    check_modifiable(ptr);
    if (NIL_P(c)) return Qnil;
    if (RB_INTEGER_TYPE_P(c)) {
        int len, cc = NUM2INT(c);
        char buf[16];

        enc = rb_enc_get(ptr->string);
        len = rb_enc_codelen(cc, enc);
        if (len <= 0) rb_enc_uint_chr(cc, enc);
        rb_enc_mbcput(cc, buf, enc);
        return strio_unget_bytes(ptr, buf, len);
    }
    else {
        SafeStringValue(c);
        enc = rb_enc_get(ptr->string);
        enc2 = rb_enc_get(c);
        if (enc != enc2 && enc != rb_ascii8bit_encoding()) {
            c = rb_str_conv_enc(c, enc2, enc);
        }
        strio_unget_bytes(ptr, RSTRING_PTR(c), RSTRING_LEN(c));
        RB_GC_GUARD(c);
        return Qnil;
    }
}

Возвращает один символ (переданный в качестве параметра) в буфер strio, чтобы последующее буферизованное чтение вернуло его. Нет ограничений на количество возвратов, включая возвраты за начало строки буфера.

write(string) → integer Показать исходный код
syswrite(string) → integer 
static VALUE
strio_write(VALUE self, VALUE str)
{
    struct StringIO *ptr = writable(self);
    long len, olen;
    rb_encoding *enc, *enc2;
    rb_encoding *const ascii8bit = rb_ascii8bit_encoding();

    if (!RB_TYPE_P(str, T_STRING))
        str = rb_obj_as_string(str);
    enc = get_enc(ptr);
    enc2 = rb_enc_get(str);
    if (enc != enc2 && enc != ascii8bit) {
        str = rb_str_conv_enc(str, enc2, enc);
    }
    len = RSTRING_LEN(str);
    if (len == 0) return INT2FIX(0);
    check_modifiable(ptr);
    olen = RSTRING_LEN(ptr->string);
    if (ptr->flags & FMODE_APPEND) {
        ptr->pos = olen;
    }
    if (ptr->pos == olen) {
        if (enc == ascii8bit || enc2 == ascii8bit) {
            rb_enc_str_buf_cat(ptr->string, RSTRING_PTR(str), len, enc);
            OBJ_INFECT(ptr->string, str);
        }
        else {
            rb_str_buf_append(ptr->string, str);
        }
    }
    else {
        strio_extend(ptr, ptr->pos, len);
        memmove(RSTRING_PTR(ptr->string)+ptr->pos, RSTRING_PTR(str), len);
        OBJ_INFECT(ptr->string, str);
    }
    OBJ_INFECT(ptr->string, self);
    RB_GC_GUARD(str);
    ptr->pos += len;
    return LONG2NUM(len);
}

Добавляет заданную строку в строку-буфер strio. Поток должен быть открыт для записи. Если аргумент не является строкой, он будет преобразован в строку с использованием to_s. Возвращает количество записанных байтов. См. IO#write.

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API