io.vertx.rxjava.core.http.HttpClientRequest Maven / Gradle / Ivy
/*
* Copyright 2014 Red Hat, Inc.
*
* Red Hat licenses this file to you under the Apache License, version 2.0
* (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.vertx.rxjava.core.http;
import rx.Observable;
import rx.Single;
import io.vertx.rx.java.RxHelper;
import io.vertx.rx.java.WriteStreamSubscriber;
import io.vertx.rx.java.SingleOnSubscribeAdapter;
import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Iterator;
import java.util.function.Function;
import java.util.stream.Collectors;
import io.vertx.core.Handler;
import io.vertx.core.AsyncResult;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import io.vertx.lang.rx.RxGen;
import io.vertx.lang.rx.TypeArg;
import io.vertx.lang.rx.MappingIterator;
/**
* Represents a client-side HTTP request.
*
* Instances are created by an {@link io.vertx.rxjava.core.http.HttpClient} instance, via one of the methods corresponding to the
* specific HTTP methods, or the generic request methods. On creation the request will not have been written to the
* wire.
*
* Once a request has been obtained, headers can be set on it, and data can be written to its body if required. Once
* you are ready to send the request, one of the {@link io.vertx.rxjava.core.http.HttpClientRequest#end} methods should be called.
*
* Nothing is actually sent until the request has been internally assigned an HTTP connection.
*
* The {@link io.vertx.rxjava.core.http.HttpClient} instance will return an instance of this class immediately, even if there are no HTTP
* connections available in the pool. Any requests sent before a connection is assigned will be queued
* internally and actually sent when an HTTP connection becomes available from the pool.
*
* The headers of the request are queued for writing either when the {@link io.vertx.rxjava.core.http.HttpClientRequest#end} method is called, or, when the first
* part of the body is written, whichever occurs first.
*
* This class supports both chunked and non-chunked HTTP.
*
* It implements {@link io.vertx.rxjava.core.streams.WriteStream} so it can be used with
* {@link io.vertx.rxjava.core.streams.Pump} to pump data with flow control.
*
* An example of using this class is as follows:
*
*
*
* NOTE: This class has been automatically generated from the {@link io.vertx.core.http.HttpClientRequest original} non RX-ified interface using Vert.x codegen.
*/
@RxGen(io.vertx.core.http.HttpClientRequest.class)
public class HttpClientRequest implements io.vertx.rxjava.core.streams.WriteStream, io.vertx.rxjava.core.streams.ReadStream {
@Override
public String toString() {
return delegate.toString();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
HttpClientRequest that = (HttpClientRequest) o;
return delegate.equals(that.delegate);
}
@Override
public int hashCode() {
return delegate.hashCode();
}
public static final TypeArg __TYPE_ARG = new TypeArg<>( obj -> new HttpClientRequest((io.vertx.core.http.HttpClientRequest) obj),
HttpClientRequest::getDelegate
);
private final io.vertx.core.http.HttpClientRequest delegate;
public HttpClientRequest(io.vertx.core.http.HttpClientRequest delegate) {
this.delegate = delegate;
}
public HttpClientRequest(Object delegate) {
this.delegate = (io.vertx.core.http.HttpClientRequest)delegate;
}
public io.vertx.core.http.HttpClientRequest getDelegate() {
return delegate;
}
private Observable observable;
public synchronized Observable toObservable() {
if (observable == null) {
Function conv = io.vertx.rxjava.core.http.HttpClientResponse::newInstance;
observable = RxHelper.toObservable(delegate, conv);
}
return observable;
}
private WriteStreamSubscriber subscriber;
public synchronized WriteStreamSubscriber toSubscriber() {
if (subscriber == null) {
Function conv = io.vertx.rxjava.core.buffer.Buffer::getDelegate;
subscriber = RxHelper.toSubscriber(getDelegate(), conv);
}
return subscriber;
}
private static final TypeArg TYPE_ARG_0 = new TypeArg(o1 -> io.vertx.rxjava.core.http.HttpClientResponse.newInstance((io.vertx.core.http.HttpClientResponse)o1), o1 -> o1.getDelegate());
/**
* This will return true if there are more bytes in the write queue than the value set using {@link io.vertx.rxjava.core.http.HttpClientRequest#setWriteQueueMaxSize}
* @return true if write queue is full
*/
public boolean writeQueueFull() {
boolean ret = delegate.writeQueueFull();
return ret;
}
/**
* Pause this stream and return a to transfer the elements of this stream to a destination .
*
* The stream will be resumed when the pipe will be wired to a WriteStream.
* @return a pipe
*/
public io.vertx.rxjava.core.streams.Pipe pipe() {
io.vertx.rxjava.core.streams.Pipe ret = io.vertx.rxjava.core.streams.Pipe.newInstance((io.vertx.core.streams.Pipe)delegate.pipe(), TYPE_ARG_0);
return ret;
}
/**
* Like {@link io.vertx.rxjava.core.streams.ReadStream#pipeTo} but with no completion handler.
* @param dst
*/
public void pipeTo(io.vertx.rxjava.core.streams.WriteStream dst) {
delegate.pipeTo(dst.getDelegate());
}
/**
* Pipe this ReadStream to the WriteStream.
*
* Elements emitted by this stream will be written to the write stream until this stream ends or fails.
*
* Once this stream has ended or failed, the write stream will be ended and the handler will be
* called with the result.
* @param dst the destination write stream
* @param handler
*/
public void pipeTo(io.vertx.rxjava.core.streams.WriteStream dst, Handler> handler) {
delegate.pipeTo(dst.getDelegate(), handler);
}
/**
* Pipe this ReadStream to the WriteStream.
*
* Elements emitted by this stream will be written to the write stream until this stream ends or fails.
*
* Once this stream has ended or failed, the write stream will be ended and the handler will be
* called with the result.
* @param dst the destination write stream
* @return
* @deprecated use {@link #rxPipeTo} instead
*/
@Deprecated()
public Observable pipeToObservable(io.vertx.rxjava.core.streams.WriteStream dst) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
pipeTo(dst, handler.toHandler());
return handler;
}
/**
* Pipe this ReadStream to the WriteStream.
*
* Elements emitted by this stream will be written to the write stream until this stream ends or fails.
*
* Once this stream has ended or failed, the write stream will be ended and the handler will be
* called with the result.
* @param dst the destination write stream
* @return
*/
public Single rxPipeTo(io.vertx.rxjava.core.streams.WriteStream dst) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
pipeTo(dst, fut);
}));
}
public io.vertx.rxjava.core.http.HttpClientRequest exceptionHandler(Handler handler) {
delegate.exceptionHandler(handler);
return this;
}
/**
* @param data
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest write(io.vertx.rxjava.core.buffer.Buffer data) {
delegate.write(data.getDelegate());
return this;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param data
* @param handler
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest write(io.vertx.rxjava.core.buffer.Buffer data, Handler> handler) {
delegate.write(data.getDelegate(), handler);
return this;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param data
* @return
* @deprecated use {@link #rxWrite} instead
*/
@Deprecated()
public Observable writeObservable(io.vertx.rxjava.core.buffer.Buffer data) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
write(data, handler.toHandler());
return handler;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param data
* @return
*/
public Single rxWrite(io.vertx.rxjava.core.buffer.Buffer data) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
write(data, fut);
}));
}
public io.vertx.rxjava.core.http.HttpClientRequest setWriteQueueMaxSize(int maxSize) {
delegate.setWriteQueueMaxSize(maxSize);
return this;
}
public io.vertx.rxjava.core.http.HttpClientRequest drainHandler(Handler handler) {
delegate.drainHandler(handler);
return this;
}
/**
* @param handler
* @return
*/
@Deprecated()
public io.vertx.rxjava.core.http.HttpClientRequest handler(Handler handler) {
delegate.handler(new Handler() {
public void handle(io.vertx.core.http.HttpClientResponse event) {
handler.handle(io.vertx.rxjava.core.http.HttpClientResponse.newInstance((io.vertx.core.http.HttpClientResponse)event));
}
});
return this;
}
/**
* @return
*/
@Deprecated()
public io.vertx.rxjava.core.http.HttpClientRequest pause() {
delegate.pause();
return this;
}
/**
* @return
*/
@Deprecated()
public io.vertx.rxjava.core.http.HttpClientRequest resume() {
delegate.resume();
return this;
}
/**
* @param amount
* @return
*/
@Deprecated()
public io.vertx.rxjava.core.http.HttpClientRequest fetch(long amount) {
delegate.fetch(amount);
return this;
}
/**
* @param endHandler
* @return
*/
@Deprecated()
public io.vertx.rxjava.core.http.HttpClientRequest endHandler(Handler endHandler) {
delegate.endHandler(endHandler);
return this;
}
/**
* Set the request to follow HTTP redirects up to {@link io.vertx.core.http.HttpClientOptions}.
* @param followRedirects true to follow HTTP redirects
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest setFollowRedirects(boolean followRedirects) {
delegate.setFollowRedirects(followRedirects);
return this;
}
/**
* Set the max number of HTTP redirects this request will follow. The default is 0 which means
* no redirects.
* @param maxRedirects the number of HTTP redirect to follow
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest setMaxRedirects(int maxRedirects) {
delegate.setMaxRedirects(maxRedirects);
return this;
}
/**
* If chunked is true then the request will be set into HTTP chunked mode
* @param chunked true if chunked encoding
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest setChunked(boolean chunked) {
delegate.setChunked(chunked);
return this;
}
/**
* @return Is the request chunked?
*/
public boolean isChunked() {
boolean ret = delegate.isChunked();
return ret;
}
/**
* The HTTP method for the request.
* @return
*/
public io.vertx.core.http.HttpMethod method() {
io.vertx.core.http.HttpMethod ret = delegate.method();
return ret;
}
/**
* @return the raw value of the method this request sends
*/
public String getRawMethod() {
String ret = delegate.getRawMethod();
return ret;
}
/**
* Set the value the method to send when the method is used.
* @param method the raw method
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest setRawMethod(String method) {
delegate.setRawMethod(method);
return this;
}
/**
* @return the absolute URI corresponding to the the HTTP request
*/
public String absoluteURI() {
String ret = delegate.absoluteURI();
return ret;
}
/**
* @return The URI of the request.
*/
public String uri() {
String ret = delegate.uri();
return ret;
}
/**
* @return The path part of the uri. For example /somepath/somemorepath/someresource.foo
*/
public String path() {
String ret = delegate.path();
return ret;
}
/**
* @return the query part of the uri. For example someparam=32&someotherparam=x
*/
public String query() {
String ret = delegate.query();
return ret;
}
/**
* Set the request host.
*
* For HTTP/2 it sets the pseudo header otherwise it sets the header
* @param host
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest setHost(String host) {
delegate.setHost(host);
return this;
}
/**
* @return the request host. For HTTP/2 it returns the pseudo header otherwise it returns the header
*/
public String getHost() {
String ret = delegate.getHost();
return ret;
}
/**
* @return The HTTP headers
*/
public io.vertx.rxjava.core.MultiMap headers() {
if (cached_0 != null) {
return cached_0;
}
io.vertx.rxjava.core.MultiMap ret = io.vertx.rxjava.core.MultiMap.newInstance((io.vertx.core.MultiMap)delegate.headers());
cached_0 = ret;
return ret;
}
/**
* Put an HTTP header
* @param name The header name
* @param value The header value
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest putHeader(String name, String value) {
delegate.putHeader(name, value);
return this;
}
/**
* Write a {@link java.lang.String} to the request body, encoded as UTF-8.
* @param chunk
* @return @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest write(String chunk) {
delegate.write(chunk);
return this;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param chunk
* @param handler
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest write(String chunk, Handler> handler) {
delegate.write(chunk, handler);
return this;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param chunk
* @return
* @deprecated use {@link #rxWrite} instead
*/
@Deprecated()
public Observable writeObservable(String chunk) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
write(chunk, handler.toHandler());
return handler;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param chunk
* @return
*/
public Single rxWrite(String chunk) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
write(chunk, fut);
}));
}
/**
* Write a {@link java.lang.String} to the request body, encoded using the encoding enc.
* @param chunk
* @param enc
* @return @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest write(String chunk, String enc) {
delegate.write(chunk, enc);
return this;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param chunk
* @param enc
* @param handler
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest write(String chunk, String enc, Handler> handler) {
delegate.write(chunk, enc, handler);
return this;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param chunk
* @param enc
* @return
* @deprecated use {@link #rxWrite} instead
*/
@Deprecated()
public Observable writeObservable(String chunk, String enc) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
write(chunk, enc, handler.toHandler());
return handler;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#write} but with an handler called when the operation completes
* @param chunk
* @param enc
* @return
*/
public Single rxWrite(String chunk, String enc) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
write(chunk, enc, fut);
}));
}
/**
* If you send an HTTP request with the header Expect set to the value 100-continue
* and the server responds with an interim HTTP response with a status code of 100 and a continue handler
* has been set using this method, then the handler will be called.
*
* You can then continue to write data to the request body and later end it. This is normally used in conjunction with
* the {@link io.vertx.rxjava.core.http.HttpClientRequest#sendHead} method to force the request header to be written before the request has ended.
* @param handler
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest continueHandler(Handler handler) {
delegate.continueHandler(handler);
return this;
}
/**
* Forces the head of the request to be written before {@link io.vertx.rxjava.core.http.HttpClientRequest#end} is called on the request or any data is
* written to it.
*
* This is normally used to implement HTTP 100-continue handling, see for
* more information.
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest sendHead() {
delegate.sendHead();
return this;
}
/**
* Like {@link io.vertx.rxjava.core.http.HttpClientRequest#sendHead} but with an handler after headers have been sent. The handler will be called with
* the {@link io.vertx.core.http.HttpVersion} if it can be determined or null otherwise.
* @param completionHandler
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest sendHead(Handler completionHandler) {
delegate.sendHead(completionHandler);
return this;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but writes a String in UTF-8 encoding
* @param chunk
*/
public void end(String chunk) {
delegate.end(chunk);
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @param handler
*/
public void end(String chunk, Handler> handler) {
delegate.end(chunk, handler);
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @return
* @deprecated use {@link #rxEnd} instead
*/
@Deprecated()
public Observable endObservable(String chunk) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
end(chunk, handler.toHandler());
return handler;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @return
*/
public Single rxEnd(String chunk) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
end(chunk, fut);
}));
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but writes a String with the specified encoding
* @param chunk
* @param enc
*/
public void end(String chunk, String enc) {
delegate.end(chunk, enc);
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @param enc
* @param handler
*/
public void end(String chunk, String enc, Handler> handler) {
delegate.end(chunk, enc, handler);
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @param enc
* @return
* @deprecated use {@link #rxEnd} instead
*/
@Deprecated()
public Observable endObservable(String chunk, String enc) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
end(chunk, enc, handler.toHandler());
return handler;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @param enc
* @return
*/
public Single rxEnd(String chunk, String enc) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
end(chunk, enc, fut);
}));
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but writes some data to the request body before ending. If the request is not chunked and
* no other data has been written then the Content-Length header will be automatically set
* @param chunk
*/
public void end(io.vertx.rxjava.core.buffer.Buffer chunk) {
delegate.end(chunk.getDelegate());
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @param handler
*/
public void end(io.vertx.rxjava.core.buffer.Buffer chunk, Handler> handler) {
delegate.end(chunk.getDelegate(), handler);
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @return
* @deprecated use {@link #rxEnd} instead
*/
@Deprecated()
public Observable endObservable(io.vertx.rxjava.core.buffer.Buffer chunk) {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
end(chunk, handler.toHandler());
return handler;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param chunk
* @return
*/
public Single rxEnd(io.vertx.rxjava.core.buffer.Buffer chunk) {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
end(chunk, fut);
}));
}
/**
* Ends the request. If no data has been written to the request body, and {@link io.vertx.rxjava.core.http.HttpClientRequest#sendHead} has not been called then
* the actual request won't get written until this method gets called.
*
* Once the request has ended, it cannot be used any more,
*/
public void end() {
delegate.end();
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @param handler
*/
public void end(Handler> handler) {
delegate.end(handler);
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @return
* @deprecated use {@link #rxEnd} instead
*/
@Deprecated()
public Observable endObservable() {
io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
end(handler.toHandler());
return handler;
}
/**
* Same as {@link io.vertx.rxjava.core.http.HttpClientRequest#end} but with an handler called when the operation completes
* @return
*/
public Single rxEnd() {
return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
end(fut);
}));
}
/**
* Set's the amount of time after which if the request does not return any data within the timeout period an
* {@link java.util.concurrent.TimeoutException} will be passed to the exception handler (if provided) and
* the request will be closed.
*
* Calling this method more than once has the effect of canceling any existing timeout and starting
* the timeout from scratch.
* @param timeoutMs The quantity of time in milliseconds.
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest setTimeout(long timeoutMs) {
delegate.setTimeout(timeoutMs);
return this;
}
/**
* Set a push handler for this request.
*
* The handler is called when the client receives a push promise from the server. The handler can be called
* multiple times, for each push promise.
*
* The handler is called with a read-only {@link io.vertx.rxjava.core.http.HttpClientRequest}, the following methods can be called:
*
*
* - {@link io.vertx.rxjava.core.http.HttpClientRequest#method}
* - {@link io.vertx.rxjava.core.http.HttpClientRequest#uri}
* - {@link io.vertx.rxjava.core.http.HttpClientRequest#headers}
* - {@link io.vertx.rxjava.core.http.HttpClientRequest#getHost}
*
*
* In addition the handler should call the {@link io.vertx.rxjava.core.http.HttpClientRequest#handler} method to set an handler to
* process the response.
* @param handler the handler
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest pushHandler(Handler handler) {
delegate.pushHandler(new Handler() {
public void handle(io.vertx.core.http.HttpClientRequest event) {
handler.handle(io.vertx.rxjava.core.http.HttpClientRequest.newInstance((io.vertx.core.http.HttpClientRequest)event));
}
});
return this;
}
/**
* Reset this stream with the error code 0.
* @return
*/
public boolean reset() {
boolean ret = delegate.reset();
return ret;
}
/**
* Reset this request:
*
*
* - for HTTP/2, this performs send an HTTP/2 reset frame with the specified error
code
* - for HTTP/1.x, this closes the connection when the current request is inflight
*
*
* When the request has not yet been sent, the request will be aborted and false is returned as indicator.
*
* @param code the error code
* @return true when reset has been performed
*/
public boolean reset(long code) {
boolean ret = delegate.reset(code);
return ret;
}
/**
* @return the {@link io.vertx.rxjava.core.http.HttpConnection} associated with this request
*/
public io.vertx.rxjava.core.http.HttpConnection connection() {
if (cached_1 != null) {
return cached_1;
}
io.vertx.rxjava.core.http.HttpConnection ret = io.vertx.rxjava.core.http.HttpConnection.newInstance((io.vertx.core.http.HttpConnection)delegate.connection());
cached_1 = ret;
return ret;
}
/**
* Set a connection handler called when an HTTP connection has been established.
* @param handler the handler
* @return a reference to this, so the API can be used fluently
*/
@Deprecated()
public io.vertx.rxjava.core.http.HttpClientRequest connectionHandler(Handler handler) {
delegate.connectionHandler(new Handler() {
public void handle(io.vertx.core.http.HttpConnection event) {
handler.handle(io.vertx.rxjava.core.http.HttpConnection.newInstance((io.vertx.core.http.HttpConnection)event));
}
});
return this;
}
/**
* Write an HTTP/2 frame to the request, allowing to extend the HTTP/2 protocol.
*
* The frame is sent immediatly and is not subject to flow control.
*
* This method must be called after the request headers have been sent and only for the protocol HTTP/2.
* The {@link io.vertx.rxjava.core.http.HttpClientRequest#sendHead} should be used for this purpose.
* @param type the 8-bit frame type
* @param flags the 8-bit frame flags
* @param payload the frame payload
* @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest writeCustomFrame(int type, int flags, io.vertx.rxjava.core.buffer.Buffer payload) {
delegate.writeCustomFrame(type, flags, payload.getDelegate());
return this;
}
/**
* @return the id of the stream of this response, when it is not yet determined, i.e the request has not been yet sent or it is not supported HTTP/1.x
*/
public int streamId() {
int ret = delegate.streamId();
return ret;
}
/**
* Like {@link io.vertx.rxjava.core.http.HttpClientRequest#writeCustomFrame} but with an {@link io.vertx.rxjava.core.http.HttpFrame}.
* @param frame the frame to write
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest writeCustomFrame(io.vertx.rxjava.core.http.HttpFrame frame) {
delegate.writeCustomFrame(frame.getDelegate());
return this;
}
/**
* Sets the priority of the associated stream.
*
* This is not implemented for HTTP/1.x.
* @param streamPriority the priority of this request's stream
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest setStreamPriority(io.vertx.core.http.StreamPriority streamPriority) {
delegate.setStreamPriority(streamPriority);
return this;
}
/**
* @return the priority of the associated HTTP/2 stream for HTTP/2 otherwise null
*/
public io.vertx.core.http.StreamPriority getStreamPriority() {
io.vertx.core.http.StreamPriority ret = delegate.getStreamPriority();
return ret;
}
/**
* Like {@link io.vertx.rxjava.core.http.HttpClientRequest#putHeader} but using CharSequence
* @param name
* @param value
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest putHeader(java.lang.CharSequence name, java.lang.CharSequence value) {
delegate.putHeader(name, value);
return this;
}
/**
* Put an HTTP header with multiple values
* @param name The header name
* @param values The header values
* @return @return a reference to this, so the API can be used fluently
*/
public io.vertx.rxjava.core.http.HttpClientRequest putHeader(String name, java.lang.Iterable values) {
delegate.putHeader(name, values);
return this;
}
/**
* Like {@link io.vertx.rxjava.core.http.HttpClientRequest#putHeader} but using CharSequence
* @param name
* @param values
* @return
*/
public io.vertx.rxjava.core.http.HttpClientRequest putHeader(java.lang.CharSequence name, java.lang.Iterable values) {
delegate.putHeader(name, values);
return this;
}
private io.vertx.rxjava.core.MultiMap cached_0;
private io.vertx.rxjava.core.http.HttpConnection cached_1;
public static HttpClientRequest newInstance(io.vertx.core.http.HttpClientRequest arg) {
return arg != null ? new HttpClientRequest(arg) : null;
}
}