Class: StringIO

Inherits:
Data
  • Object
show all
Includes:
Enumerable, Readable, Writable
Defined in:
ext/stringio/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.



176
177
178
179
180
181
182
183
184
185
186
 
# File 'ext/stringio/stringio.c', line 176

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);
    return strio_init(argc, argv, ptr, self);
}

Class Method Details

.new(*args) ⇒ Object

:nodoc:



256
257
258
259
260
261
262
263
264
265
266
 
# File 'ext/stringio/stringio.c', line 256

static VALUE
strio_s_new(int argc, VALUE *argv, VALUE klass)
{
    if (rb_block_given_p()) {
  VALUE cname = rb_obj_as_string(klass);

  rb_warn("%"PRIsVALUE"::new() does not take block; use %"PRIsVALUE"::open() instead",
    cname, cname);
    }
    return rb_class_new_instance(argc, argv, klass);
}

.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) 


247
248
249
250
251
252
253
 
# File 'ext/stringio/stringio.c', line 247

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

#binmode ⇒ true

Returns:

  • (true) 


520
521
522
523
524
525
526
527
528
529
530
531
 
# File 'ext/stringio/stringio.c', line 520

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 ⇒ Object

This is a deprecated alias for #each_byte.



684
685
686
687
688
689
690
691
 
# File 'ext/stringio/stringio.c', line 684

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);
}

#chars ⇒ Object

This is a deprecated alias for each_char.



908
909
910
911
912
913
914
915
 
# File 'ext/stringio/stringio.c', line 908

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);
}

#close ⇒ nil

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

Returns:

  • (nil) 


368
369
370
371
372
373
374
 
# File 'ext/stringio/stringio.c', line 368

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

#close_read ⇒ nil

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

Returns:

  • (nil) 


383
384
385
386
387
388
389
390
391
392
 
# File 'ext/stringio/stringio.c', line 383

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;
}

#close_write ⇒ nil

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

Returns:

  • (nil) 


401
402
403
404
405
406
407
408
409
410
 
# File 'ext/stringio/stringio.c', line 401

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;
}

#closed? ⇒ Boolean

Returns true if strio is completely closed, false otherwise.

Returns:

  • (Boolean) 


418
419
420
421
422
423
424
 
# File 'ext/stringio/stringio.c', line 418

static VALUE
strio_closed(VALUE self)
{
    StringIO(self);
    if (!CLOSED(self)) return Qfalse;
    return Qtrue;
}

#closed_read? ⇒ Boolean

Returns true if strio is not readable, false otherwise.

Returns:

  • (Boolean) 


432
433
434
435
436
437
438
 
# File 'ext/stringio/stringio.c', line 432

static VALUE
strio_closed_read(VALUE self)
{
    StringIO(self);
    if (READABLE(self)) return Qfalse;
    return Qtrue;
}

#closed_write? ⇒ Boolean

Returns true if strio is not writable, false otherwise.

Returns:

  • (Boolean) 


446
447
448
449
450
451
452
 
# File 'ext/stringio/stringio.c', line 446

static VALUE
strio_closed_write(VALUE self)
{
    StringIO(self);
    if (WRITABLE(self)) return Qfalse;
    return Qtrue;
}

#codepoints ⇒ Object

This is a deprecated alias for each_codepoint.



952
953
954
955
956
957
958
959
 
# File 'ext/stringio/stringio.c', line 952

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(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

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) 


1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
 
# File 'ext/stringio/stringio.c', line 1192

static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    VALUE line;
    struct getline_arg arg;

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

    if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
  rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
    }

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

#each_byte {|byte| ... } ⇒ Object #each_byte ⇒ Enumerator

See IO#each_byte.

Overloads:

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

    Yields:

    • (byte)
  • #each_byte ⇒ Enumerator

    Returns:

    • (Enumerator) 


667
668
669
670
671
672
673
674
675
676
677
678
679
 
# File 'ext/stringio/stringio.c', line 667

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;
}

#each_char {|char| ... } ⇒ Object #each_char ⇒ Enumerator

See IO#each_char.

Overloads:

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

    Yields:

    • (char)
  • #each_char ⇒ Enumerator

    Returns:

    • (Enumerator) 


892
893
894
895
896
897
898
899
900
901
902
903
 
# File 'ext/stringio/stringio.c', line 892

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;
}

#each_codepoint {|c| ... } ⇒ Object #each_codepoint ⇒ Enumerator

See IO#each_codepoint.

Overloads:

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

    Yields:

    • (c)
  • #each_codepoint ⇒ Enumerator

    Returns:

    • (Enumerator) 


