Class: StringIO

Inherits:
Data
  • Object
show all
Includes:
Enumerable
Defined in:
stringio.c

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#new(string = ""[, mode]) ⇒ Object

Creates new StringIO instance from with string and mode.



# File 'stringio.c'

/*
 * call-seq: StringIO.new(string=""[, mode])
 *
 * Creates new StringIO instance from with _string_ and _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);
    return self;
}

Class Method Details

.open(string = ""[, mode]) {|strio| ... } ⇒ Object

Equivalent to StringIO.new except that when it is called with a block, it yields with the new instance and closes it, and returns the result which returned from the block.

Yields:

  • (strio)


# File 'stringio.c'

/*
 * call-seq: StringIO.open(string=""[, mode]) {|strio| ...}
 *
 * Equivalent to StringIO.new except that when it is called with a block, it
 * yields with the new instance and closes it, and returns the result which
 * returned from the block.
 */
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);
}

Instance Method Details

#<<Object

#binmodeObject

Returns strio itself. Just for compatibility to IO.



# File 'stringio.c'

/*
 * Returns *strio* itself.  Just for compatibility to IO.
 */
static VALUE
strio_self(VALUE self)
{
    StringIO(self);
    return self;
}

#bytes {|byte| ... } ⇒ Object #bytesEnumerator

strio.each_byte {|byte| block } -> strio

strio.each_byte                  -> anEnumerator

See IO#each_byte.

Overloads:

  • #bytes {|byte| ... } ⇒ Object

    Yields:

    • (byte)
  • #bytesEnumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.bytes {|byte| block }      -> strio
 *   strio.bytes                      -> anEnumerator
 *
 *   strio.each_byte {|byte| block }  -> strio
 *   strio.each_byte                  -> anEnumerator
 *
 * See IO#each_byte.
 */
