Creates an empty, resizeable and writeableIO::Memory with the given initialcapacity for the internal buffer.

io = IO::Memory.new
slice = Bytes.new(1)
io.pos         # => 0
io.read(slice) # => 0
slice          # => Bytes[0]

Creates anIO::Memory whose contents are the exact contents ofstring. The createdIO::Memory is non-resizeable and non-writeable.

TheIO starts at position zero for reading.

io = IO::Memory.new "hello"
io.pos        # => 0
io.gets(2)    # => "he"
io.print "hi" # raises IO::Error

Creates anIO::Memory that will read, and optionally write, from/to the given slice. The createdIO::Memory is non-resizeable.

The IO starts at position zero for reading.

slice = Slice.new(6) { |i| ('a'.ord + i).to_u8 }
io = IO::Memory.new slice, writeable: false
io.pos            # => 0
io.read(slice)    # => 6
String.new(slice) # => "abcdef"

Returns the internal buffer as aPointer(UInt8).

Same as#size.

Clears the internal buffer and resets the position to zero. Raises if thisIO::Memory is non-resizeable.

io = IO::Memory.new
io << "abc"
io.rewind
io.gets(1) # => "a"
io.clear
io.pos         # => 0
io.gets_to_end # => ""

io = IO::Memory.new "hello"
io.clear # raises IO::Error

Closes thisIO. Further operations on thisIO will raise anIO::Error.

io = IO::Memory.new "hello"
io.close
io.gets_to_end # raises IO::Error (closed stream)

Determines if thisIO is closed.

io = IO::Memory.new "hello"
io.closed? # => false
io.close
io.closed? # => true

Returnstrue if thisIO::Memory has no contents.

io = IO::Memory.new
io.empty? # => true
io.print "hello"
io.empty? # => false

Reads the rest of thisIO data as a writableBytes.

io = IO::Memory.new Bytes[0, 1, 3, 6, 10, 15]
io.getb_to_end # => Bytes[0, 1, 3, 6, 10, 15]
io.getb_to_end # => Bytes[]

Reads the rest of thisIO data as aString.

io = IO::Memory.new "hello world"
io.gets_to_end # => "hello world"
io.gets_to_end # => ""

Peeks into this IO, if possible.

It returns:

• nil if this IO isn't peekable at this moment or at all
• an empty slice if it is, but EOF was reached
• a non-empty slice if some data can be peeked

The returned bytes are only valid data until a next call to any method that reads from this IO is invoked.

By default this method returnsnil, but IO implementations that provide buffering or wrap other IOs should override this method.

Returns the current position (in bytes) of thisIO.

io = IO::Memory.new "hello"
io.pos     # => 0
io.gets(2) # => "he"
io.pos     # => 2

Sets the current position (in bytes) of thisIO.

io = IO::Memory.new "hello"
io.pos = 3
io.gets # => "lo"

SeeIO#read(slice).

Yields anIO::Memory to read a section of thisIO's buffer.

During the block durationself becomes read-only, so multiple concurrent open are allowed.

Reads a single byte from thisIO. Returnsnil if there is no more data to read.

io = IO::Memory.new "a"
io.read_byte # => 97
io.read_byte # => nil

Rewinds thisIO to the initial position (zero).

io = IO::Memory.new "hello"
io.gets(2) # => "he"
io.rewind
io.gets(2) # => "he"

Seeks to a givenoffset (in bytes) according to thewhence argument.

io = IO::Memory.new("abcdef")
io.gets(3) # => "abc"
io.seek(1, IO::Seek::Set)
io.gets(2) # => "bc"
io.seek(-1, IO::Seek::Current)
io.gets(1) # => "c"

Returns the total number of bytes in thisIO.

io = IO::Memory.new "hello"
io.size # => 5

Reads and discards bytes fromself until there are no more bytes.

Appends this internal buffer to the givenIO.

Returns a newString that contains the contents of the internal buffer.

io = IO::Memory.new
io.print 1, 2, 3
io.to_s # => "123"

Returns the underlying bytes.

io = IO::Memory.new
io.print "hello"

io.to_slice # => Bytes[104, 101, 108, 108, 111]

SeeIO#write(slice). Raises if thisIO::Memory is non-writeable, or if it's non-resizeable and a resize is needed.

SeeIO#write_byte. Raises if thisIO::Memory is non-writeable, or if it's non-resizeable and a resize is needed.