io.vertx.up.uca.jooq.cache.AsideDelete 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
There is a newer version: 0.9.0
package io.vertx.up.uca.jooq.cache;

import io.vertx.core.Future;
import io.vertx.core.json.JsonObject;
import io.vertx.tp.plugin.cache.hit.CMessage;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

import java.util.List;

/**
 * @author Lang
 * Empty aspect for placeholder here
 */
@Aspect
@SuppressWarnings("all")
public class AsideDelete extends L1AsideWriting {
/*    @Before(value = "initialization(io.vertx.up.uca.jooq.UxJooq.new(..)) && args(clazz,dao)", argNames = "clazz,dao")
    public void init(final Class clazz, final VertxDAO dao) {
        super.initialize(clazz, dao);
    }*/
    /*
     * delete(T)
     *      <-- delete(JsonObject)
     *      <-- delete(JsonObject, pojo)
     *      <-- deleteJ(T)
     *      <-- deleteJ(JsonObject)
     *      <-- deleteJ(JsonObject, pojo)
     *
     * deleteAsync(T)
     *      <-- deleteAsync(JsonObject)
     *      <-- deleteAsync(JsonObject, pojo)
     *      <-- deleteJAsync(T)
     *      <-- deleteJAsync(JsonObject)
     *      <-- deleteJAsync(JsonObject, pojo)
     *
     * delete(List)
     *      <-- delete(JsonArray)
     *      <-- delete(JsonArray, pojo)
     *      <-- deleteJ(List)
     *      <-- deleteJ(JsonArray)
     *      <-- deleteJ(JsonArray, pojo)
     *
     * deleteAsync(List)
     *      <-- deleteAsync(JsonArray)
     *      <-- deleteAsync(JsonArray, pojo)
     *      <-- deleteJAsync(List)
     *      <-- deleteJAsync(JsonArray)
     *      <-- deleteJAsync(JsonArray, pojo)
     *
     * deleteById(ID...)
     * deleteById(Collection ids)
     * deleteByIdAsync(ID...)
     * deleteByIdAsync(Collection ids)
     *
     * deleteBy(JsonObject)
     * deleteBy(JsonObject, pojo)
     * deleteByAsync(JsonObject)
     * deleteByAsync(JsonObject, pojo)
     */

    /*
     * deleteById
     * deleteByIdAsync
     */
    @Around(value = "execution(* io.vertx.up.uca.jooq.UxJooq.deleteById*(..)) && args(id)", argNames = "id")
    public  T deleteById(final ProceedingJoinPoint point, final Object id) throws Throwable {
        /*
         * Object[] / Collection
         */
        final List messages = this.messages(id, point);
        return this.writeAsync(messages, point);
    }

    /*
     * deleteBy
     */
    @Around(value = "execution(* io.vertx.up.uca.jooq.UxJooq.deleteBy(..))")
    public Boolean deleteBy(final ProceedingJoinPoint point) throws Throwable {
        if (L1Analyzer.isMatch(point, JsonObject.class)) {
            /*
             * Get all ids
             * deleteBy(JsonObject)
             */
            final List messages = this.messagesCond(point);
            return this.writeAsync(messages, point);
        } else {
            /*
             * Pojo mode ignored
             * deleteBy(JsonObject, pojo)
             */
            final List messages = this.messagesPojo(point, 0);
            return this.writeAsync(messages, point);
        }
    }

    /*
     * deleteByAsync
     */
    @Around(value = "execution(* io.vertx.up.uca.jooq.UxJooq.deleteByAsync(..))")
    public Future deleteByAsync(final ProceedingJoinPoint point) throws Throwable {
        if (L1Analyzer.isMatch(point, JsonObject.class)) {
            /*
             * Get all ids
             * deleteByAsync(JsonObject)
             */
            final List messages = this.messagesCond(point);
            return this.writeAsync(messages, point);
        } else {
            /*
             * Pojo mode ignored
             * deleteByAsync(JsonObject, pojo)
             */
            final List messages = this.messagesPojo(point, 0);
            return this.writeAsync(messages, point);
        }
    }

    /*
     * delete(T)
     */
    @Around(value = "execution(* io.vertx.up.uca.jooq.UxJooq.delete(T))")
    public  T delete(final ProceedingJoinPoint point) throws Throwable {
        /*
         *  T
         */
        final List messages = this.messagesT(point);
        return this.writeAsync(messages, point);
    }

    /*
     * delete(List)
     */
    @Around(value = "execution(* io.vertx.up.uca.jooq.UxJooq.delete(java.util.List))")
    public  List deleteList(final ProceedingJoinPoint point) throws Throwable {
        /*
         *  List
         */
        final List messages = this.messagesT(point);
        return this.writeAsync(messages, point);
    }

    /*
     * deleteAsync(T)
     */
    @Around(value = "execution(* io.vertx.up.uca.jooq.UxJooq.deleteAsync(T))")
    public  Future deleteAsync(final ProceedingJoinPoint point) throws Throwable {
        /*
         *  Future
         */
        final List messages = this.messagesT(point);
        return this.writeAsync(messages, point);
    }

    /*
     * deleteAsync(List)
     */
    @Around(value = "execution(* io.vertx.up.uca.jooq.UxJooq.deleteAsync(java.util.List))")
    public  Future> deleteListAsync(final ProceedingJoinPoint point) throws Throwable {
        /*
         *  Future>
         */
        final List messages = this.messagesT(point);
        return this.writeAsync(messages, point);
    }
}