Ux (( Vertx Core ) vertx-up: Core Engine 0.6.2 API)

java.lang.Object
- io.vertx.up.unity.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 and 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.Mongo`
`static class`	`Ux.Opt`
`static class`	`Ux.Pool`

Constructor Summary

Constructors
Constructor and Description

Ux()

Constructors
Constructor and Description
`Ux()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`applyBool(Boolean result)`
`static <T> Function<io.vertx.core.json.JsonObject,io.vertx.core.Future<io.vertx.core.json.JsonObject>>`	`applyMount(String field, Function<T,io.vertx.core.Future<io.vertx.core.json.JsonObject>> function)`
`static <T> Function<io.vertx.core.json.JsonObject,io.vertx.core.Future<io.vertx.core.json.JsonObject>>`	`applyMountJson(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 mergedPojo)`
`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.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 io.vertx.core.json.JsonObject`	`criteria(io.vertx.core.json.JsonObject data, String pojo)`
`static void`	`debug(Object... objects)`
`static <T> io.vertx.core.Future<T>`	`debug(T item)`
`static <T> T`	`debug(Throwable error, Supplier<T> supplier)`
`static io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>>`	`dictCalc(io.vertx.up.commune.exchange.DictConfig dict, io.vertx.core.MultiMap paramsMap)`
`static ConcurrentMap<String,io.vertx.up.commune.exchange.DictEpsilon>`	`dictEpsilon(io.vertx.core.json.JsonObject epsilon)`
`static <T> io.vertx.core.Future<T>`	`dictTo(T record, io.vertx.up.commune.exchange.DictFabric fabric)`
`static Envelop`	`fromEnvelop(Class<? extends io.vertx.up.exception.WebException> clazz, Object... args)`
`static <T> T`	`fromEnvelop(Envelop envelop, Class<T> clazz, String pojo)`
`static io.vertx.core.json.JsonObject`	`fromEnvelop(Envelop envelop, String pojo)`
`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> 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 <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.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> 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<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 <T> io.vertx.core.Future<io.vertx.core.json.JsonObject>`	`futureJ(T entity)`
`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, String pojo)`
`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<io.vertx.core.json.JsonObject>>`	`futureL()`
`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> Function<List<T>,io.vertx.core.Future<List<io.vertx.core.json.JsonObject>>>`	`futureL(String pojo)`
`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, Class<T> clazz)`
`static <T> T`	`getT(Envelop envelop, int index, Class<T> clazz)`
`static <T> T`	`getT1(Envelop envelop, Class<T> clazz)`
`static <T> T`	`getT2(Envelop envelop, Class<T> clazz)`
`static <T> io.vertx.core.Future<T>`	`handler(Consumer<io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>> handler)`
`static <T> io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>`	`handler(io.vertx.core.eventbus.Message<Envelop> message)`
`static io.vertx.up.fn.wait.Log`	`log(Class<?> clazz)` Create new log instance for store `Annal` mapping
`static void`	`nativeInit(io.vertx.core.json.JsonObject init)` This method will be configured in `vertx-extension.yml` file in common situation, The file content should be as following:
`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 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 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`	`ruleNil(io.vertx.core.json.JsonObject recordN, io.vertx.core.json.JsonObject recordO)`
`static io.vertx.core.json.JsonObject`	`ruleTwins(io.vertx.core.json.JsonObject recordO, io.vertx.core.json.JsonObject recordN)`
`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(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 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 <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 <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 <T> io.vertx.core.Future<List<T>>`	`thenCombineT(List<io.vertx.core.Future<T>> futures)`
`static <I,O> io.vertx.core.Future<List<O>>`	`thenCombineT(List<I> source, Function<I,io.vertx.core.Future<O>> consumer)`
`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<FileUpload>` 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.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`	`whereOr()`
`static io.vertx.core.json.JsonObject`	`whereOr(String field, Object value)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- Ux
```
public Ux()
```

Method Detail

log
```
public static io.vertx.up.fn.wait.Log log(Class<?> clazz)
```
Create new log instance for store Annal mapping

Parameters:

clazz - The logger target that contains Annal

Returns:

the instance of io.vertx.up.fn.wait.Log

debug

public static void debug(Object... objects)

debug

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

debug

public static <T> T debug(Throwable error,
                          Supplier<T> supplier)

otherwise

public static Function<Throwable,Envelop> otherwise()

otherwise

public static <T> Function<Throwable,T> otherwise(Supplier<T> supplier)

otherwise

public static <T> Function<Throwable,T> otherwise(T input)

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)

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)

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<FileUpload> by fieldname

Parameters:: fileUploads - FileUpload Set
Returns:: Map of field = Set<FileUpload>

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)

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,
                                                                                 String mergedPojo)

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)

futureE

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

futureE

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

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)

futureL

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

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)

applyMount

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

applyMountJson

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

applyBool

public static io.vertx.core.Future<io.vertx.core.json.JsonObject> applyBool(Boolean result)

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:

// <pre><code>
--------> generateFun ( Supplier )     operatorFun ( BiConsumer )
--------> json1 -> ? future<out1>  ->  operatorFun[0] -> (json1, out1) -> merged1
jarray -> json2 -> ? future<out2>  ->  operatorFun[1] -> (json2, out2) -> merged2  -> merged ( Future<JsonArray> )
--------> json3 -> ? future<out3>  ->  operatorFun[2] -> (json3, out3) -> merged3
// </code></pre>

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)

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)

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)

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)

getInteger

public static Integer getInteger(Envelop envelop)

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

    Ix.infoInit(LOGGER, "IxConfiguration...");
}
// </code></pre>
```
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.DictEpsilon> 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.DictConfig dict,
                                                                                                io.vertx.core.MultiMap paramsMap)

dictTo

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

Class Ux

「Kt」Utility X Component in zero

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Ux

Method Detail

log

debug

debug

debug

otherwise

otherwise

otherwise

ruleAll

ruleAll

ruleAll

ruleAll

ruleAny

ruleAny

ruleAny

ruleAny

ruleTwins

ruleNil

ruleNil

ruleApt

toJson

toJson

toJson

toJson

toZip

fromJson

fromJson

fromJson

fromJson

criteria

toFile

toFile

toFile

fromEnvelop

fromEnvelop

fromEnvelop

future

future

future

future

complex

complex

complex

complex

handler

handler

compare

compare

futureE

futureE

futureA

futureA

futureA

futureA

futureA

futureJ

futureJM

futureJ

futureJ

futureJ

futureJ

futureL

futureL

futureL

futureL

futureJ

futureA

futureG

futureG

futureG

futureG

applyMount