static VALUE
strio_each_byte(VALUE self)
{
    struct StringIO *ptr = readable(StringIO(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;
}

#chars {|char| ... } ⇒ Object #charsEnumerator

strio.each_char {|char| block } -> strio

strio.each_char                  -> anEnumerator

See IO#each_char.

Overloads:

  • #chars {|char| ... } ⇒ Object

    Yields:

    • (char)
  • #charsEnumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.chars {|char| block }      -> strio
 *   strio.chars                      -> anEnumerator
 *
 *   strio.each_char {|char| block }  -> strio
 *   strio.each_char                  -> anEnumerator
 *
 * See IO#each_char.
 */
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;
}

#closenil

Closes strio. The strio is unavailable for any further data operations; an IOError is raised if such an attempt is made.

Returns:

  • (nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.close  -> nil
 *
 * Closes strio.  The *strio* is unavailable for any further data
 * operations; an +IOError+ is raised if such an attempt is made.
 */
static VALUE
strio_close(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (CLOSED(ptr)) {
    rb_raise(rb_eIOError, "closed stream");
    }
    ptr->flags &= ~FMODE_READWRITE;
    return Qnil;
}

#close_readnil

Closes the read end of a StringIO. Will raise an IOError if the strio is not readable.

Returns:

  • (nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.close_read    -> nil
 *
 * Closes the read end of a StringIO.  Will raise an +IOError+ if the
 * *strio* is not readable.
 */
static VALUE
strio_close_read(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (!READABLE(ptr)) {
    rb_raise(rb_eIOError, "closing non-duplex IO for reading");
    }
    ptr->flags &= ~FMODE_READABLE;
    return Qnil;
}

#close_writenil

Closes the write end of a StringIO. Will raise an IOError if the strio is not writeable.

Returns:

  • (nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.close_write    -> nil
 *
 * Closes the write end of a StringIO.  Will raise an  +IOError+ if the
 * *strio* is not writeable.
 */
static VALUE
strio_close_write(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (!WRITABLE(ptr)) {
    rb_raise(rb_eIOError, "closing non-duplex IO for writing");
    }
    ptr->flags &= ~FMODE_WRITABLE;
    return Qnil;
}

#closed?Boolean

Returns true if strio is completely closed, false otherwise.

Returns:

  • (Boolean)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.closed?    -> true or false
 *
 * Returns +true+ if *strio* is completely closed, +false+ otherwise.
 */
static VALUE
strio_closed(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (!CLOSED(ptr)) return Qfalse;
    return Qtrue;
}

#closed_read?Boolean

Returns true if strio is not readable, false otherwise.

Returns:

  • (Boolean)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.closed_read?    -> true or false
 *
 * Returns +true+ if *strio* is not readable, +false+ otherwise.
 */
static VALUE
strio_closed_read(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (READABLE(ptr)) return Qfalse;
    return Qtrue;
}

#closed_write?Boolean

Returns true if strio is not writable, false otherwise.

Returns:

  • (Boolean)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.closed_write?    -> true or false
 *
 * Returns +true+ if *strio* is not writable, +false+ otherwise.
 */
static VALUE
strio_closed_write(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (WRITABLE(ptr)) return Qfalse;
    return Qtrue;
}

#codepoints {|c| ... } ⇒ Object #codepointsEnumerator

strio.each_codepoint {|c| block } -> strio

strio.each_codepoint               -> anEnumerator

See IO#each_codepoint.

Overloads:

  • #codepoints {|c| ... } ⇒ Object

    Yields:

    • (c)
  • #codepointsEnumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.codepoints {|c| block }      -> strio
 *   strio.codepoints                   -> anEnumerator
 *
 *   strio.each_codepoint {|c| block }  -> strio
 *   strio.each_codepoint               -> anEnumerator
 *
 * See IO#each_codepoint.
 */
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(StringIO(self));
    enc = rb_enc_get(ptr->string);
    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;
}

#each(sep = $/) {|line| ... } ⇒ Object #each(limit) {|line| ... } ⇒ Object #each(sep, limit) {|line| ... } ⇒ Object #each(...) ⇒ Enumerator

strio.each_line(sep=$/) {|line| block } -> strio

strio.each_line(limit) {|line| block }     -> strio
strio.each_line(sep,limit) {|line| block } -> strio
strio.each_line(...)                       -> anEnumerator

strio.lines(sep=$/) {|line| block }        -> strio
strio.lines(limit) {|line| block }         -> strio
strio.lines(sep,limit) {|line| block }     -> strio
strio.lines(...)                           -> anEnumerator

See IO#each.

Overloads:

  • #each(sep = $/) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(limit) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(sep, limit) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(...) ⇒ Enumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.each(sep=$/) {|line| block }         -> strio
 *   strio.each(limit) {|line| block }          -> strio
 *   strio.each(sep, limit) {|line| block }     -> strio
 *   strio.each(...)                            -> anEnumerator
 *
 *   strio.each_line(sep=$/) {|line| block }    -> strio
 *   strio.each_line(limit) {|line| block }     -> strio
 *   strio.each_line(sep,limit) {|line| block } -> strio
 *   strio.each_line(...)                       -> anEnumerator
 *
 *   strio.lines(sep=$/) {|line| block }        -> strio
 *   strio.lines(limit) {|line| block }         -> strio
 *   strio.lines(sep,limit) {|line| block }     -> strio
 *   strio.lines(...)                           -> anEnumerator
 *
 * See IO#each.
 */
static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    VALUE line;

    RETURN_ENUMERATOR(self, argc, argv);

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

#bytes {|byte| ... } ⇒ Object #bytesEnumerator

strio.each_byte {|byte| block } -> strio

strio.each_byte                  -> anEnumerator

See IO#each_byte.

Overloads:

  • #bytes {|byte| ... } ⇒ Object

    Yields:

    • (byte)
  • #bytesEnumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.bytes {|byte| block }      -> strio
 *   strio.bytes                      -> anEnumerator
 *
 *   strio.each_byte {|byte| block }  -> strio
 *   strio.each_byte                  -> anEnumerator
 *
 * See IO#each_byte.
 */
static VALUE
strio_each_byte(VALUE self)
{
    struct StringIO *ptr = readable(StringIO(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;
}

#chars {|char| ... } ⇒ Object #charsEnumerator

strio.each_char {|char| block } -> strio

strio.each_char                  -> anEnumerator

See IO#each_char.

Overloads:

  • #chars {|char| ... } ⇒ Object

    Yields:

    • (char)
  • #charsEnumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.chars {|char| block }      -> strio
 *   strio.chars                      -> anEnumerator
 *
 *   strio.each_char {|char| block }  -> strio
 *   strio.each_char                  -> anEnumerator
 *
 * See IO#each_char.
 */
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;
}

#codepoints {|c| ... } ⇒ Object #codepointsEnumerator

strio.each_codepoint {|c| block } -> strio

strio.each_codepoint               -> anEnumerator

See IO#each_codepoint.

Overloads:

  • #codepoints {|c| ... } ⇒ Object

    Yields:

    • (c)
  • #codepointsEnumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.codepoints {|c| block }      -> strio
 *   strio.codepoints                   -> anEnumerator
 *
 *   strio.each_codepoint {|c| block }  -> strio
 *   strio.each_codepoint               -> anEnumerator
 *
 * See IO#each_codepoint.
 */
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(StringIO(self));
    enc = rb_enc_get(ptr->string);
    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;
}

#each(sep = $/) {|line| ... } ⇒ Object #each(limit) {|line| ... } ⇒ Object #each(sep, limit) {|line| ... } ⇒ Object #each(...) ⇒ Enumerator

strio.each_line(sep=$/) {|line| block } -> strio

strio.each_line(limit) {|line| block }     -> strio
strio.each_line(sep,limit) {|line| block } -> strio
strio.each_line(...)                       -> anEnumerator

strio.lines(sep=$/) {|line| block }        -> strio
strio.lines(limit) {|line| block }         -> strio
strio.lines(sep,limit) {|line| block }     -> strio
strio.lines(...)                           -> anEnumerator

See IO#each.

Overloads:

  • #each(sep = $/) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(limit) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(sep, limit) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(...) ⇒ Enumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.each(sep=$/) {|line| block }         -> strio
 *   strio.each(limit) {|line| block }          -> strio
 *   strio.each(sep, limit) {|line| block }     -> strio
 *   strio.each(...)                            -> anEnumerator
 *
 *   strio.each_line(sep=$/) {|line| block }    -> strio
 *   strio.each_line(limit) {|line| block }     -> strio
 *   strio.each_line(sep,limit) {|line| block } -> strio
 *   strio.each_line(...)                       -> anEnumerator
 *
 *   strio.lines(sep=$/) {|line| block }        -> strio
 *   strio.lines(limit) {|line| block }         -> strio
 *   strio.lines(sep,limit) {|line| block }     -> strio
 *   strio.lines(...)                           -> anEnumerator
 *
 * See IO#each.
 */
static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    VALUE line;

    RETURN_ENUMERATOR(self, argc, argv);

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

#eofBoolean #eof?Boolean

Returns true if strio is at end of file. The stringio must be opened for reading or an IOError will be raised.

Overloads:

  • #eofBoolean

    Returns:

    • (Boolean)
  • #eof?Boolean

    Returns:

    • (Boolean)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.eof     -> true or false
 *   strio.eof?    -> true or false
 *
 * Returns true if *strio* is at end of file. The stringio must be
 * opened for reading or an +IOError+ will be raised.
 */
static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(StringIO(self));
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}

#eofBoolean #eof?Boolean

Returns true if strio is at end of file. The stringio must be opened for reading or an IOError will be raised.

Overloads:

  • #eofBoolean

    Returns:

    • (Boolean)
  • #eof?Boolean

    Returns:

    • (Boolean)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.eof     -> true or false
 *   strio.eof?    -> true or false
 *
 * Returns true if *strio* is at end of file. The stringio must be
 * opened for reading or an +IOError+ will be raised.
 */
static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(StringIO(self));
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}

#external_encodingEncoding

Returns the Encoding object that represents the encoding of the file. If strio is write mode and no encoding is specified, returns nil.

Returns:

  • (Encoding)


# File 'stringio.c'

/*
 *  call-seq:
 *     strio.external_encoding   => encoding
 *
 *  Returns the Encoding object that represents the encoding of the file.
 *  If strio is write mode and no encoding is specified, returns <code>nil</code>.
 */

static VALUE
strio_external_encoding(VALUE self)
{
    return rb_enc_from_encoding(rb_enc_get(StringIO(self)->string));
}

#fcntlObject

Raises NotImplementedError.



# File 'stringio.c'

/*
 * Raises NotImplementedError.
 */
static VALUE
strio_unimpl(int argc, VALUE *argv, VALUE self)
{
    StringIO(self);
    rb_notimplement();
    return Qnil;        /* not reached */
}

#filenoObject

Returns nil. Just for compatibility to IO.



# File 'stringio.c'

/*
 * Returns +nil+.  Just for compatibility to IO.
 */
static VALUE
strio_nil(VALUE self)
{
    StringIO(self);
    return Qnil;
}

#flushObject

Returns strio itself. Just for compatibility to IO.



# File 'stringio.c'

/*
 * Returns *strio* itself.  Just for compatibility to IO.
 */
static VALUE
strio_self(VALUE self)
{
    StringIO(self);
    return self;
}

#fsyncObject

Returns 0. Just for compatibility to IO.



# File 'stringio.c'

/*
 * Returns 0.  Just for compatibility to IO.
 */
static VALUE
strio_0(VALUE self)
{
    StringIO(self);
    return INT2FIX(0);
}

#getbyteFixnum?

See IO#getbyte.

Returns:

  • (Fixnum, nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.getbyte   -> fixnum or nil
 *
 * See IO#getbyte.
 */
static VALUE
strio_getbyte(VALUE self)
{
    struct StringIO *ptr = readable(StringIO(self));
    int c;
    if (ptr->pos >= RSTRING_LEN(ptr->string)) {
    return Qnil;
    }
    c = RSTRING_PTR(ptr->string)[ptr->pos++];
    return CHR2FIX(c);
}

#getcString?

See IO#getc.

Returns:

  • (String, nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.getc   -> string or nil
 *
 * See IO#getc.
 */
static VALUE
strio_getc(VALUE self)
{
    struct StringIO *ptr = readable(StringIO(self));
    rb_encoding *enc = rb_enc_get(ptr->string);
    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, rb_enc_get(ptr->string));
}

#gets(sep = $/) ⇒ String? #gets(limit) ⇒ String? #gets(sep, limit) ⇒ String?

See IO#gets.

Overloads:

  • #gets(sep = $/) ⇒ String?

    Returns:

    • (String, nil)
  • #gets(limit) ⇒ String?

    Returns:

    • (String, nil)
  • #gets(sep, limit) ⇒ String?

    Returns:

    • (String, nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.gets(sep=$/)     -> string or nil
 *   strio.gets(limit)      -> string or nil
 *   strio.gets(sep, limit) -> string or nil
 *
 * See IO#gets.
 */
static VALUE
strio_gets(int argc, VALUE *argv, VALUE self)
{
    VALUE str = strio_getline(argc, argv, readable(StringIO(self)));

    rb_lastline_set(str);
    return str;
}

#initialize_copyObject

:nodoc:



# File 'stringio.c'

/* :nodoc: */
static VALUE
strio_copy(VALUE copy, VALUE orig)
{
    struct StringIO *ptr;

    orig = rb_convert_type(orig, T_DATA, "StringIO", "to_strio");
    if (copy == orig) return copy;
    ptr = StringIO(orig);
    if (check_strio(copy)) {
    strio_free(DATA_PTR(copy));
    }
    DATA_PTR(copy) = ptr;
    OBJ_INFECT(copy, orig);
    ++ptr->count;
    return copy;
}

#internal_encodingEncoding

Returns the Encoding of the internal string if conversion is specified. Otherwise returns nil.

Returns:

  • (Encoding)


# File 'stringio.c'

/*
 *  call-seq:
 *     strio.internal_encoding   => encoding
 *
 *  Returns the Encoding of the internal string if conversion is
 *  specified.  Otherwise returns nil.
 */

static VALUE
strio_internal_encoding(VALUE self)
{
     return Qnil;
}

#isattyObject

Returns false. Just for compatibility to IO.



# File 'stringio.c'

/*
 * Returns +false+.  Just for compatibility to IO.
 */
static VALUE
strio_false(VALUE self)
{
    StringIO(self);
    return Qfalse;
}

#sizeInteger

Returns the size of the buffer string.

Returns:

  • (Integer)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.size   -> integer
 *
 * Returns the size of the buffer string.
 */
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));
}

