• Home
• io.reactiverse
• elasticsearch-client-rxjava2
• 0.8.1ec7.5.1
• source code
• RestHighLevelClient.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.reactiverse.elasticsearch.client.reactivex.RestHighLevelClient 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.reactiverse.elasticsearch.client.reactivex;

import java.util.Map;
import io.reactivex.Observable;
import io.reactivex.Flowable;
import io.reactivex.Single;
import io.reactivex.Completable;
import io.reactivex.Maybe;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.action.explain.ExplainRequest;
import org.elasticsearch.action.fieldcaps.FieldCapabilitiesResponse;
import org.elasticsearch.script.mustache.SearchTemplateRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.script.mustache.MultiSearchTemplateResponse;
import org.elasticsearch.action.fieldcaps.FieldCapabilitiesRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.client.core.TermVectorsRequest;
import org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.MultiGetResponse;
import org.elasticsearch.index.rankeval.RankEvalRequest;
import org.elasticsearch.action.explain.ExplainResponse;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.client.core.MultiTermVectorsRequest;
import org.elasticsearch.index.rankeval.RankEvalResponse;
import org.elasticsearch.action.admin.cluster.storedscripts.GetStoredScriptResponse;
import org.elasticsearch.action.search.MultiSearchResponse;
import org.elasticsearch.action.admin.cluster.storedscripts.PutStoredScriptRequest;
import org.elasticsearch.action.search.ClearScrollRequest;
import org.elasticsearch.action.get.MultiGetRequest;
import org.elasticsearch.action.admin.cluster.storedscripts.DeleteStoredScriptRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.ClearScrollResponse;
import org.elasticsearch.client.core.CountResponse;
import org.elasticsearch.action.admin.cluster.node.tasks.list.ListTasksResponse;
import org.elasticsearch.client.core.MultiTermVectorsResponse;
import org.elasticsearch.action.search.MultiSearchRequest;
import org.elasticsearch.action.index.IndexResponse;
import io.vertx.core.AsyncResult;
import org.elasticsearch.index.reindex.UpdateByQueryRequest;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.script.mustache.SearchTemplateResponse;
import org.elasticsearch.script.mustache.MultiSearchTemplateRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RethrottleRequest;
import org.elasticsearch.action.search.SearchScrollRequest;
import io.vertx.core.Handler;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.client.core.TermVectorsResponse;
import org.elasticsearch.index.reindex.ReindexRequest;


@io.vertx.lang.rx.RxGen(io.reactiverse.elasticsearch.client.RestHighLevelClient.class)
public class RestHighLevelClient {

  @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;
    RestHighLevelClient that = (RestHighLevelClient) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final io.vertx.lang.rx.TypeArg __TYPE_ARG = new io.vertx.lang.rx.TypeArg<>(    obj -> new RestHighLevelClient((io.reactiverse.elasticsearch.client.RestHighLevelClient) obj),
    RestHighLevelClient::getDelegate
  );

  private final io.reactiverse.elasticsearch.client.RestHighLevelClient delegate;
  
  public RestHighLevelClient(io.reactiverse.elasticsearch.client.RestHighLevelClient delegate) {
    this.delegate = delegate;
  }

  public io.reactiverse.elasticsearch.client.RestHighLevelClient getDelegate() {
    return delegate;
  }

  public static io.reactiverse.elasticsearch.client.reactivex.RestHighLevelClient create(io.vertx.reactivex.core.Vertx vertx, RestClientBuilder restClientBuilder) { 
    io.reactiverse.elasticsearch.client.reactivex.RestHighLevelClient ret = io.reactiverse.elasticsearch.client.reactivex.RestHighLevelClient.newInstance(io.reactiverse.elasticsearch.client.RestHighLevelClient.create(vertx.getDelegate(), restClientBuilder));
    return ret;
  }

  public void close() { 
    delegate.close();
  }

