# abstract class Crystal::EventLoop

- Crystal::EventLoop
- Reference
- Object

##
Included Modules

- Crystal::EventLoop::FileDescriptor
- Crystal::EventLoop::Socket

##
Direct Known Subclasses

- Crystal::EventLoop::Polling

##
Defined in:

crystal/event_loop.cr:1
crystal/event_loop.cr:147
crystal/event_loop/file_descriptor.cr
crystal/event_loop/socket.cr

##
Constructors

- .create(parallelism : Int32 = 1) : self

  Creates an event loop instance.

- .current : self

##
Class Method Summary

- .backend_class
- .current? : self | Nil
- .default_file_blocking? : Bool
- .default_socket_blocking? : Bool
- .remove(file_descriptor : Crystal::System::FileDescriptor) : Nil

  Removes the file descriptor from the event loop.

- .remove(socket : ::Socket) : Nil

  Removes the socket from the event loop.

##
Instance Method Summary

- #create_resume_event(fiber : Fiber) : Event

  Create a new resume event for a fiber.

- #create_timeout_event(fiber : Fiber) : Event

  Creates a timeout_event.

- #drain(& : Fiber -> ) : Nil

  Blocks the current scheduler until all the pending events have completed.

- #interrupt : Nil

  Tells a blocking run loop to no longer wait for events to activate.

- #run(blocking : Bool) : Bool

  Runs the loop.

- #sleep(duration : Time::Span) : Nil

  Suspend the current fiber for duration.

### Instance methods inherited from module `Crystal::EventLoop::Socket`

accept(socket : ::Socket) : Tuple(::Socket::Handle, Bool) | Nil accept, close(socket : ::Socket) : Nil close, connect(socket : ::Socket, address : ::Socket::Addrinfo | ::Socket::Address, timeout : Time::Span | Nil) : IO::Error | Nil connect, read(socket : ::Socket, slice : Bytes) : Int32 read, receive_from(socket : ::Socket, slice : Bytes) : Tuple(Int32, ::Socket::Address) receive_from, send_to(socket : ::Socket, slice : Bytes, address : ::Socket::Address) : Int32 send_to, shutdown(socket : ::Socket) : Nil shutdown, socket(family : ::Socket::Family, type : ::Socket::Type, protocol : ::Socket::Protocol, blocking : Bool | Nil) : Tuple(::Socket::Handle, Bool) socket, socketpair(type : ::Socket::Type, protocol : ::Socket::Protocol) : Tuple(Tuple(::Socket::Handle, ::Socket::Handle), Bool) socketpair, wait_readable(socket : ::Socket) : Nil wait_readable, wait_writable(socket : ::Socket) : Nil wait_writable, write(socket : ::Socket, slice : Bytes) : Int32 write

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

close(file_descriptor : Crystal::System::FileDescriptor) : Nil close, open(path : String, flags : Int32, permissions : File::Permissions, blocking : Bool | Nil) : Tuple(System::FileDescriptor::Handle, Bool) | Errno | WinError open, pipe(read_blocking : Bool | Nil, write_blocking : Bool | Nil) : Tuple(IO::FileDescriptor, IO::FileDescriptor) pipe, read(file_descriptor : Crystal::System::FileDescriptor, slice : Bytes) : Int32 read, reopened(file_descriptor : Crystal::System::FileDescriptor) : Nil reopened, shutdown(file_descriptor : Crystal::System::FileDescriptor) : Nil shutdown, wait_readable(file_descriptor : Crystal::System::FileDescriptor) : Nil wait_readable, wait_writable(file_descriptor : Crystal::System::FileDescriptor) : Nil wait_writable, write(file_descriptor : Crystal::System::FileDescriptor, slice : Bytes) : Int32 write

### 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, unsafe_construct(address : Pointer, *args, **opts) : self unsafe_construct

### Class methods inherited from class `Reference`

pre_initialize(address : Pointer) pre_initialize

### 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!(message)
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 : String | IO, root : String)
from_json(string_or_io : String | IO) from_json, from_yaml(string_or_io : String | IO) from_yaml

### Macros inherited from class `Object`

class_getter(*names, &block) class_getter, class_getter!(*names) class_getter!, class_getter?(*names, &block) class_getter?, class_property(*names, &block) class_property, class_property!(*names) class_property!, class_property?(*names, &block) class_property?, class_setter(*names) class_setter, def_clone def_clone, def_equals(*fields) def_equals, def_equals_and_hash(*fields) def_equals_and_hash, def_hash(*fields) def_hash, delegate(*methods, to object) delegate, forward_missing_to(delegate) forward_missing_to, getter(*names, &block) getter, getter!(*names) getter!, getter?(*names, &block) getter?, property(*names, &block) property, property!(*names) property!, property?(*names, &block) property?, setter(*names) setter

##
Constructor Detail

def self.create(parallelism : Int32 = 1) : self #

Creates an event loop instance.

The parallelism arg is informational. It reports how many schedulers are expected to register with the event loop instance. Because schedulers are dynamically started and execution contexts can be resized, more or less schedulers may really register in practice.

def self.current : self #

##
Class Method Detail

def self.backend_class #
def self.current? : self | Nil #
def self.default_file_blocking? : Bool #
def self.default_socket_blocking? : Bool #
def self.remove(file_descriptor : Crystal::System::FileDescriptor) : Nil #

Removes the file descriptor from the event loop. Can be used to free up memory resources associated with the file descriptor, as well as removing the file descriptor from kernel data structures.

Called by `::IO::FileDescriptor#finalize` before closing the file descriptor. Errors shall be silently ignored.

def self.remove(socket : ::Socket) : Nil #

Removes the socket from the event loop. Can be used to free up memory resources associated with the socket, as well as removing the socket from kernel data structures.

Called by `::Socket#finalize` before closing the socket. Errors shall be silently ignored.

##
Instance Method Detail

def create_resume_event(fiber : Fiber) : Event #

Create a new resume event for a fiber.

NOTE optional.

abstract def create_timeout_event(fiber : Fiber) : Event #

Creates a timeout_event.

def drain(& : Fiber -> ) : Nil #

Blocks the current scheduler until all the pending events have completed. Must yield every runnable fiber.

Optional.

abstract def interrupt : Nil #

Tells a blocking run loop to no longer wait for events to activate. It may for example enqueue a NOOP event with an immediate (or past) timeout. Having activated an event, the loop shall return, allowing the blocked thread to continue.

Should be a NOOP when the loop isn't running or is running in a nonblocking mode.

NOTE we assume that multiple threads won't run the event loop at the same time in parallel, but this assumption may change in the future!

abstract def run(blocking : Bool) : Bool #

Runs the loop.

Returns immediately if events are activable. Set `blocking` to false to return immediately if there are no activable events; set it to true to wait for activable events, which will block the current thread until then.

Returns `true` on normal returns (e.g. has activated events, has pending events but blocking was false) and `false` when there are no registered events.

abstract def sleep(duration : Time::Span) : Nil #

Suspend the current fiber for duration.