924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
 
# File 'ext/stringio/stringio.c', line 924

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;
}

#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

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) 


1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
 
# File 'ext/stringio/stringio.c', line 1192

static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    VALUE line;
    struct getline_arg arg;

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

    if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
  rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
    }

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

#eof ⇒ Boolean #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:

  • #eof ⇒ Boolean

    Returns:

    • (Boolean)
  • #eof? ⇒ Boolean

    Returns:

    • (Boolean) 


462
463
464
465
466
467
468
 
# File 'ext/stringio/stringio.c', line 462

static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(self);
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}

#eof ⇒ Boolean #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:

  • #eof ⇒ Boolean

    Returns:

    • (Boolean)
  • #eof? ⇒ Boolean

    Returns:

    • (Boolean) 


462
463
464
465
466
467
468
 
# File 'ext/stringio/stringio.c', line 462

static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(self);
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}

#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 nil.

Returns:

  • (Encoding) 


1555
1556
1557
1558
1559
1560
 
# File 'ext/stringio/stringio.c', line 1555

static VALUE
strio_external_encoding(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    return rb_enc_from_encoding(get_enc(ptr));
}

#fcntl ⇒ Object

#fileno ⇒ nil

Returns:

  • (nil)

#flush ⇒ Object

#fsync ⇒ 0

Returns:

  • (0)

#getbyte ⇒ Fixnum?

See IO#getbyte.

Returns:

  • (Fixnum, nil) 


724
725
726
727
728
729
730
731
732
733
734
 
# File 'ext/stringio/stringio.c', line 724

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);
}

#getc ⇒ String?

See IO#getc.

Returns:

  • (String, nil) 


699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
 
# File 'ext/stringio/stringio.c', line 699

static VALUE
strio_getc(VALUE self)
{
    struct StringIO *ptr = readable(self);
    rb_encoding *enc = get_enc(ptr);
    VALUE str = ptr->string;
    long pos = ptr->pos;
    int len;
    char *p;

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

#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) 


1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
 
# File 'ext/stringio/stringio.c', line 1146

static VALUE
strio_gets(int argc, VALUE *argv, VALUE self)
{
    struct getline_arg arg;
    VALUE str;

    if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
  struct StringIO *ptr = readable(self);
  return rb_enc_str_new(0, 0, get_enc(ptr));
    }

    str = strio_getline(&arg, readable(self));
    rb_lastline_set(str);
    return str;
}

#initialize_copy(orig) ⇒ Object

:nodoc:



471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
 
# File 'ext/stringio/stringio.c', line 471

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);
    RBASIC(copy)->flags &= ~STRIO_READWRITE;
    RBASIC(copy)->flags |= RBASIC(orig)->flags & STRIO_READWRITE;
    ++ptr->count;
    return copy;
}

#internal_encoding ⇒ Encoding

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

Returns:

  • (Encoding) 


1570
1571
1572
1573
1574
 
# File 'ext/stringio/stringio.c', line 1570

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

#isatty ⇒ nil #tty? ⇒ nil

Overloads:

  • #isatty ⇒ nil

    Returns:

    • (nil)
  • #tty? ⇒ nil

    Returns:

    • (nil)

#length ⇒ Integer #size ⇒ Integer

Returns the size of the buffer string.

Overloads:

  • #length ⇒ Integer

    Returns:

    • (Integer)
  • #size ⇒ Integer

    Returns:

    • (Integer) 


1514
1515
1516
1517
1518
1519
1520
1521
1522
 
# File 'ext/stringio/stringio.c', line 1514

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

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) 


500
501
502
503
504
 
# File 'ext/stringio/stringio.c', line 500

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) 


513
514
515
516
517
518
 
# File 'ext/stringio/stringio.c', line 513

static VALUE
strio_set_lineno(VALUE self, VALUE lineno)
{
    StringIO(self)->lineno = NUM2LONG(lineno);
    return lineno;
}

#lines(*args) ⇒ Object

This is a deprecated alias for each_line.



1214
1215
1216
1217
1218
1219
1220
1221
 
# File 'ext/stringio/stringio.c', line 1214

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);
}

#pid ⇒ nil

Returns:

  • (nil)

#pos ⇒ Integer #tell ⇒ Integer

Returns the current offset (in bytes) of strio.

Overloads:

  • #pos ⇒ Integer

    Returns:

    • (Integer)
  • #tell ⇒ Integer

    Returns:

    • (Integer) 


564
565
566
567
568
 
# File 'ext/stringio/stringio.c', line 564

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) 


