Class List Method List File List

# Module: Vertx::WebSocketBase

Includes:
  ReadStream, WriteStream
Included in:
  ServerWebSocket, WebSocket, WebSocketBaseImpl
Defined in:
  /Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb

## Instance Method Summary (collapse)

- - (String) binary_handler_id
  When a Websocket is created it automatically registers an event handler with the event bus - the ID of that handler is given by this method.
- - (self) binary_message_handler { ... }
  Set a binary message handler on the connection.
- - (void) close
  Close the WebSocket.
- - (self) close_handler { ... }
  Set a close handler.
- - (self) drain_handler { ... }
- - (void) end(t = nil)
  Same as #end but writes some data to the stream before ending.
- - (self) end_handler { ... }
- - (self) exception_handler { ... }
- - (self) frame_handler { ... }
  Set a frame handler on the connection.
- - (self) handler { ... }
- - (::Vertx::SocketAddress) local_address
  The local address for this socket.
- - (self) pause
- - (::Vertx::SocketAddress) remote_address
  The remote address for this socket.
- - (self) resume
- - (self) set_write_queue_max_size(maxSize = nil)
- - (String) text_handler_id
  When a Websocket is created it automatically registers an event handler with the eventbus, the ID of that handler is given by textHandlerID.
- - (self) text_message_handler { ... }
  Set a text message handler on the connection.
- - (self) write(data = nil)
- - (self) write_binary_message(data = nil)
  Writes a (potentially large) piece of binary data to the connection.
- - (self) write_final_binary_frame(data = nil)
  Write a final WebSocket binary frame to the connection.
- - (self) write_final_text_frame(text = nil)
  Write a final WebSocket text frame to the connection.
- - (self) write_frame(frame = nil)
  Write a WebSocket frame to the connection.
- - (true, false) write_queue_full
  This will return true if there are more bytes in the write queue than the value set using #set_write_queue_max_size.
- - (self) write_text_message(text = nil)
  Writes a (potentially large) piece of text data to the connection.

## Instance Method Details

### - (`String`) binary_handler_id

When a `Websocket` is created it automatically registers an event handler with the event bus - the ID of that handler is given by this method.

Given this ID, a different event loop can send a binary frame to that event handler using the event bus and that buffer will be received by this instance in its own event loop and written to the underlying connection. This allows you to write data to other WebSockets which are owned by different event loops.

Returns:

- (`String`) —
  the binary handler id

Raises:

- (`ArgumentError`)

    108
    109
    110
    111
    112
    113
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 108

    def binary_handler_id
      if !block_given?
        return @j_del.java_method(:binaryHandlerID, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling binary_handler_id()"
    end

### - (`self`) binary_message_handler { ... }

Set a binary message handler on the connection. This handler serves a similar purpose to #handler except that if a message comes into the socket in multiple frames, the data from the frames will be aggregated into a single buffer before calling the handler (using Vertx::WebSocketFrame#is_final to find the boundaries).

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    215
    216
    217
    218
    219
    220
    221
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 215

    def binary_message_handler
      if block_given?
        @j_del.java_method(:binaryMessageHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Buffer)) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling binary_message_handler()"
    end

### - (`void`) close

This method returns an undefined value.

Close the WebSocket.

Raises:

