io.vertx.up.unity

Class Ux

java.lang.Object

io.vertx.up.unity.Ux

public final class Ux
extends Object

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()

Method Summary

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> io.vertx.core.Future<io.vertx.core.json.JsonObject>	applyRpc(String name, String address, io.vertx.core.json.JsonObject params)
static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject>	applyRpc(String name, String address, String field, Object value)
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 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 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.config.Dict dict, io.vertx.core.MultiMap paramsMap)
static ConcurrentMap<String,io.vertx.up.commune.config.DictEpsilon>	dictEpsilon(io.vertx.core.json.JsonObject epsilon)
static Envelop	envelop(Class<? extends io.vertx.up.exception.WebException> clazz, Object... args)
static <T> Envelop	envelop(T entity)
static <T> Envelop	envelop(T entity, io.vertx.up.exception.WebException error)
static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray>	fnJArray(List<T> item)
static io.vertx.core.Future<io.vertx.core.json.JsonArray>	fnJArray(io.vertx.up.commune.Record[] records)
static <T> Function<List<T>,io.vertx.core.Future<io.vertx.core.json.JsonArray>>	fnJArray(String pojo)
static <T> io.vertx.core.Future<List<io.vertx.core.json.JsonObject>>	fnJList(List<T> item)
static <T> Function<List<T>,io.vertx.core.Future<List<io.vertx.core.json.JsonObject>>>	fnJList(String pojo)
static io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>>	fnJMap(io.vertx.core.json.JsonArray item, String field)
static <T> io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>>	fnJMap(List<T> item, String field)
static io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>>	fnJMapType(io.vertx.core.json.JsonArray item)
static <T> io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>>	fnJMapType(List<T> item)
static io.vertx.core.Future<io.vertx.core.json.JsonObject>	fnJObject(io.vertx.up.commune.Record record)
static <T> Function<T,io.vertx.core.Future<io.vertx.core.json.JsonObject>>	fnJObject(String pojo)
static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject>	fnJObject(T item)
static io.vertx.core.Future<io.vertx.core.json.JsonObject>	fnRpc(io.vertx.core.json.JsonArray array)
static io.vertx.core.Future<io.vertx.core.json.JsonArray>	fnRpc(io.vertx.core.json.JsonObject data)
static <T> T	fromEnvelop(Envelop envelop, Class<T> clazz, String pojo)
static io.vertx.core.json.JsonObject	fromEnvelop(Envelop envelop, String pojo)
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 io.vertx.core.json.JsonObject	fromJson(io.vertx.core.json.JsonObject data, 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 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.JsonArray	getArray3(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.Handler<io.vertx.core.AsyncResult<T>>	handler(io.vertx.core.eventbus.Message<Envelop> message)
static void	initComponent(io.vertx.core.json.JsonObject init)
static io.vertx.up.fn.wait.Log	log(Class<?> clazz)
static Function<Throwable,Envelop>	otherwise()
static <T> Function<Throwable,T>	otherwise(Supplier<T> supplier)
static <T> io.vertx.core.Future<ConcurrentMap<String,T>>	thenCombine(ConcurrentMap<String,io.vertx.core.Future<T>> futureMap)
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)
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)
static io.vertx.core.Future<io.vertx.core.json.JsonArray>	thenCombine(List<io.vertx.core.Future<io.vertx.core.json.JsonObject>> futures)
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 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> io.vertx.core.json.JsonArray	toArray(List<T> list)
static <T> io.vertx.core.json.JsonArray	toArray(List<T> list, String pojo)
static io.vertx.core.json.JsonArray	toArray(io.vertx.up.commune.Record[] records)
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	toToggle(Object... args)
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)

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)

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)

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)

toToggle

public static io.vertx.core.json.JsonObject toToggle(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)

fromJson

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

toArray

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

toArray

public static io.vertx.core.json.JsonArray toArray(io.vertx.up.commune.Record[] records)

toArray

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

envelop

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

envelop

public static <T> Envelop envelop(T entity)

envelop

public static <T> Envelop envelop(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()

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)

handler

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

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)

fnRpc

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

fnRpc

public static io.vertx.core.Future<io.vertx.core.json.JsonArray> fnRpc(io.vertx.core.json.JsonObject data)

fnJObject

public static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> fnJObject(T item)

fnJArray

public static <T> io.vertx.core.Future<io.vertx.core.json.JsonArray> fnJArray(List<T> item)

fnJList

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

fnJArray

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

fnJObject

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

fnJObject

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

fnJArray

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

fnJList

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

fnJMap

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

fnJMap

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

fnJMapType

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

fnJMapType

public static io.vertx.core.Future<ConcurrentMap<String,io.vertx.core.json.JsonArray>> fnJMapType(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)

applyRpc

public static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> applyRpc(String name,
                                                                               String address,
                                                                               io.vertx.core.json.JsonObject params)

applyRpc

public static <T> io.vertx.core.Future<io.vertx.core.json.JsonObject> applyRpc(String name,
                                                                               String address,
                                                                               String field,
                                                                               Object value)

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)

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 The workflow --------> generateFun ( Supplier ) operatorFun ( BiConsumer ) --------> json1 -> ? future -> operatorFun[0] -> (json1, out1) -> merged1 jarray -> json2 -> ? future -> operatorFun[1] -> (json2, out2) -> merged2 -> merged --------> json3 -> ? future -> operatorFun[2] -> (json3, out3) -> merged3

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)

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 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 ->

thenCombine

public static io.vertx.core.Future<io.vertx.core.json.JsonArray> thenCombine(List<io.vertx.core.Future<io.vertx.core.json.JsonObject>> futures)

Parameters:

futures - The list of futures

Returns:

The final result of 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)

thenCombineT

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

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)

thenCombine

public static <T> io.vertx.core.Future<ConcurrentMap<String,T>> thenCombine(ConcurrentMap<String,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)

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)

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)

getArray3

public static io.vertx.core.json.JsonArray getArray3(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)

initComponent

public static void initComponent(io.vertx.core.json.JsonObject init)

dictEpsilon

public static ConcurrentMap<String,io.vertx.up.commune.config.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.config.Dict dict,
                                                                                                io.vertx.core.MultiMap paramsMap)