Class List Method List File List

# Class: VertxWeb::SockJSSocket

Inherits:
  Object
  - Object
  - VertxWeb::SockJSSocket
  show all
Includes:
  Vertx::ReadStream, Vertx::WriteStream
Defined in:
  /Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb

## Overview

You interact with SockJS clients through instances of SockJS socket.

The API is very similar to Vertx::WebSocket. It implements both and so it can be used with Vertx::Pump to pump data with flow control.

## Constant Summary

@@j_api_type =

      Object.new

## Class Method Summary (collapse)

- + (Boolean) accept?(obj)
- + (Object) j_api_type
- + (Object) j_class
- + (Object) unwrap(obj)
- + (Object) wrap(obj)

## Instance Method Summary (collapse)

- - (void) close(statusCode = nil, reason = nil)
  Close it giving a status code and reason.
- - (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) fetch(amount = nil)
  Fetch the specified amount of elements.
- - (self) handler { ... }
- - (::Vertx::MultiMap) headers
  Return the headers corresponding to the last request for this socket or the websocket handshake Any cookie headers will be removed for security reasons.
- - (::Vertx::SocketAddress) local_address
  Return the local address for this socket.
- - (self) pause
- - (::Vertx::SocketAddress) remote_address
  Return the remote address for this socket.
- - (self) resume
- - (self) set_write_queue_max_size(maxSize = nil)
- - (String) uri
  Return the URI corresponding to the last request for this socket or the websocket handshake.
- - (::VertxWeb::Session) web_session
  The Vert.x-Web session corresponding to this socket.
- - (::VertxAuthCommon::User) web_user
  The Vert.x-Web user corresponding to this socket.
- - (self) write(param_1 = nil)
  Write a String to the socket, encoded in UTF-8.
- - (String) write_handler_id
  When a SockJSSocket is created it automatically registers an event handler with the event bus, the ID of that handler is given by writeHandlerID.
- - (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.

## Class Method Details

### + (`Boolean`) accept?(obj)

Returns:

- (`Boolean`)

    32
    33
    34
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 32

    def @@j_api_type.accept?(obj)
      obj.class == SockJSSocket
    end

### + (`Object`) j_api_type

    41
    42
    43
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 41

    def self.j_api_type
      @@j_api_type
    end

### + (`Object`) j_class

    44
    45
    46
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 44

    def self.j_class
      Java::IoVertxExtWebHandlerSockjs::SockJSSocket.java_class
    end

### + (`Object`) unwrap(obj)

    38
    39
    40
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 38

    def @@j_api_type.unwrap(obj)
      obj.j_del
    end

### + (`Object`) wrap(obj)

    35
    36
    37
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 35

    def @@j_api_type.wrap(obj)
      SockJSSocket.new(obj)
    end

## Instance Method Details

### - (`void`) close(statusCode = nil, reason = nil)

This method returns an undefined value.

Close it giving a status code and reason. Only Applicable to RawWebSocket will downgrade to plain close for other transports.

Parameters:

- statusCode (`Fixnum`) (defaults to: `nil`)
- reason (`String`) (defaults to: `nil`)

Raises:

- (`ArgumentError`)

    173
    174
    175
    176
    177
    178
    179
    180
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 173

    def close(statusCode=nil,reason=nil)
      if !block_given? && statusCode == nil && reason == nil
        return @j_del.java_method(:close, []).call()
      elsif statusCode.class == Fixnum && reason.class == String && !block_given?
        return @j_del.java_method(:close, [Java::int.java_class,Java::java.lang.String.java_class]).call(statusCode,reason)
      end
      raise ArgumentError, "Invalid arguments when calling close(#{statusCode},#{reason})"
    end

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

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    148
    149
    150
    151
    152
    153
    154
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 148

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

    50
    51
    52
    53
    54
    55
    56
    57
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 50

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

    114
    115
    116
    117
    118
    119
    120
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 114

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

    80
    81
    82
    83
    84
    85
    86
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 80

    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`) fetch(amount = nil)

Fetch the specified `amount` of elements. If the `ReadStream` has been paused, reading will recommence with the specified `amount` of items, otherwise the specified `amount` will be added to the current stream demand.

Parameters:

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

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    71
    72
    73
    74
    75
    76
    77
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 71

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

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

Yields:

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    89
    90
    91
    92
    93
    94
    95
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 89

    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::MultiMap`) headers

