struct
   Crystal::EventLoop::Polling::Event
   
  
  Overview
Information about the event that a Fiber is waiting on.
The event can be waiting for IO with or without a timeout, or be a timed
event such as sleep or a select timeout (without IO).
The events can be found in different queues, for example Timers and/or
Waiters depending on their type.
Included Modules
- Crystal::PointerLinkedList::Node
- Crystal::PointerPairingHeap::Node
Defined in:
crystal/event_loop/polling/event.crConstructors
Instance Method Summary
- #fiber : Fiber
- #heap_child=(heap_child : Pointer(self) | Nil)
- #heap_child? : Pointer(self) | Nil
- 
        #heap_compare(other : Pointer(self)) : Bool
        
          Compare self with other. 
- #heap_next=(heap_next : Pointer(self) | Nil)
- #heap_next? : Pointer(self) | Nil
- #heap_previous=(heap_previous : Pointer(self) | Nil)
- #heap_previous? : Pointer(self) | Nil
- 
        #index : Arena::Index | Nil
        
          Arena index to access the associated PollDescriptorwhen processing an IO event.
- 
        #index? : Arena::Index | Nil | Nil
        
          Arena index to access the associated PollDescriptorwhen processing an IO event.
- #next : Pointer(self)
- #next=(next __arg0 : Pointer(self))
- #previous : Pointer(self)
- #previous=(previous : Pointer(self))
- 
        #timed_out! : Bool
        
          Mark the IO event as timed out. 
- 
        #timed_out? : Bool
        
          True if an IO event has timed out (i.e. 
- #type : Type
- 
        #wake_at : Time::Span
        
          The absolute time, against the monotonic clock, at which a timed event shall trigger. 
- 
        #wake_at=(wake_at : Time::Span | Nil)
        
          Manually set the absolute time (against the monotonic clock). 
- 
        #wake_at? : Time::Span | Nil
        
          The absolute time, against the monotonic clock, at which a timed event shall trigger. 
Instance methods inherited from module Crystal::PointerPairingHeap::Node
  
  
    
      heap_compare(other : Pointer(self)) : Bool
    heap_compare
    
  
      
      
      
    
      
      
      
      
    
      
  Instance methods inherited from struct Struct
  
  
    
      ==(other) : Bool
    ==, 
    
  
    
      hash(hasher)
    hash, 
    
  
    
      inspect(io : IO) : Nil
    inspect, 
    
  
    
      pretty_print(pp) : Nil
    pretty_print, 
    
  
    
      to_s(io : IO) : Nil
    to_s
    
  
      
      
      
    
      
  Instance methods inherited from struct Value
  
  
    
      ==(other : JSON::Any)==(other : YAML::Any)
==(other) ==, dup dup
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, root : String)from_json(string_or_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
Instance Method Detail
Compare self with other. For example:
Use < to create a min heap.
Use > to create a max heap.
Arena index to access the associated PollDescriptor when processing an IO
event. Nil for timed events (sleep, select timeout).
Arena index to access the associated PollDescriptor when processing an IO
event. Nil for timed events (sleep, select timeout).
The absolute time, against the monotonic clock, at which a timed event shall trigger. Nil for IO events without a timeout.
Manually set the absolute time (against the monotonic clock). This is meant
for FiberEvent to set and cancel its inner sleep or select timeout; these
objects are allocated once per Fiber.
NOTE  musn't be changed after registering the event into Timers!
The absolute time, against the monotonic clock, at which a timed event shall trigger. Nil for IO events without a timeout.