IO::FileDescriptor - Crystal 1.5.0

# class IO::FileDescriptor

- IO::FileDescriptor
- IO
- Reference
- Object

##
Overview

An `IO` over a file descriptor.

##
Included Modules

- Crystal::System::FileDescriptor
- IO::Buffered

##
Direct Known Subclasses

- File

##
Defined in:

io/console.cr
io/file_descriptor.cr

##
Constructors

- .new(fd, blocking = nil)

##
Class Method Summary

- .fcntl(fd, cmd, arg = 0)

##
Instance Method Summary

- #blocking
- #blocking=(value)
- #close_on_exec=(value : Bool)
- #close_on_exec? : Bool
- #closed? : Bool

  Returns `true` if this `IO` is closed.

- #cooked(&)

  Enables character processing for the duration of the given block.

- #cooked! : Nil

  Enables character processing for this IO.

- #fcntl(cmd, arg = 0)
- #fd : Int

  The raw file-descriptor.

- #finalize
- #flock_exclusive(blocking = true, &)
- #flock_exclusive(blocking = true) : Nil

  Places an exclusive advisory lock.

- #flock_shared(blocking = true, &)
- #flock_shared(blocking = true) : Nil

  Places a shared advisory lock.

- #flock_unlock : Nil

  Removes an existing advisory lock held by this process.

- #fsync(flush_metadata = true) : Nil

  Flushes all data written to this File Descriptor to the disk device so that all changed information can be retrieved even if the system crashes or is rebooted.

- #info
- #inspect(io : IO) : Nil

  Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

- #noecho(&)

  Turns off character echoing for the duration of the given block.

- #noecho!

  Turns off character echoing for this IO.

- #pos=(value)

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

- #pretty_print(pp)
- #raw(&)

  Enables raw mode for the duration of the given block.

- #raw!

  Enables raw mode for this IO.

- #reopen(other : IO::FileDescriptor)
- #seek(offset, whence : Seek = Seek::Set)

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

- #seek(offset, whence : Seek = Seek::Set, &)

  Same as `#seek` but yields to the block after seeking and eventually seeks back to the original position when the block returns.

- #tty? : Bool

  Returns `true` if this `IO` is associated with a terminal device (tty), `false` otherwise.

##
Macro Summary

- cooked_from_tc_mode!
- noecho_from_tc_mode!
- raw_from_tc_mode!

### Instance methods inherited from module `IO::Buffered`

buffer_size : Int32 buffer_size, buffer_size=(value) buffer_size=, close : Nil close, flush flush, flush_on_newline=(flush_on_newline) flush_on_newline=, flush_on_newline? : Bool flush_on_newline?, peek : Bytes? peek, pos : Int64 pos, read(slice : Bytes) : Int32 read, read_buffering=(read_buffering) read_buffering=, read_buffering? : Bool read_buffering?, rewind rewind, sync=(sync) sync=, sync? : Bool sync?, unbuffered_close unbuffered_close, unbuffered_flush unbuffered_flush, unbuffered_read(slice : Bytes) unbuffered_read, unbuffered_rewind unbuffered_rewind, unbuffered_write(slice : Bytes) unbuffered_write, write(slice : Bytes) : Nil write

### Instance methods inherited from module `Crystal::System::FileDescriptor`

file_descriptor_close : Nil file_descriptor_close

### Class methods inherited from module `Crystal::System::FileDescriptor`

fcntl(fd, cmd, arg = 0) fcntl, from_stdio(fd) from_stdio, pipe(read_blocking, write_blocking) pipe, pread(fd, buffer, offset) pread

### Instance methods inherited from module `IO::Evented`

evented_close : Nil evented_close, evented_read(slice : Bytes, errno_msg : String, &) : Int32 evented_read, evented_reopen : Nil evented_reopen, evented_send(slice : Bytes, errno_msg : String, &) : Int32 evented_send, evented_write(slice : Bytes, errno_msg : String, &) : Nil evented_write, read_timeout : Time::Span? read_timeout, read_timeout=(read_timeout : Number) : Number
read_timeout=(timeout : Time::Span?) : Time::Span? read_timeout=, write_timeout : Time::Span? write_timeout, write_timeout=(write_timeout : Number) : Number
write_timeout=(timeout : Time::Span?) : Time::Span? write_timeout=

