/** * Same as {@link io.vertx.rxjava.core.http.HttpServerResponse#end} but writes some data to the response body before ending. If the response is not chunked and * no other data has been written then the @code{Content-Length} header will be automatically set. * @param chunk the buffer to write before ending the response */ public void end(io.vertx.rxjava.core.buffer.Buffer chunk) { delegate.end(chunk.getDelegate()); }
/** * 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. * @param data the data to write * @return a reference to this, so the API can be used fluently */ public io.vertx.rxjava.core.http.WebSocketBase writeBinaryMessage(io.vertx.rxjava.core.buffer.Buffer data) { delegate.writeBinaryMessage(data.getDelegate()); return this; }
/** * Sends a <code>SEND</code> frame to the server. * @param headers the headers, must not be <code>null</code> * @param body the body, may be <code>null</code> * @param receiptHandler the handler invoked when the <code>RECEIPT</code> frame associated with the sent frame has been received. The handler receives the sent frame. * @return the current {@link io.vertx.rxjava.ext.stomp.StompClientConnection} */ public io.vertx.rxjava.ext.stomp.StompClientConnection send(Map<String, String> headers, io.vertx.rxjava.core.buffer.Buffer body, Handler<Frame> receiptHandler) { delegate.send(headers, body.getDelegate(), receiptHandler); return this; }
/** * Sends a <code>SEND</code> frame to the server to the given destination. The message does not have any other header. * @param destination the destination, must not be <code>null</code> * @param body the body, may be <code>null</code> * @param receiptHandler the handler invoked when the <code>RECEIPT</code> frame associated with the sent frame has been received. The handler receives the sent frame. * @return the current {@link io.vertx.rxjava.ext.stomp.StompClientConnection} */ public io.vertx.rxjava.ext.stomp.StompClientConnection send(String destination, io.vertx.rxjava.core.buffer.Buffer body, Handler<Frame> receiptHandler) { delegate.send(destination, body.getDelegate(), receiptHandler); return this; }
/** * Flip the parser into delimited mode, and where the delimiter can be represented * by the delimiter <code>delim</code>. * <p> * This method can be called multiple times with different values of delim while data is being parsed. * @param delim the new delimiter */ public void delimitedMode(io.vertx.rxjava.core.buffer.Buffer delim) { delegate.delimitedMode(delim.getDelegate()); }
/** * Handle a <code>Buffer</code>, pretty much like calling {@link io.vertx.core.Handler}. * @param buffer * @return a reference to this, so the API can be used fluently */ public io.vertx.rxjava.core.parsetools.JsonParser write(io.vertx.rxjava.core.buffer.Buffer buffer) { delegate.write(buffer.getDelegate()); return this; }
/** * Same as {@link io.vertx.rxjava.core.http.WebSocketBase#end} but writes some data to the stream before ending. * @param t */ public void end(io.vertx.rxjava.core.buffer.Buffer t) { delegate.end(t.getDelegate()); }
/** * Like {@link io.vertx.rxjava.kafka.client.producer.KafkaProducerRecord#addHeader} but with a key/value pair * @param key * @param value * @return */ public io.vertx.rxjava.kafka.client.producer.KafkaProducerRecord<K, V> addHeader(String key, io.vertx.rxjava.core.buffer.Buffer value) { delegate.addHeader(key, value.getDelegate()); return this; }
/** * Same as {@link io.vertx.rxjava.core.http.WebSocketBase#end} but writes some data to the stream before ending. * @param t */ public void end(io.vertx.rxjava.core.buffer.Buffer t) { delegate.end(t.getDelegate()); }
/** * Sends a <code>SEND</code> frame to the server. * @param headers the headers, must not be <code>null</code> * @param body the body, may be <code>null</code> * @return the current {@link io.vertx.rxjava.ext.stomp.StompClientConnection} */ public io.vertx.rxjava.ext.stomp.StompClientConnection send(Map<String, String> headers, io.vertx.rxjava.core.buffer.Buffer body) { delegate.send(headers, body.getDelegate()); return this; }
/** * Like {@link io.vertx.rxjava.kafka.client.producer.KafkaProducerRecord#addHeader} but with a key/value pair * @param key * @param value * @return */ public io.vertx.rxjava.kafka.client.producer.KafkaProducerRecord<K, V> addHeader(String key, io.vertx.rxjava.core.buffer.Buffer value) { delegate.addHeader(key, value.getDelegate()); return this; }
/** * Set the body. Used by the {@link io.vertx.rxjava.ext.web.handler.BodyHandler}. You will not normally call this method. * @param body the body */ public void setBody(io.vertx.rxjava.core.buffer.Buffer body) { delegate.setBody(body.getDelegate()); }
/** * Blocking version of {@link io.vertx.rxjava.core.file.FileSystem#writeFile} * @param path * @param data * @return */ public io.vertx.rxjava.core.file.FileSystem writeFileBlocking(String path, io.vertx.rxjava.core.buffer.Buffer data) { delegate.writeFileBlocking(path, data.getDelegate()); return this; }
/** * Same as {@link io.vertx.rxjava.core.file.AsyncFile#end} but writes some data to the stream before ending. * @param t */ public void end(io.vertx.rxjava.core.buffer.Buffer t) { delegate.end(t.getDelegate()); }
/** * Same as {@link io.vertx.rxjava.core.net.NetSocket#end} but writes some data to the stream before ending. * @param t */ public void end(io.vertx.rxjava.core.buffer.Buffer t) { delegate.end(t.getDelegate()); }
/** * This method is called to provide the parser with data. * @param buffer a chunk of data */ public void handle(io.vertx.rxjava.core.buffer.Buffer buffer) { delegate.handle(buffer.getDelegate()); }
/** * Handle a <code>Buffer</code>, pretty much like calling {@link io.vertx.core.Handler}. * @param buffer * @return a reference to this, so the API can be used fluently */ public io.vertx.rxjava.core.parsetools.JsonParser write(io.vertx.rxjava.core.buffer.Buffer buffer) { delegate.write(buffer.getDelegate()); return this; }
/** * Create a continuation frame * @param data the data for the frame * @param isFinal true if it's the final frame in the WebSocket message * @return the frame */ public static io.vertx.rxjava.core.http.WebSocketFrame continuationFrame(io.vertx.rxjava.core.buffer.Buffer data, boolean isFinal) { io.vertx.rxjava.core.http.WebSocketFrame ret = io.vertx.rxjava.core.http.WebSocketFrame.newInstance(io.vertx.core.http.WebSocketFrame.continuationFrame(data.getDelegate(), isFinal)); return ret; }
/** * Create a new <code>RecordParser</code> instance, initially in delimited mode, and where the delimiter can be represented * by the <code>Buffer</code> delim. * <p> * @param delim the initial delimiter buffer * @return */ public static io.vertx.rxjava.core.parsetools.RecordParser newDelimited(io.vertx.rxjava.core.buffer.Buffer delim) { io.vertx.rxjava.core.parsetools.RecordParser ret = io.vertx.rxjava.core.parsetools.RecordParser.newInstance(io.vertx.core.parsetools.RecordParser.newDelimited(delim.getDelegate())); return ret; }
/** * Create a new <code>JsonParser</code> instance. * @param stream * @return */ public static io.vertx.rxjava.core.parsetools.JsonParser newParser(Observable<io.vertx.rxjava.core.buffer.Buffer> stream) { io.vertx.rxjava.core.parsetools.JsonParser ret = io.vertx.rxjava.core.parsetools.JsonParser.newInstance(io.vertx.core.parsetools.JsonParser.newParser(io.vertx.rx.java.ReadStreamSubscriber.asReadStream(stream,obj -> (io.vertx.core.buffer.Buffer)obj.getDelegate()).resume())); return ret; }