Package io.vertx.up.unity

Class Ux

  • public final class Ux
extends Object
    #「Kt」Utility X Component in zero Here Ux is a util interface of uniform to call different tools. It just like helper for business usage.

    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      static class  Ux.Job  
      static class  Ux.Join  
      static class  Ux.Jooq
      Inner class of `Jooq` tool of Jooq Engine operations based on pojo here.
      static class  Ux.Jwt  
      static class  Ux.Opt  
      static class  Ux.Pool  
      static class  Ux.Timer  

    • Constructor Summary

      Constructors 
      Constructor Description
      Ux()  

    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method Description
      static <T> Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> attach​(String field, Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> function)  
      static <T> Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> attachJ​(String field, io.vertx.core.json.JsonObject data)  
      static <T> Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> attachJ​(String field, Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> function)  
      static <T,​R>
      ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​List<T>>      		 compare​(List<T> original, List<T> current, Function<T,​R> fnValue)  
      static <T,​R>
      ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​List<T>>      		 compare​(List<T> original, List<T> current, Function<T,​R> fnValue, String pojoFile)  
      static <T,​R>
      ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​List<T>>      		 compare​(List<T> original, List<T> current, Set<String> uniqueSet)  
      static <T,​R>
      ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​List<T>>      		 compare​(List<T> original, List<T> current, Set<String> uniqueSet, String pojoFile)  
      static ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​io.vertx.core.json.JsonArray> compareJ​(io.vertx.core.json.JsonArray original, io.vertx.core.json.JsonArray current, io.vertx.core.json.JsonArray matrix)  
      static ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​io.vertx.core.json.JsonArray> compareJ​(io.vertx.core.json.JsonArray original, io.vertx.core.json.JsonArray current, Set<String> fields)  
      static io.vertx.core.Future<ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​io.vertx.core.json.JsonArray>> compareJAsync​(io.vertx.core.json.JsonArray original, io.vertx.core.json.JsonArray current, io.vertx.core.json.JsonArray matrix)  
      static io.vertx.core.Future<ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​io.vertx.core.json.JsonArray>> compareJAsync​(io.vertx.core.json.JsonArray original, io.vertx.core.json.JsonArray current, Set<String> fields)  
      static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> compareRun​(ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​List<T>> compared, Function<List<T>,​io.vertx.core.Future<List<T>>> insertAsyncFn, Function<List<T>,​io.vertx.core.Future<List<T>>> updateAsyncFn)  
      static io.vertx.core.Future<io.vertx.core.json.JsonObject> complex​(io.vertx.core.json.JsonObject input, Predicate<io.vertx.core.json.JsonObject> predicate, Supplier<io.vertx.core.Future<io.vertx.core.json.JsonObject>> executor)  
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> complex​(io.vertx.up.atom.query.Pagination first, Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<Integer>> total, Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> page, Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> result)  
      static Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> complex​(Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<Integer>> total, Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> page, Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> result)  
      static Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> complex​(Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> page)  
      static io.vertx.core.json.JsonObject criteria​(io.vertx.core.json.JsonObject data, String pojo)  
      static void debug​(Object... objects)  
      static <T> T debug​(Throwable error, Supplier<T> supplier)  
      static <T> io.vertx.core.Future<T> debug​(T item)  
      static io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> dictCalc​(io.vertx.up.commune.exchange.DiSetting dict, io.vertx.core.MultiMap paramsMap)  
      static ConcurrentMap<String,​io.vertx.up.commune.exchange.DiConsumer> dictEpsilon​(io.vertx.core.json.JsonObject epsilon)  
      static <T> io.vertx.core.Future<T> dictTo​(T record, io.vertx.up.commune.exchange.DiFabric fabric)  
      static <T> io.vertx.core.Future<T> fromAsync​(CompletionStage<T> state)  
      static <T> T fromEnvelop​(Envelop envelop, Class<T> clazz, String pojo)  
      static io.vertx.core.json.JsonObject fromEnvelop​(Envelop envelop, String pojo)  
      static Envelop fromEnvelop​(Class<? extends io.vertx.up.exception.WebException> clazz, Object... args)  
      static <T> Envelop fromEnvelop​(T entity)  
      static <T> Envelop fromEnvelop​(T entity, io.vertx.up.exception.WebException error)  
      static <T> T fromEnvelop1​(Envelop envelop, Class<T> clazz, String pojo)  
      static io.vertx.core.json.JsonObject fromEnvelop1​(Envelop envelop, String pojo)  
      static <T> T fromEnvelop2​(Envelop envelop, Class<T> clazz, String pojo)  
      static io.vertx.core.json.JsonObject fromEnvelop2​(Envelop envelop, String pojo)  
      static <T> List<T> fromJson​(io.vertx.core.json.JsonArray array, Class<T> clazz)  
      static <T> List<T> fromJson​(io.vertx.core.json.JsonArray array, Class<T> clazz, String pojo)  
      static <T> T fromJson​(io.vertx.core.json.JsonObject data, Class<T> clazz)  
      static <T> T fromJson​(io.vertx.core.json.JsonObject data, Class<T> clazz, String pojo)  
      static <T> List<T> fromPage​(io.vertx.core.json.JsonObject data, Class<T> clazz)  
      static <T> io.vertx.core.Future<T> future()  
      static <T> io.vertx.core.Future<T> future​(T entity)  
      static <T> io.vertx.core.Future<T> future​(T input, List<Function<T,​io.vertx.core.Future<T>>> functions)  
      static <T> io.vertx.core.Future<T> future​(T input, Set<Function<T,​io.vertx.core.Future<T>>> functions)  
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA()  
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA​(io.vertx.up.commune.Record[] records)  
      static <T> Function<List<T>,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> futureA​(String pojo)  
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA​(Throwable ex)  
      static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA​(List<T> list)  
      static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA​(List<T> list, String pojo)  
      static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureB​(boolean checked)  
      static io.vertx.core.Future<Boolean> futureB​(io.vertx.core.json.JsonObject checked)  
      static <T> Function<Throwable,​io.vertx.core.Future<T>> futureE​(Supplier<T> supplier)  
      static <T> Function<Throwable,​io.vertx.core.Future<T>> futureE​(T input)  
      static io.vertx.core.Future<Boolean> futureF()  
      static io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> futureG​(io.vertx.core.json.JsonArray item)  
      static io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> futureG​(io.vertx.core.json.JsonArray item, String field)  
      static <T> io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> futureG​(List<T> item)  
      static <T> io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> futureG​(List<T> item, String field)  
      static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ()  
      static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ​(io.vertx.up.commune.Record record)  
      static <T> Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> futureJ​(String pojo)  
      static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ​(Throwable ex)  
      static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ​(T entity)  
      static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ​(T entity, String pojo)  
      static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJA​(io.vertx.core.json.JsonArray array)  
      static <T,​R>
      Function<List<R>,​io.vertx.core.Future<io.vertx.core.json.JsonObject>>      		 futureJM​(T entity, String field)  
      static <T> io.vertx.core.Future<List<T>> futureL()  
      static <T> Function<List<T>,​io.vertx.core.Future<List<io.vertx.core.json.JsonObject>>> futureL​(String pojo)  
      static <T> io.vertx.core.Future<List<io.vertx.core.json.JsonObject>> futureL​(List<T> list)  
      static <T> io.vertx.core.Future<List<io.vertx.core.json.JsonObject>> futureL​(List<T> list, String pojo)  
      static <T> io.vertx.core.Future<List<io.vertx.core.json.JsonObject>> futureLJ()  
      static io.vertx.core.Future<Boolean> futureT()  
      static io.vertx.core.json.JsonArray getArray​(Envelop envelop)  
      static io.vertx.core.json.JsonArray getArray​(Envelop envelop, int index)  
      static io.vertx.core.json.JsonArray getArray1​(Envelop envelop)  
      static io.vertx.core.json.JsonArray getArray2​(Envelop envelop)  
      static io.vertx.core.json.JsonObject getBody​(Envelop envelop)  
      static <T> T getBodyT​(Envelop envelop, Class<T> clazz)  
      static Integer getInteger​(Envelop envelop)  
      static Integer getInteger​(Envelop envelop, int index)  
      static Integer getInteger1​(Envelop envelop)  
      static Integer getInteger2​(Envelop envelop)  
      static io.vertx.core.json.JsonObject getJson​(Envelop envelop)  
      static io.vertx.core.json.JsonObject getJson​(Envelop envelop, int index)  
      static io.vertx.core.json.JsonObject getJson1​(Envelop envelop)  
      static io.vertx.core.json.JsonObject getJson2​(Envelop envelop)  
      static Long getLong​(Envelop envelop)  
      static Long getLong​(Envelop envelop, int index)  
      static Long getLong1​(Envelop envelop)  
      static Long getLong2​(Envelop envelop)  
      static String getString​(Envelop envelop)  
      static String getString​(Envelop envelop, int index)  
      static String getString1​(Envelop envelop)  
      static String getString2​(Envelop envelop)  
      static <T> T getT​(Envelop envelop, int index, Class<T> clazz)  
      static <T> T getT​(Envelop envelop, Class<T> clazz)  
      static <T> T getT1​(Envelop envelop, Class<T> clazz)  
      static <T> T getT2​(Envelop envelop, Class<T> clazz)  
      static io.vertx.up.atom.secure.Vis getVis​(Envelop envelop)  
      static io.vertx.up.atom.secure.Vis getVis​(Envelop envelop, int index)  
      static io.vertx.up.atom.secure.Vis getVis1​(Envelop envelop)  
      static io.vertx.up.atom.secure.Vis getVis2​(Envelop envelop)  
      static <T> io.vertx.core.Handler<io.vertx.core.AsyncResult<T>> handler​(io.vertx.core.eventbus.Message<Envelop> message)  
      static <T> io.vertx.core.Future<T> handler​(Consumer<io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>> handler)  
      static String keyUser​(io.vertx.ext.auth.User user)  
      static io.vertx.up.fn.wait.Log log​(Class<?> clazz)
      Create new log instance for store `Annal` mapping Debug method for help us to do development 1) log: for branch log creation 2) debug: 3) otherwise: ( Business Part: Debugging )
      static io.vertx.core.Future<Boolean> nativeInit​(io.vertx.core.json.JsonArray components, io.vertx.core.Vertx vertx)
      This method will be configured in `vertx-extension.yml` file in common situation, The file content should be as following: ```yml //
      static io.vertx.core.Vertx nativeVertx()  
      static io.vertx.core.WorkerExecutor nativeWorker​(String name)  
      static io.vertx.core.WorkerExecutor nativeWorker​(String name, Integer minutes)  
      static Function<Throwable,​Envelop> otherwise()  
      static <T> Function<Throwable,​T> otherwise​(Supplier<T> supplier)  
      static <T> Function<Throwable,​T> otherwise​(T input)  
      static io.vertx.core.json.JsonObject outBool​(boolean checked)  
      static io.vertx.core.json.JsonObject outBool​(String key, boolean checked)  
      static io.vertx.core.json.JsonObject pageData()  
      static io.vertx.core.json.JsonObject pageData​(io.vertx.core.json.JsonArray data, long size)  
      static io.vertx.core.json.JsonArray pageData​(io.vertx.core.json.JsonObject data)  
      static io.vertx.core.json.JsonObject pageData​(io.vertx.core.json.JsonObject pageData, Function<io.vertx.core.json.JsonArray,​io.vertx.core.json.JsonArray> function)  
      static ConcurrentMap<Boolean,​io.vertx.core.json.JsonArray> ruleAll​(Collection<io.vertx.up.commune.rule.RuleTerm> rules, io.vertx.core.json.JsonArray input)  
      static io.vertx.core.json.JsonObject ruleAll​(Collection<io.vertx.up.commune.rule.RuleTerm> rules, io.vertx.core.json.JsonArray source, io.vertx.core.json.JsonObject record)  
      static io.vertx.core.json.JsonObject ruleAll​(Collection<io.vertx.up.commune.rule.RuleTerm> rules, io.vertx.core.json.JsonObject input)  
      static io.vertx.core.json.JsonObject ruleAll​(Collection<io.vertx.up.commune.rule.RuleTerm> rules, io.vertx.core.json.JsonObject recordO, io.vertx.core.json.JsonObject recordN)  
      static ConcurrentMap<Boolean,​io.vertx.core.json.JsonArray> ruleAny​(Collection<io.vertx.up.commune.rule.RuleTerm> rules, io.vertx.core.json.JsonArray input)  
      static io.vertx.core.json.JsonObject ruleAny​(Collection<io.vertx.up.commune.rule.RuleTerm> rules, io.vertx.core.json.JsonArray source, io.vertx.core.json.JsonObject record)  
      static io.vertx.core.json.JsonObject ruleAny​(Collection<io.vertx.up.commune.rule.RuleTerm> rules, io.vertx.core.json.JsonObject input)  
      static io.vertx.core.json.JsonObject ruleAny​(Collection<io.vertx.up.commune.rule.RuleTerm> rules, io.vertx.core.json.JsonObject record0, io.vertx.core.json.JsonObject recordN)  
      static io.vertx.up.atom.record.Apt ruleApt​(io.vertx.core.json.JsonArray twins, boolean isReplaced)  
      static boolean ruleJEqual​(io.vertx.core.json.JsonObject record, io.vertx.core.json.JsonObject latest, io.vertx.core.json.JsonArray matrix)  
      static boolean ruleJEqual​(io.vertx.core.json.JsonObject record, io.vertx.core.json.JsonObject latest, Set<String> fields)  
      static io.vertx.core.json.JsonObject ruleJFind​(io.vertx.core.json.JsonArray source, io.vertx.core.json.JsonObject expected, io.vertx.core.json.JsonArray matrix)  
      static io.vertx.core.json.JsonObject ruleJFind​(io.vertx.core.json.JsonArray source, io.vertx.core.json.JsonObject expected, Set<String> fields)  
      static boolean ruleJOk​(io.vertx.core.json.JsonObject record, io.vertx.core.json.JsonArray matrix)  
      static boolean ruleJOk​(io.vertx.core.json.JsonObject record, Set<String> fields)  
      static io.vertx.core.json.JsonArray ruleJReduce​(io.vertx.core.json.JsonArray records, io.vertx.core.json.JsonArray matrix)  
      static io.vertx.core.json.JsonArray ruleJReduce​(io.vertx.core.json.JsonArray records, Set<String> fields)  
      static io.vertx.core.json.JsonObject ruleNil​(io.vertx.core.json.JsonObject recordN, io.vertx.core.json.JsonObject recordO)  
      static io.vertx.core.json.JsonObject ruleNil​(io.vertx.core.json.JsonObject twins, io.vertx.up.eon.em.ChangeFlag flag)  
      static io.vertx.core.json.JsonObject ruleTwins​(io.vertx.core.json.JsonObject recordO, io.vertx.core.json.JsonObject recordN)  
      static <F,​S,​T>
      io.vertx.core.Future<T>      		 thenCombine​(io.vertx.core.Future<F> futureF, io.vertx.core.Future<S> futureS, BiFunction<F,​S,​io.vertx.core.Future<T>> consumer)  
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombine​(io.vertx.core.Future<io.vertx.core.json.JsonArray> source, Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> generateFun, BinaryOperator<io.vertx.core.json.JsonObject> operatorFun)
      Future async specific workflow for combine future here.
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombine​(io.vertx.core.json.JsonArray input, Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> function)  
      static io.vertx.core.Future<io.vertx.core.json.JsonObject> thenCombine​(io.vertx.core.json.JsonObject source, Function<io.vertx.core.json.JsonObject,​List<io.vertx.core.Future>> generateFun, BiConsumer<io.vertx.core.json.JsonObject,​io.vertx.core.json.JsonObject>... operatorFun)
      The workflow ------> generateFun ( Supplier ) operatorFun ( BiConsumer ) ------> future1 ( json -> ? future ) -> operatorFun[0] -> (json, out1) -> merged1 -> json -> future2 ( json -> ? future ) -> operatorFun[1] -> (json, out2) -> merged2 -> merged ------> future3 ( json -> ? future ) -> operatorFun[2] -> (json, out3) -> merged3 ->
      static <K,​T>
      io.vertx.core.Future<ConcurrentMap<K,​T>>      		 thenCombine​(ConcurrentMap<K,​io.vertx.core.Future<T>> futureMap)  
      static <F,​S,​T>
      io.vertx.core.Future<T>      		 thenCombine​(Supplier<io.vertx.core.Future<F>> futureF, Supplier<io.vertx.core.Future<S>> futureS, BiFunction<F,​S,​io.vertx.core.Future<T>> consumer)  
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombine​(List<io.vertx.core.Future<io.vertx.core.json.JsonObject>> futures)
      input: - List: [future1, future2, future3] output: - Future: JsonArray ( future1 -> json, future2 -> json, future3 -> json ) The workflow future1 -> (in1 -> out1) future2 -> (in2 -> out2) --> future ( [out1, out2, out3] ) future3 -> (in3 -> out3)
      static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombineArray​(io.vertx.core.json.JsonArray source, Class<T> clazz, Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> consumer)  
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombineArray​(io.vertx.core.json.JsonArray source, Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> consumer)  
      static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombineArray​(List<io.vertx.core.Future<io.vertx.core.json.JsonArray>> futures)  
      static <T> io.vertx.core.Future<List<T>> thenCombineArrayT​(List<io.vertx.core.Future<List<T>>> futures)  
      static <I,​O>
      io.vertx.core.Future<List<O>>      		 thenCombineT​(List<I> source, Function<I,​io.vertx.core.Future<O>> consumer)  
      static <T> io.vertx.core.Future<List<T>> thenCombineT​(List<io.vertx.core.Future<T>> futures)  
      static io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> thenCompress​(List<io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>>> futures)  
      static <T> io.vertx.core.Future<T> thenError​(Class<? extends io.vertx.up.exception.WebException> clazz, Object... args)
      Common usage: To error directly
      static <T> io.vertx.core.Future<T> thenErrorSigma​(Class<?> clazz, String sigma, Supplier<io.vertx.core.Future<T>> supplier)  
      static <T> T toFile​(io.vertx.ext.web.FileUpload fileUpload, Class<?> expected, Function<String,​io.vertx.core.buffer.Buffer> consumer)
      Single file upload converting
      static ConcurrentMap<String,​Set<io.vertx.ext.web.FileUpload>> toFile​(Set<io.vertx.ext.web.FileUpload> fileUploads)
      Split `Set` by fieldname
      static <T> T toFile​(Set<io.vertx.ext.web.FileUpload> fileUploads, Class<?> expected, Function<String,​io.vertx.core.buffer.Buffer> consumer)
      File upload tool to convert data
      static <T> io.vertx.core.json.JsonArray toJson​(List<T> list)  
      static <T> io.vertx.core.json.JsonArray toJson​(List<T> list, String pojo)  
      static <T> io.vertx.core.json.JsonObject toJson​(T entity)  
      static <T> io.vertx.core.json.JsonObject toJson​(T entity, String pojo)  
      static io.vertx.core.json.JsonObject toZip​(Object... args)  
      static io.vertx.up.commune.Record[] updateR​(io.vertx.up.commune.Record[] record, io.vertx.core.json.JsonArray array)  
      static io.vertx.up.commune.Record[] updateR​(io.vertx.up.commune.Record[] record, io.vertx.core.json.JsonArray array, String field)  
      static io.vertx.up.commune.Record updateR​(io.vertx.up.commune.Record record, io.vertx.core.json.JsonObject params)  
      static <T> List<T> updateT​(List<T> query, io.vertx.core.json.JsonArray params)  
      static <T> List<T> updateT​(List<T> query, io.vertx.core.json.JsonArray params, String field)  
      static <T> T updateT​(T query, io.vertx.core.json.JsonObject params)  
      static io.vertx.core.json.JsonObject whereAnd()  
      static io.vertx.core.json.JsonObject whereAnd​(String field, Object value)  
      static io.vertx.core.json.JsonObject whereDay​(io.vertx.core.json.JsonObject filters, String field, Instant instant)  
      static io.vertx.core.json.JsonObject whereDay​(io.vertx.core.json.JsonObject filters, String field, LocalDateTime instant)  
      static io.vertx.core.json.JsonObject whereKeys​(io.vertx.core.json.JsonArray keys)  
      static io.vertx.core.json.JsonObject whereKeys​(Set<String> keys)  
      static io.vertx.core.json.JsonObject whereOr()  
      static io.vertx.core.json.JsonObject whereOr​(String field, Object value)  
      static io.vertx.core.json.JsonObject whereQrA​(io.vertx.core.json.JsonObject qr, io.vertx.up.atom.Kv<String,​Object> kv)  
      static io.vertx.core.json.JsonObject whereQrA​(io.vertx.core.json.JsonObject qr, String field, Object value)  

    • Constructor Detail

      • Ux

        public Ux()

    • Method Detail

      • outBool

        public static io.vertx.core.json.JsonObject outBool​(boolean checked)

      • outBool

        public static io.vertx.core.json.JsonObject outBool​(String key,
                                                    boolean checked)

      • log

        public static io.vertx.up.fn.wait.Log log​(Class<?> clazz)
        Create new log instance for store `Annal` mapping Debug method for help us to do development 1) log: for branch log creation 2) debug: 3) otherwise: ( Business Part: Debugging )

      • debug

        public static void debug​(Object... objects)

      • debug

        public static <T> io.vertx.core.Future<T> debug​(T item)

      • updateT

        public static <T> T updateT​(T query,
                            io.vertx.core.json.JsonObject params)

      • updateT

        public static <T> List<T> updateT​(List<T> query,
                                  io.vertx.core.json.JsonArray params)

      • updateT

        public static <T> List<T> updateT​(List<T> query,
                                  io.vertx.core.json.JsonArray params,
                                  String field)

      • updateR

        public static io.vertx.up.commune.Record updateR​(io.vertx.up.commune.Record record,
                                                 io.vertx.core.json.JsonObject params)

      • updateR

        public static io.vertx.up.commune.Record[] updateR​(io.vertx.up.commune.Record[] record,
                                                   io.vertx.core.json.JsonArray array)

      • updateR

        public static io.vertx.up.commune.Record[] updateR​(io.vertx.up.commune.Record[] record,
                                                   io.vertx.core.json.JsonArray array,
                                                   String field)

      • ruleAll

        public static io.vertx.core.json.JsonObject ruleAll​(Collection<io.vertx.up.commune.rule.RuleTerm> rules,
                                                    io.vertx.core.json.JsonObject input)

      • ruleAll

        public static ConcurrentMap<Boolean,​io.vertx.core.json.JsonArray> ruleAll​(Collection<io.vertx.up.commune.rule.RuleTerm> rules,
                                                                                io.vertx.core.json.JsonArray input)

      • ruleAll

        public static io.vertx.core.json.JsonObject ruleAll​(Collection<io.vertx.up.commune.rule.RuleTerm> rules,
                                                    io.vertx.core.json.JsonObject recordO,
                                                    io.vertx.core.json.JsonObject recordN)

      • ruleAll

        public static io.vertx.core.json.JsonObject ruleAll​(Collection<io.vertx.up.commune.rule.RuleTerm> rules,
                                                    io.vertx.core.json.JsonArray source,
                                                    io.vertx.core.json.JsonObject record)

      • ruleAny

        public static io.vertx.core.json.JsonObject ruleAny​(Collection<io.vertx.up.commune.rule.RuleTerm> rules,
                                                    io.vertx.core.json.JsonObject input)

      • ruleAny

        public static io.vertx.core.json.JsonObject ruleAny​(Collection<io.vertx.up.commune.rule.RuleTerm> rules,
                                                    io.vertx.core.json.JsonObject record0,
                                                    io.vertx.core.json.JsonObject recordN)

      • ruleAny

        public static io.vertx.core.json.JsonObject ruleAny​(Collection<io.vertx.up.commune.rule.RuleTerm> rules,
                                                    io.vertx.core.json.JsonArray source,
                                                    io.vertx.core.json.JsonObject record)

      • ruleAny

        public static ConcurrentMap<Boolean,​io.vertx.core.json.JsonArray> ruleAny​(Collection<io.vertx.up.commune.rule.RuleTerm> rules,
                                                                                io.vertx.core.json.JsonArray input)

      • ruleTwins

        public static io.vertx.core.json.JsonObject ruleTwins​(io.vertx.core.json.JsonObject recordO,
                                                      io.vertx.core.json.JsonObject recordN)

      • ruleNil

        public static io.vertx.core.json.JsonObject ruleNil​(io.vertx.core.json.JsonObject twins,
                                                    io.vertx.up.eon.em.ChangeFlag flag)

      • ruleNil

        public static io.vertx.core.json.JsonObject ruleNil​(io.vertx.core.json.JsonObject recordN,
                                                    io.vertx.core.json.JsonObject recordO)

      • ruleApt

        public static io.vertx.up.atom.record.Apt ruleApt​(io.vertx.core.json.JsonArray twins,
                                                  boolean isReplaced)

      • ruleJOk

        public static boolean ruleJOk​(io.vertx.core.json.JsonObject record,
                              Set<String> fields)

      • ruleJOk

        public static boolean ruleJOk​(io.vertx.core.json.JsonObject record,
                              io.vertx.core.json.JsonArray matrix)

      • ruleJReduce

        public static io.vertx.core.json.JsonArray ruleJReduce​(io.vertx.core.json.JsonArray records,
                                                       Set<String> fields)

      • ruleJReduce

        public static io.vertx.core.json.JsonArray ruleJReduce​(io.vertx.core.json.JsonArray records,
                                                       io.vertx.core.json.JsonArray matrix)

      • ruleJEqual

        public static boolean ruleJEqual​(io.vertx.core.json.JsonObject record,
                                 io.vertx.core.json.JsonObject latest,
                                 Set<String> fields)

      • ruleJEqual

        public static boolean ruleJEqual​(io.vertx.core.json.JsonObject record,
                                 io.vertx.core.json.JsonObject latest,
                                 io.vertx.core.json.JsonArray matrix)

      • ruleJFind

        public static io.vertx.core.json.JsonObject ruleJFind​(io.vertx.core.json.JsonArray source,
                                                      io.vertx.core.json.JsonObject expected,
                                                      Set<String> fields)

      • ruleJFind

        public static io.vertx.core.json.JsonObject ruleJFind​(io.vertx.core.json.JsonArray source,
                                                      io.vertx.core.json.JsonObject expected,
                                                      io.vertx.core.json.JsonArray matrix)

      • toJson

        public static <T> io.vertx.core.json.JsonObject toJson​(T entity)

      • toJson

        public static <T> io.vertx.core.json.JsonObject toJson​(T entity,
                                                       String pojo)

      • toJson

        public static <T> io.vertx.core.json.JsonArray toJson​(List<T> list)

      • toJson

        public static <T> io.vertx.core.json.JsonArray toJson​(List<T> list,
                                                      String pojo)

      • toZip

        public static io.vertx.core.json.JsonObject toZip​(Object... args)

      • fromJson

        public static <T> T fromJson​(io.vertx.core.json.JsonObject data,
                             Class<T> clazz)

      • fromJson

        public static <T> List<T> fromJson​(io.vertx.core.json.JsonArray array,
                                   Class<T> clazz)

      • fromPage

        public static <T> List<T> fromPage​(io.vertx.core.json.JsonObject data,
                                   Class<T> clazz)

      • fromJson

        public static <T> T fromJson​(io.vertx.core.json.JsonObject data,
                             Class<T> clazz,
                             String pojo)

      • fromJson

        public static <T> List<T> fromJson​(io.vertx.core.json.JsonArray array,
                                   Class<T> clazz,
                                   String pojo)

      • criteria

        public static io.vertx.core.json.JsonObject criteria​(io.vertx.core.json.JsonObject data,
                                                     String pojo)

      • toFile

        public static <T> T toFile​(Set<io.vertx.ext.web.FileUpload> fileUploads,
                           Class<?> expected,
                           Function<String,​io.vertx.core.buffer.Buffer> consumer)
        File upload tool to convert data
        Type Parameters:
        T - Returned type for declared
        Parameters:
        fileUploads - Set of file uploads
        expected - The method declared type
        consumer - File consumer to read `filename` to Buffer
        Returns:
        T reference that converted

      • toFile

        public static <T> T toFile​(io.vertx.ext.web.FileUpload fileUpload,
                           Class<?> expected,
                           Function<String,​io.vertx.core.buffer.Buffer> consumer)
        Single file upload converting
        Type Parameters:
        T - Returned type of declared
        Parameters:
        fileUpload - The `FileUpload` reference
        expected - The method declared type
        consumer - File consumer to read `filename` to Buffer
        Returns:
        T reference that converted

      • toFile

        public static ConcurrentMap<String,​Set<io.vertx.ext.web.FileUpload>> toFile​(Set<io.vertx.ext.web.FileUpload> fileUploads)
        Split `Set` by fieldname
        Parameters:
        fileUploads - FileUpload Set
        Returns:
        Map of `field = Set`

      • fromEnvelop

        public static Envelop fromEnvelop​(Class<? extends io.vertx.up.exception.WebException> clazz,
                                  Object... args)

      • fromEnvelop

        public static <T> Envelop fromEnvelop​(T entity)

      • fromEnvelop

        public static <T> Envelop fromEnvelop​(T entity,
                                      io.vertx.up.exception.WebException error)

      • fromAsync

        public static <T> io.vertx.core.Future<T> fromAsync​(CompletionStage<T> state)

      • future

        public static <T> io.vertx.core.Future<T> future​(T entity)

      • future

        public static <T> io.vertx.core.Future<T> future​(T input,
                                                 List<Function<T,​io.vertx.core.Future<T>>> functions)

      • future

        public static <T> io.vertx.core.Future<T> future​(T input,
                                                 Set<Function<T,​io.vertx.core.Future<T>>> functions)

      • future

        public static <T> io.vertx.core.Future<T> future()

      • complex

        public static io.vertx.core.Future<io.vertx.core.json.JsonObject> complex​(io.vertx.core.json.JsonObject input,
                                                                          Predicate<io.vertx.core.json.JsonObject> predicate,
                                                                          Supplier<io.vertx.core.Future<io.vertx.core.json.JsonObject>> executor)

      • complex

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> complex​(io.vertx.up.atom.query.Pagination first,
                                                                         Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<Integer>> total,
                                                                         Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> page,
                                                                         Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> result)

      • complex

        public static Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> complex​(Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<Integer>> total,
                                                                                                                           Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> page,
                                                                                                                           Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> result)

      • complex

        public static Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> complex​(Function<io.vertx.up.atom.query.Pagination,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> page)

      • handler

        public static <T> io.vertx.core.Handler<io.vertx.core.AsyncResult<T>> handler​(io.vertx.core.eventbus.Message<Envelop> message)

      • handler

        public static <T> io.vertx.core.Future<T> handler​(Consumer<io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>> handler)

      • compare

        public static <T,​R> ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​List<T>> compare​(List<T> original,
                                                                                             List<T> current,
                                                                                             Function<T,​R> fnValue)

      • compareJ

        public static ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​io.vertx.core.json.JsonArray> compareJ​(io.vertx.core.json.JsonArray original,
                                                                                                       io.vertx.core.json.JsonArray current,
                                                                                                       Set<String> fields)

      • compareJAsync

        public static io.vertx.core.Future<ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​io.vertx.core.json.JsonArray>> compareJAsync​(io.vertx.core.json.JsonArray original,
                                                                                                                                  io.vertx.core.json.JsonArray current,
                                                                                                                                  Set<String> fields)

      • compareJ

        public static ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​io.vertx.core.json.JsonArray> compareJ​(io.vertx.core.json.JsonArray original,
                                                                                                       io.vertx.core.json.JsonArray current,
                                                                                                       io.vertx.core.json.JsonArray matrix)

      • compareJAsync

        public static io.vertx.core.Future<ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​io.vertx.core.json.JsonArray>> compareJAsync​(io.vertx.core.json.JsonArray original,
                                                                                                                                  io.vertx.core.json.JsonArray current,
                                                                                                                                  io.vertx.core.json.JsonArray matrix)

      • compareRun

        public static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> compareRun​(ConcurrentMap<io.vertx.up.eon.em.ChangeFlag,​List<T>> compared,
                                                                                Function<List<T>,​io.vertx.core.Future<List<T>>> insertAsyncFn,
                                                                                Function<List<T>,​io.vertx.core.Future<List<T>>> updateAsyncFn)

      • futureT

        public static io.vertx.core.Future<Boolean> futureT()

      • futureF

        public static io.vertx.core.Future<Boolean> futureF()

      • futureL

        public static <T> io.vertx.core.Future<List<T>> futureL()

      • futureB

        public static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureB​(boolean checked)

      • futureB

        public static io.vertx.core.Future<Boolean> futureB​(io.vertx.core.json.JsonObject checked)

      • futureJA

        public static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJA​(io.vertx.core.json.JsonArray array)

      • futureE

        public static <T> Function<Throwable,​io.vertx.core.Future<T>> futureE​(T input)

      • futureA

        public static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA​(List<T> list,
                                                                             String pojo)

      • futureA

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA()

      • futureA

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA​(Throwable ex)

      • futureA

        public static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA​(List<T> list)

      • futureA

        public static <T> Function<List<T>,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> futureA​(String pojo)

      • futureJ

        public static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ​(T entity,
                                                                              String pojo)

      • futureJM

        public static <T,​R> Function<List<R>,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> futureJM​(T entity,
                                                                                                               String field)

      • futureJ

        public static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ()

      • futureJ

        public static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ​(Throwable ex)

      • futureJ

        public static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ​(T entity)

      • futureJ

        public static <T> Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> futureJ​(String pojo)

      • futureL

        public static <T> io.vertx.core.Future<List<io.vertx.core.json.JsonObject>> futureL​(List<T> list,
                                                                                    String pojo)

      • futureLJ

        public static <T> io.vertx.core.Future<List<io.vertx.core.json.JsonObject>> futureLJ()

      • futureL

        public static <T> io.vertx.core.Future<List<io.vertx.core.json.JsonObject>> futureL​(List<T> list)

      • futureL

        public static <T> Function<List<T>,​io.vertx.core.Future<List<io.vertx.core.json.JsonObject>>> futureL​(String pojo)

      • futureJ

        public static io.vertx.core.Future<io.vertx.core.json.JsonObject> futureJ​(io.vertx.up.commune.Record record)

      • futureA

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> futureA​(io.vertx.up.commune.Record[] records)

      • futureG

        public static <T> io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> futureG​(List<T> item,
                                                                                                         String field)

      • futureG

        public static io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> futureG​(io.vertx.core.json.JsonArray item,
                                                                                                     String field)

      • futureG

        public static <T> io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> futureG​(List<T> item)

      • futureG

        public static io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> futureG​(io.vertx.core.json.JsonArray item)

      • attach

        public static <T> Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> attach​(String field,
                                                                                                                           Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> function)

      • attachJ

        public static <T> Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> attachJ​(String field,
                                                                                                                            Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> function)

      • attachJ

        public static <T> Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> attachJ​(String field,
                                                                                                io.vertx.core.json.JsonObject data)

      • pageData

        public static io.vertx.core.json.JsonObject pageData()

      • pageData

        public static io.vertx.core.json.JsonObject pageData​(io.vertx.core.json.JsonArray data,
                                                     long size)

      • pageData

        public static io.vertx.core.json.JsonArray pageData​(io.vertx.core.json.JsonObject data)

      • pageData

        public static io.vertx.core.json.JsonObject pageData​(io.vertx.core.json.JsonObject pageData,
                                                     Function<io.vertx.core.json.JsonArray,​io.vertx.core.json.JsonArray> function)

      • thenCombine

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombine​(io.vertx.core.Future<io.vertx.core.json.JsonArray> source,
                                                                             Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> generateFun,
                                                                             BinaryOperator<io.vertx.core.json.JsonObject> operatorFun)
        Future async specific workflow for combine future here. For example: ```shell // 
        
 --------> generateFun ( Supplier )     operatorFun ( BiConsumer )
 --------> json1 -> ? future  ->  operatorFun[0] -> (json1, out1) -> merged1
 jarray -> json2 -> ? future  ->  operatorFun[1] -> (json2, out2) -> merged2  -> merged ( Future )
 --------> json3 -> ? future  ->  operatorFun[2] -> (json3, out3) -> merged3
 //
        ```
        Parameters:
        source - The first query result of list
        generateFun - (json) -> future(out) ( each record )
        operatorFun - (json, out) -> merged
        Returns:
        It often used in secondary select in database here

      • thenCombine

        public static io.vertx.core.Future<io.vertx.core.json.JsonObject> thenCombine​(io.vertx.core.json.JsonObject source,
                                                                              Function<io.vertx.core.json.JsonObject,​List<io.vertx.core.Future>> generateFun,
                                                                              BiConsumer<io.vertx.core.json.JsonObject,​io.vertx.core.json.JsonObject>... operatorFun)
        The workflow ------> generateFun ( Supplier ) operatorFun ( BiConsumer ) ------> future1 ( json -> ? future ) -> operatorFun[0] -> (json, out1) -> merged1 -> json -> future2 ( json -> ? future ) -> operatorFun[1] -> (json, out2) -> merged2 -> merged ------> future3 ( json -> ? future ) -> operatorFun[2] -> (json, out3) -> merged3 ->
        Parameters:
        source - The input json object
        generateFun - The json object should generate list, each future should be json object
        operatorFun - merged the result to json object instead of other
        Returns:
        The final result of future

      • thenCombine

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombine​(List<io.vertx.core.Future<io.vertx.core.json.JsonObject>> futures)
        input: - List: [future1, future2, future3] output: - Future: JsonArray ( future1 -> json, future2 -> json, future3 -> json ) The workflow future1 -> (in1 -> out1) future2 -> (in2 -> out2) --> future ( [out1, out2, out3] ) future3 -> (in3 -> out3)
        Parameters:
        futures - The list of futures
        Returns:
        The final result of futures

      • thenCombine

        public static <F,​S,​T> io.vertx.core.Future<T> thenCombine​(Supplier<io.vertx.core.Future<F>> futureF,
                                                                      Supplier<io.vertx.core.Future<S>> futureS,
                                                                      BiFunction<F,​S,​io.vertx.core.Future<T>> consumer)

      • thenCombine

        public static <F,​S,​T> io.vertx.core.Future<T> thenCombine​(io.vertx.core.Future<F> futureF,
                                                                      io.vertx.core.Future<S> futureS,
                                                                      BiFunction<F,​S,​io.vertx.core.Future<T>> consumer)

      • thenCombine

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombine​(io.vertx.core.json.JsonArray input,
                                                                             Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonObject>> function)

      • thenCombineT

        public static <T> io.vertx.core.Future<List<T>> thenCombineT​(List<io.vertx.core.Future<T>> futures)

      • thenCombineT

        public static <I,​O> io.vertx.core.Future<List<O>> thenCombineT​(List<I> source,
                                                                     Function<I,​io.vertx.core.Future<O>> consumer)

      • thenCombine

        public static <K,​T> io.vertx.core.Future<ConcurrentMap<K,​T>> thenCombine​(ConcurrentMap<K,​io.vertx.core.Future<T>> futureMap)

      • thenCombineArray

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombineArray​(List<io.vertx.core.Future<io.vertx.core.json.JsonArray>> futures)

      • thenCombineArray

        public static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombineArray​(io.vertx.core.json.JsonArray source,
                                                                                  Function<io.vertx.core.json.JsonObject,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> consumer)

      • thenCombineArray

        public static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombineArray​(io.vertx.core.json.JsonArray source,
                                                                                      Class<T> clazz,
                                                                                      Function<T,​io.vertx.core.Future<io.vertx.core.json.JsonArray>> consumer)

      • thenCombineArrayT

        public static <T> io.vertx.core.Future<List<T>> thenCombineArrayT​(List<io.vertx.core.Future<List<T>>> futures)

      • thenCompress

        public static io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> thenCompress​(List<io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>>> futures)

      • thenError

        public static <T> io.vertx.core.Future<T> thenError​(Class<? extends io.vertx.up.exception.WebException> clazz,
                                                    Object... args)
        Common usage: To error directly
        Parameters:
        clazz - The type of WebException, class type, it will be created by reflection.
        args - The rule - arg0: this.getClass(), Because all the first arg of WebException must be clazz here. - argX: the arguments of WebException constructor here, instead of fixed arguments.

      • thenErrorSigma

        public static <T> io.vertx.core.Future<T> thenErrorSigma​(Class<?> clazz,
                                                         String sigma,
                                                         Supplier<io.vertx.core.Future<T>> supplier)

      • whereDay

        public static io.vertx.core.json.JsonObject whereDay​(io.vertx.core.json.JsonObject filters,
                                                     String field,
                                                     Instant instant)

      • whereDay

        public static io.vertx.core.json.JsonObject whereDay​(io.vertx.core.json.JsonObject filters,
                                                     String field,
                                                     LocalDateTime instant)

      • whereKeys

        public static io.vertx.core.json.JsonObject whereKeys​(Set<String> keys)

      • whereKeys

        public static io.vertx.core.json.JsonObject whereKeys​(io.vertx.core.json.JsonArray keys)

      • whereAnd

        public static io.vertx.core.json.JsonObject whereAnd()

      • whereAnd

        public static io.vertx.core.json.JsonObject whereAnd​(String field,
                                                     Object value)

      • whereOr

        public static io.vertx.core.json.JsonObject whereOr()

      • whereOr

        public static io.vertx.core.json.JsonObject whereOr​(String field,
                                                    Object value)

      • whereQrA

        public static io.vertx.core.json.JsonObject whereQrA​(io.vertx.core.json.JsonObject qr,
                                                     io.vertx.up.atom.Kv<String,​Object> kv)

      • whereQrA

        public static io.vertx.core.json.JsonObject whereQrA​(io.vertx.core.json.JsonObject qr,
                                                     String field,
                                                     Object value)

      • getArray

        public static io.vertx.core.json.JsonArray getArray​(Envelop envelop,
                                                    int index)

      • getArray

        public static io.vertx.core.json.JsonArray getArray​(Envelop envelop)

      • getArray1

        public static io.vertx.core.json.JsonArray getArray1​(Envelop envelop)

      • getArray2

        public static io.vertx.core.json.JsonArray getArray2​(Envelop envelop)

      • getString

        public static String getString​(Envelop envelop,
                               int index)

      • getString

        public static String getString​(Envelop envelop)

      • getString1

        public static String getString1​(Envelop envelop)

      • getString2

        public static String getString2​(Envelop envelop)

      • getVis

        public static io.vertx.up.atom.secure.Vis getVis​(Envelop envelop,
                                                 int index)

      • getVis

        public static io.vertx.up.atom.secure.Vis getVis​(Envelop envelop)

      • getVis1

        public static io.vertx.up.atom.secure.Vis getVis1​(Envelop envelop)

      • getVis2

        public static io.vertx.up.atom.secure.Vis getVis2​(Envelop envelop)

      • getJson

        public static io.vertx.core.json.JsonObject getJson​(Envelop envelop,
                                                    int index)

      • fromEnvelop

        public static <T> T fromEnvelop​(Envelop envelop,
                                Class<T> clazz,
                                String pojo)

      • fromEnvelop

        public static io.vertx.core.json.JsonObject fromEnvelop​(Envelop envelop,
                                                        String pojo)

      • getJson

        public static io.vertx.core.json.JsonObject getJson​(Envelop envelop)

      • fromEnvelop1

        public static <T> T fromEnvelop1​(Envelop envelop,
                                 Class<T> clazz,
                                 String pojo)

      • fromEnvelop1

        public static io.vertx.core.json.JsonObject fromEnvelop1​(Envelop envelop,
                                                         String pojo)

      • getJson1

        public static io.vertx.core.json.JsonObject getJson1​(Envelop envelop)

      • getJson2

        public static io.vertx.core.json.JsonObject getJson2​(Envelop envelop)

      • fromEnvelop2

        public static io.vertx.core.json.JsonObject fromEnvelop2​(Envelop envelop,
                                                         String pojo)

      • fromEnvelop2

        public static <T> T fromEnvelop2​(Envelop envelop,
                                 Class<T> clazz,
                                 String pojo)

      • getInteger

        public static Integer getInteger​(Envelop envelop,
                                 int index)

      • getInteger1

        public static Integer getInteger1​(Envelop envelop)

      • getInteger2

        public static Integer getInteger2​(Envelop envelop)

      • getLong

        public static Long getLong​(Envelop envelop,
                           int index)

      • getLong

        public static Long getLong​(Envelop envelop)

      • getLong1

        public static Long getLong1​(Envelop envelop)

      • getLong2

        public static Long getLong2​(Envelop envelop)

      • getT

        public static <T> T getT​(Envelop envelop,
                         int index,
                         Class<T> clazz)

      • getT

        public static <T> T getT​(Envelop envelop,
                         Class<T> clazz)

      • getT1

        public static <T> T getT1​(Envelop envelop,
                          Class<T> clazz)

      • getT2

        public static <T> T getT2​(Envelop envelop,
                          Class<T> clazz)

      • getBody

        public static io.vertx.core.json.JsonObject getBody​(Envelop envelop)

      • getBodyT

        public static <T> T getBodyT​(Envelop envelop,
                             Class<T> clazz)

      • nativeInit

        public static io.vertx.core.Future<Boolean> nativeInit​(io.vertx.core.json.JsonArray components,
                                                       io.vertx.core.Vertx vertx)
        This method will be configured in `vertx-extension.yml` file in common situation, The file content should be as following: ```yml // 
        
 init:
   - component: "[ComponentName1]"
   - component: "[ComponentName2]"
 //
        ``` All components here will be called when container starting, the component must declare the init method as ```java // 
        
 public static void init(){
     // Here are initialize code logical
     Ke.banner("「Εκδήλωση」- Crud ( Ix )");

     Ix.infoInit(LOGGER, "IxConfiguration...");
 }
 //
        ``` This method should be used when you want to develop zero extension module for business requirement.
        Parameters:
        init - The configuration data came from `init` node in file

      • nativeVertx

        public static io.vertx.core.Vertx nativeVertx()

      • nativeWorker

        public static io.vertx.core.WorkerExecutor nativeWorker​(String name)

      • nativeWorker

        public static io.vertx.core.WorkerExecutor nativeWorker​(String name,
                                                        Integer minutes)

      • dictEpsilon

        public static ConcurrentMap<String,​io.vertx.up.commune.exchange.DiConsumer> dictEpsilon​(io.vertx.core.json.JsonObject epsilon)

      • dictCalc

        public static io.vertx.core.Future<ConcurrentMap<String,​io.vertx.core.json.JsonArray>> dictCalc​(io.vertx.up.commune.exchange.DiSetting dict,
                                                                                                      io.vertx.core.MultiMap paramsMap)

      • dictTo

        public static <T> io.vertx.core.Future<T> dictTo​(T record,
                                                 io.vertx.up.commune.exchange.DiFabric fabric)

      • keyUser

        public static String keyUser​(io.vertx.ext.auth.User user)