#linenoInteger

Returns the current line number in strio. The stringio must be opened for reading. lineno counts the number of times gets is called, rather than the number of newlines encountered. The two values will differ if gets is called with a separator other than newline. See also the $. variable.

Returns:

  • (Integer)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.lineno    -> integer
 *
 * Returns the current line number in *strio*. The stringio must be
 * opened for reading. +lineno+ counts the number of times  +gets+ is
 * called, rather than the number of newlines  encountered. The two
 * values will differ if +gets+ is  called with a separator other than
 * newline.  See also the  <code>$.</code> variable.
 */
static VALUE
strio_get_lineno(VALUE self)
{
    return LONG2NUM(StringIO(self)->lineno);
}

#lineno=(integer) ⇒ Integer

Manually sets the current line number to the given value. $. is updated only on the next read.

Returns:

  • (Integer)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.lineno = integer    -> integer
 *
 * Manually sets the current line number to the given value.
 * <code>$.</code> is updated only on the next read.
 */
static VALUE
strio_set_lineno(VALUE self, VALUE lineno)
{
    StringIO(self)->lineno = NUM2LONG(lineno);
    return lineno;
}

#each(sep = $/) {|line| ... } ⇒ Object #each(limit) {|line| ... } ⇒ Object #each(sep, limit) {|line| ... } ⇒ Object #each(...) ⇒ Enumerator