Return the headers corresponding to the last request for this socket or the websocket handshake Any cookie headers will be removed for security reasons

Returns:

- (`::Vertx::MultiMap`)

Raises:

- (`ArgumentError`)

    200
    201
    202
    203
    204
    205
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 200

    def headers
      if !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:headers, []).call(),::Vertx::MultiMap)
      end
      raise ArgumentError, "Invalid arguments when calling headers()"
    end

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

Return the local address for this socket

Returns:

- (`::Vertx::SocketAddress`)

Raises:

- (`ArgumentError`)

    191
    192
    193
    194
    195
    196
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 191

    def local_address
      if !block_given?
        return ::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`)

    97
    98
    99
    100
    101
    102
    103
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 97

    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

Return the remote address for this socket

Returns:

- (`::Vertx::SocketAddress`)

Raises:

- (`ArgumentError`)

    183
    184
    185
    186
    187
    188
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 183

    def remote_address
      if !block_given?
        return ::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`)

    105
    106
    107
    108
    109
    110
    111
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 105

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

    139
    140
    141
    142
    143
    144
    145
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 139

    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`) uri

Return the URI corresponding to the last request for this socket or the websocket handshake

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    208
    209
    210
    211
    212
    213
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 208

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

### - (`::VertxWeb::Session`) web_session

Returns the Vert.x-Web session corresponding to this socket

Returns:

- (`::VertxWeb::Session`) —
  the Vert.x-Web session corresponding to this socket

Raises:

- (`ArgumentError`)

    215
    216
    217
    218
    219
    220
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 215

    def web_session
      if !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:webSession, []).call(),::VertxWeb::Session)
      end
      raise ArgumentError, "Invalid arguments when calling web_session()"
    end

### - (`::VertxAuthCommon::User`) web_user

Returns the Vert.x-Web user corresponding to this socket

Returns:

- (`::VertxAuthCommon::User`) —
  the Vert.x-Web user corresponding to this socket

Raises:

- (`ArgumentError`)

    222
    223
    224
    225
    226
    227
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 222

    def web_user
      if !block_given?
        return ::Vertx::Util::Utils.safe_create(@j_del.java_method(:webUser, []).call(),::VertxAuthCommon::User)
      end
      raise ArgumentError, "Invalid arguments when calling web_user()"
    end

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

Write a String to the socket, encoded in UTF-8.

Overloads:

- - (`self`) write(data)

  Parameters:

  - data (`::Vertx::Buffer`)
- - (`self`) write(data)

  Parameters:

  - data (`String`) —
    the string to write

Returns:

- (`self`)

Raises:

- (`ArgumentError`)

    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 127

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

### - (`String`) write_handler_id

When a `SockJSSocket` is created it automatically registers an event handler with the event bus, the ID of that handler is given by `writeHandlerID`.

Given this ID, a different event loop can send a buffer 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 socket. This allows you to write data to other sockets which are owned by different event loops.

Returns:

- (`String`)

Raises:

- (`ArgumentError`)

    162
    163
    164
    165
    166
    167
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 162

    def write_handler_id
      if !block_given?
        return @j_del.java_method(:writeHandlerID, []).call()
      end
      raise ArgumentError, "Invalid arguments when calling write_handler_id()"
    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`)

    60
    61
    62
    63
    64
    65
    # File '/Users/julien/java/vertx-aggregator/modules/vertx-lang-ruby/vertx-lang-ruby/target/classes/vertx-web/sock_js_socket.rb', line 60

    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