576
577
578
579
580
581
582
583
584
585
586
 
# File 'ext/stringio/stringio.c', line 576

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;
}

#putc(obj) ⇒ Object

See IO#putc.

Returns:

  • (Object) 


1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
 
# File 'ext/stringio/stringio.c', line 1343

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;
}

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

See IO#read.

Returns:

  • (String, nil) 


1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
 
# File 'ext/stringio/stringio.c', line 1375

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);
  }
  /* fall through */
      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) {
      rb_encoding *enc = binary ? rb_ascii8bit_encoding() : get_enc(ptr);
      if (NIL_P(str)) {
    str = rb_str_new(0, 0);
      }
      else {
    rb_str_resize(str, 0);
      }
      rb_enc_associate(str, enc);
      return str;
  }
  else {
      len -= ptr->pos;
  }
  break;
    }
    if (NIL_P(str)) {
  rb_encoding *enc = binary ? rb_ascii8bit_encoding() : get_enc(ptr);
  str = strio_substr(ptr, ptr->pos, len, enc);
    }
    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;
}

#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) 


1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
 
# File 'ext/stringio/stringio.c', line 1231

static VALUE
strio_readlines(int argc, VALUE *argv, VALUE self)
{
    VALUE ary, line;
    struct getline_arg arg;

    StringIO(self);
    ary = rb_ary_new();
    if (prepare_getline_args(&arg, argc, argv)->limit == 0) {
  rb_raise(rb_eArgError, "invalid limit: 0 for readlines");
    }

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

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

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



547
548
549
550
551
552
553
554
555
 
# File 'ext/stringio/stringio.c', line 547

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);
    }
    return strio_init(argc, argv, StringIO(self), self);
}

#rewind ⇒ 0

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

Returns:

  • (0) 


595
596
597
598
599
600
601
602
 
# File 'ext/stringio/stringio.c', line 595

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) 


611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
 
# File 'ext/stringio/stringio.c', line 611

static VALUE
strio_seek(int argc, VALUE *argv, VALUE self)
{
    VALUE whence;
    struct StringIO *ptr = StringIO(self);
    long amount, offset;

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

#set_encoding(ext_enc, [int_enc[, opt]]) ⇒ Object

Specify the encoding of the StringIO as ext_enc. Use the default external encoding if ext_enc is nil. 2nd argument int_enc and optional hash opt argument are ignored; they are for API compatibility to IO.



1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
 
# File 'ext/stringio/stringio.c', line 1586

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;
}

#length ⇒ Integer #size ⇒ Integer

Returns the size of the buffer string.

Overloads:

  • #length ⇒ Integer

    Returns:

    • (Integer)
  • #size ⇒ Integer

    Returns:

    • (Integer) 


1514
1515
1516
1517
1518
1519
1520
1521
1522
 
# File 'ext/stringio/stringio.c', line 1514

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

Returns underlying String object, the subject of IO.

Returns:

  • (String) 


335
336
337
338
339
 
# File 'ext/stringio/stringio.c', line 335

static VALUE
strio_get_string(VALUE self)
{
    return StringIO(self)->string;
}

#string=(string) ⇒ String

Changes underlying String object, the subject of IO.

Returns:

  • (String) 


347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'ext/stringio/stringio.c', line 347

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;
}

#sync ⇒ true

Returns true always.

Returns:

  • (true) 


649
650
651
652
653
654
 
# File 'ext/stringio/stringio.c', line 649

static VALUE
strio_get_sync(VALUE self)
{
    StringIO(self);
    return Qtrue;
}

#sync=(boolean) ⇒ Boolean

Returns:

  • (Boolean)

#tell ⇒ Object

#truncate(integer) ⇒ 0

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

Returns:

  • (0) 


1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
 
# File 'ext/stringio/stringio.c', line 1531

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;
}

#tty? ⇒ Boolean

Returns:

  • (Boolean)

#ungetbyte(fixnum) ⇒ nil

See IO#ungetbyte

Returns:

  • (nil) 


802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
 
# File 'ext/stringio/stringio.c', line 802

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;
    }
}

#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) 


765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
 
# File 'ext/stringio/stringio.c', line 765

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;
    }
}

#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) 


1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
 
# File 'ext/stringio/stringio.c', line 1259

static VALUE
strio_write_m(int argc, VALUE *argv, VALUE self)
{
    long len = 0;
    while (argc-- > 0) {
  /* StringIO can't exceed long limit */
  len += strio_write(self, *argv++);
    }
    return LONG2NUM(len);
}