class MFile

• MFile
• IO
• Reference
• Object

Overview

Memory mapped file Max 2GB files (Slice is currently limited to Int32) If no #capacity is given the file is open in read only mode and #capacity is set to the current file size. If the process crashes the file will be #capacity large, not #size large, only on graceful close is the file truncated to its #size. The file does not expand further than initial #capacity, unless manually expanded.

Defined in:

Constant Summary

PAGESIZE = (LibC.sysconf(LibC::SC_PAGESIZE)).to_u32

Constructors

• .new(path : String, capacity : Int | Nil = nil)

  Map a file, if no capacity is given the file must exists and the file will be mapped as readonly The file won't be truncated if the capacity is smaller than current size

• .open(path) : MFile

  Opens an existing file in readonly mode

Class Method Summary

• .open(path, &)

  Opens an existing file in readonly mode

Instance Method Summary

• #advise(advice : Advice, offset = 0, length = @capacity)
• #capacity : Int32
• #close(truncate_to_size = true) : Nil

  Unmapping the file The file will be truncated to the current position unless readonly or deleted

• #closed? : Bool

  Returns true if this IO is closed.

• #delete
• #disk_usage : UInt64
• #finalize
• #flush

  Flushes buffered data, if any.

• #fsync
• #move(new_path : String)
• #path : String
• #pos : Int32

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

• #pos=(pos : Int32)
• #punch_hole(size : UInt32, offset : UInt32 = 0_u32) : UInt32
• #read(slice : Bytes)

  Reads at most slice.size bytes from this IO into slice.

• #resize(new_size : Int) : Nil
• #rewind

  Rewinds this IO.

• #seek(offset, whence : IO::Seek = IO::Seek::Set)

  Seeks to a given offset (in bytes) according to the whence argument.

• #size : Int32
• #to_slice : Slice(UInt8)
• #truncate(new_size : Int) : Int32
• #write(slice : Bytes) : Nil

  Writes the contents of slice into this IO.

Constructor Detail

Class Method Detail

Instance Method Detail

File.write("testfile", "hello")

file = File.new("testfile")
file.pos     # => 0
file.gets(2) # => "he"
file.pos     # => 2

io = IO::Memory.new "hello"
slice = Bytes.new(4)
io.read(slice) # => 4
slice          # => Bytes[104, 101, 108, 108]
io.read(slice) # => 1
slice          # => Bytes[111, 101, 108, 108]
io.read(slice) # => 0

File.write("testfile", "abc")

file = File.new("testfile")
file.gets(3) # => "abc"
file.seek(1, IO::Seek::Set)
file.gets(2) # => "bc"
file.seek(-1, IO::Seek::Current)
file.gets(1) # => "c"

io = IO::Memory.new
slice = Bytes.new(4) { |i| ('a'.ord + i).to_u8 }
io.write(slice)
io.to_s # => "abcd"