- (`ArgumentError`)

    224
    225
    226
    227
    228
    229
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 224

    def close
      if !block_given?
        return @j_del.java_method(:close, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling close()"
    end

### - (`self`) close_handler { ... }

Set a close handler. This will be called when the WebSocket is closed.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    182
    183
    184
    185
    186
    187
    188
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 182

    def close_handler
      if block_given?
        @j_del.java_method(:closeHandler, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling close_handler()"
    end

### - (`self`) drain_handler { ... }

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    94
    95
    96
    97
    98
    99
    100
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 94

    def drain_handler
      if block_given?
        @j_del.java_method(:drainHandler, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling drain_handler()"
    end

### - (`void`) end(t = nil)

This method returns an undefined value.

Same as #end but writes some data to the stream before ending.

Parameters:

- t (`::Vertx::Buffer`) (defaults to: `nil`)

Raises:

- (`ArgumentError`)

    15
    16
    17
    18
    19
    20
    21
    22
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 15

    def end(t=nil)
      if !block_given? && t == nil
        return @j_del.java_method(:end, []).call()
      elsif t.class.method_defined?(:j_del) && !block_given?
        return @j_del.java_method(:end, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(t.j_del)
      end
      raise ArgumentError, "Invalid arguments when calling end(#{t})"
    end

### - (`self`) end_handler { ... }

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    67
    68
    69
    70
    71
    72
    73
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 67

    def end_handler
      if block_given?
        @j_del.java_method(:endHandler, [Java::IoVertxCore::Handler.java_class]).call(Proc.new { yield })
        return self
      end
      raise ArgumentError, "Invalid arguments when calling end_handler()"
    end

### - (`self`) exception_handler { ... }

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    33
    34
    35
    36
    37
    38
    39
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 33

    def exception_handler
      if block_given?
        @j_del.java_method(:exceptionHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.from_throwable(event)) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling exception_handler()"
    end

### - (`self`) frame_handler { ... }

Set a frame handler on the connection. This handler will be called when frames are read on the connection.

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    192
    193
    194
    195
    196
    197
    198
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 192

    def frame_handler
      if block_given?
        @j_del.java_method(:frameHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::WebSocketFrame)) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling frame_handler()"
    end

### - (`self`) handler { ... }

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    42
    43
    44
    45
    46
    47
    48
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 42

    def handler
      if block_given?
        @j_del.java_method(:handler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(::Vertx::Util::Utils.safe_create(event,::Vertx::Buffer)) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling handler()"
    end

### - (`::Vertx::SocketAddress`) local_address

Returns the local address for this socket

Returns:

- (`::Vertx::SocketAddress`) —
  the local address for this socket

Raises:

- (`ArgumentError`)

    241
    242
    243
    244
    245
    246
    247
    248
    249
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 241

    def local_address
      if !block_given?
        if @cached_local_address != nil
          return @cached_local_address
        end
        return @cached_local_address = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:localAddress, []).call(),::Vertx::SocketAddress)
      end
      raise ArgumentError, "Invalid arguments when calling local_address()"
    end

### - (`self`) pause

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    50
    51
    52
    53
    54
    55
    56
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 50

    def pause
      if !block_given?
        @j_del.java_method(:pause, []).call()
        return self
      end
      raise ArgumentError, "Invalid arguments when calling pause()"
    end

### - (`::Vertx::SocketAddress`) remote_address

Returns the remote address for this socket

Returns:

- (`::Vertx::SocketAddress`) —
  the remote address for this socket

Raises:

- (`ArgumentError`)

    231
    232
    233
    234
    235
    236
    237
    238
    239
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 231

    def remote_address
      if !block_given?
        if @cached_remote_address != nil
          return @cached_remote_address
        end
        return @cached_remote_address = ::Vertx::Util::Utils.safe_create(@j_del.java_method(:remoteAddress, []).call(),::Vertx::SocketAddress)
      end
      raise ArgumentError, "Invalid arguments when calling remote_address()"
    end

### - (`self`) resume

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    58
    59
    60
    61
    62
    63
    64
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 58

    def resume
      if !block_given?
        @j_del.java_method(:resume, []).call()
        return self
      end
      raise ArgumentError, "Invalid arguments when calling resume()"
    end

### - (`self`) set_write_queue_max_size(maxSize = nil)

Parameters:

- maxSize (`Fixnum`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    85
    86
    87
    88
    89
    90
    91
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 85

    def set_write_queue_max_size(maxSize=nil)
      if maxSize.class == Fixnum && !block_given?
        @j_del.java_method(:setWriteQueueMaxSize, [Java::int.java_class]).call(maxSize)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling set_write_queue_max_size(#{maxSize})"
    end

### - (`String`) text_handler_id

When a `Websocket` is created it automatically registers an event handler with the eventbus, the ID of that handler is given by `textHandlerID`.

Given this ID, a different event loop can send a text frame to that event handler using the event bus and that buffer will be received by this instance in its own event loop and written to the underlying connection. This allows you to write data to other WebSockets which are owned by different event loops.

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    121
    122
    123
    124
    125
    126
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 121

    def text_handler_id
      if !block_given?
        return @j_del.java_method(:textHandlerID, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling text_handler_id()"
    end

### - (`self`) text_message_handler { ... }

Set a text message handler on the connection. This handler will be called similar to the , but the buffer will be converted to a String first

Yields:

- the handler

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    203
    204
    205
    206
    207
    208
    209
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 203

    def text_message_handler
      if block_given?
        @j_del.java_method(:textMessageHandler, [Java::IoVertxCore::Handler.java_class]).call((Proc.new { |event| yield(event) }))
        return self
      end
      raise ArgumentError, "Invalid arguments when calling text_message_handler()"
    end

### - (`self`) write(data = nil)

Parameters:

- data (`::Vertx::Buffer`) (defaults to: `nil`)

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    76
    77
    78
    79
    80
    81
    82
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 76

    def write(data=nil)
      if data.class.method_defined?(:j_del) && !block_given?
        @j_del.java_method(:write, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(data.j_del)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write(#{data})"
    end

### - (`self`) write_binary_message(data = nil)

Writes a (potentially large) piece of binary data to the connection. This data might be written as multiple frames if it exceeds the maximum WebSocket frame size.

Parameters:

- data (`::Vertx::Buffer`) (defaults to: `nil`) —
  the data to write

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    161
    162
    163
    164
    165
    166
    167
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 161

    def write_binary_message(data=nil)
      if data.class.method_defined?(:j_del) && !block_given?
        @j_del.java_method(:writeBinaryMessage, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(data.j_del)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_binary_message(#{data})"
    end

### - (`self`) write_final_binary_frame(data = nil)

Write a final WebSocket binary frame to the connection

Parameters:

- data (`::Vertx::Buffer`) (defaults to: `nil`) —
  The data to write

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    150
    151
    152
    153
    154
    155
    156
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 150

    def write_final_binary_frame(data=nil)
      if data.class.method_defined?(:j_del) && !block_given?
        @j_del.java_method(:writeFinalBinaryFrame, [Java::IoVertxCoreBuffer::Buffer.java_class]).call(data.j_del)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_final_binary_frame(#{data})"
    end

### - (`self`) write_final_text_frame(text = nil)

Write a final WebSocket text frame to the connection

Parameters:

- text (`String`) (defaults to: `nil`) —
  The text to write

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    140
    141
    142
    143
    144
    145
    146
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 140

    def write_final_text_frame(text=nil)
      if text.class == String && !block_given?
        @j_del.java_method(:writeFinalTextFrame, [Java::java.lang.String.java_class]).call(text)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_final_text_frame(#{text})"
    end

### - (`self`) write_frame(frame = nil)

Write a WebSocket frame to the connection

Parameters:

- frame (`::Vertx::WebSocketFrame`) (defaults to: `nil`) —
  the frame to write

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    130
    131
    132
    133
    134
    135
    136
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 130

    def write_frame(frame=nil)
      if frame.class.method_defined?(:j_del) && !block_given?
        @j_del.java_method(:writeFrame, [Java::IoVertxCoreHttp::WebSocketFrame.java_class]).call(frame.j_del)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_frame(#{frame})"
    end

### - (`true`, `false`) write_queue_full

This will return `true` if there are more bytes in the write queue than the value set using #set_write_queue_max_size

Returns:

- (`true`, `false`) —
  true if write queue is full

Raises:

- (`ArgumentError`)

    25
    26
    27
    28
    29
    30
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 25

    def write_queue_full
      if !block_given?
        return @j_del.java_method(:writeQueueFull, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling write_queue_full()"
    end

### - (`self`) write_text_message(text = nil)

Writes a (potentially large) piece of text data to the connection. This data might be written as multiple frames if it exceeds the maximum WebSocket frame size.

Parameters:

- text (`String`) (defaults to: `nil`) —
  the data to write

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    172
    173
    174
    175
    176
    177
    178
    # File '/Users/julien/java/vertx-stack/stack-docs/target/rb/vertx/web_socket_base.rb', line 172

    def write_text_message(text=nil)
      if text.class == String && !block_given?
        @j_del.java_method(:writeTextMessage, [Java::java.lang.String.java_class]).call(text)
        return self
      end
      raise ArgumentError, "Invalid arguments when calling write_text_message(#{text})"
    end