strio.each_line(sep=$/) {|line| block } -> strio

strio.each_line(limit) {|line| block }     -> strio
strio.each_line(sep,limit) {|line| block } -> strio
strio.each_line(...)                       -> anEnumerator

strio.lines(sep=$/) {|line| block }        -> strio
strio.lines(limit) {|line| block }         -> strio
strio.lines(sep,limit) {|line| block }     -> strio
strio.lines(...)                           -> anEnumerator

See IO#each.

Overloads:

  • #each(sep = $/) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(limit) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(sep, limit) {|line| ... } ⇒ Object

    Yields:

    • (line)
  • #each(...) ⇒ Enumerator

    Returns:

    • (Enumerator)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.each(sep=$/) {|line| block }         -> strio
 *   strio.each(limit) {|line| block }          -> strio
 *   strio.each(sep, limit) {|line| block }     -> strio
 *   strio.each(...)                            -> anEnumerator
 *
 *   strio.each_line(sep=$/) {|line| block }    -> strio
 *   strio.each_line(limit) {|line| block }     -> strio
 *   strio.each_line(sep,limit) {|line| block } -> strio
 *   strio.each_line(...)                       -> anEnumerator
 *
 *   strio.lines(sep=$/) {|line| block }        -> strio
 *   strio.lines(limit) {|line| block }         -> strio
 *   strio.lines(sep,limit) {|line| block }     -> strio
 *   strio.lines(...)                           -> anEnumerator
 *
 * See IO#each.
 */
