org.example.httpclient.JunkApi$HttpClient Maven / Gradle / Ivy

Go to download
package org.example.httpclient;


import io.avaje.http.api.*;
import io.avaje.http.client.HttpApiProvider;
import io.avaje.http.client.HttpCall;
import io.avaje.http.client.HttpClientContext;
import java.io.InputStream;
import java.lang.String;
import java.net.http.HttpRequest.BodyPublisher;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandler;
import java.nio.file.Path;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Stream;
import org.example.CommonParams;
import org.example.JunkApi;
import org.example.MyForm;
import org.example.Repo;

@Generated("avaje-http-client-generator")
public class JunkApi$HttpClient implements JunkApi {

  private final HttpClientContext clientContext;

  public JunkApi$HttpClient(HttpClientContext ctx) {
    this.clientContext = ctx;
  }

  // POST 
  @Override
  public void asVoid() {
    clientContext.request()
      .POST()
      .asVoid();
  }

  // POST 
  @Override
  public HttpResponse asVoid2() {
    return clientContext.request()
      .POST()
      .asVoid();
  }

  // POST 
  @Override
  public String asPlainString() {
    return clientContext.request()
      .POST()
      .asPlainString().body();
  }

  // POST 
  @Override
  public HttpResponse asString2() {
    return clientContext.request()
      .POST()
      .asString();
  }

  // POST 
  @Override
  public HttpResponse asBytes2() {
    return clientContext.request()
      .POST()
      .asByteArray();
  }

  // POST 
  @Override
  public HttpResponse asInputStream2() {
    return clientContext.request()
      .POST()
      .asInputStream();
  }

  // POST 
  @Override
  public HttpResponse> asLines2() {
    return clientContext.request()
      .POST()
      .asLines();
  }

  // POST 
  @Override
  public Repo bean() {
    return clientContext.request()
      .POST()
      .bean(Repo.class);
  }

  // POST 
  @Override
  public List list() {
    return clientContext.request()
      .POST()
      .list(Repo.class);
  }

  // POST 
  @Override
  public Stream stream() {
    return clientContext.request()
      .POST()
      .stream(Repo.class);
  }

  // POST 
  @Override
  public CompletableFuture cfBean() {
    return clientContext.request()
      .POST()
      .async().bean(Repo.class);
  }

  // POST 
  @Override
  public CompletableFuture> cfList() {
    return clientContext.request()
      .POST()
      .async().list(Repo.class);
  }

  // POST 
  @Override
  public CompletableFuture> cfStream() {
    return clientContext.request()
      .POST()
      .async().stream(Repo.class);
  }

  // POST 
  @Override
  public HttpCall callBean() {
    return clientContext.request()
      .POST()
      .call().bean(Repo.class);
  }

  // POST 
  @Override
  public HttpCall> callList() {
    return clientContext.request()
      .POST()
      .call().list(Repo.class);
  }

  // POST 
  @Override
  public HttpCall> callStream() {
    return clientContext.request()
      .POST()
      .call().stream(Repo.class);
  }

  // POST 
  @Override
  public CompletableFuture> cfVoid() {
    return clientContext.request()
      .POST()
      .async().asVoid();
  }

  // POST 
  @Override
  public CompletableFuture> cfString() {
    return clientContext.request()
      .POST()
      .async().asString();
  }

  // POST 
  @Override
  public CompletableFuture> cfBytes() {
    return clientContext.request()
      .POST()
      .async().asByteArray();
  }

  // POST 
  @Override
  public CompletableFuture> cfInputStream() {
    return clientContext.request()
      .POST()
      .async().asInputStream();
  }

  // POST 
  @Override
  public CompletableFuture>> cfLines() {
    return clientContext.request()
      .POST()
      .async().asLines();
  }

  // POST 
  @Override
  public HttpCall> callVoid() {
    return clientContext.request()
      .POST()
      .call().asVoid();
  }

  // POST 
  @Override
  public HttpCall> callString() {
    return clientContext.request()
      .POST()
      .call().asString();
  }

  // POST 
  @Override
  public HttpCall> callBytes() {
    return clientContext.request()
      .POST()
      .call().asByteArray();
  }

