com.emikra.vertx.orientdb.OrientDBServiceVertxEBProxy.java Source code

Introduction

Here is the source code for com.emikra.vertx.orientdb.OrientDBServiceVertxEBProxy.java

Source

/*
* 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 com.emikra.vertx.orientdb;

import com.emikra.vertx.orientdb.OrientDBService;
import io.vertx.core.eventbus.DeliveryOptions;
import io.vertx.core.Vertx;
import io.vertx.core.Future;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import io.vertx.serviceproxy.ProxyHelper;
import com.emikra.vertx.orientdb.OrientDBService;
import com.emikra.vertx.orientdb.CreateClassParams;
import io.vertx.core.Vertx;
import io.vertx.core.json.JsonObject;
import io.vertx.core.AsyncResult;
import io.vertx.core.Handler;
import com.emikra.vertx.orientdb.database.data.CreateDatabaseParams;

/*
  Generated Proxy code - DO NOT EDIT
  @author Roger the Robot
*/
public class OrientDBServiceVertxEBProxy implements OrientDBService {

    private Vertx _vertx;
    private String _address;
    private boolean closed;

    public OrientDBServiceVertxEBProxy(Vertx vertx, String address) {
        this._vertx = vertx;
        this._address = address;
    }

    public void createDatabase(CreateDatabaseParams options, Handler<AsyncResult<JsonObject>> handler) {
        if (closed) {
            handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
            return;
        }
        JsonObject _json = new JsonObject();
        _json.put("options", options == null ? null : options.toJson());
        DeliveryOptions _deliveryOptions = new DeliveryOptions();
        _deliveryOptions.addHeader("action", "createDatabase");
        _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
            if (res.failed()) {
                handler.handle(Future.failedFuture(res.cause()));
            } else {
                handler.handle(Future.succeededFuture(res.result().body()));
            }
        });
    }

    public void createDocument(JsonObject document, Handler<AsyncResult<JsonObject>> handler) {
        if (closed) {
            handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
            return;
        }
        JsonObject _json = new JsonObject();
        _json.put("document", document);
        DeliveryOptions _deliveryOptions = new DeliveryOptions();
        _deliveryOptions.addHeader("action", "createDocument");
        _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
            if (res.failed()) {
                handler.handle(Future.failedFuture(res.cause()));
            } else {
                handler.handle(Future.succeededFuture(res.result().body()));
            }
        });
    }

    public void createVertex(JsonObject vertexDoc, Handler<AsyncResult<JsonObject>> handler) {
        if (closed) {
            handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
            return;
        }
        JsonObject _json = new JsonObject();
        _json.put("vertexDoc", vertexDoc);
        DeliveryOptions _deliveryOptions = new DeliveryOptions();
        _deliveryOptions.addHeader("action", "createVertex");
        _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
            if (res.failed()) {
                handler.handle(Future.failedFuture(res.cause()));
            } else {
                handler.handle(Future.succeededFuture(res.result().body()));
            }
        });
    }

    public void createEdge(JsonObject edgeDoc, Handler<AsyncResult<JsonObject>> handler) {
        if (closed) {
            handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
            return;
        }
        JsonObject _json = new JsonObject();
        _json.put("edgeDoc", edgeDoc);
        DeliveryOptions _deliveryOptions = new DeliveryOptions();
        _deliveryOptions.addHeader("action", "createEdge");
        _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
            if (res.failed()) {
                handler.handle(Future.failedFuture(res.cause()));
            } else {
                handler.handle(Future.succeededFuture(res.result().body()));
            }
        });
    }

    public void createClass(CreateClassParams params, Handler<AsyncResult<JsonObject>> handler) {
        if (closed) {
            handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
            return;
        }
        JsonObject _json = new JsonObject();
        _json.put("params", params == null ? null : params.toJson());
        DeliveryOptions _deliveryOptions = new DeliveryOptions();
        _deliveryOptions.addHeader("action", "createClass");
        _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
            if (res.failed()) {
                handler.handle(Future.failedFuture(res.cause()));
            } else {
                handler.handle(Future.succeededFuture(res.result().body()));
            }
        });
    }

    public void getDocument(JsonObject docQuery, Handler<AsyncResult<JsonObject>> handler) {
        if (closed) {
            handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
            return;
        }
        JsonObject _json = new JsonObject();
        _json.put("docQuery", docQuery);
        DeliveryOptions _deliveryOptions = new DeliveryOptions();
        _deliveryOptions.addHeader("action", "getDocument");
        _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
            if (res.failed()) {
                handler.handle(Future.failedFuture(res.cause()));
            } else {
                handler.handle(Future.succeededFuture(res.result().body()));
            }
        });
    }

    public void getVertex(JsonObject vertexQuery, Handler<AsyncResult<JsonObject>> handler) {
        if (closed) {
            handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
            return;
        }
        JsonObject _json = new JsonObject();
        _json.put("vertexQuery", vertexQuery);
        DeliveryOptions _deliveryOptions = new DeliveryOptions();
        _deliveryOptions.addHeader("action", "getVertex");
        _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
            if (res.failed()) {
                handler.handle(Future.failedFuture(res.cause()));
            } else {
                handler.handle(Future.succeededFuture(res.result().body()));
            }
        });
    }

    public void getEdge(JsonObject edgeQuery, Handler<AsyncResult<JsonObject>> handler) {
        if (closed) {
            handler.handle(Future.failedFuture(new IllegalStateException("Proxy is closed")));
            return;
        }
        JsonObject _json = new JsonObject();
        _json.put("edgeQuery", edgeQuery);
        DeliveryOptions _deliveryOptions = new DeliveryOptions();
        _deliveryOptions.addHeader("action", "getEdge");
        _vertx.eventBus().<JsonObject>send(_address, _json, _deliveryOptions, res -> {
            if (res.failed()) {
                handler.handle(Future.failedFuture(res.cause()));
            } else {
                handler.handle(Future.succeededFuture(res.result().body()));
            }
        });
    }

    private List<Character> convertToListChar(JsonArray arr) {
        List<Character> list = new ArrayList<>();
        for (Object obj : arr) {
            Integer jobj = (Integer) obj;
            list.add((char) jobj.intValue());
        }
        return list;
    }

    private Set<Character> convertToSetChar(JsonArray arr) {
        Set<Character> set = new HashSet<>();
        for (Object obj : arr) {
            Integer jobj = (Integer) obj;
            set.add((char) jobj.intValue());
        }
        return set;
    }

    private <T> Map<String, T> convertMap(Map map) {
        return (Map<String, T>) map;
    }

    private <T> List<T> convertList(List list) {
        return (List<T>) list;
    }

    private <T> Set<T> convertSet(List list) {
        return new HashSet<T>((List<T>) list);
    }
}