static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    VALUE line;

    RETURN_ENUMERATOR(self, argc, argv);

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

#pidObject

Returns nil. Just for compatibility to IO.



# File 'stringio.c'

/*
 * Returns +nil+.  Just for compatibility to IO.
 */
static VALUE
strio_nil(VALUE self)
{
    StringIO(self);
    return Qnil;
}

#posInteger #tellInteger

Returns the current offset (in bytes) of strio.

Overloads:

  • #posInteger

    Returns:

    • (Integer)
  • #tellInteger

    Returns:

    • (Integer)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.pos     -> integer
 *   strio.tell    -> integer
 *
 * Returns the current offset (in bytes) of *strio*.
 */
static VALUE
strio_get_pos(VALUE self)
{
    return LONG2NUM(StringIO(self)->pos);
}

#pos=(integer) ⇒ Integer

Seeks to the given position (in bytes) in strio.

Returns:

  • (Integer)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.pos = integer    -> integer
 *
 * Seeks to the given position (in bytes) in *strio*.
 */
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;
}

#printfObject

#putc(obj) ⇒ Object

See IO#putc.

Returns:

  • (Object)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.putc(obj)    -> obj
 *
 * See IO#putc.
 */
static VALUE
strio_putc(VALUE self, VALUE ch)
{
    struct StringIO *ptr = writable(StringIO(self));
    int c = NUM2CHR(ch);
    long olen;

    check_modifiable(ptr);
    olen = RSTRING_LEN(ptr->string);
    if (ptr->flags & FMODE_APPEND) {
    ptr->pos = olen;
    }
    strio_extend(ptr, ptr->pos, 1);
    RSTRING_PTR(ptr->string)[ptr->pos++] = c;
    OBJ_INFECT(ptr->string, self);
    return ch;
}

#putsObject

#read([length [, buffer]]) ⇒ String?

See IO#read.

