Class: Async::IO::Generic

Inherits:
Wrapper
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/async/io/generic.rb

Overview

Represents an asynchronous IO within a reactor.

Direct Known Subclasses

BasicSocket, SSLSocket

Constant Summary collapse

WRAPPERS = 
{}

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Class Attribute Details

.wrapped_klass ⇒ Object (readonly)

Returns the value of attribute wrapped_klass.



55
56
57
 
# File 'lib/async/io/generic.rb', line 55

def wrapped_klass
  @wrapped_klass
end

Class Method Details

.wrap(*args) ⇒ Object

Instantiate a wrapped instance of the class, and optionally yield it to a given block, closing it afterwards.



69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/async/io/generic.rb', line 69

def wrap(*args)
  wrapper = self.new(@wrapped_klass.new(*args))
  
  if block_given?
    begin
      yield wrapper
    ensure
      wrapper.close
    end
  else
    return wrapper
  end
end

.wrap_blocking_method(new_name, method_name, invert: true) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/async/io/generic.rb', line 41

def wrap_blocking_method(new_name, method_name, invert: true)
  define_method(new_name) do |*args|
    async_send(method_name, *args)
  end
  
  if invert
    # We define the original _nonblock method to call the async variant. We ignore options.
    # define_method(method_name) do |*args, **options|
    #   self.__send__(new_name, *args)
    # end
    def_delegators :@io, method_name
  end
end

.wraps(klass, *additional_methods) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
 
# File 'lib/async/io/generic.rb', line 57

def wraps(klass, *additional_methods)
  @wrapped_klass = klass
  WRAPPERS[klass] = self
  
  # These are methods implemented by the wrapped class, that we aren't overriding, that may be of interest:
  # fallback_methods = klass.instance_methods(false) - instance_methods
  # puts "Forwarding #{klass} methods #{fallback_methods} to @io"
  
  def_delegators :@io, *additional_methods
end

Instance Method Details

#read ⇒ Object

Invokes ‘read_nonblock` on the underlying io. If the operation would block, the current task is paused until the operation can succeed, at which point it’s resumed and the operation is completed.

Examples:

data = io.read(512)



88
 
# File 'lib/async/io/generic.rb', line 88

wrap_blocking_method :read, :read_nonblock

#write ⇒ Object

Invokes ‘write_nonblock` on the underlying io. If the operation would block, the current task is paused until the operation can succeed, at which point it’s resumed and the operation is completed.

Examples:

io.write("Hello World")



92
 
# File 'lib/async/io/generic.rb', line 92

wrap_blocking_method :write, :write_nonblock