Class: IO::LikeHelpers::DuplexedIO

Inherits:
DelegatedIO show all
Defined in:
lib/io/like_helpers/duplexed_io.rb

Overview

This class encapsulates 2 streams (one readable, one writable) into a single stream. It is primarily intended to serve as an ancestor for IO::Like and should not be used directly.

Direct Known Subclasses

IO::Like

Instance Method Summary collapse

Methods inherited from DelegatedIO

#advise, #autoclose=, #autoclose?, #close_on_exec?, create_finalizer, #fcntl, #fdatasync, #fileno, #fsync, #ioctl, #nonblock?, #nread, #path, #pid, #pread, #read, #ready?, #seek, #stat, #to_io, #tty?, #wait

Methods inherited from AbstractIO

#advise, #close_on_exec?, #fcntl, #fdatasync, #fileno, #fsync, #ioctl, #nonblock, #nonblock?, #nread, open, #path, #pid, #pread, #read, #ready?, #seek, #stat, #to_io, #tty?, #wait

Constructor Details

#initialize(delegate_r, delegate_w = delegate_r, autoclose: true) ⇒ DuplexedIO

Creates a new intance of this class.

Parameters:

  • delegate_r (LikeHelpers::AbstractIO) —

    a readable stream

  • delegate_w (LikeHelpers::AbstractIO) (defaults to: delegate_r) —

    a writable stream

  • autoclose (Boolean) (defaults to: true) —

    when true close the delegate when this stream is closed

Raises:

  • (ArgumentError) 


19
20
21
22
23
24
25
26
27
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 19

def initialize(delegate_r, delegate_w = delegate_r, autoclose: true)
  raise ArgumentError, 'delegate_r cannot be nil' if delegate_r.nil?
  raise ArgumentError, 'delegate_w cannot be nil' if delegate_w.nil?

  @delegate_w = delegate_w
  @closed_write = false

  super(delegate_r, autoclose: autoclose)
end

Instance Method Details

#close ⇒ nil, ...

Closes this stream.

The delegates are closed if autoclose is enabled for the stream.

Returns:

  • (nil) —

    on success

  • (:wait_readable, :wait_writable) —

    if the stream is non-blocking and the operation would block



37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 37

def close
  return nil if closed?

  begin
    result = close_write
  ensure
    # Complete the closing process if the writable delegate closed normally or
    # an exception was raised.
    result = close_read unless Symbol === result
  end

  result
end

#close_on_exec=(close_on_exec) ⇒ Boolean

Sets the close-on-exec flag for the underlying file descriptors of the delegates.

Note that setting this to false can lead to file descriptor leaks in multithreaded applications that fork and exec or use the system method.

Returns:

  • (Boolean) 


133
134
135
136
137
138
139
140
141
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 133

def close_on_exec=(close_on_exec)
  return super unless duplexed?

  assert_open

  delegate_w.close_on_exec = delegate_r.close_on_exec = close_on_exec

  close_on_exec
end

#close_read ⇒ nil, ...

Closes the readable delegate.

Returns:

  • (nil) —

    on success

  • (:wait_readable, :wait_writable) —

    if the stream is non-blocking and the operation would block



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 79

def close_read
  return nil if closed_read?

  begin
    result = delegate_r.close if @autoclose
  ensure
    # Complete the closing process if the delegate closed normally or an
    # exception was raised.
    unless Symbol === result
      @closed_write = true unless duplexed?
      @closed = true
      @delegate = @delegate_w
      disable_finalizer
      enable_finalizer if @autoclose && ! closed?
    end
  end

  result
end

#close_write ⇒ nil, ...

Closes the writable delegate.

Returns:

  • (nil) —

    on success

  • (:wait_readable, :wait_writable) —

    if the stream is non-blocking and the operation would block



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 105

def close_write
  return nil if closed_write?

  begin
    result = delegate_w.close if @autoclose
  ensure
    # Complete the closing process if the delegate closed normally or an
    # exception was raised.
    unless Symbol === result
      @closed = true unless duplexed?
      @closed_write = true
      @delegate_w = @delegate
      disable_finalizer
      enable_finalizer if @autoclose && ! closed?
    end
  end

  result
end

#closed? ⇒ Boolean

Returns true if both delegates are closed and false otherwise.

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 61

def closed?
  closed_read? && closed_write?
end

#closed_read? ⇒ Boolean

Returns true if the readable delegate is closed and false otherwise.

Returns:

  • (Boolean) 


55
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 55

alias_method :closed_read?, :closed?

#closed_write? ⇒ Boolean

Returns true if the writable delegate is closed and false otherwise.

Returns:

  • (Boolean) 


69
70
71
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 69

def closed_write?
  @closed_write
end

#inspect ⇒ String

Returns a string representation of this object.

Returns:

  • (String) —

    a string representation of this object



145
146
147
148
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 145

def inspect
  return super unless duplexed?
  "<#{self.class}:#{delegate_r.inspect}, #{delegate_w.inspect}>"
end

#nonblock=(nonblock) ⇒ Boolean

Sets the blocking mode for the stream.

Returns:

  • (Boolean) 


154
155
156
157
158
159
160
161
162
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 154

def nonblock=(nonblock)
  return super unless duplexed?

  assert_open

  delegate_w.nonblock = delegate_r.nonblock = nonblock

  nonblock
end

#pwrite(*args, **kwargs, &b) ⇒ Object

Calls ‘delegate_w.write(*args, **kwargs, &b)` after asserting that the stream is writable.



167
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 167

delegate :pwrite, to: :delegate_w, assert: :writable

#readable? ⇒ Boolean

Returns true if the stream is readable and false otherwise.

Returns:

  • (Boolean) 


173
174
175
176
177
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 173

def readable?
  return false if closed_read?
  return @readable if defined?(@readable) && ! @readable.nil?
  @readable = delegate_r.readable?
end

#writable? ⇒ Boolean

Returns true if the stream is writable and false otherwise.

Returns:

  • (Boolean) 


188
189
190
191
192
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 188

def writable?
  return false if closed_write?
  return @writable if defined?(@writable) && ! @writable.nil?
  @writable = delegate_w.writable?
end

#write(*args, **kwargs, &b) ⇒ Object

Calls ‘delegate_w.write(*args, **kwargs, &b)` after asserting that the stream is writable.



182
 
# File 'lib/io/like_helpers/duplexed_io.rb', line 182

delegate :write, to: :delegate_w, assert: :writable