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, Protocol::Line, 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.



59
60
61
 
# File 'lib/async/io/generic.rb', line 59

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.



73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/async/io/generic.rb', line 73

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

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



45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/async/io/generic.rb', line 45

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 



61
62
63
64
65
66
67
68
69
70
 
# File 'lib/async/io/generic.rb', line 61

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

#connected? ⇒ Boolean

Returns:

  • (Boolean) 


120
121
122
 
# File 'lib/async/io/generic.rb', line 120

def connected?
	!@io.closed?
end

#nonblock ⇒ Object Also known as: nonblock= 



111
112
113
 
# File 'lib/async/io/generic.rb', line 111

def nonblock
	true
end

#nonblock? ⇒ Boolean

Returns:

  • (Boolean) 


116
117
118
 
# File 'lib/async/io/generic.rb', line 116

def nonblock?
	true
end

#read ⇒ Object Also known as: sysread, readpartial

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)


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

wrap_blocking_method :read, :read_nonblock

#wait(timeout = nil, mode = :read) ⇒ Object 



100
101
102
103
104
105
106
107
108
109
 
# File 'lib/async/io/generic.rb', line 100

def wait(timeout = nil, mode = :read)
	case mode
	when :read
		wait_readable(timeout)
	when :write
		wait_writable(timeout)
	else
		wait_any(:rw, timeout)
	end
end

#write ⇒ Object Also known as: syswrite, <<

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")


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

wrap_blocking_method :write, :write_nonblock