### 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, getb_to_end : Bytes getb_to_end, 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(fd, blocking = nil) #

##
Class Method Detail

def self.fcntl(fd, cmd, arg = 0) #

##
Instance Method Detail

def blocking #
def blocking=(value) #
def close_on_exec=(value : Bool) #
def close_on_exec? : Bool #
def closed? : Bool #
Description copied from class IO

Returns `true` if this `IO` is closed.

`IO` defines returns `false`, but including types may override.

def cooked(&) #

Enables character processing for the duration of the given block. The so called cooked mode is the standard behavior of a terminal, doing line wise editing by the terminal and only sending the input to the program on a newline. Only call this when this IO is a TTY, such as a not redirected stdin.

def cooked! : Nil #

Enables character processing for this IO. The so called cooked mode is the standard behavior of a terminal, doing line wise editing by the terminal and only sending the input to the program on a newline. Only call this when this IO is a TTY, such as a not redirected stdin.

def fcntl(cmd, arg = 0) #
def fd : Int #

The raw file-descriptor. It is defined to be an `Int`, but its size is platform-specific.

def finalize #
def flock_exclusive(blocking = true, &) #
def flock_exclusive(blocking = true) : Nil #

Places an exclusive advisory lock. Only one process may hold an exclusive lock for a given file descriptor at a given time. `IO::Error` is raised if blocking is set to `false` and any existing lock is set.

def flock_shared(blocking = true, &) #
def flock_shared(blocking = true) : Nil #

Places a shared advisory lock. More than one process may hold a shared lock for a given file descriptor at a given time. `IO::Error` is raised if blocking is set to `false` and an existing exclusive lock is set.

def flock_unlock : Nil #

Removes an existing advisory lock held by this process.

def fsync(flush_metadata = true) : Nil #

Flushes all data written to this File Descriptor to the disk device so that all changed information can be retrieved even if the system crashes or is rebooted. The call blocks until the device reports that the transfer has completed. To reduce disk activity the flush_metadata parameter can be set to false, then the syscall fdatasync will be used and only data required for subsequent data retrieval is flushed. Metadata such as modified time and access time is not written.

NOTE Metadata is flushed even when flush_metadata is false on Windows and DragonFly BSD.

def info #
def inspect(io : IO) : Nil #
Description copied from class Reference

Appends a String representation of this object which includes its class name, its object address and the values of all instance variables.

    class Person
      def initialize(@name : String, @age : Int32)
      end
    end

    Person.new("John", 32).inspect # => #<Person:0x10fd31f20 @name="John", @age=32>

def noecho(&) #

Turns off character echoing for the duration of the given block. This will prevent displaying back to the user what they enter on the terminal. Only call this when this IO is a TTY, such as a not redirected stdin.

    print "Enter password: "
    password = STDIN.noecho &.gets.try &.chomp
    puts

def noecho! #

Turns off character echoing for this IO. This will prevent displaying back to the user what they enter on the terminal. Only call this when this IO is a TTY, such as a not redirected stdin.

def pos=(value) #

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

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

    file = File.new("testfile")
    file.pos = 3
    file.gets_to_end # => "lo"

def pretty_print(pp) #
def raw(&) #

Enables raw mode for the duration of the given block. In raw mode every keypress is directly sent to the program, no interpretation is done by the terminal. Only call this when this IO is a TTY, such as a not redirected stdin.

def raw! #

Enables raw mode for this IO. In raw mode every keypress is directly sent to the program, no interpretation is done by the terminal. Only call this when this IO is a TTY, such as a not redirected stdin.

def reopen(other : IO::FileDescriptor) #
def seek(offset, whence : Seek = Seek::Set) #

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

    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"

def seek(offset, whence : Seek = Seek::Set, &) #

Same as `#seek` but yields to the block after seeking and eventually seeks back to the original position when the block returns.

def tty? : Bool #
Description copied from class IO

Returns `true` if this `IO` is associated with a terminal device (tty), `false` otherwise.

IO returns `false`, but including types may override.

    STDIN.tty?          # => true
    IO::Memory.new.tty? # => false

##
Macro Detail

macro cooked_from_tc_mode! #
macro noecho_from_tc_mode! #
macro raw_from_tc_mode! #