Returns:

  • (String, nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.read([length [, buffer]])    -> string, buffer, or nil
 *
 * See IO#read.
 */
static VALUE
strio_read(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = readable(StringIO(self));
    VALUE str = Qnil;
    long len;

    switch (argc) {
      case 2:
    str = argv[1];
    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;
        }
        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;
      default:
    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
    }
    if (NIL_P(str)) {
    str = strio_substr(ptr, ptr->pos, len);
    if (argc > 0) 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 (NIL_P(str)) {
    str = rb_str_new(0, 0);
    len = 0;
    }
    else {
    ptr->pos += len = RSTRING_LEN(str);
    }
    return str;
}

#sysread(integer[, outbuf]) ⇒ String

Similar to #read, but raises EOFError at end of string instead of returning nil, as well as IO#sysread does.

Returns:

  • (String)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.sysread(integer[, outbuf])    -> string
 *
 * Similar to #read, but raises +EOFError+ at end of string instead of
 * returning +nil+, as well as IO#sysread does.
 */
static VALUE
strio_sysread(int argc, VALUE *argv, VALUE self)
{
    VALUE val = strio_read(argc, argv, self);
    if (NIL_P(val)) {
    rb_eof_error();
    }
    return val;
}

#readbyteFixnum

See IO#readbyte.

Returns:

  • (Fixnum)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.readbyte   -> fixnum
 *
 * See IO#readbyte.
 */
static VALUE
strio_readbyte(VALUE self)
{
    VALUE c = strio_getbyte(self);
    if (NIL_P(c)) rb_eof_error();
    return c;
}

#readcharString

See IO#readchar.

Returns:

  • (String)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.readchar   -> string
 *
 * See IO#readchar.
 */
static VALUE
strio_readchar(VALUE self)
{
    VALUE c = strio_getc(self);
    if (NIL_P(c)) rb_eof_error();
    return c;
}

#readline(sep = $/) ⇒ String #readline(limit) ⇒ String? #readline(sep, limit) ⇒ String?

See IO#readline.

Overloads:

  • #readline(sep = $/) ⇒ String

    Returns:

    • (String)
  • #readline(limit) ⇒ String?

    Returns:

    • (String, nil)
  • #readline(sep, limit) ⇒ String?

    Returns:

    • (String, nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.readline(sep=$/)     -> string
 *   strio.readline(limit)      -> string or nil
 *   strio.readline(sep, limit) -> string or nil
 *
 * See IO#readline.
 */
static VALUE
strio_readline(int argc, VALUE *argv, VALUE self)
{
    VALUE line = strio_gets(argc, argv, self);
    if (NIL_P(line)) rb_eof_error();
    return line;
}

#readlines(sep = $/) ⇒ Array #readlines(limit) ⇒ Array #readlines(sep, limit) ⇒ Array

See IO#readlines.

Overloads:

  • #readlines(sep = $/) ⇒ Array

    Returns:

    • (Array)
  • #readlines(limit) ⇒ Array

    Returns:

    • (Array)
  • #readlines(sep, limit) ⇒ Array

    Returns:

    • (Array)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.readlines(sep=$/)    ->   array
 *   strio.readlines(limit)     ->   array
 *   strio.readlines(sep,limit) ->   array
 *
 * See IO#readlines.
 */
static VALUE
strio_readlines(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    VALUE ary = rb_ary_new(), line;
    while (!NIL_P(line = strio_getline(argc, argv, readable(ptr)))) {
    rb_ary_push(ary, line);
    }
    return ary;
}

#sysread(integer[, outbuf]) ⇒ String

Similar to #read, but raises EOFError at end of string instead of returning nil, as well as IO#sysread does.

Returns:

  • (String)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.sysread(integer[, outbuf])    -> string
 *
 * Similar to #read, but raises +EOFError+ at end of string instead of
 * returning +nil+, as well as IO#sysread does.
 */
static VALUE
strio_sysread(int argc, VALUE *argv, VALUE self)
{
    VALUE val = strio_read(argc, argv, self);
    if (NIL_P(val)) {
    rb_eof_error();
    }
    return val;
}

#reopen(other_StrIO) ⇒ Object #reopen(string, mode) ⇒ Object

Reinitializes strio with the given other_StrIO or string and mode (see StringIO#new).



# File 'stringio.c'

/*
 * call-seq:
 *   strio.reopen(other_StrIO)     -> strio
 *   strio.reopen(string, mode)    -> strio
 *
 * Reinitializes *strio* with the given <i>other_StrIO</i> or _string_
 * and _mode_ (see StringIO#new).
 */
static VALUE
strio_reopen(int argc, VALUE *argv, VALUE self)
{
    if (!OBJ_TAINTED(self)) rb_secure(4);
    if (argc == 1 && TYPE(*argv) != T_STRING) {
    return strio_copy(self, *argv);
    }
    strio_init(argc, argv, StringIO(self));
    return self;
}

#rewind0

Positions strio to the beginning of input, resetting lineno to zero.

Returns:

  • (0)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.rewind    -> 0
 *
 * Positions *strio* to the beginning of input, resetting
 * +lineno+ to zero.
 */
static VALUE
strio_rewind(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    ptr->pos = 0;
    ptr->lineno = 0;
    return INT2FIX(0);
}

#seek(amount, whence = SEEK_SET) ⇒ 0

Seeks to a given offset amount in the stream according to the value of whence (see IO#seek).

Returns:

  • (0)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.seek(amount, whence=SEEK_SET) -> 0
 *
 * Seeks to a given offset _amount_ in the stream according to
 * the value of _whence_ (see IO#seek).
 */
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(ptr)) {
    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);
}

#set_encoding(ext_enc) ⇒ Object

Tagged with the encoding specified.



# File 'stringio.c'

/*
 *  call-seq:
 *     strio.set_encoding(ext_enc)                => strio
 *
 *  Tagged with the encoding specified.
 */

static VALUE
strio_set_encoding(VALUE self, VALUE ext_enc)
{
    rb_encoding* enc;
    VALUE str = StringIO(self)->string;
    enc = rb_to_encoding(ext_enc);
    rb_enc_associate(str, enc);
    return self;
}

#sizeInteger

Returns the size of the buffer string.

Returns:

  • (Integer)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.size   -> integer
 *
 * Returns the size of the buffer string.
 */
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));
}

