Creates an empty, resizeable and writeable IO::Memory with the given initial capacity for the internal buffer.

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

Creates an IO::Memory whose contents are the exact contents of string. The created IO::Memory is non-resizeable and non-writeable.

The IO 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 an IO::Memory that will read, and optionally write, from/to the given slice. The created IO::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 a Pointer(UInt8).

Same as #size.

Clears the internal buffer and resets the position to zero. Raises if this IO::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 this IO. Further operations on this IO will raise an IO::Error.

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

Determines if this IO is closed.

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

Returns true if this IO::Memory has no contents.

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

Reads the rest of this IO data as a writable Bytes.

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 this IO data as a String.

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 returns nil, but IO implementations that provide buffering or wrap other IOs should override this method.

Returns the current position (in bytes) of this IO.

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

Sets the current position (in bytes) of this IO.

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

See IO#read(slice).

Yields an IO::Memory to read a section of this IO's buffer.

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

Reads a single byte from this IO. Returns nil if there is no more data to read.

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

Rewinds this IO to the initial position (zero).

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

Seeks to a given offset (in bytes) according to the whence 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 this IO.

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

Reads and discards bytes from self until there are no more bytes.

Appends this internal buffer to the given IO.

Returns a new String 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]

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

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