io.vertx.up.uca.jooq.cache.L1Aside Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of vertx-up Show documentation
The newest version!
package io.vertx.up.uca.jooq.cache;

import io.horizon.fn.ErrorSupplier;
import io.vertx.core.Future;
import io.vertx.tp.plugin.cache.Harp;
import io.vertx.tp.plugin.cache.hit.CMessage;
import io.vertx.tp.plugin.cache.l1.L1Cache;
import io.vertx.tp.plugin.cache.util.CacheAside;
import io.vertx.up.fn.Fn;
import io.vertx.up.uca.jooq.JqAnalyzer;

import java.util.List;
import java.util.Objects;
import java.util.function.Supplier;

/**
 * @author Lang
 * L1 Cache abstract class
 */
public class L1Aside {
    protected final transient JqAnalyzer analyzer;

    protected final transient L1Cache cacheL1;

    public L1Aside(final JqAnalyzer analyzer) {
        /*
         * Dao / Analyzer
         */
        this.analyzer = analyzer;
        /*
         * Vertx Processing
         */
        this.cacheL1 = Harp.cacheL1();
    }

    // ------------------ Private Processing -------------------------
    /*
     * 1) writeCache
     * 2) deleteCache
     * 2) wrapRead/wrapReadAsync
     */
    /*
     * Private method for write
     */
    private void writeCache(final CMessage message) {
        if (Objects.nonNull(this.cacheL1)) {
            this.cacheL1.write(message);
        }
    }

    void deleteCache(final List message) {
        if (Objects.nonNull(this.cacheL1)) {
            this.cacheL1.delete(message.toArray(new CMessage[]{}));
        }
    }

    private  T wrapRead(final CMessage message) {
        if (Objects.isNull(this.cacheL1)) {
            return null;
        } else {
            return this.cacheL1.read(message);
        }
    }

    private  Future wrapReadAsync(final CMessage message) {
        if (Objects.isNull(this.cacheL1)) {
            return Future.succeededFuture();
        } else {
            return this.cacheL1.readAsync(message);
        }
    }

    private Boolean wrapExist(final CMessage message) {
        if (Objects.isNull(this.cacheL1)) {
            return Boolean.FALSE;
        } else {
            return this.cacheL1.exist(message);
        }
    }

    private Future wrapExistAsync(final CMessage message) {
        if (Objects.isNull(this.cacheL1)) {
            return Future.succeededFuture(Boolean.FALSE);
        } else {
            return this.cacheL1.existAsync(message);
        }
    }

    // ------------------ Usage interface -------------------------
    /*
     * -- delete
     *    deleteAsync
     * Delete cache information
     */
     T delete(final List messages, final ErrorSupplier actualSupplier) {
        /* Actual Supplier */
        final Supplier wrapActual = () -> Fn.monad(actualSupplier, null);

        /* After Callback */
        return CacheAside.after(wrapActual, ret -> this.deleteCache(messages));
    }

     Future deleteAsync(final List messages, final ErrorSupplier> actualSupplier) {
        /* Actual Supplier */
        final Supplier> wrapActual = () -> Fn.monadAsync(actualSupplier, null);

        /* After Callback */
        return CacheAside.afterAsync(wrapActual, ret -> this.deleteCache(messages));
    }

    /*
     * -- read
     *    readAsync
     * Read information such as T & List returned from cache here
     */
     T read(final CMessage message, final ErrorSupplier actualSupplier) {
        /* Actual Supplier */
        final Supplier wrapActual = () -> Fn.monad(actualSupplier, null);

        /* Cache Supplier */
        final Supplier wrapCache = () -> this.wrapRead(message);

        /* Read with callback */
        return CacheAside.before(wrapCache, wrapActual, entity -> this.writeCache(message.data(entity)));
    }

     Future readAsync(final CMessage message, final ErrorSupplier> actualSupplier) {
        /* Actual Supplier */
        final Supplier> wrapActual = () -> Fn.monadAsync(actualSupplier, null);

        /* Cache Supplier */
        final Supplier> wrapCache = () -> this.wrapReadAsync(message);

        /* Read with callback */
        return CacheAside.beforeAsync(wrapCache, wrapActual, entity -> this.writeCache(message.data(entity)));
    }

    /*
     *
     * -- exist
     *    existAsync
     * Exist such as T & List, the different point is returned type is Boolean
     */
    Boolean exist(final CMessage message, final ErrorSupplier actualSupplier) {
        /* Actual Supplier */
        final Supplier wrapActual = () -> Fn.monad(actualSupplier, Boolean.FALSE);

        /* Cache Supplier */
        final Supplier wrapCache = () -> this.wrapExist(message);

        /* Read with callback */
        return CacheAside.check(wrapCache, wrapActual);
    }

    Future existAsync(final CMessage message, final ErrorSupplier> actualSupplier) {
        /* Build to supplier */
        final Supplier> wrapActual = () -> Fn.monadAsync(actualSupplier, Boolean.FALSE);

        /* Cache Supplier */
        final Supplier> wrapCache = () -> this.wrapExistAsync(message);

        return CacheAside.checkAsync(wrapCache, wrapActual);
    }
}