  // POST 
  @Override
  public HttpCall> callInputStream() {
    return clientContext.request()
      .POST()
      .call().asInputStream();
  }

  // POST 
  @Override
  public HttpCall>> callLines() {
    return clientContext.request()
      .POST()
      .call().asLines();
  }

  // GET 
  @Override
  public  HttpResponse withHandGeneric(BodyHandler handler) {
    return clientContext.request()
      .GET()
      .withHandler(handler);
  }

  // GET 
  @Override
  public HttpResponse withHandPath(BodyHandler handler) {
    return clientContext.request()
      .GET()
      .withHandler(handler);
  }

  // GET 
  @Override
  public  CompletableFuture> cfWithHandGeneric(BodyHandler handler) {
    return clientContext.request()
      .GET()
      .async().withHandler(handler);
  }

  // GET 
  @Override
  public CompletableFuture> cfWithHandPath(BodyHandler handler) {
    return clientContext.request()
      .GET()
      .async().withHandler(handler);
  }

  // GET 
  @Override
  public  HttpCall> callWithHandGeneric(BodyHandler handler) {
    return clientContext.request()
      .GET()
      .call().withHandler(handler);
  }

  // GET 
  @Override
  public HttpCall> callWithHandPath(BodyHandler handler) {
    return clientContext.request()
      .GET()
      .call().withHandler(handler);
  }

  // POST /{id}/foo/{name}
  @Override
  public HttpResponse postWithBody(String id, String name, BodyPublisher body, String other) {
    return clientContext.request()
      .path(id).path("foo").path(name)
      .queryParam("other", other)
      .body(body)
      .POST()
      .asVoid();
  }

  // GET /{id}
  @Override
  public HttpResponse getWithHandler(String id, BodyHandler myHandler, String other) {
    return clientContext.request()
      .path(id)
      .queryParam("other", other)
      .GET()
      .withHandler(myHandler);
  }

  // GET /{id}
  @Override
  public  HttpResponse getWithGeneralHandler(String id, BodyHandler myHandler) {
    return clientContext.request()
      .path(id)
      .GET()
      .withHandler(myHandler);
  }

  // POST /{id}/foo/{name}
  @Override
  public HttpResponse reqBodyResHand2(BodyHandler handler, BodyPublisher body, String id, String name, String other) {
    return clientContext.request()
      .path(id).path("foo").path(name)
      .queryParam("other", other)
      .body(body)
      .POST()
      .withHandler(handler);
  }

  // POST foo/{email}
  @Override
  public void postFormWithPath(String email, String name, String other) {
    clientContext.request()
      .path("foo").path(email)
      .formParam("name", name)
      .formParam("other", other)
      .POST()
      .asVoid();
  }

  // POST withBeanParam/{id}
  @Override
  public void postWithBeanParam(UUID id, CommonParams commonParams) {
    clientContext.request()
      .path("withBeanParam").path(id)
      .queryParam("firstRow", commonParams.firstRow())
      .queryParam("maxRows", commonParams.maxRows)
      .queryParam("sortBy", commonParams.sortBy)
      .queryParam("X-Xtr", commonParams.getExtra())
      .header("Filter", commonParams.filter)
      .POST()
      .asVoid();
  }

  // POST withFormParam/{id}
  @Override
  public void postWithFormParam(UUID id, MyForm theForm, CommonParams commonParams) {
    clientContext.request()
      .path("withFormParam").path(id)
      .queryParam("firstRow", commonParams.firstRow())
      .queryParam("maxRows", commonParams.maxRows)
      .queryParam("sortBy", commonParams.sortBy)
      .queryParam("X-Xtr", commonParams.getExtra())
      .header("Filter", commonParams.filter)
      .formParam("name", theForm.name)
      .formParam("email", theForm.email())
      .formParam("started", theForm.started)
      .header("MFoo", theForm.fooHead)
      .POST()
      .asVoid();
  }

  public static class Provider implements HttpApiProvider {
    @Override
    public Class type() {
      return JunkApi.class;
    }
    @Override
    public JunkApi provide(HttpClientContext client) {
      return new JunkApi$HttpClient(client);
    }
  }
}