#stringString

Returns underlying String object, the subject of IO.

Returns:

  • (String)


# File 'stringio.c'

/*
 * call-seq: strio.string     -> string
 *
 * Returns underlying String object, the subject of IO.
 */
static VALUE
strio_get_string(VALUE self)
{
    return StringIO(self)->string;
}

#string=(string) ⇒ String

Changes underlying String object, the subject of IO.

Returns:

  • (String)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.string = string  -> string
 *
 * Changes underlying String object, the subject of IO.
 */
static VALUE
strio_set_string(VALUE self, VALUE string)
{
    struct StringIO *ptr = StringIO(self);

    if (!OBJ_TAINTED(self)) rb_secure(4);
    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;
}

#synctrue

Returns true always.

Returns:

  • (true)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.sync    -> true
 *
 * Returns +true+ always.
 */
static VALUE
strio_get_sync(VALUE self)
{
    StringIO(self);
    return Qtrue;
}

#sync=Object

Returns the argument unchanged. Just for compatibility to IO.



# File 'stringio.c'

/*
 * Returns the argument unchanged.  Just for compatibility to IO.
 */
static VALUE
strio_first(VALUE self, VALUE arg)
{
    StringIO(self);
    return arg;
}

#sysread(integer[, outbuf]) ⇒ String

Similar to #read, but raises EOFError at end of string instead of returning nil, as well as IO#sysread does.

Returns:

  • (String)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.sysread(integer[, outbuf])    -> string
 *
 * Similar to #read, but raises +EOFError+ at end of string instead of
 * returning +nil+, as well as IO#sysread does.
 */
static VALUE
strio_sysread(int argc, VALUE *argv, VALUE self)
{
    VALUE val = strio_read(argc, argv, self);
    if (NIL_P(val)) {
    rb_eof_error();
    }
    return val;
}

#syswriteObject

#tellObject

#truncate(integer) ⇒ 0

Truncates the buffer string to at most integer bytes. The strio must be opened for writing.

Returns:

  • (0)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.truncate(integer)    -> 0
 *
 * Truncates the buffer string to at most _integer_ bytes. The *strio*
 * must be opened for writing.
 */
static VALUE
strio_truncate(VALUE self, VALUE len)
{
    VALUE string = writable(StringIO(self))->string;
    long l = NUM2LONG(len);
    long plen = RSTRING_LEN(string);
    if (l < 0) {
    error_inval("negative legnth");
    }
    rb_str_resize(string, l);
    if (plen < l) {
    MEMZERO(RSTRING_PTR(string) + plen, char, l - plen);
    }
    return len;
}

#tty?Object

Returns false. Just for compatibility to IO.



# File 'stringio.c'

/*
 * Returns +false+.  Just for compatibility to IO.
 */
static VALUE
strio_false(VALUE self)
{
    StringIO(self);
    return Qfalse;
}

#ungetbyte(fixnum) ⇒ nil

See IO#ungetbyte

