class IO::Memory

Overview

An IO that reads and writes from a buffer in memory.

The internal buffer can be resizeable and/or writeable depending on how an IO::Memory is constructed.

Defined in:

io/memory.cr

Constructors

Instance Method Summary

Instance methods inherited from class IO

<<(obj) : self <<, close close, closed? : Bool closed?, each_byte(&) : Nil
each_byte
each_byte
, each_char(&) : Nil
each_char
each_char
, each_line(*args, **options, &block : String -> ) : Nil
each_line(*args, **options)
each_line
, encoding : String encoding, flush flush, gets(limit : Int, chomp = false) : String?
gets(delimiter : Char, limit : Int, chomp = false) : String?
gets(delimiter : Char, chomp = false) : String?
gets(delimiter : String, chomp = false) : String?
gets(chomp = true) : String?
gets
, gets_to_end : String gets_to_end, peek : Bytes? peek, pos pos, pos=(value) pos=, print(obj : _) : Nil
print(*objects : _) : Nil
print
, printf(format_string, args : Array | Tuple) : Nil
printf(format_string, *args) : Nil
printf
, puts(string : String) : Nil
puts(obj : _) : Nil
puts : Nil
puts(*objects : _) : Nil
puts
, read(slice : Bytes) read, read_at(offset, bytesize, & : IO -> ) read_at, read_byte : UInt8? read_byte, read_bytes(type, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) read_bytes, read_char : Char? read_char, read_fully(slice : Bytes) : Int32 read_fully, read_fully?(slice : Bytes) : Int32? read_fully?, read_line(*args, **options) : String read_line, read_string(bytesize : Int) : String read_string, read_utf8(slice : Bytes) read_utf8, read_utf8_byte : UInt8? read_utf8_byte, rewind rewind, seek(offset, whence : Seek = Seek::Set) seek, set_encoding(encoding : String, invalid : Symbol? = nil) : Nil set_encoding, skip(bytes_count : Int) : Nil skip, skip_to_end : Nil skip_to_end, tell tell, tty? : Bool tty?, write(slice : Bytes) : Nil write, write_byte(byte : UInt8) : Nil write_byte, write_bytes(object, format : IO::ByteFormat = IO::ByteFormat::SystemEndian) : Nil write_bytes, write_string(slice : Bytes) : Nil write_string, write_utf8(slice : Bytes) : Nil write_utf8

Class methods inherited from class IO

copy(src, dst, limit : Int) : Int64
copy(src, dst) : Int64
copy
, pipe(read_blocking = false, write_blocking = false) : Tuple(IO::FileDescriptor, IO::FileDescriptor)
pipe(read_blocking = false, write_blocking = false, &)
pipe
, same_content?(stream1 : IO, stream2 : IO) : Bool same_content?

Instance methods inherited from class Reference

==(other : self)
==(other : JSON::Any)
==(other : YAML::Any)
==(other)
==
, dup dup, hash(hasher) hash, initialize initialize, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference) : Bool
same?(other : Nil)
same?
, to_s(io : IO) : Nil to_s

Constructor methods inherited from class Reference

new new

Instance methods inherited from class Object

! : Bool !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other)
===
, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash
hash
, in?(collection : Object) : Bool
in?(*values : Object) : Bool
in?
, inspect(io : IO) : Nil
inspect : String
inspect
, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String
to_json
, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil
to_pretty_json
, to_s(io : IO) : Nil
to_s : String
to_s
, to_yaml(io : IO) : Nil
to_yaml : String
to_yaml
, try(&) try, unsafe_as(type : T.class) forall T unsafe_as

Class methods inherited from class Object

from_json(string_or_io, root : String)
from_json(string_or_io)
from_json
, from_yaml(string_or_io : String | IO) from_yaml

Constructor Detail

def self.new(capacity : Int = 64) #

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]

[View source]
def self.new(string : String) #

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

[View source]
def self.new(slice : Bytes, writeable = true) #

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"

[View source]

Instance Method Detail

def buffer : Pointer(UInt8) #

Returns the internal buffer as a Pointer(UInt8).


[View source]
def bytesize : Int32 #

Same as #size.


[View source]
def clear : Nil #

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

[View source]
def close : Nil #

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)

[View source]
def closed? : Bool #

Determines if this IO is closed.

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

[View source]
def empty? : Bool #

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

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

[View source]
def gets_to_end : String #
Description copied from class IO

Reads the rest of this IO data as a String.

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

[View source]
def peek : Bytes #
Description copied from class IO

Peeks into this IO, if possible.

It returns:

  • nil if this IO isn't peekable
  • 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.


[View source]
def pos : Int32 #

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

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

[View source]
def pos=(value) #

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

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

[View source]
def read(slice : Bytes) : Int32 #

[View source]
def read_at(offset, bytesize, & : IO -> ) #

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.


[View source]
def read_byte : UInt8? #
Description copied from class IO

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

[View source]
def rewind : self #

Rewinds this IO to the initial position (zero).

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

[View source]
def seek(offset, whence : Seek = Seek::Set) #

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"

[View source]
def size : Int32 #

Returns the total number of bytes in this IO.

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

[View source]
def skip_to_end : Nil #
Description copied from class IO

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


[View source]
def to_s(io : IO) : Nil #

Appends this internal buffer to the given IO.


[View source]
def to_s : String #

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"

[View source]
def to_slice : Bytes #

Returns the underlying bytes.

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

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

[View source]
def write(slice : Bytes) : Nil #

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


[View source]
def write_byte(byte : UInt8) : Nil #

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


[View source]