/** * Adds a new value with the specified name and value. * * @param name The name * @param value The value being added * @return a reference to this, so the API can be used fluently */ @Fluent MultiMap add(String name, String value);
/** * Adds all the entries from another MultiMap to this one * * @return a reference to this, so the API can be used fluently */ @Fluent MultiMap addAll(MultiMap map);
/** * Copy a file from the path {@code from} to path {@code to}, asynchronously. * <p> * The copy will fail if the destination already exists. * * @param from the path to copy from * @param to the path to copy to * @param handler the handler that will be called on completion * @return a reference to this, so the API can be used fluently */ @Fluent FileSystem copy(String from, String to, Handler<AsyncResult<Void>> handler);
/** * Blocking version of {@link #copy(String, String, Handler)} */ @Fluent FileSystem copyBlocking(String from, String to) ;
/** * Create a symbolic link on the file system from {@code link} to {@code existing}, asynchronously. * * @param link the link * @param existing the link destination * @param handler the handler that will be called on completion * @return a reference to this, so the API can be used fluently */ @Fluent FileSystem symlink(String link, String existing, Handler<AsyncResult<Void>> handler);
/** * Blocking version of {@link #link(String, String, Handler)} */ @Fluent FileSystem symlinkBlocking(String link, String existing) ;
/** * Unlinks the link on the file system represented by the path {@code link}, asynchronously. * * @param link the link * @param handler the handler that will be called on completion * @return a reference to this, so the API can be used fluently */ @Fluent FileSystem unlink(String link, Handler<AsyncResult<Void>> handler);
/** * Blocking version of {@link #mkdirs(String, String, Handler)} */ @Fluent FileSystem mkdirsBlocking(String path, String perms) ;
/** * Creates the file, and writes the specified {@code Buffer data} to the file represented by the path {@code path}, * asynchronously. * * @param path path to the file * @param handler the handler that will be called on completion * @return a reference to this, so the API can be used fluently */ @Fluent FileSystem writeFile(String path, Buffer data, Handler<AsyncResult<Void>> handler);
/** * Blocking version of {@link #createFile(String, Handler)} */ @Fluent FileSystem createFileBlocking(String path) ;
/** * Convenience method for receiving the entire request body in one piece. * <p> * This saves you having to manually set a dataHandler and an endHandler and append the chunks of the body until * the whole body received. Don't use this if your request body is large - you could potentially run out of RAM. * * @param bodyHandler This handler will be called after all the body has been received */ @Fluent HttpClientResponse bodyHandler(Handler<Buffer> bodyHandler);
/** * Set an handler for stream priority changes. * <p/> * This is not implemented for HTTP/1.x. * * @param handler the handler to be called when the stream priority changes */ @Fluent HttpClientResponse streamPriorityHandler(Handler<StreamPriority> handler); }
/** * Sets the summary of the CLI. * * @param summary the summary * @return the current {@link CLI} instance */ @Fluent CLI setSummary(String summary);
/** * Sets the list of arguments. * * @param options the list of options, must not be {@code null} * @return the current {@link CLI} instance */ @Fluent CLI setOptions(List<Option> options);
/** * Removes an argument identified by its index. This method does nothing if the argument cannot be found. * * @param index the argument index * @return the current {@link CLI} instance */ @Fluent CLI removeArgument(int index);
/** * Like {@link #send(String, Object, DeliveryOptions)} but specifying a {@code replyHandler} that will be called if the recipient * subsequently replies to the message. * * @param address the address to send it to * @param message the message, may be {@code null} * @param options delivery options * @param replyHandler reply handler will be called when any reply from the recipient is received, may be {@code null} * @return a reference to this, so the API can be used fluently */ @Fluent <T> EventBus send(String address, Object message, DeliveryOptions options, Handler<AsyncResult<Message<T>>> replyHandler);
/** * Set the status message * * @return a reference to this, so the API can be used fluently */ @Fluent HttpServerResponse setStatusMessage(String statusMessage);
/** * Put an HTTP trailer * * @param name the trailer name * @param value the trailer value * @return a reference to this, so the API can be used fluently */ @Fluent HttpServerResponse putTrailer(String name, String value);
/** * Like {@link #push(HttpMethod, String, String, MultiMap, Handler)} with no headers. */ @Fluent HttpServerResponse push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler);
/** * Like {@link #sendHead()} but with an handler after headers have been sent. The handler will be called with * the {@link HttpVersion} if it can be determined or null otherwise.<p> */ @Fluent HttpClientRequest sendHead(Handler<HttpVersion> completionHandler);