Returns:

  • (nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.ungetbyte(fixnum)   -> nil
 *
 * See IO#ungetbyte
 */
static VALUE
strio_ungetbyte(VALUE self, VALUE c)
{
    struct StringIO *ptr = readable(StringIO(self));
    char buf[1], *cp = buf;
    long pos = ptr->pos, cl = 1;
    VALUE str = ptr->string;

    if (NIL_P(c)) return Qnil;
    if (FIXNUM_P(c)) {
    buf[0] = (char)FIX2INT(c);
    }
    else {
    SafeStringValue(c);
    cp = RSTRING_PTR(c);
    cl = RSTRING_LEN(c);
    if (cl == 0) return Qnil;
    }
    rb_str_modify(str);
    if (cl > pos) {
    char *s;
    long rest = RSTRING_LEN(str) - pos;
    rb_str_resize(str, rest + cl);
    s = RSTRING_PTR(str);
    memmove(s + cl, s + pos, rest);
    pos = 0;
    }
    else {
    pos -= cl;
    }
    memcpy(RSTRING_PTR(str) + pos, cp, cl);
    ptr->pos = pos;
    RB_GC_GUARD(c);
    return Qnil;
}

#ungetc(string) ⇒ nil

Pushes back one character (passed as a parameter) onto strio such that a subsequent buffered read will return it. There is no limitation for multiple pushbacks including pushing back behind the beginning of the buffer string.

Returns:

  • (nil)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.ungetc(string)   -> nil
 *
 * Pushes back one character (passed as a parameter) onto *strio*
 * such that a subsequent buffered read will return it.  There is no
 * limitation for multiple pushbacks including pushing back behind the
 * beginning of the buffer string.
 */
static VALUE
strio_ungetc(VALUE self, VALUE c)
{
    struct StringIO *ptr = readable(StringIO(self));
    long lpos, clen;
    char *p, *pend;
    rb_encoding *enc, *enc2;

    if (NIL_P(c)) return Qnil;
    if (FIXNUM_P(c)) {
    int cc = FIX2INT(c);
    char buf[16];

    enc = rb_enc_get(ptr->string);
    rb_enc_mbcput(cc, buf, enc);
    c = rb_enc_str_new(buf, rb_enc_codelen(cc, enc), enc);
    }
    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);
    }
    }
    if (RSTRING_LEN(ptr->string) < ptr->pos) {
    long len = RSTRING_LEN(ptr->string);
    rb_str_resize(ptr->string, ptr->pos - 1);
    memset(RSTRING_PTR(ptr->string) + len, 0, ptr->pos - len - 1);
    rb_str_concat(ptr->string, c);
    ptr->pos--;
    }
    else {
    /* get logical position */
    lpos = 0; p = RSTRING_PTR(ptr->string); pend = p + ptr->pos;
    for (;;) {
        clen = rb_enc_mbclen(p, pend, enc);
        if (p+clen >= pend) break;
        p += clen;
        lpos++;
    }
    clen = p - RSTRING_PTR(ptr->string);
    rb_str_update(ptr->string, lpos, ptr->pos ? 1 : 0, c);
    ptr->pos = clen;
    }

    return Qnil;
}

#write(string) ⇒ Integer #syswrite(string) ⇒ Integer

Appends the given string to the underlying buffer string of strio. The stream must be opened for writing. If the argument is not a string, it will be converted to a string using to_s. Returns the number of bytes written. See IO#write.

Overloads:

  • #write(string) ⇒ Integer

    Returns:

    • (Integer)
  • #syswrite(string) ⇒ Integer

    Returns:

    • (Integer)


# File 'stringio.c'

/*
 * call-seq:
 *   strio.write(string)    -> integer
 *   strio.syswrite(string) -> integer
 *
 * Appends the given string to the underlying buffer string of *strio*.
 * The stream must be opened for writing.  If the argument is not a
 * string, it will be converted to a string using <code>to_s</code>.
 * Returns the number of bytes written.  See IO#write.
 */
static VALUE
strio_write(VALUE self, VALUE str)
{
    struct StringIO *ptr = writable(StringIO(self));
    long len, olen;
    rb_encoding *enc, *enc2;

    RB_GC_GUARD(str);
    if (TYPE(str) != T_STRING)
    str = rb_obj_as_string(str);
    enc = rb_enc_get(ptr->string);
    enc2 = rb_enc_get(str);
    if (enc != enc2 && enc != rb_ascii8bit_encoding()) {
    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) {
    rb_str_cat(ptr->string, RSTRING_PTR(str), len);
    }
    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);
    ptr->pos += len;
    return LONG2NUM(len);
}

#write_nonblockObject