co.spraybot.messagerunner.datastores.TransientDataStoreParcelProcessor Maven / Gradle / Ivy

Go to download
package co.spraybot.messagerunner.datastores;

import co.spraybot.messagerunner.DataStoreParcelProcessor;
import co.spraybot.messagerunner.DataStoreParcel;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.AsyncResult;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

public class TransientDataStoreParcelProcessor extends AbstractVerticle implements DataStoreParcelProcessor {

    private Map data = new HashMap<>();

    private Map>> writeParcelHandlerMap;

    public TransientDataStoreParcelProcessor() {
        setwriteParcelHandlerMap();
    }

    private void setwriteParcelHandlerMap() {
        writeParcelHandlerMap = new HashMap<>();
        writeParcelHandlerMap.put(String.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (String) parcel.getValue()));
        writeParcelHandlerMap.put(Integer.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (Integer) parcel.getValue()));
        writeParcelHandlerMap.put(Double.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (Double) parcel.getValue()));
        writeParcelHandlerMap.put(Boolean.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (Boolean) parcel.getValue()));
        writeParcelHandlerMap.put(JsonObject.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (JsonObject) parcel.getValue()));
        writeParcelHandlerMap.put(JsonArray.class, (DataStoreParcel parcel) -> write(parcel.getKey(), (JsonArray) parcel.getValue()));
    }

    @Override
    public void start() throws Exception {
        super.start();
    }

    @Override
    public Future write(String key, JsonObject value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, JsonArray value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, String value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, int value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, double value) {
        return doWrite(key, value);
    }

    @Override
    public Future write(String key, boolean value) {
        return doWrite(key, value);
    }

    private Future doWrite(String key, Object value) {
        data.put(key, value);
        return Future.succeededFuture(true);
    }

    @Override
    public  Future read(String key) {
        return Future.succeededFuture((T) data.get(key));
    }

    @Override
    public  Future erase(String key) {
        return Future.succeededFuture((T) data.remove(key));
    }

    @Override
    public Future eraseEverything() {
        data.clear();
        return Future.succeededFuture();
    }

    @Override
    public Future processParcel(DataStoreParcel parcel, String replyAddress) {
        if (parcel.getDataStoreOperation().equals(Operation.WRITE)) {
            return processWriteOperation(parcel, replyAddress);
        } else if (parcel.getDataStoreOperation().equals(Operation.READ)) {
            return processReadOperation(parcel, replyAddress);
        } else if (parcel.getDataStoreOperation().equals(Operation.ERASE)) {
            return processEraseOperation(parcel, replyAddress);
        } else if (parcel.getDataStoreOperation().equals(Operation.ERASE_EVERYTHING)) {
            return processEraseEverythingOperation(replyAddress);
        }

        return null;
    }

    private Future processWriteOperation(DataStoreParcel parcel, String replyAddress) {
        Future future = Future.future();
        EventBus eventBus = getVertx().eventBus();
        Class valueType = parcel.getValueType();
        Handler> writtenHandler = ar -> {
            eventBus.send(replyAddress, ar.result());
        };

        for (Map.Entry>> valueTypeHandlerInfo : writeParcelHandlerMap.entrySet()) {
            Class _vt = valueTypeHandlerInfo.getKey();
            Function> function = valueTypeHandlerInfo.getValue();

            if (valueType.isAssignableFrom(_vt)) {
                function.apply(parcel).setHandler(writtenHandler);
            }
        }

        return future;
    }

    private Future processReadOperation(DataStoreParcel parcel, String replyAddress) {
        Future future = Future.future();

        read(parcel.getKey()).setHandler(ar -> {
            getVertx().eventBus().send(replyAddress, ar.result());
        });

        return future;
    }

    private Future processEraseOperation(DataStoreParcel parcel, String replyAddress) {
        Future future = Future.future();

        erase(parcel.getKey()).setHandler(ar -> {
            getVertx().eventBus().send(replyAddress, ar.result());
        });

        return future;
    }

    private Future processEraseEverythingOperation(String replyAddress) {
        Future future = Future.future();

        eraseEverything().setHandler(ar -> {
            getVertx().eventBus().send(replyAddress, null);
        });

        return future;
    }


}