java.lang.Object
- io.vertx.mutiny.ext.web.handler.sockjs.SockJSSocket

All Implemented Interfaces:

io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>, io.vertx.mutiny.core.streams.StreamBase, io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
```
public class SockJSSocket
extends Object
implements io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>, io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
```
You interact with SockJS clients through instances of SockJS socket.
The API is very similar to WebSocket. It implements both and so it can be used with Pump to pump data with flow control.

NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field Description

static io.smallrye.mutiny.vertx.TypeArg<SockJSSocket> __TYPE_ARG

Constructor Summary

Constructors
Constructor Description

SockJSSocket(io.vertx.ext.web.handler.sockjs.SockJSSocket delegate)

SockJSSocket(Object delegate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`close()`
`void`	`close(int statusCode, String reason)`
`SockJSSocket`	`closeHandler(Runnable closeHandler)`
`SockJSSocket`	`drainHandler(Runnable handler)`
`io.smallrye.mutiny.Uni<Void>`	`end()`
`io.smallrye.mutiny.Uni<Void>`	`end(io.vertx.mutiny.core.buffer.Buffer data)`
`Void`	`endAndAwait()`
`Void`	`endAndAwait(io.vertx.mutiny.core.buffer.Buffer data)`
`void`	`endAndForget()`
`void`	`endAndForget(io.vertx.mutiny.core.buffer.Buffer data)`
`SockJSSocket`	`endHandler(Runnable endHandler)`
`boolean`	`equals(Object o)`
`SockJSSocket`	`exceptionHandler(Consumer<Throwable> handler)`
`SockJSSocket`	`fetch(long amount)`
`io.vertx.ext.web.handler.sockjs.SockJSSocket`	`getDelegate()`
`SockJSSocket`	`handler(Consumer<io.vertx.mutiny.core.buffer.Buffer> handler)`
`int`	`hashCode()`
`io.vertx.mutiny.core.MultiMap`	`headers()`
`io.vertx.mutiny.core.net.SocketAddress`	`localAddress()`
`static SockJSSocket`	`newInstance(io.vertx.ext.web.handler.sockjs.SockJSSocket arg)`
`SockJSSocket`	`pause()`
`io.vertx.mutiny.core.streams.Pipe<io.vertx.mutiny.core.buffer.Buffer>`	`pipe()`
`io.smallrye.mutiny.Uni<Void>`	`pipeTo(io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer> dst)`
`Void`	`pipeToAndAwait(io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer> dst)`
`void`	`pipeToAndForget(io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer> dst)`
`io.vertx.mutiny.core.net.SocketAddress`	`remoteAddress()`
`SockJSSocket`	`resume()`
`RoutingContext`	`routingContext()`
`SockJSSocket`	`setWriteQueueMaxSize(int maxSize)`
`Iterable<io.vertx.mutiny.core.buffer.Buffer>`	`toBlockingIterable()`
`Stream<io.vertx.mutiny.core.buffer.Buffer>`	`toBlockingStream()`
`io.smallrye.mutiny.Multi<io.vertx.mutiny.core.buffer.Buffer>`	`toMulti()`
`String`	`toString()`
`io.smallrye.mutiny.vertx.WriteStreamSubscriber<io.vertx.mutiny.core.buffer.Buffer>`	`toSubscriber()`
`String`	`uri()`
`Session`	`webSession()`
`io.vertx.mutiny.ext.auth.User`	`webUser()`
`io.smallrye.mutiny.Uni<Void>`	`write(io.vertx.mutiny.core.buffer.Buffer data)`
`io.smallrye.mutiny.Uni<Void>`	`write(String data)`
`Void`	`writeAndAwait(io.vertx.mutiny.core.buffer.Buffer data)`
`Void`	`writeAndAwait(String data)`
`void`	`writeAndForget(io.vertx.mutiny.core.buffer.Buffer data)`
`void`	`writeAndForget(String data)`
`String`	`writeHandlerID()`
`boolean`	`writeQueueFull()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - __TYPE_ARG
```
public static final io.smallrye.mutiny.vertx.TypeArg<SockJSSocket> __TYPE_ARG
```
- Constructor Detail
  - SockJSSocket
```
public SockJSSocket(io.vertx.ext.web.handler.sockjs.SockJSSocket delegate)
```
  - SockJSSocket
```
public SockJSSocket(Object delegate)
```
- Method Detail
  - getDelegate
```
public io.vertx.ext.web.handler.sockjs.SockJSSocket getDelegate()
```
    Specified by:
    
    getDelegate in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
    
    Specified by:
    
    getDelegate in interface io.vertx.mutiny.core.streams.StreamBase
    
    Specified by:
    
    getDelegate in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toSubscriber
```
@CheckReturnValue
public io.smallrye.mutiny.vertx.WriteStreamSubscriber<io.vertx.mutiny.core.buffer.Buffer> toSubscriber()
```
  - end
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end()
```
    Specified by:
    
    end in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - endAndAwait
```
public Void endAndAwait()
```
    Specified by:
    
    endAndAwait in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - endAndForget
```
public void endAndForget()
```
    Specified by:
    
    endAndForget in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - end
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end(io.vertx.mutiny.core.buffer.Buffer data)
```
    Specified by:
    
    end in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - endAndAwait
```
public Void endAndAwait(io.vertx.mutiny.core.buffer.Buffer data)
```
    Specified by:
    
    endAndAwait in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - endAndForget
```
public void endAndForget(io.vertx.mutiny.core.buffer.Buffer data)
```
    Specified by:
    
    endAndForget in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - writeQueueFull
```
public boolean writeQueueFull()
```
    Specified by:
    
    writeQueueFull in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - pipe
```
public io.vertx.mutiny.core.streams.Pipe<io.vertx.mutiny.core.buffer.Buffer> pipe()
```
    Specified by:
    
    pipe in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - pipeTo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> pipeTo(io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer> dst)
```
    Specified by:
    
    pipeTo in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - pipeToAndAwait
```
public Void pipeToAndAwait(io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer> dst)
```
    Specified by:
    
    pipeToAndAwait in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - pipeToAndForget
```
public void pipeToAndForget(io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer> dst)
```
    Specified by:
    
    pipeToAndForget in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - exceptionHandler
```
public SockJSSocket exceptionHandler(Consumer<Throwable> handler)
```
    Specified by:
    
    exceptionHandler in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
    
    Specified by:
    
    exceptionHandler in interface io.vertx.mutiny.core.streams.StreamBase
    
    Specified by:
    
    exceptionHandler in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - handler
```
public SockJSSocket handler(Consumer<io.vertx.mutiny.core.buffer.Buffer> handler)
```
    Specified by:
    
    handler in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - pause
```
public SockJSSocket pause()
```
    Specified by:
    
    pause in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - resume
```
public SockJSSocket resume()
```
    Specified by:
    
    resume in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - fetch
```
public SockJSSocket fetch(long amount)
```
    Specified by:
    
    fetch in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - endHandler
```
public SockJSSocket endHandler(Runnable endHandler)
```
    Specified by:
    
    endHandler in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - closeHandler
```
public SockJSSocket closeHandler(Runnable closeHandler)
```
  - write
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> write(String data)
```
  - writeAndAwait
```
public Void writeAndAwait(String data)
```
  - writeAndForget
```
public void writeAndForget(String data)
```
  - write
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Void> write(io.vertx.mutiny.core.buffer.Buffer data)
```
    Specified by:
    
    write in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - writeAndAwait
```
public Void writeAndAwait(io.vertx.mutiny.core.buffer.Buffer data)
```
    Specified by:
    
    writeAndAwait in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - writeAndForget
```
public void writeAndForget(io.vertx.mutiny.core.buffer.Buffer data)
```
    Specified by:
    
    writeAndForget in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - setWriteQueueMaxSize
```
public SockJSSocket setWriteQueueMaxSize(int maxSize)
```
    Specified by:
    
    setWriteQueueMaxSize in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - drainHandler
```
public SockJSSocket drainHandler(Runnable handler)
```
    Specified by:
    
    drainHandler in interface io.vertx.mutiny.core.streams.WriteStream<io.vertx.mutiny.core.buffer.Buffer>
  - writeHandlerID
```
public String writeHandlerID()
```
    Returns:
    
    the writeHandlerID or null if writeHandler registration is disabled in SockJSHandlerOptions
  - close
```
public void close()
```
  - close
```
public void close(int statusCode,
                  String reason)
```
    Parameters:
    
    statusCode -
    
    reason -
  - remoteAddress
```
public io.vertx.mutiny.core.net.SocketAddress remoteAddress()
```
    Returns:
  - localAddress
```
public io.vertx.mutiny.core.net.SocketAddress localAddress()
```
    Returns:
  - headers
```
public io.vertx.mutiny.core.MultiMap headers()
```
    Returns:
  - uri
```
public String uri()
```
    Returns:
  - routingContext
```
public RoutingContext routingContext()
```
    Returns:
    
    the Vert.x-Web RoutingContext corresponding to this socket
  - webSession
```
public Session webSession()
```
    Returns:
    
    the Vert.x-Web session corresponding to this socket
  - webUser
```
public io.vertx.mutiny.ext.auth.User webUser()
```
    Returns:
    
    the Vert.x-Web user corresponding to this socket
  - toMulti
```
@CheckReturnValue
public io.smallrye.mutiny.Multi<io.vertx.mutiny.core.buffer.Buffer> toMulti()
```
    Specified by:
    
    toMulti in interface io.vertx.mutiny.core.streams.ReadStream<io.vertx.mutiny.core.buffer.Buffer>
  - toBlockingIterable
```
public Iterable<io.vertx.mutiny.core.buffer.Buffer> toBlockingIterable()
```
  - toBlockingStream
```
public Stream<io.vertx.mutiny.core.buffer.Buffer> toBlockingStream()
```
  - newInstance
```
public static SockJSSocket newInstance(io.vertx.ext.web.handler.sockjs.SockJSSocket arg)
```

Constructor	Description
`SockJSSocket(io.vertx.ext.web.handler.sockjs.SockJSSocket delegate)`
`SockJSSocket(Object delegate)`

Class SockJSSocket

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

SockJSSocket

SockJSSocket

Method Detail

getDelegate

toString

equals

hashCode

toSubscriber

end

endAndAwait

endAndForget

end

endAndAwait

endAndForget

writeQueueFull

pipe

pipeTo

pipeToAndAwait

pipeToAndForget

exceptionHandler

handler

pause

resume

fetch

endHandler

closeHandler

write

writeAndAwait

writeAndForget

write

writeAndAwait

writeAndForget

setWriteQueueMaxSize

drainHandler

writeHandlerID

close

close

remoteAddress

localAddress

headers

uri

routingContext

webSession

webUser

toMulti

toBlockingIterable

toBlockingStream

newInstance