  public io.reactiverse.elasticsearch.client.reactivex.IndicesClient indices() { 
    io.reactiverse.elasticsearch.client.reactivex.IndicesClient ret = io.reactiverse.elasticsearch.client.reactivex.IndicesClient.newInstance(delegate.indices());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.ClusterClient cluster() { 
    io.reactiverse.elasticsearch.client.reactivex.ClusterClient ret = io.reactiverse.elasticsearch.client.reactivex.ClusterClient.newInstance(delegate.cluster());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.IngestClient ingest() { 
    io.reactiverse.elasticsearch.client.reactivex.IngestClient ret = io.reactiverse.elasticsearch.client.reactivex.IngestClient.newInstance(delegate.ingest());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.SnapshotClient snapshot() { 
    io.reactiverse.elasticsearch.client.reactivex.SnapshotClient ret = io.reactiverse.elasticsearch.client.reactivex.SnapshotClient.newInstance(delegate.snapshot());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.RollupClient rollup() { 
    io.reactiverse.elasticsearch.client.reactivex.RollupClient ret = io.reactiverse.elasticsearch.client.reactivex.RollupClient.newInstance(delegate.rollup());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.CcrClient ccr() { 
    io.reactiverse.elasticsearch.client.reactivex.CcrClient ret = io.reactiverse.elasticsearch.client.reactivex.CcrClient.newInstance(delegate.ccr());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.TasksClient tasks() { 
    io.reactiverse.elasticsearch.client.reactivex.TasksClient ret = io.reactiverse.elasticsearch.client.reactivex.TasksClient.newInstance(delegate.tasks());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.XPackClient xpack() { 
    io.reactiverse.elasticsearch.client.reactivex.XPackClient ret = io.reactiverse.elasticsearch.client.reactivex.XPackClient.newInstance(delegate.xpack());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.WatcherClient watcher() { 
    io.reactiverse.elasticsearch.client.reactivex.WatcherClient ret = io.reactiverse.elasticsearch.client.reactivex.WatcherClient.newInstance(delegate.watcher());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.GraphClient graph() { 
    io.reactiverse.elasticsearch.client.reactivex.GraphClient ret = io.reactiverse.elasticsearch.client.reactivex.GraphClient.newInstance(delegate.graph());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.LicenseClient license() { 
    io.reactiverse.elasticsearch.client.reactivex.LicenseClient ret = io.reactiverse.elasticsearch.client.reactivex.LicenseClient.newInstance(delegate.license());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.IndexLifecycleClient indexLifecycle() { 
    io.reactiverse.elasticsearch.client.reactivex.IndexLifecycleClient ret = io.reactiverse.elasticsearch.client.reactivex.IndexLifecycleClient.newInstance(delegate.indexLifecycle());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.MachineLearningClient machineLearning() { 
    io.reactiverse.elasticsearch.client.reactivex.MachineLearningClient ret = io.reactiverse.elasticsearch.client.reactivex.MachineLearningClient.newInstance(delegate.machineLearning());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.SecurityClient security() { 
    io.reactiverse.elasticsearch.client.reactivex.SecurityClient ret = io.reactiverse.elasticsearch.client.reactivex.SecurityClient.newInstance(delegate.security());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.TransformClient transform() { 
    io.reactiverse.elasticsearch.client.reactivex.TransformClient ret = io.reactiverse.elasticsearch.client.reactivex.TransformClient.newInstance(delegate.transform());
    return ret;
  }

  public io.reactiverse.elasticsearch.client.reactivex.EnrichClient enrich() { 
    io.reactiverse.elasticsearch.client.reactivex.EnrichClient ret = io.reactiverse.elasticsearch.client.reactivex.EnrichClient.newInstance(delegate.enrich());
    return ret;
  }

  public void bulkAsync(BulkRequest bulkRequest, RequestOptions options, Handler> handler) { 
    delegate.bulkAsync(bulkRequest, options, handler);
  }

  public Single rxBulkAsync(BulkRequest bulkRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      bulkAsync(bulkRequest, options, handler);
    });
  }

  public void reindexAsync(ReindexRequest reindexRequest, RequestOptions options, Handler> handler) { 
    delegate.reindexAsync(reindexRequest, options, handler);
  }

  public Single rxReindexAsync(ReindexRequest reindexRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      reindexAsync(reindexRequest, options, handler);
    });
  }

  public void updateByQueryAsync(UpdateByQueryRequest updateByQueryRequest, RequestOptions options, Handler> handler) { 
    delegate.updateByQueryAsync(updateByQueryRequest, options, handler);
  }

  public Single rxUpdateByQueryAsync(UpdateByQueryRequest updateByQueryRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      updateByQueryAsync(updateByQueryRequest, options, handler);
    });
  }

  public void deleteByQueryAsync(DeleteByQueryRequest deleteByQueryRequest, RequestOptions options, Handler> handler) { 
    delegate.deleteByQueryAsync(deleteByQueryRequest, options, handler);
  }

  public Single rxDeleteByQueryAsync(DeleteByQueryRequest deleteByQueryRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      deleteByQueryAsync(deleteByQueryRequest, options, handler);
    });
  }

  public void deleteByQueryRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options, Handler> handler) { 
    delegate.deleteByQueryRethrottleAsync(rethrottleRequest, options, handler);
  }

  public Single rxDeleteByQueryRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      deleteByQueryRethrottleAsync(rethrottleRequest, options, handler);
    });
  }

  public void updateByQueryRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options, Handler> handler) { 
    delegate.updateByQueryRethrottleAsync(rethrottleRequest, options, handler);
  }

  public Single rxUpdateByQueryRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      updateByQueryRethrottleAsync(rethrottleRequest, options, handler);
    });
  }

  public void reindexRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options, Handler> handler) { 
    delegate.reindexRethrottleAsync(rethrottleRequest, options, handler);
  }

  public Single rxReindexRethrottleAsync(RethrottleRequest rethrottleRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      reindexRethrottleAsync(rethrottleRequest, options, handler);
    });
  }

  public void getAsync(GetRequest getRequest, RequestOptions options, Handler> handler) { 
    delegate.getAsync(getRequest, options, handler);
  }

  public Single rxGetAsync(GetRequest getRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getAsync(getRequest, options, handler);
    });
  }

  public void mgetAsync(MultiGetRequest multiGetRequest, RequestOptions options, Handler> handler) { 
    delegate.mgetAsync(multiGetRequest, options, handler);
  }

  public Single rxMgetAsync(MultiGetRequest multiGetRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      mgetAsync(multiGetRequest, options, handler);
    });
  }

  public void existsAsync(GetRequest getRequest, RequestOptions options, Handler> handler) { 
    delegate.existsAsync(getRequest, options, handler);
  }

  public Single rxExistsAsync(GetRequest getRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      existsAsync(getRequest, options, handler);
    });
  }

  public void existsSourceAsync(GetRequest getRequest, RequestOptions options, Handler> handler) { 
    delegate.existsSourceAsync(getRequest, options, handler);
  }

  public Single rxExistsSourceAsync(GetRequest getRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      existsSourceAsync(getRequest, options, handler);
    });
  }

  public void indexAsync(IndexRequest indexRequest, RequestOptions options, Handler> handler) { 
    delegate.indexAsync(indexRequest, options, handler);
  }

  public Single rxIndexAsync(IndexRequest indexRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      indexAsync(indexRequest, options, handler);
    });
  }

  public void countAsync(CountRequest countRequest, RequestOptions options, Handler> handler) { 
    delegate.countAsync(countRequest, options, handler);
  }

  public Single rxCountAsync(CountRequest countRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      countAsync(countRequest, options, handler);
    });
  }

  public void updateAsync(UpdateRequest updateRequest, RequestOptions options, Handler> handler) { 
    delegate.updateAsync(updateRequest, options, handler);
  }

  public Single rxUpdateAsync(UpdateRequest updateRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      updateAsync(updateRequest, options, handler);
    });
  }

  public void deleteAsync(DeleteRequest deleteRequest, RequestOptions options, Handler> handler) { 
    delegate.deleteAsync(deleteRequest, options, handler);
  }

  public Single rxDeleteAsync(DeleteRequest deleteRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      deleteAsync(deleteRequest, options, handler);
    });
  }

  public void searchAsync(SearchRequest searchRequest, RequestOptions options, Handler> handler) { 
    delegate.searchAsync(searchRequest, options, handler);
  }

  public Single rxSearchAsync(SearchRequest searchRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      searchAsync(searchRequest, options, handler);
    });
  }

  public void msearchAsync(MultiSearchRequest searchRequest, RequestOptions options, Handler> handler) { 
    delegate.msearchAsync(searchRequest, options, handler);
  }

  public Single rxMsearchAsync(MultiSearchRequest searchRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      msearchAsync(searchRequest, options, handler);
    });
  }

  public void scrollAsync(SearchScrollRequest searchScrollRequest, RequestOptions options, Handler> handler) { 
    delegate.scrollAsync(searchScrollRequest, options, handler);
  }

  public Single rxScrollAsync(SearchScrollRequest searchScrollRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      scrollAsync(searchScrollRequest, options, handler);
    });
  }

  public void clearScrollAsync(ClearScrollRequest clearScrollRequest, RequestOptions options, Handler> handler) { 
    delegate.clearScrollAsync(clearScrollRequest, options, handler);
  }

  public Single rxClearScrollAsync(ClearScrollRequest clearScrollRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      clearScrollAsync(clearScrollRequest, options, handler);
    });
  }

  public void searchTemplateAsync(SearchTemplateRequest searchTemplateRequest, RequestOptions options, Handler> handler) { 
    delegate.searchTemplateAsync(searchTemplateRequest, options, handler);
  }

  public Single rxSearchTemplateAsync(SearchTemplateRequest searchTemplateRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      searchTemplateAsync(searchTemplateRequest, options, handler);
    });
  }

  public void explainAsync(ExplainRequest explainRequest, RequestOptions options, Handler> handler) { 
    delegate.explainAsync(explainRequest, options, handler);
  }

  public Single rxExplainAsync(ExplainRequest explainRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      explainAsync(explainRequest, options, handler);
    });
  }

  public void termvectorsAsync(TermVectorsRequest request, RequestOptions options, Handler> handler) { 
    delegate.termvectorsAsync(request, options, handler);
  }

  public Single rxTermvectorsAsync(TermVectorsRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      termvectorsAsync(request, options, handler);
    });
  }

  public void mtermvectorsAsync(MultiTermVectorsRequest request, RequestOptions options, Handler> handler) { 
    delegate.mtermvectorsAsync(request, options, handler);
  }

  public Single rxMtermvectorsAsync(MultiTermVectorsRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      mtermvectorsAsync(request, options, handler);
    });
  }

  public void msearchTemplateAsync(MultiSearchTemplateRequest multiSearchTemplateRequest, RequestOptions options, Handler> handler) { 
    delegate.msearchTemplateAsync(multiSearchTemplateRequest, options, handler);
  }

  public Single rxMsearchTemplateAsync(MultiSearchTemplateRequest multiSearchTemplateRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      msearchTemplateAsync(multiSearchTemplateRequest, options, handler);
    });
  }

  public void rankEvalAsync(RankEvalRequest rankEvalRequest, RequestOptions options, Handler> handler) { 
    delegate.rankEvalAsync(rankEvalRequest, options, handler);
  }

  public Single rxRankEvalAsync(RankEvalRequest rankEvalRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      rankEvalAsync(rankEvalRequest, options, handler);
    });
  }

  public void getScriptAsync(GetStoredScriptRequest request, RequestOptions options, Handler> handler) { 
    delegate.getScriptAsync(request, options, handler);
  }

  public Single rxGetScriptAsync(GetStoredScriptRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      getScriptAsync(request, options, handler);
    });
  }

  public void deleteScriptAsync(DeleteStoredScriptRequest request, RequestOptions options, Handler> handler) { 
    delegate.deleteScriptAsync(request, options, handler);
  }

  public Single rxDeleteScriptAsync(DeleteStoredScriptRequest request, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      deleteScriptAsync(request, options, handler);
    });
  }

  public void putScriptAsync(PutStoredScriptRequest putStoredScriptRequest, RequestOptions options, Handler> handler) { 
    delegate.putScriptAsync(putStoredScriptRequest, options, handler);
  }

  public Single rxPutScriptAsync(PutStoredScriptRequest putStoredScriptRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      putScriptAsync(putStoredScriptRequest, options, handler);
    });
  }

  public void fieldCapsAsync(FieldCapabilitiesRequest fieldCapabilitiesRequest, RequestOptions options, Handler> handler) { 
    delegate.fieldCapsAsync(fieldCapabilitiesRequest, options, handler);
  }

  public Single rxFieldCapsAsync(FieldCapabilitiesRequest fieldCapabilitiesRequest, RequestOptions options) { 
    return io.vertx.reactivex.impl.AsyncResultSingle.toSingle(handler -> {
      fieldCapsAsync(fieldCapabilitiesRequest, options, handler);
    });
  }


  public static  RestHighLevelClient newInstance(io.reactiverse.elasticsearch.client.RestHighLevelClient arg) {
    return arg != null ? new RestHighLevelClient(arg) : null;
  }
}