Lang (Java Tool 1.26.2 API)

java.lang.Object
- org.osgl.Lang

All Implemented Interfaces:

Serializable

Direct Known Subclasses:

$, Osgl
```
public class Lang
extends Object
implements Serializable
```
Osgl is the umbrella namespace aggregates core utilities of OSGL toolkit:
- Function interfaces and base implementations
- currying utilities
- Tuple and multi-elements tupbles
- Option
- core utilities like ts()
- predefined functions aggregated in the F namespace
More about function interface

Under Osgl, there are six function interfaces defined, from Func0 to Func5, where the last digit means the number of parameters the function is applied to. For example, the apply method of Func0 takes no parameter while that of Func2 takes two parameters. All these function interfaces are defined with generic type parameters, corresponding to the type of all parameters and that of the return value. For procedure (a function that does not return anything), the user application could use Void as the return value type, and return null in the apply method implementation.

For each function interface, OSGL provide a base class, from F0 to F5. Within the base class, OSGL implement several utility methods, including
- currying methods, returns function takes fewer parameter with given parameter specified
- chain, returns composed function with a function takes the result of this function
- andThen, returns composed function with an array of same signature functions
- breakOut, short cut the function execution sequence by throwing out a Lang.Break instance
Usually user application should define their function implementation by extending the base class in order to benefit from the utility methods; however in certain cases, e.g. a function implementation already extends another base class, user implementation cannot extends the base function class, OSGL provides easy way to convert user’s implementation to corresponding base class implementation, here is one example of how to do it:
```
  void foo(Func2<Integer, String> f) {  F2<Integer, String> newF = f2(f);  newF.chain(…);  …  } 
```
Dumb functions, for certain case where a dumb function is needed, OSGL defines dumb function instances for each function interface, say, from F0 to F5. Note the name of the dumb function instance is the same as the name of the base function class. But they belong to different concept, class and instance, so there is no conflict in the code. For each dumb function instance, a corresponding type safe version is provided, f0() to f5(), this is the same case of java.util.Collections.EMPTY_LIST and java.util.Collections.emptyList()

Utility methods
Version:

0.8

Author:

Gelin Luo

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Lang._ConvertStage<FROM>`
`static class`	`Lang._IsClass`
`static class`	`Lang._IsModifier`
`static class`	`Lang._IsReflectMember`
`static class`	`Lang._MappingStage` A stage of object for mapping operation
`static interface`	`Lang.Bijection<X,Y>` See http://en.wikipedia.org/wiki/Bijection.
`static class`	`Lang.Binary<LEFT,RIGHT>` Alias of `Lang.Tuple`
`static class`	`Lang.Break` A Break is used to shortcut a sequence of function executions
`static class`	`Lang.Comparator<T>` Adapt JDK Comparator (since 1.2) to Functional programming.
`static class`	`Lang.Conf` Namespace to configure or extend OSGL _ utilities
`static class`	`Lang.F` The namespace to aggregate predefined core functions
`static class`	`Lang.F0<R>` Default implementation for `Lang.Func0`.
`static class`	`Lang.F1<P1,R>` Base implementation of `Lang.Function` function.
`static class`	`Lang.F2<P1,P2,R>` Base implementation of `Lang.Func2` function.
`static class`	`Lang.F3<P1,P2,P3,R>` Base implementation of `Lang.Func3` function.
`static class`	`Lang.F4<P1,P2,P3,P4,R>` Base implementation of `Lang.Func4` function.
`static class`	`Lang.F5<P1,P2,P3,P4,P5,R>` Base implementation of `Lang.Func5` function.
`static class`	`Lang.Factory<T>` The class adapt traditional Factory to Function
`static interface`	`Lang.Func0<R>` Define a function that apply to no parameter (strictly this is not a function)
`static interface`	`Lang.Func1<P1,R>` Alias of `Lang.Function`
`static interface`	`Lang.Func2<P1,P2,R>` Define a function structure that accept two parameter
`static interface`	`Lang.Func3<P1,P2,P3,R>` Define a function structure that accept three parameter
`static interface`	`Lang.Func4<P1,P2,P3,P4,R>` Define a function structure that accept four parameter
`static interface`	`Lang.Func5<P1,P2,P3,P4,P5,R>` Define a function structure that accept five parameter
`static class`	`Lang.FuncBase` The base for all Fx function class implemention
`static interface`	`Lang.Function<T,U>` Define a function structure that accept one parameter.
`static class`	`Lang.IndexedVisitor<K,T>` An `IndexedVisitor` provide a tool to iterate through a Map or indexed list by passing the key/index and the value to the function.
`static class`	`Lang.Meta<T>`
`static interface`	`Lang.MultiplicableFunction<P1,R>` A `Lang.Function` function that support `Lang.MultiplicableFunction.times(int)` operation
`static class`	`Lang.None<T>`
`static class`	`Lang.Operator<T>`
`static class`	`Lang.Option<T>` Defines an option of element `T`.
`static class`	`Lang.Pair<LEFT,RIGHT>` Alias of `Lang.Binary`
`static class`	`Lang.Predicate<T>` `Predicate` is a predefined `Function<Boolean, T>` typed function with a set of utilities dealing with boolean operations.
`static class`	`Lang.Processor<T>` Define a processor function which applied to one parameter and return the parameter instance after processing on the parameter
`static class`	`Lang.Producer<PRODUCT>` A Producer is a provider that `Lang.Producer.produce()` product
`static class`	`Lang.Provider<ELEMENT>` A Provider is a function that apply to nothing and return an element
`static class`	`Lang.Quadruple<A,B,C,D>`
`static class`	`Lang.Quintuple<A,B,C,D,E>`
`static class`	`Lang.Some<T>`
`static class`	`Lang.T2<A,B>` Alias of `Lang.Pair`
`static class`	`Lang.T3<A,B,C>`
`static class`	`Lang.T4<A,B,C,D>`
`static class`	`Lang.T5<A,B,C,D,E>`
`static class`	`Lang.Transformer<FROM,TO>` A Transformer is literally a kind of `Lang.F1` function
`static class`	`Lang.Triple<A,B,C>` A tuple with three elements
`static class`	`Lang.Tuple<A,B>`
`static class`	`Lang.TypeConverter<FROM,TO>` A `TypeConverter` is a `Lang.Transformer` that convert a type to another
`static class`	`Lang.V1<P1>`
`static class`	`Lang.V2<P1,P2>`
`static class`	`Lang.V3<P1,P2,P3>`
`static class`	`Lang.V4<P1,P2,P3,P4>`
`static class`	`Lang.V5<P1,P2,P3,P4,P5>`
`static class`	`Lang.Val<T>`
`static class`	`Lang.Var<T>`
`static class`	`Lang.Visitor<T>` Define a visitor (known as Consumer in java 8) function which applied to one parameter and without return type

Field Summary

Fields
Modifier and Type	Field and Description
`static Lang.Break`	`BREAK` A predefined Break instance without payload
`static Lang.Conf`	`conf`
`static Object`	`DUMB` A dumb object instance
`static Lang.F0`	`F0` A dumb function for `Lang.Func0` that does nothing and return `null`
`static Lang.F1`	`F1` A dumb `Lang.Function` implementation that does nothing and return null
`static Lang.F2`	`F2` A dumb `Lang.Func2` implementation that does nothing and return null
`static Lang.F3`	`F3` A dumb `Lang.Func3` implementation that does nothing and return null
`static Lang.F4`	`F4` A dumb `Lang.Func4` implementation that does nothing and return null
`static Lang.F5`	`F5` A dumb `Lang.Func5` implementation that does nothing and return null
`static Lang`	`INSTANCE`
`static boolean`	`IS_64`
`static boolean`	`IS_SERVER`
`static int`	`JAVA_VERSION`
`static Lang.None`	`NONE`
`static OS`	`OS`
`static PropertyHandlerFactory`	`propertyHandlerFactory`
`static osgl.version.Version`	`VERSION`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Lang()

Constructors
Modifier	Constructor and Description
`protected`	`Lang()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static boolean`	`allNull(Object o, Object... oa)` Check if all objects in the parameter list is null
`static Set<Class>`	`allTypesOf(Class<?> type)` Returns all types that
`static boolean`	`anyNull(Object o, Object... oa)` Check if any objects in the parameter list is null
`static <T extends Enum<T>> T`	`asEnum(Class<T> enumClass, String name)` Return an enum value from code
`static <T extends Enum<T>> T`	`asEnum(Class<T> enumClass, String name, boolean exactMatch)` Return an enum value from code
`static Boolean[]`	`asObject(boolean[] pa)`
`static Byte[]`	`asObject(byte[] pa)`
`static Character[]`	`asObject(char[] pa)`
`static Double[]`	`asObject(double[] pa)`
`static Float[]`	`asObject(float[] pa)`
`static Integer[]`	`asObject(int[] pa)`
`static Long[]`	`asObject(long[] pa)`
`static Short[]`	`asObject(short[] pa)`
`static boolean[]`	`asPrimitive(Boolean[] oa)`
`static byte[]`	`asPrimitive(Byte[] oa)`
`static char[]`	`asPrimitive(Character[] oa)`
`static double[]`	`asPrimitive(Double[] oa)`
`static float[]`	`asPrimitive(Float[] oa)`
`static int[]`	`asPrimitive(Integer[] oa)`
`static long[]`	`asPrimitive(Long[] oa)`
`static short[]`	`asPrimitive(Short[] oa)`
`static <T> Future<T>`	`async(Lang.F0<T> callback, int milliseconds)` Execute callback asynchronously after delay specified
`static <A,B> Lang.T2<A,B>`	`Binary(A a, B b)`
`static boolean`	`bool(BigDecimal v)` Do bool evaluation on a BigDecimal value
`static boolean`	`bool(BigInteger v)` Do bool evaluation on a BigInteger value
`static boolean`	`bool(boolean v)`
`static boolean`	`bool(byte v)` Do bool evaluation on a byte value
`static boolean`	`bool(char v)` Do bool evaluation on a char value
`static boolean`	`bool(Collection<?> c)` Do bool evaluation on a collection.
`static boolean`	`bool(double v)` Do bool evaluation on a double value
`static boolean`	`bool(File v)` Do bool evaluation on a File instance.
`static boolean`	`bool(float v)` Do bool evaluation on a float value
`static boolean`	`bool(int v)` Do bool evaluation on a int value
`static boolean`	`bool(Lang.Func0<?> v)` Do bool evaluation on an `Lang.Func0` instance.
`static boolean`	`bool(long v)` Do bool evaluation on a long value
`static boolean`	`bool(Map<?,?> m)` Do bool evaluation on a map.
`static boolean`	`bool(Object v)` Evaluate an object’s bool value.
`static boolean`	`bool(String s)` Do bool evaluation on a String.
`static <T> Lang.Break`	`breakOut(T e)` A utility method to throw out a Break with payload
`static <T> T`	`cast(Object o)`
`static <T> Lang.Option<T>`	`cast(Object o, Class<T> c)` Cast an object to a type.
`static <T> Class<T>`	`classForName(String className)`
`static <T> Class<T>`	`classForName(String className, ClassLoader classLoader)`
`static Lang._MappingStage`	`clone(Object source)` Prepare a `DataMapper.Semantic.DEEP_COPY` from `source` to an new instance with the same time of `source`
`static boolean[]`	`cloneOf(boolean[] array)`
`static byte[]`	`cloneOf(byte[] array)`
`static char[]`	`cloneOf(char[] array)`
`static double[]`	`cloneOf(double[] array)`
`static float[]`	`cloneOf(float[] array)`
`static int[]`	`cloneOf(int[] array)`
`static long[]`	`cloneOf(long[] array)`
`static short[]`	`cloneOf(short[] array)`
`static String[]`	`cloneOf(String[] array)`
`static <T> T`	`cloneOf(T source)` Returns clone of a given `source` object.
`static <T> T`	`cloneOf(T source, Lang.Function<Class,?> instanceFactory)` Returns clone of a given `source` object.
`static Class<?>`	`commonSuperTypeOf(Collection<?> objects)`
`static Class<?>`	`commonSuperTypeOf(Object o1, Object o2, Object... others)`
`static <T> Lang.Comparator<T>`	`comparator(Comparator<? super T> c)` Adapt a jdk `Comparator` into `osgl Comparator`
`static <T> Lang.Comparator<T>`	`comparator(Lang.Func2<? super T,? super T,Integer> f)` Adapt a general `Lang.Func2` function with (T, T, Integer) type into `Comparator`
`static boolean[]`	`concat(boolean[] a1, boolean[] a2)`
`static boolean[]`	`concat(boolean[] a1, boolean[] a2, boolean[]... rest)`
`static byte[]`	`concat(byte[] a1, byte[] a2)`
`static byte[]`	`concat(byte[] a1, byte[] a2, byte[]... rest)`
`static char[]`	`concat(char[] a1, char[] a2)`
`static char[]`	`concat(char[] a1, char[] a2, char[]... rest)`
`static double[]`	`concat(double[] a1, double[] a2)`
`static double[]`	`concat(double[] a1, double[] a2, double[]... rest)`
`static float[]`	`concat(float[] a1, float[] a2)`
`static float[]`	`concat(float[] a1, float[] a2, float[]... rest)`
`static int[]`	`concat(int[] a1, int[] a2)`
`static int[]`	`concat(int[] a1, int[] a2, int[]... rest)`
`static long[]`	`concat(long[] a1, long[] a2)`
`static long[]`	`concat(long[] a1, long[] a2, long[]... rest)`
`static short[]`	`concat(short[] a1, short[] a2)`
`static short[]`	`concat(short[] a1, short[] a2, short[]... rest)`
`static <T> T[]`	`concat(T[] a, T t)`
`static <T> T[]`	`concat(T[] a1, T[] a2)`
`static <T> T[]`	`concat(T[] a1, T[] a2, T[]... rest)`
`static <T> Const<T>`	`constant()`
`static <T> Const<T>`	`constant(T t)`
`static <T> ContextLocal<T>`	`contextLocal()`
`static <T> ContextLocal<T>`	`contextLocal(ContextLocal.InitialValueProvider<T> ivp)`
`static <FROM> Lang._ConvertStage<FROM>`	`convert(FROM from)`
`static Lang._MappingStage`	`copy(Object source)` Prepare a Mapping operation with `shallow copy` semantic
`static Lang._MappingStage`	`deepCopy(Object source)` Prepare a Mapping operation with `deep copy` semantic
`static <T> T`	`deserialize(byte[] ba)`
`static <T> T`	`deserialize(byte[] ba, Class<T> c)`
`static void`	`echo(String msg, Object... args)`
`static <T> T`	`ensureGet(T t1, Lang.F0<T> def1)`
`static <T> T`	`ensureGet(T t1, List<T> defs)`
`static <T> T`	`ensureGet(T t1, T def1)`
`static <T> T`	`ensureGet(T t1, T def1, T def2)`
`static <T> T`	`ensureGet(T t1, T def1, T def2, T def3)`
`static boolean`	`eq(boolean a, boolean b)` Check if two `boolean` value equals to each other
`static boolean`	`eq(byte a, byte b)` Check if two `byte` value equals to each other
`static boolean`	`eq(char a, char b)` Check if two `char` value equals to each other
`static boolean`	`eq(double a, double b)` Check if two `double` value equals to each other
`static boolean`	`eq(float a, float b)` Check if two `float` value equals to each other
`static boolean`	`eq(int a, int b)` Check if two `int` value equals to each other
`static boolean`	`eq(long a, long b)` Check if two `long` value equals to each other
`static boolean`	`eq(Object a, Object b)` Check if two object is equals to each other.
`static boolean`	`eq(short a, short b)` Check if two `short` value equals to each other
`static boolean`	`eq2(Object a, Object b)` Check if two objects are equals to each other.
`boolean`	`equals(Object obj)`
`static void`	`error(String msg, Object... args)`
`static Map<String,Object>`	`evaluate(Annotation anno)` Evaluate Annotation properties
`static <T> Lang.F0<T>`	`f0()` Return a dumb function for `Lang.Func0`.
`static <R> Lang.F0<R>`	`f0(Lang.Func0<? extends R> f0)` Convert a general `Lang.Func0` typed function to `Lang.F0` type
`static <P1,R> Lang.F1<P1,R>`	`f1()` The type-safe version of `F1`
`static <X,Y> Lang.F1<X,Y>`	`f1(Lang.Bijection<X,Y> f1)`
`static <P1,R> Lang.F1<P1,R>`	`f1(Lang.Function<? super P1,? extends R> f1)` Convert a general `Lang.Function` function into a `Lang.F1` typed function
`static <P1,P2,R> Lang.F2<P1,P2,R>`	`f2()` The type-safe version of `F2`
`static <P1,P2,R> Lang.F2<P1,P2,R>`	`f2(Lang.Func2<? super P1,? super P2,? extends R> f2)` Convert a general `Lang.Func2` function into a `Lang.F2` typed function
`static <P1,P2,P3,R> Lang.F3<P1,P2,P3,R>`	`f3()` The type-safe version of `F3`
`static <P1,P2,P3,R> Lang.F3<P1,P2,P3,R>`	`f3(Lang.Func3<? super P1,? super P2,? super P3,? extends R> f3)` Convert a general `Lang.Func3` function into a `Lang.F3` typed function
`static <P1,P2,P3,P4,R> Lang.F4<P1,P2,P3,P4,R>`	`f4()` The type-safe version of `F4`
`static <P1,P2,P3,P4,R> Lang.F4<P1,P2,P3,P4,R>`	`f4(Lang.Func4<? super P1,? super P2,? super P3,? super P4,? extends R> f4)` Convert a general `Lang.Func4` function into a `Lang.F4` typed function
`static <P1,P2,P3,P4,P5,R> Lang.F5<P1,P2,P3,P4,P5,R>`	`f5()` The type-safe version of `F5`
`static <P1,P2,P3,P4,P5,R> Lang.F5<P1,P2,P3,P4,P5,R>`	`f5(Lang.Func5<? super P1,? super P2,? super P3,? super P4,? super P5,? extends R> f5)` Convert a general `Lang.Func5` function into a `Lang.F5` typed function
`static <T> Lang.Factory<T>`	`factory(Lang.Func0<T> func)`
`static Field`	`fieldOf(Class<?> c, String name)` Returns non-static field of a class by name.
`static Field`	`fieldOf(Class<?> c, String name, boolean noStatic)` Returns field of a class by name.
`static Field`	`fieldOf(Class<?> c, String name, Class<?> rootClass, boolean noStatic)` Returns field of a class by name.
`static List<Field>`	`fieldsOf(Class<?> c)` Returns all fields of a class and all super classes.
`static List<Field>`	`fieldsOf(Class<?> c, boolean noStatic)` Returns all fields of a class and all super classes.
`static List<Field>`	`fieldsOf(Class<?> c, Class<?> rootClass, boolean noStatic)` Returns all fields of a class and all super classes until root class.
`static List<Field>`	`fieldsOf(Class<?> c, Class<?> rootClass, boolean includeRootClass, boolean noStatic)` Returns all fields of a class and all super classes until root class.
`static List<Field>`	`fieldsOf(Class<?> c, Class<?> rootClass, boolean includeRootClass, Lang.Function<Field,Boolean> filter)` Returns all fields of a class and all super classes until root class.
`static List<Field>`	`fieldsOf(Class<?> c, Class<?> rootClass, Lang.Function<Field,Boolean> filter)` Returns all fields of a class and all super classes until root class.
`static List<Field>`	`fieldsOf(Class<?> c, Lang.Function<Class<?>,Boolean> classFilter, Lang.Function<Field,Boolean> fieldFilter)` Returns all fields of a class and all super classes until classFilter not applied.
`static List<Field>`	`fieldsOf(Class<?> c, Lang.Function<Field,Boolean> filter)` Returns all fields of a class and all super classes.
`static void`	`fill(boolean element, boolean[] array)`
`static void`	`fill(byte element, byte[] array)`
`static void`	`fill(char element, char[] array)`
`static void`	`fill(double element, double[] array)`
`static void`	`fill(float element, float[] array)`
`static void`	`fill(int element, int[] array)`
`static void`	`fill(long element, long[] array)`
`static void`	`fill(short element, short[] array)`
`static <T> void`	`fill(T element, T[] array)`
`static Lang._MappingStage`	`flatCopy(Object source)` Prepare a Mapping operation with `flat copy` semantic
`static String`	`fmt(String tmpl, Object... args)` Alias of `S.fmt(String, Object...)`
`static <T> Lang.Predicate<T>`	`generalPredicate(Lang.Visitor<? super T> f)` Convert a general `Function<T, ?>` typed function to `Predicate<T>` function.
`static <T> T`	`getFieldValue(Object obj, Field field)` Get value of an object field.
`static Method`	`getMethod(Class c, String methodName, Class... argTypes)` Returns `Method` by name and argument type
`static Method`	`getMethod(Class c, String methodName, Object... pa)` Returns `Method` by name and parameter value
`static <T> T`	`getProperty(CacheService cache, Object entity, String property)`
`static <T> T`	`getProperty(Object entity, String property)`
`static <T> Lang.Meta<T>`	`given(T t)`
`static <T> Lang.Visitor<T>`	`guardedVisitor(Lang.Function<? super T,Boolean> predicate, Lang.Visitor<? super T> visitor)` Return a composed visitor function that only applies when the guard predicate test returns `true`
`int`	`hashCode()`
`static <T> Lang.Meta<T>`	`having(T t)`
`static int`	`hc()`
`static int`	`hc(boolean o)`
`static int`	`hc(boolean[] oa)`
`static int`	`hc(byte o)`
`static int`	`hc(byte[] oa)`
`static int`	`hc(char o)`
`static int`	`hc(char[] oa)`
`static int`	`hc(double o)`
`static int`	`hc(double[] oa)` Calculate hashcode of double array specified
`static int`	`hc(float o)`
`static int`	`hc(float[] oa)`
`static int`	`hc(int o)`
`static int`	`hc(int[] oa)`
`static int`	`hc(long o)`
`static int`	`hc(long[] oa)`
`static int`	`hc(Object o)` Calculate hashcode of objects specified
`static int`	`hc(Object o1, Object o2)` Calculate hashcode of objects specified
`static int`	`hc(Object o1, Object o2, Object o3)` Calculate hashcode of objects specified
`static int`	`hc(Object o1, Object o2, Object o3, Object o4)` Calculate hashcode of objects specified
`static int`	`hc(Object o1, Object o2, Object o3, Object o4, Object o5)` Calculate hashcode of objects specified
`static int`	`hc(Object o1, Object o2, Object o3, Object o4, Object o5, Object... args)` Calculate hashcode of objects specified
`static int`	`hc(short o)`
`static int`	`hc(short[] oa)`
`static <T> T`	`ifNullThen(T t1, Lang.F0<T> def1)`
`static <T> T`	`ifNullThen(T t1, T def1)`
`static <K,T> Lang.IndexedVisitor<K,T>`	`indexGuardedVisitor(Lang.Function<? super K,Boolean> guard, Lang.Visitor<? super T> visitor)`
`static void`	`init()`
`static Set<Class>`	`interfacesOf(Class<?> type)` Returns all implemented interfaces of a give type
`static <T,R> R`	`invokeStatic(Class<T> c, String methodName, Object... pa)` Invoke a static method by name and parameters
`static <T,R> R`	`invokeStatic(Lang.Var<Method> methodBag, Class<T> c, String methodName, Object... pa)` Invoke a static method by name and parameters.
`static <R> R`	`invokeStatic(Method method, Object... pa)` Invoke a static method.
`static <T,R> R`	`invokeVirtual(Lang.Var<Method> methodBag, T o, String methodName, Object... pa)` Invoke a virtual method by instance, method name and arguments.
`static <T,R> R`	`invokeVirtual(T o, Method method, Object... pa)` Invoke a virtual `method`.
`static <T,R> R`	`invokeVirtual(T o, String methodName, Object... pa)` Invoke a virtual method by instance, method name and arguments.
`static Lang._IsClass`	`is(Class<?> c)`
`static Lang._IsReflectMember`	`is(Member member)`
`static Lang._IsClass`	`is(Object t)`
`static boolean`	`isCollectionType(Class<?> c)` Check if a given class `c` is a collection type.
`static boolean`	`isImmutable(Object o)` Check if an Object or class is immutable
`static boolean`	`isNotNull(Object o)` Check if an object is not `null` and not `NONE`
`static boolean`	`isNull(Object o)` Check if an object is `null` or `NONE`
`static boolean`	`isPrimitive(Class<?> c)` Deprecated.
`static boolean`	`isPrimitiveType(Class<?> c)` Check if a given class is a primitive type.
`static boolean`	`isPrimitiveType(String name)` Check if a given string is a primitive type name.
`static boolean`	`isSimpleType(Class<?> c)` Check if a give class `c` is a simple type.
`static boolean`	`isWrapper(Class<?> c)` Deprecated.
`static boolean`	`isWrapperType(Class<?> c)` Check if a given class is a wrapper type of a primitive type.
`static int`	`iterableHashCode(Iterable<?> it)`
`static Lang._MappingStage`	`map(Object source)` Prepare a Mapping operation with `map` semantic and `keyword matching`
`static <T> T`	`materialize(byte[] ba)`
`static <T> T`	`materialize(byte[] ba, Class<T> c)`
`static Lang._MappingStage`	`merge(Object source)` Prepare a Mapping operation with `merge` semantic
`static Lang._MappingStage`	`mergeMap(Object source)` Prepare a Mapping operation with `merge map` semantic and `keyword matching`
`static <T> Lang.Meta<T>`	`meta(T t)`
`static long`	`ms()` Return `current time millis`
`static boolean`	`ne(Object a, Object b)` Check if two objects are equals to each other.
`static boolean[]`	`newArray(boolean[] model)`
`static boolean[]`	`newArray(boolean[] model, int size)`
`static byte[]`	`newArray(byte[] model)`
`static byte[]`	`newArray(byte[] model, int size)`
`static char[]`	`newArray(char[] model)`
`static char[]`	`newArray(char[] model, int size)`
`static double[]`	`newArray(double[] model)`
`static double[]`	`newArray(double[] model, int size)`
`static float[]`	`newArray(float[] model)`
`static float[]`	`newArray(float[] model, int size)`
`static int[]`	`newArray(int[] model)`
`static int[]`	`newArray(int[] model, int size)`
`static long[]`	`newArray(long[] model)`
`static long[]`	`newArray(long[] model, int size)`
`static short[]`	`newArray(short[] model)`
`static short[]`	`newArray(short[] model, int size)`
`static <T> T[]`	`newArray(T[] model)` Create an new array with specified array type and length
`static <T> T[]`	`newArray(T[] model, int size)` Create an new array with specified type and length
`static <T> T`	`newInstance(Class<T> c)`
`static <T> T`	`newInstance(Class<T> c, Object p1, Object p2, Object p3, Object p4, Object p5, Object... pa)`
`static <T,P1> T`	`newInstance(Class<T> c, P1 p1)`
`static <T,P1,P2> T`	`newInstance(Class<T> c, P1 p1, P2 p2)`
`static <T,P1,P2,P3> T`	`newInstance(Class<T> c, P1 p1, P2 p2, P3 p3)`
`static <T,P1,P2,P3,P4> T`	`newInstance(Class<T> c, P1 p1, P2 p2, P3 p3, P4 p4)`
`static <T,P1,P2,P3,P4,P5> T`	`newInstance(Class<T> c, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)`
`static <T> T`	`newInstance(String className)`
`static <T> T`	`newInstance(String className, ClassLoader cl)`
`static void`	`nil()` An empty method.
`static <T> Lang.None<T>`	`none()`
`static boolean`	`noneNull(Object o, Object... oa)`
`static boolean`	`not(BigDecimal v)` Returns negative of `bool(BigDecimal)`
`static boolean`	`not(BigInteger v)` Returns negative of `bool(BigInteger)`
`static boolean`	`not(boolean v)` Returns negative of a boolean value
`static boolean`	`not(byte v)` Returns negative of `bool(byte)`
`static boolean`	`not(char v)` Returns negative of `bool(char)`
`static boolean`	`not(Collection<?> c)` Returns negative of `bool(java.util.Collection)`
`static boolean`	`not(double v)` Returns negative of `bool(double)`
`static boolean`	`not(File file)` Returns negative of `bool(File)`
`static boolean`	`not(float v)` Returns negative of `bool(float)`
`static boolean`	`not(int v)` Returns negative of `bool(int)`
`static boolean`	`not(Lang.Func0<?> f)` Returns negative of `bool(Func0)`
`static boolean`	`not(long v)` Returns negative of `bool(long)`
`static boolean`	`not(Map<?,?> m)` Returns negative of `bool(java.util.Map)`
`static boolean`	`not(Object o)` Returns negative of `bool(java.lang.Object)`
`static boolean`	`not(String s)` Returns negative of `bool(java.lang.String)`
`static <T> T`	`notNull(T o)` Deprecated.
`static <T> T`	`NPE(T o)`
`static long`	`ns()` Return `current nano time`
`static <A,B> Lang.T2<A,B>`	`Pair(A a, B b)`
`static <T> Lang.Predicate<T>`	`predicate(Lang.Function<? super T,Boolean> f)` Convert a `Function<T, Boolean>` typed function to `Predicate<T>` function.
`static <T> T`	`primitiveDefaultValue(Class<T> c)`
`static Class`	`primitiveTypeOf(Class c)`
`static boolean`	`random(boolean[] a)`
`static byte`	`random(byte[] a)`
`static <T> T`	`random(C.Range<T> range)` Returns a random element picked from elements in a `range`.
`static char`	`random(char[] a)`
`static <T extends Enum> T`	`random(Class<T> enumType)` Pickup a random enum value from the enum type.
`static double`	`random(double[] a)`
`static float`	`random(float[] a)`
`static int`	`random(int[] a)`
`static <T> T`	`random(List<T> list)` Returns a random element picked from elements in a `list`.
`static long`	`random(long[] a)`
`static short`	`random(short[] a)`
`static <T> T`	`random(T[] ta)` Returns a random element picked from elements in `ta`.
`static <T> T`	`random(T t1, T... ta)` Returns a random element picked from `t1` and elements in `ta`.
`static String`	`randomStr()` Alias of `S.random()`
`static String`	`randomStr(int len)` Alias of `S.random(int)`
`static <T> List<T>`	`randomSubList(List<T> list)` Create a list contains random selected elements in the `list` specified.
`static <T> List<T>`	`randomSubList(List<T> list, int minSize)` Create a list contains random selected elements in the `list` specified.
`static <T> T`	`requireNotNull(T o)` Return the object if it is not null, otherwise throw out `NullPointerException`.
`static <T> T`	`requireNotNull(T o, String errorTemplate, Object... errorArgs)` Return the object if it is not null, otherwise throw out `NullPointerException` with error message specified
`static boolean[]`	`resetArray(boolean[] array)`
`static byte[]`	`resetArray(byte[] array)`
`static char[]`	`resetArray(char[] array)`
`static double[]`	`resetArray(double[] array)`
`static float[]`	`resetArray(float[] array)`
`static int[]`	`resetArray(int[] array)`
`static long[]`	`resetArray(long[] array)`
`static Object`	`resetArray(Object array)`
`static short[]`	`resetArray(short[] array)`
`static <T> T[]`	`resetArray(T[] array)`
`static void`	`resetFieldValue(Object obj, Field field)`
`static boolean[]`	`reverse(boolean[] a)`
`static byte[]`	`reverse(byte[] a)`
`static char[]`	`reverse(char[] a)`
`static double[]`	`reverse(double[] a)`
`static float[]`	`reverse(float[] a)`
`static int[]`	`reverse(int[] a)`
`static long[]`	`reverse(long[] a)`
`static Object[]`	`reverse(Object[] a)`
`static short[]`	`reverse(short[] a)`
`static <T> Lang.Option<Class<T>>`	`safeClassForName(String className)`
`static <T> Lang.Option<Class<T>>`	`safeClassForName(String className, ClassLoader classLoader)`
`static <T> Lang.Option<T>`	`safeNewInstance(String className)`
`static <T> int`	`search(T element, T... elements)` Search an element in a array
`static <T> T`	`secureRandom(C.Range<T> range)` The secure version of `random(C.Range)`.
`static <T> T`	`secureRandom(List<T> list)` The secure version of `random(List)`.
`static <T> T`	`secureRandom(T[] ta)` The secure version of `random(Object[])`.
`static <T> T`	`secureRandom(T t1, T... ta)` The secure version of `random(Object, Object[])`.
`static <T> byte[]`	`serialize(T obj)`
`static void`	`setField(String fieldName, Class<?> type, Object val)` Set value to a static field of given class
`static <T,F> T`	`setField(String fieldName, T obj, F val)` Set an object field value using reflection.
`static void`	`setFieldValue(Object obj, Field field, Object fieldValue)`
`static void`	`setFieldValue(String fieldName, Class<?> type, Object val)` Alias of `setField(String, Class, Object)`
`static <T,F> T`	`setFieldValue(String fieldName, T obj, F val)` Alias of `setField(String, Object, Object)`
`static void`	`setProperty(CacheService cache, Object entity, Object val, String property)`
`static void`	`setProperty(Object entity, Object val, String property)`
`static void`	`setStaticFieldValue(Class host, String fieldName, Object fieldValue)`
`static void`	`setStaticFieldValue(Field field, Object fieldValue)`
`static void`	`sleep(long ms)` A convenient shortcut for `Thread.sleep(long)`.
`static <T> Lang.Option<T>`	`some(T a)`
`static boolean[]`	`subarray(boolean[] src, int begin, int end)`
`static byte[]`	`subarray(byte[] src, int begin, int end)`
`static char[]`	`subarray(char[] src, int begin, int end)`
`static double[]`	`subarray(double[] src, int begin, int end)`
`static float[]`	`subarray(float[] src, int begin, int end)`
`static int[]`	`subarray(int[] src, int begin, int end)`
`static long[]`	`subarray(long[] src, int begin, int end)`
`static short[]`	`subarray(short[] src, int begin, int end)`
`static <T> T[]`	`subarray(T[] src, int begin, int end)`
`static List<Class>`	`superClassesOf(Class<?> type)` Returns all super classes of a given type ordered by affinity.
`static <A,B> Lang.T2<A,B>`	`T2(A a, B b)`
`static <A,B,C> Lang.T3<A,B,C>`	`T3(A a, B b, C c)`
`static <A,B,C,D> Lang.T4<A,B,C,D>`	`T4(A a, B b, C c, D d)`
`static <A,B,C,D,E> Lang.T5<A,B,C,D,E>`	`T5(A a, B b, C c, D d, E e)`
`static <T> Lang.Meta<T>`	`take(T t)`
`static <T> T`	`times(Lang.Function<T,T> func, T initVal, int n)`
`String`	`toString()`
`static String`	`toString(Object o)` Returns String representation of an object instance.
`static String`	`toString2(Object o)`
`static long`	`ts()` Return current time stamp in nano seconds.
`static <P1,P2> Lang.Binary<P1,P2>`	`Tuple(P1 a, P2 b)`
`static <T> Lang.Val<T>`	`val(T t)`
`static <T> Lang.Var<T>`	`var()`
`static <T> Lang.Var<T>`	`var(T t)`
`static <T> Lang.Visitor<T>`	`visitor(Lang.Function<? super T,?> f)` Convert a `Function<? super T, Void>` function into a `Lang.Visitor`
`static Class`	`wrapperClassOf(Class c)`

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

Field Detail
- VERSION
```
public static final osgl.version.Version VERSION
```
- INSTANCE
```
public static final Lang INSTANCE
```
- F0
```
public static final Lang.F0 F0
```
  A dumb function for Lang.Func0 that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f0()
- F1
```
public static final Lang.F1 F1
```
  A dumb Lang.Function implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f1()
- F2
```
public static final Lang.F2 F2
```
  A dumb Lang.Func2 implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f2()
- F3
```
public static final Lang.F3 F3
```
  A dumb Lang.Func3 implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f3()
- F4
```
public static final Lang.F4 F4
```
  A dumb Lang.Func4 implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f4()
- F5
```
public static final Lang.F5 F5
```
  A dumb Lang.Func5 implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f5()
- BREAK
```
public static final Lang.Break BREAK
```
  A predefined Break instance without payload
- NONE
```
public static final Lang.None NONE
```
- DUMB
```
public static final Object DUMB
```
  A dumb object instance
- propertyHandlerFactory
```
public static PropertyHandlerFactory propertyHandlerFactory
```
- conf
```
public static final Lang.Conf conf
```
- JAVA_VERSION
```
public static final int JAVA_VERSION
```
- IS_SERVER
```
public static final boolean IS_SERVER
```
- IS_64
```
public static final boolean IS_64
```
- OS
```
public static final OS OS
```

Constructor Detail
- Lang
```
protected Lang()
```

Method Detail

equals

public final boolean equals(Object obj)

Overrides:: equals in class Object

hashCode
```
public final int hashCode()
```
Overrides:

hashCode in class Object

toString
```
public final String toString()
```
Overrides:

toString in class Object

factory

public static <T> Lang.Factory<T> factory(Lang.Func0<T> func)

f0
```
public static <T> Lang.F0<T> f0()
```
Return a dumb function for Lang.Func0. This is the type-safe version of F0

Type Parameters:

T - a generic type that matches whatever type required by the context of applying the function

Returns:

A dumb function that always return null

Since:

0.2

f0
```
public static <R> Lang.F0<R> f0(Lang.Func0<? extends R> f0)
```
Convert a general Lang.Func0 typed function to Lang.F0 type

Type Parameters:

R - the generic type of the return value when applying function f0

Parameters:

f0 - a function of type Lang.Func0 that returns type R value

Returns:

a Lang.F0 type that is equaivlent to function f0

Since:

0.2

f1
```
public static <P1,R> Lang.F1<P1,R> f1()
```
The type-safe version of F1

Type Parameters:

P1 - the argument type

R - the return value type

Returns:

a dumb function F1

Since:

0.2

f1
```
public static <P1,R> Lang.F1<P1,R> f1(Lang.Function<? super P1,? extends R> f1)
```
Convert a general Lang.Function function into a Lang.F1 typed function

Type Parameters:

P1 - the argument type

R - the return value type

Parameters:

f1 - the function that consumes P1 and produce R

Returns:

whatever of type R

Since:

0.2

f1

public static <X,Y> Lang.F1<X,Y> f1(Lang.Bijection<X,Y> f1)

f2
```
public static <P1,P2,R> Lang.F2<P1,P2,R> f2()
```
The type-safe version of F2

Type Parameters:

P1 - the type of the first param the new function applied to

P2 - the type of the second param the new function applied to

R - the type of new function application result

Returns:

the dumb function F2

Since:

0.2

f2
```
public static <P1,P2,R> Lang.F2<P1,P2,R> f2(Lang.Func2<? super P1,? super P2,? extends R> f2)
```
Convert a general Lang.Func2 function into a Lang.F2 typed function

Type Parameters:

P1 - the type of the first param the new function applied to

P2 - the type of the second param the new function applied to

R - the type of new function application result

Parameters:

f2 - the function that takes two arguments and return type R

Returns:

a F2 instance corresponding to the specified Func2 instance

Since:

0.2

f3
```
public static <P1,P2,P3,R> Lang.F3<P1,P2,P3,R> f3()
```
The type-safe version of F3

Type Parameters:

P1 - the type of first parameter this function applied to

P2 - the type of second parameter this function applied to

P3 - the type of thrid parameter this function applied to

R - the type of the return value when this function applied to the parameter(s)

Returns:

the dumb function F3

Since:

0.2

f3
```
public static <P1,P2,P3,R> Lang.F3<P1,P2,P3,R> f3(Lang.Func3<? super P1,? super P2,? super P3,? extends R> f3)
```
Convert a general Lang.Func3 function into a Lang.F3 typed function

Type Parameters:

P1 - type of argument 1

P2 - type of argument 2

P3 - type of argument 3

R - return type

Parameters:

f3 - the general function with three params

Returns:

the F3 typed instance which is equivalent to f3

Since:

0.2

f4
```
public static <P1,P2,P3,P4,R> Lang.F4<P1,P2,P3,P4,R> f4()
```
The type-safe version of F4

Type Parameters:

P1 - type of first argument

P2 - type of second argument

P3 - type of third argument

P4 - type of fourth argument

R - type of return value

Returns:

the dumb F4 function

Since:

0.2

f4
```
public static <P1,P2,P3,P4,R> Lang.F4<P1,P2,P3,P4,R> f4(Lang.Func4<? super P1,? super P2,? super P3,? super P4,? extends R> f4)
```
Convert a general Lang.Func4 function into a Lang.F4 typed function

Type Parameters:

P1 - type of first argument

P2 - type of second argument

P3 - type of third argument

P4 - type of fourth argument

R - type of return value

Parameters:

f4 - the function to be converted

Returns:

the function of Lang.F4 type that is equivalent to function f4

Since:

0.2

f5
```
public static <P1,P2,P3,P4,P5,R> Lang.F5<P1,P2,P3,P4,P5,R> f5()
```
The type-safe version of F5

Type Parameters:

P1 - type of first argument

P2 - type of second argument

P3 - type of third argument

P4 - type of fourth argument

P5 - type of fifth argument

R - type of return value

Returns:

a dumb F5 function

Since:

0.2

f5
```
public static <P1,P2,P3,P4,P5,R> Lang.F5<P1,P2,P3,P4,P5,R> f5(Lang.Func5<? super P1,? super P2,? super P3,? super P4,? super P5,? extends R> f5)
```
Convert a general Lang.Func5 function into a Lang.F5 typed function

Type Parameters:

P1 - type of first argument

P2 - type of second argument

P3 - type of third argument

P4 - type of fourth argument

P5 - type of fifth argument

R - type of return value

Parameters:

f5 - the function to be converted

Returns:

the function of Lang.F5 type that is equivalent to function f5

Since:

0.2

comparator
```
public static <T> Lang.Comparator<T> comparator(Lang.Func2<? super T,? super T,Integer> f)
```
Adapt a general Lang.Func2 function with (T, T, Integer) type into Comparator

Type Parameters:

T - the type of the parameter

Parameters:

f - The function takes two params (the same type) and returns integer

Returns:

a Comparator instance backed by function f

comparator
```
public static <T> Lang.Comparator<T> comparator(Comparator<? super T> c)
```
Adapt a jdk Comparator into osgl Comparator

Type Parameters:

T - the element type the comparator compares

Parameters:

c - the jdk compator

Returns:

a Comparator instance backed by comparator c

predicate
```
public static <T> Lang.Predicate<T> predicate(Lang.Function<? super T,Boolean> f)
```
Convert a Function<T, Boolean> typed function to Predicate<T> function.
If the function specified is already a Lang.Predicate, then the function itself is returned

Type Parameters:

T - the argument type

Parameters:

f - the function to be converted

Returns:

a function of Lang.Predicate type that is equivalent to function f

Since:

0.2

generalPredicate
```
public static <T> Lang.Predicate<T> generalPredicate(Lang.Visitor<? super T> f)
```
Convert a general Function<T, ?> typed function to Predicate<T> function. When the predicate function returned apply to a param, it will first apply the specified f1 to the param, and they call bool(java.lang.Object) to evaluate the boolean value of the return object of the application.
If the function specified is already a Lang.Predicate, then the function itself is returned

Type Parameters:

T - the argument type

Parameters:

f - the function

Returns:

the function of Lang.Predicate type that is equivalent to the function f

Since:

0.2

visitor
```
public static <T> Lang.Visitor<T> visitor(Lang.Function<? super T,?> f)
```
Convert a Function<? super T, Void> function into a Lang.Visitor

Type Parameters:

T - the argument type

Parameters:

f - the function to be cast

Returns:

a Lang.Visitor type function that is equal with the function f

Since:

0.2

guardedVisitor
```
public static <T> Lang.Visitor<T> guardedVisitor(Lang.Function<? super T,Boolean> predicate,
                                                 Lang.Visitor<? super T> visitor)
```
Return a composed visitor function that only applies when the guard predicate test returns true

Type Parameters:

T - the type of the element be tested and visited

Parameters:

predicate - the predicate to test the element been visited

visitor - the function that visit(accept) the element if the guard tested the element successfully

Returns:

the composed function

breakOut
```
public static <T> Lang.Break breakOut(T e)
```
A utility method to throw out a Break with payload

Type Parameters:

T - the type of the payload

Parameters:

e - the payload object

Returns:

a Break instance with the payload specified

indexGuardedVisitor

public static <K,T> Lang.IndexedVisitor<K,T> indexGuardedVisitor(Lang.Function<? super K,Boolean> guard,
                                                                 Lang.Visitor<? super T> visitor)

convert

public static <FROM> Lang._ConvertStage<FROM> convert(FROM from)

Tuple

public static <P1,P2> Lang.Binary<P1,P2> Tuple(P1 a,
                                               P2 b)

T2

public static <A,B> Lang.T2<A,B> T2(A a,
                                    B b)

Binary

public static <A,B> Lang.T2<A,B> Binary(A a,
                                        B b)

Pair

public static <A,B> Lang.T2<A,B> Pair(A a,
                                      B b)

T3

public static <A,B,C> Lang.T3<A,B,C> T3(A a,
                                        B b,
                                        C c)

T4

public static <A,B,C,D> Lang.T4<A,B,C,D> T4(A a,
                                            B b,
                                            C c,
                                            D d)

T5

public static <A,B,C,D,E> Lang.T5<A,B,C,D,E> T5(A a,
                                                B b,
                                                C c,
                                                D d,
                                                E e)

some

public static <T> Lang.Option<T> some(T a)

none

public static <T> Lang.None<T> none()

var

public static <T> Lang.Var<T> var(T t)

var
```
public static <T> Lang.Var<T> var()
```

val

public static <T> Lang.Val<T> val(T t)

constant

public static <T> Const<T> constant(T t)

constant

public static <T> Const<T> constant()

eq
```
public static boolean eq(Object a,
                         Object b)
```
Check if two object is equals to each other.

Parameters:

a - the first object

b - the second object

Returns:

true if a equals to b

See Also:

ne(Object, Object)

eq2
```
public static boolean eq2(Object a,
                          Object b)
```
Check if two objects are equals to each other. The comparison will do array equal matching if needed

Parameters:

a - the first object

b - the second object

Returns:

true if the first object equals to the second object

eq
```
public static boolean eq(boolean a,
                         boolean b)
```
Check if two boolean value equals to each other

Parameters:

a - boolean a

b - boolean b

Returns:

true if a == b

eq
```
public static boolean eq(byte a,
                         byte b)
```
Check if two byte value equals to each other

Parameters:

a - byte a

b - byte b

Returns:

true if a == b

eq
```
public static boolean eq(char a,
                         char b)
```
Check if two char value equals to each other

Parameters:

a - char a

b - char b

Returns:

true if a == b

eq
```
public static boolean eq(short a,
                         short b)
```
Check if two short value equals to each other

Parameters:

a - short a

b - short b

Returns:

true if a == b

eq
```
public static boolean eq(int a,
                         int b)
```
Check if two int value equals to each other

Parameters:

a - int a

b - int b

Returns:

true if a == b

eq
```
public static boolean eq(float a,
                         float b)
```
Check if two float value equals to each other

Parameters:

a - float a

b - float b

Returns:

true if a == b

eq
```
public static boolean eq(long a,
                         long b)
```
Check if two long value equals to each other

Parameters:

a - long a

b - long b

Returns:

true if a == b

eq
```
public static boolean eq(double a,
                         double b)
```
Check if two double value equals to each other

Parameters:

a - double a

b - double b

Returns:

true if a == b

ne
```
public static boolean ne(Object a,
                         Object b)
```
Check if two objects are equals to each other.

Parameters:

a - the first object

b - the second object

Returns:

false if a equals to b

See Also:

eq(Object, Object)

bool

public static boolean bool(Object v)

Evaluate an object’s bool value. The rules are:

case	bool value
`null`	`false`
`NONE`	`false`
String	`S.notEmpty(v)`
Collection	`!v.isEmpty()`
Array	length of the array > 0
Byte	`v != 0`
Char	`v != 0`
Integer	`v != 0`
Long	`v != 0L`
Float	`Math.abs(v) > Float.MIN_NORMAL`
Double	`Math.abs(v) > Double.MIN_NORMAL`
BigInteger	`!BigInteger.ZERO.equals(v)`
BigDecimal	`!BigDecimal.ZERO.equals(v)`
File	`v.exists()`
`Lang.Func0`	`bool(v.apply())`
Other types	`true`

Parameters:: v - the value to be evaluated
Returns:: true if v evaluate to true, false otherwise

bool

public static boolean bool(boolean v)

bool
```
public static boolean bool(String s)
```
Do bool evaluation on a String.

A String typed instance is considered to be false when
1. it is null or empty, or
2. it equals to false (case insensitive mode)
Parameters:

s - the string to be evaluated

Returns:

true if s is not empty and s is not false

See Also:

S.empty(String)

bool
```
public static boolean bool(Collection<?> c)
```
Do bool evaluation on a collection.

Parameters:

c - the collection to be evaluated

Returns:

true if the collection is not empty

See Also:

Collection.isEmpty()

bool
```
public static boolean bool(Map<?,?> m)
```
Do bool evaluation on a map.

Parameters:

m - the map to be evaluated

Returns:

true if the map is not empty

See Also:

Map.isEmpty()

bool
```
public static boolean bool(byte v)
```
Do bool evaluation on a byte value

Parameters:

v - the value to be evaluated

Returns:

true if the value != 0

bool
```
public static boolean bool(char v)
```
Do bool evaluation on a char value

Parameters:

v - the value to be evaluated

Returns:

true if the value != 0

bool
```
public static boolean bool(int v)
```
Do bool evaluation on a int value

Parameters:

v - the value to be evaluated

Returns:

true if the value != 0

bool
```
public static boolean bool(long v)
```
Do bool evaluation on a long value

Parameters:

v - the value to be evaluated

Returns:

true if the value != 0

bool
```
public static boolean bool(float v)
```
Do bool evaluation on a float value

Parameters:

v - the value to be evaluated

Returns:

true if Math.abs(v) > Float.MIN_NORMAL

bool
```
public static boolean bool(double v)
```
Do bool evaluation on a double value

Parameters:

v - the value to be evaluated

Returns:

true if Math.abs(v) > Double.MIN_NORMAL

bool
```
public static boolean bool(BigDecimal v)
```
Do bool evaluation on a BigDecimal value

Parameters:

v - the value to be evaluated

Returns:

true if !BigDecimal.ZERO.equals(v)

bool
```
public static boolean bool(BigInteger v)
```
Do bool evaluation on a BigInteger value

Parameters:

v - the value to be evaluated

Returns:

true if !BigInteger.ZERO.equals(v)

bool
```
public static boolean bool(File v)
```
Do bool evaluation on a File instance.

Parameters:

v - the file to be evaluated

Returns:

true if v.exists()

bool
```
public static boolean bool(Lang.Func0<?> v)
```
Do bool evaluation on an Lang.Func0 instance. This will call the Lang.Func0.apply() method and continue to do bool evaluation on the return value

Parameters:

v - the function to be evaluated

Returns:

bool(v.apply())

not
```
public static boolean not(Object o)
```
Returns negative of bool(java.lang.Object)

Parameters:

o - the object to be evaluated

Returns:

!(bool(o))

not
```
public static boolean not(boolean v)
```
Returns negative of a boolean value

Parameters:

v - the value to be evaluated

Returns:

!v

not
```
public static boolean not(String s)
```
Returns negative of bool(java.lang.String)

Parameters:

s - the String to be evaluated

Returns:

!(bool(s))

See Also:

bool(String)

not
```
public static boolean not(Map<?,?> m)
```
Returns negative of bool(java.util.Map)

Parameters:

m - a map to be evauated

Returns:

!(bool(c))

See Also:

bool(java.util.Map)

not
```
public static boolean not(Collection<?> c)
```
Returns negative of bool(java.util.Collection)

Parameters:

c - the Collection to be evaluated

Returns:

!(bool(c))

See Also:

bool(java.util.Collection)

not
```
public static boolean not(byte v)
```
Returns negative of bool(byte)

Parameters:

v - the byte to be evaluated

Returns:

!(bool(v))

not
```
public static boolean not(char v)
```
Returns negative of bool(char)

Parameters:

v - the char to be evaluated

Returns:

!(bool(v))

not
```
public static boolean not(int v)
```
Returns negative of bool(int)

Parameters:

v - the int to be evaluated

Returns:

!(bool(v))

not
```
public static boolean not(long v)
```
Returns negative of bool(long)

Parameters:

v - the long to be evaluated

Returns:

!(bool(v))

not
```
public static boolean not(float v)
```
Returns negative of bool(float)

Parameters:

v - the float to be evaluated

Returns:

!(bool(v))

not
```
public static boolean not(double v)
```
Returns negative of bool(double)

Parameters:

v - the double to be evaluated

Returns:

!(bool(v))

not
```
public static boolean not(BigDecimal v)
```
Returns negative of bool(BigDecimal)

Parameters:

v - the value to be evaluated

Returns:

!(bool(v))

not
```
public static boolean not(BigInteger v)
```
Returns negative of bool(BigInteger)

Parameters:

v - the value to be evaluated

Returns:

!(bool(v))

not
```
public static boolean not(File file)
```
Returns negative of bool(File)

Parameters:

file - the file to be evaluated

Returns:

!(bool(file))

not
```
public static boolean not(Lang.Func0<?> f)
```
Returns negative of bool(Func0)

Parameters:

f - the function to be evaluated

Returns:

!(bool(f))

isNull
```
public static boolean isNull(Object o)
```
Check if an object is null or NONE

Parameters:

o - the object to test

Returns:

true if o is null or NONE, or false otherwise

isNotNull
```
public static boolean isNotNull(Object o)
```
Check if an object is not null and not NONE

Parameters:

o - the object to test

Returns:

false if o is null or NONE, or true otherwise

anyNull
```
public static boolean anyNull(Object o,
                              Object... oa)
```
Check if any objects in the parameter list is null

Parameters:

o - the first object to be checked

oa - the array of objects to be checked

Returns:

true if any one of the argument is null

allNull
```
public static boolean allNull(Object o,
                              Object... oa)
```
Check if all objects in the parameter list is null

Parameters:

o - the first object to be checked

oa - the array of objects to be checked

Returns:

false if any one of the argument is not null and not NONE

noneNull

public static boolean noneNull(Object o,
                               Object... oa)

toString
```
public static String toString(Object o)
```
Returns String representation of an object instance. Predicate the object specified is null or NONE, then an empty string is returned

Parameters:

o - the object which will be converted into a string

Returns:

a String representation of object

toString2

public static String toString2(Object o)

fmt
```
public static String fmt(String tmpl,
                         Object... args)
```
Alias of S.fmt(String, Object...)

Parameters:

tmpl - the format template

args - the format arguments

Returns:

the formatted string

Since:

0.2

iterableHashCode

public static int iterableHashCode(Iterable<?> it)

hc
```
public static int hc()
```

hc
```
public static int hc(boolean o)
```

hc
```
public static int hc(boolean[] oa)
```

hc
```
public static int hc(short o)
```

hc
```
public static int hc(short[] oa)
```

hc
```
public static int hc(byte o)
```

hc
```
public static int hc(byte[] oa)
```

hc
```
public static int hc(char o)
```

hc
```
public static int hc(char[] oa)
```

hc
```
public static int hc(int o)
```

hc
```
public static int hc(int[] oa)
```

hc
```
public static int hc(float o)
```

hc
```
public static int hc(float[] oa)
```

hc
```
public static int hc(long o)
```

hc
```
public static int hc(long[] oa)
```

hc
```
public static int hc(double o)
```

hc
```
public static int hc(double[] oa)
```
Calculate hashcode of double array specified

Parameters:

oa - the double array

Returns:

the hash code

hc
```
public static int hc(Object o)
```
Calculate hashcode of objects specified

Parameters:

o - object on which hash code to be calculated

Returns:

the calculated hash code

hc
```
public static int hc(Object o1,
                     Object o2)
```
Calculate hashcode of objects specified

Parameters:

o1 - object 1

o2 - object 2

Returns:

the calculated hash code

hc

public static int hc(Object o1,
                     Object o2,
                     Object o3)

Calculate hashcode of objects specified

Parameters:: o1 - object 1; o2 - object 2; o3 - object 3
Returns:: the calculated hash code

hc

public static int hc(Object o1,
                     Object o2,
                     Object o3,
                     Object o4)

Calculate hashcode of objects specified

Parameters:: o1 - object 1; o2 - object 2; o3 - object 3; o4 - object 4
Returns:: the calculated hash code

hc

public static int hc(Object o1,
                     Object o2,
                     Object o3,
                     Object o4,
                     Object o5)

Calculate hashcode of objects specified

Parameters:: o1 - object 1; o2 - object 2; o3 - object 3; o4 - object 4; o5 - object 5
Returns:: the calculated hash code

hc

public static int hc(Object o1,
                     Object o2,
                     Object o3,
                     Object o4,
                     Object o5,
                     Object... args)

Calculate hashcode of objects specified

Parameters:: o1 - object 1; o2 - object 2; o3 - object 3; o4 - object 4; o5 - object 5; args - other objects
Returns:: the calculated hash code

ms
```
public static long ms()
```
Return current time millis

Returns:

the current system time millis

Since:

0.2

ns
```
public static long ns()
```
Return current nano time

Returns:

the current system nano time

Since:

0.2

ts
```
public static long ts()
```
Return current time stamp in nano seconds. Alias of ns()

Returns:

the current system nao time

Since:

0.2

nil
```
public static void nil()
```
An empty method.

asEnum
```
public static <T extends Enum<T>> T asEnum(Class<T> enumClass,
                                           String name)
```
Return an enum value from code

Type Parameters:

T - the generic enum type

Parameters:

enumClass - the enum class

name - the name of the enum value. name is case insensitive

Returns:

the enum value or null if there is no value has the name specified

asEnum
```
public static <T extends Enum<T>> T asEnum(Class<T> enumClass,
                                           String name,
                                           boolean exactMatch)
```
Return an enum value from code

Type Parameters:

T - the generic enum type

Parameters:

enumClass - the enum class

name - the name of the enum value. name is case insensitive

exactMatch - specify whether it should do exact name lookup or keyword variable lookup

Returns:

the enum value or null if there is no value has the name specified

search
```
public static <T> int search(T element,
                             T... elements)
```
Search an element in a array

Type Parameters:

T - the type

Parameters:

element - the element to be located

elements - the array of element to be searched

Returns:

the location of the element inside elements, or -1 if not found

echo

public static void echo(String msg,
                        Object... args)

error

public static void error(String msg,
                         Object... args)

ifNullThen

public static <T> T ifNullThen(T t1,
                               T def1)

ensureGet

public static <T> T ensureGet(T t1,
                              T def1)

ifNullThen

public static <T> T ifNullThen(T t1,
                               Lang.F0<T> def1)

ensureGet

public static <T> T ensureGet(T t1,
                              Lang.F0<T> def1)

ensureGet

public static <T> T ensureGet(T t1,
                              T def1,
                              T def2)

ensureGet

public static <T> T ensureGet(T t1,
                              T def1,
                              T def2,
                              T def3)

ensureGet

public static <T> T ensureGet(T t1,
                              List<T> defs)

times

public static <T> T times(Lang.Function<T,T> func,
                          T initVal,
                          int n)

given

public static <T> Lang.Meta<T> given(T t)

having

public static <T> Lang.Meta<T> having(T t)

take

public static <T> Lang.Meta<T> take(T t)

is

public static Lang._IsClass is(Object t)

is

public static Lang._IsClass is(Class<?> c)

is

public static Lang._IsReflectMember is(Member member)

interfacesOf
```
public static Set<Class> interfacesOf(Class<?> type)
```
Returns all implemented interfaces of a give type

Parameters:

type - a class

Returns:

all interfaces type implements

superClassesOf
```
public static List<Class> superClassesOf(Class<?> type)
```
Returns all super classes of a given type ordered by affinity. The Object.class is always the last element in the list.

Parameters:

type - a class

Returns:

all super classes of type

allTypesOf
```
public static Set<Class> allTypesOf(Class<?> type)
```
Returns all types that

Parameters:

type -

Returns:

cast
```
public static <T> Lang.Option<T> cast(Object o,
                                      Class<T> c)
```
Cast an object to a type. Returns an Lang.Option describing the casted value if it can be casted to the type specified, otherwise returns NONE.

Type Parameters:

T - the type of the result option value

Parameters:

o - the object to be casted

c - specify the type to be casted to

Returns:

an Option describing the typed value or NONE if it cannot be casted

cast
```
public static <T> T cast(Object o)
```

notNull
```
@Deprecated
public static <T> T notNull(T o)
```
Deprecated.

Return the object if it is not null, otherwise throw out NullPointerException.

This method is deprecated. Please use requireNotNull(Object) instead

Type Parameters:

T - the type parameter of object

Parameters:

o - the object

Returns:

the object if it is not null

Throws:

NullPointerException - if o is null

requireNotNull
```
public static <T> T requireNotNull(T o)
```
Return the object if it is not null, otherwise throw out NullPointerException.

Type Parameters:

T - the type parameter of object

Parameters:

o - the object

Returns:

the object if it is not null

Throws:

NullPointerException - if o is null

requireNotNull
```
public static <T> T requireNotNull(T o,
                                   String errorTemplate,
                                   Object... errorArgs)
```
Return the object if it is not null, otherwise throw out NullPointerException with error message specified

Type Parameters:

T - the type parameter of object

Parameters:

o - the object

errorTemplate - the error message template

errorArgs - the error message arguments

Returns:

the object if it is not null

Throws:

NullPointerException - if o is null

setField
```
public static <T,F> T setField(String fieldName,
                               T obj,
                               F val)
```
Set an object field value using reflection.

Type Parameters:

T - the type of the object

F - the type of the field value

Parameters:

fieldName - the name of the field to be set

obj - the object on which the value will be set

val - the value to be set to the field

Returns:

the object that has the new value set on the field specified

setFieldValue

public static <T,F> T setFieldValue(String fieldName,
                                    T obj,
                                    F val)

Alias of setField(String, Object, Object)

setField

public static void setField(String fieldName,
                            Class<?> type,
                            Object val)

Set value to a static field of given class

Parameters:: fieldName - the name of the field; type - the class hosts the field; val - the value to be set on the static field

setFieldValue

public static void setFieldValue(String fieldName,
                                 Class<?> type,
                                 Object val)

Alias of setField(String, Class, Object)

getFieldValue
```
public static <T> T getFieldValue(Object obj,
                                  Field field)
```
Get value of an object field.

Type Parameters:

T - the field type

Parameters:

obj - the object

field - the field

Returns:

the value of the field in the object

setFieldValue

public static void setFieldValue(Object obj,
                                 Field field,
                                 Object fieldValue)

setStaticFieldValue

public static void setStaticFieldValue(Field field,
                                       Object fieldValue)

setStaticFieldValue

public static void setStaticFieldValue(Class host,
                                       String fieldName,
                                       Object fieldValue)

resetFieldValue

public static void resetFieldValue(Object obj,
                                   Field field)

isSimpleType
```
public static boolean isSimpleType(Class<?> c)
```
Check if a give class c is a simple type. The following classes are considered to be simple type: 1. primitive types, e.g. int.class 2. Wrapper type of primitive types, e.g. Integer.class 3. String.class 4. Any class extends Enum.class 5. Locale.class

Parameters:

c - the class to be checked

Returns:

true if the give type c is simple type as described above

isCollectionType
```
public static boolean isCollectionType(Class<?> c)
```
Check if a given class c is a collection type. A collection type here means java.util.Collection plus an array class.

Parameters:

c - the class to be checked

Returns:

true if the given type c is a Collection or array

isImmutable
```
public static boolean isImmutable(Object o)
```
Check if an Object or class is immutable

Parameters:

o - the object to be checked

Returns:

true if the object is immutable or false otherwise

isPrimitiveType
```
public static boolean isPrimitiveType(Class<?> c)
```
Check if a given class is a primitive type.

Parameters:

c - the class

Returns:

true if c is primitive type

isPrimitive
```
@Deprecated
public static boolean isPrimitive(Class<?> c)
```
Deprecated.

Check if a given class is a primitive type.

This method is deprecated. Please use isPrimitiveType(Class) instead

Parameters:

c - the class

Returns:

true if c is primitive type

isPrimitiveType
```
public static boolean isPrimitiveType(String name)
```
Check if a given string is a primitive type name.

Parameters:

name - the string to be test

Returns:

true if name is primitive type name

isWrapperType
```
public static boolean isWrapperType(Class<?> c)
```
Check if a given class is a wrapper type of a primitive type.

Parameters:

c - the class

Returns:

true if c is wrapper type

isWrapper
```
@Deprecated
public static boolean isWrapper(Class<?> c)
```
Deprecated.

Check if a given class is a wrapper type of a primitive type.

This method is deprecated, please use isWrapperType(Class) instead.

Parameters:

c - the class

Returns:

true if c is wrapper type

wrapperClassOf

public static Class wrapperClassOf(Class c)

primitiveTypeOf

public static Class primitiveTypeOf(Class c)

classForName

public static <T> Class<T> classForName(String className)

classForName

public static <T> Class<T> classForName(String className,
                                        ClassLoader classLoader)

safeClassForName

public static <T> Lang.Option<Class<T>> safeClassForName(String className)

safeClassForName

public static <T> Lang.Option<Class<T>> safeClassForName(String className,
                                                         ClassLoader classLoader)

newInstance

public static <T> T newInstance(String className)

newInstance

public static <T> T newInstance(String className,
                                ClassLoader cl)

safeNewInstance

public static <T> Lang.Option<T> safeNewInstance(String className)

primitiveDefaultValue

public static <T> T primitiveDefaultValue(Class<T> c)

newInstance

public static <T> T newInstance(Class<T> c)

newInstance

public static <T,P1> T newInstance(Class<T> c,
                                   P1 p1)

newInstance

public static <T,P1,P2> T newInstance(Class<T> c,
                                      P1 p1,
                                      P2 p2)

newInstance

public static <T,P1,P2,P3> T newInstance(Class<T> c,
                                         P1 p1,
                                         P2 p2,
                                         P3 p3)

newInstance

public static <T,P1,P2,P3,P4> T newInstance(Class<T> c,
                                            P1 p1,
                                            P2 p2,
                                            P3 p3,
                                            P4 p4)

newInstance

public static <T,P1,P2,P3,P4,P5> T newInstance(Class<T> c,
                                               P1 p1,
                                               P2 p2,
                                               P3 p3,
                                               P4 p4,
                                               P5 p5)

newInstance

public static <T> T newInstance(Class<T> c,
                                Object p1,
                                Object p2,
                                Object p3,
                                Object p4,
                                Object p5,
                                Object... pa)

fieldOf
```
public static Field fieldOf(Class<?> c,
                            String name)
```
Returns non-static field of a class by name. The field might be non-public declared in super classes of the supplied class

Parameters:

c - the class

name - the name of the field

Returns:

the field instance or null if not found

fieldOf
```
public static Field fieldOf(Class<?> c,
                            String name,
                            boolean noStatic)
```
Returns field of a class by name. The field could be non-public field of super class of the class specified

Parameters:

c - the class

name - the name of the field

noStatic - specify if static fields shall be included

Returns:

the field instance or null if not found

fieldOf
```
public static Field fieldOf(Class<?> c,
                            String name,
                            Class<?> rootClass,
                            boolean noStatic)
```
Returns field of a class by name. The field could be non-public field of super class of the class specified

Parameters:

c - the class

name - the name of the field

rootClass - the class that stops of the recurive operation. Default is Object.class

noStatic - specify if static fields shall be included

Returns:

the field instance or null if not found

fieldsOf
```
public static List<Field> fieldsOf(Class<?> c)
```
Returns all fields of a class and all super classes. Note all fields returned will be called on AccessibleObject.setAccessible(boolean) with value true

Parameters:

c - the class

Returns:

a list of fields

fieldsOf
```
public static List<Field> fieldsOf(Class<?> c,
                                   Lang.Function<Field,Boolean> filter)
```
Returns all fields of a class and all super classes. Note all fields returned will be called on AccessibleObject.setAccessible(boolean) with value true

Parameters:

c - the class

filter - specify which field will be put into the list if not null

Returns:

a list of fields

fieldsOf
```
public static List<Field> fieldsOf(Class<?> c,
                                   boolean noStatic)
```
Returns all fields of a class and all super classes. Note all fields returned will be called on AccessibleObject.setAccessible(boolean) with value true

Parameters:

c - the class

noStatic - specify if static fields shall be included. Default: true

Returns:

a list of fields

fieldsOf
```
public static List<Field> fieldsOf(Class<?> c,
                                   Class<?> rootClass,
                                   boolean noStatic)
```
Returns all fields of a class and all super classes until root class. Note all fields returned will be called on AccessibleObject.setAccessible(boolean) with value true

Parameters:

c - the class

rootClass - the class that stops the recursive operation

noStatic - specify if static fields should be included

Returns:

a list of fields

fieldsOf
```
public static List<Field> fieldsOf(Class<?> c,
                                   Class<?> rootClass,
                                   boolean includeRootClass,
                                   boolean noStatic)
```
Returns all fields of a class and all super classes until root class. Note all fields returned will be called on AccessibleObject.setAccessible(boolean) with value true

Parameters:

c - the class

rootClass - the class that stops the recursive operation

noStatic - specify if static fields should be included

Returns:

a list of fields

fieldsOf
```
public static List<Field> fieldsOf(Class<?> c,
                                   Class<?> rootClass,
                                   Lang.Function<Field,Boolean> filter)
```
Returns all fields of a class and all super classes until root class. Note all fields returned will be called on AccessibleObject.setAccessible(boolean) with value true.

Parameters:

c - the class

rootClass - the class that stops the recursive lookup

filter - specify which field should be put into the list if not null

Returns:

the list of fields

fieldsOf
```
public static List<Field> fieldsOf(Class<?> c,
                                   Class<?> rootClass,
                                   boolean includeRootClass,
                                   Lang.Function<Field,Boolean> filter)
```
Returns all fields of a class and all super classes until root class. Note all fields returned will be called on AccessibleObject.setAccessible(boolean) with value true.

Parameters:

c - the class

rootClass - the class that stops the recursive lookup

includeRootClass - specify root class itself needs to be checked or not

filter - specify which field should be put into the list if not null

Returns:

the list of fields

fieldsOf
```
public static List<Field> fieldsOf(Class<?> c,
                                   Lang.Function<Class<?>,Boolean> classFilter,
                                   Lang.Function<Field,Boolean> fieldFilter)
```
Returns all fields of a class and all super classes until classFilter not applied. Note all fields returned will be called on AccessibleObject.setAccessible(boolean) with value true.

Parameters:

c - the class

classFilter - the filter to check if it should break recursive call

fieldFilter - specify which field should be put into the list if not null

Returns:

the list of fields

invokeStatic
```
public static <T,R> R invokeStatic(Class<T> c,
                                   String methodName,
                                   Object... pa)
```
Invoke a static method by name and parameters

Type Parameters:

T - the generic type of the class

R - the generic type of the return result

Parameters:

c - the class

methodName - the method name

pa - the parameters

Returns:

the result of method invocation

invokeStatic
```
public static <T,R> R invokeStatic(Lang.Var<Method> methodBag,
                                   Class<T> c,
                                   String methodName,
                                   Object... pa)
```
Invoke a static method by name and parameters. After invocation it will cache the method into method bag supplied. This method will convert all checked exception into corresponding runtime exception

Type Parameters:

T - the generic type of class

R - the generic type of return instance

Parameters:

methodBag - the method bag

c - the class

methodName - the method name

pa - the parameters

Returns:

the result of method invocation

invokeStatic
```
public static <R> R invokeStatic(Method method,
                                 Object... pa)
```
Invoke a static method. This method will convert all checked exception into corresponding runtime exception

Type Parameters:

R - the generic type of the return result

Parameters:

method - the method

pa - the arguments to invoke the method

Returns:

the result of the method invocation

invokeVirtual
```
public static <T,R> R invokeVirtual(Lang.Var<Method> methodBag,
                                    T o,
                                    String methodName,
                                    Object... pa)
```
Invoke a virtual method by instance, method name and arguments. This method will convert all checked exception into corresponding runtime exception.

After invocation, the method will be cached into the method bag supplied

Type Parameters:

T - generic type of the instance object

R - generic type of the return result

Parameters:

methodBag - A function to cache the method found by name and arguments

o - the instance on which the virtual method will be invoked

methodName - the method name

pa - the arguments

Returns:

result of method invocation

invokeVirtual
```
public static <T,R> R invokeVirtual(T o,
                                    String methodName,
                                    Object... pa)
```
Invoke a virtual method by instance, method name and arguments. This method will convert all checked exception into corresponding runtime exception

Type Parameters:

T - generic type of the instance object

R - generic type of the return result

Parameters:

o - the instance on which the virtual method will be invoked

methodName - the method name

pa - the arguments

Returns:

result of method invocation

invokeVirtual
```
public static <T,R> R invokeVirtual(T o,
                                    Method method,
                                    Object... pa)
```
Invoke a virtual method. This method will convert all checked exception to corresponding runtime exception

Type Parameters:

T - generic type of the instance

R - generic type of the result

Parameters:

o - the instance on which the method will be invoked

method - the method

pa - the arguments

Returns:

result of method invocation

getMethod

public static Method getMethod(Class c,
                               String methodName,
                               Object... pa)

Returns Method by name and parameter value

Parameters:: c - the class; methodName - the method name; pa - the parameter used to invoke the method
Returns:: the method or null if not found

getMethod

public static Method getMethod(Class c,
                               String methodName,
                               Class... argTypes)

Returns Method by name and argument type

Parameters:: c - the class; methodName - the method name; argTypes - the argument types
Returns:: the method or null if not found

getProperty

public static <T> T getProperty(Object entity,
                                String property)

getProperty

public static <T> T getProperty(CacheService cache,
                                Object entity,
                                String property)

setProperty

public static void setProperty(Object entity,
                               Object val,
                               String property)

setProperty

public static void setProperty(CacheService cache,
                               Object entity,
                               Object val,
                               String property)

serialize

public static <T> byte[] serialize(T obj)

materialize

public static <T> T materialize(byte[] ba,
                                Class<T> c)

deserialize

public static <T> T deserialize(byte[] ba,
                                Class<T> c)

materialize

public static <T> T materialize(byte[] ba)

deserialize

public static <T> T deserialize(byte[] ba)

newArray
```
public static <T> T[] newArray(T[] model)
```
Create an new array with specified array type and length

Type Parameters:

T - the array component type

Parameters:

model - the model array

Returns:

an new array with the same component type of model and length of model

newArray
```
public static <T> T[] newArray(T[] model,
                               int size)
```
Create an new array with specified type and length

Type Parameters:

T - the component type

Parameters:

model - the model array

size - the new array length

Returns:

an new array with the same type of model and length equals to size

newArray

public static int[] newArray(int[] model)

newArray

public static int[] newArray(int[] model,
                             int size)

newArray

public static byte[] newArray(byte[] model)

newArray

public static byte[] newArray(byte[] model,
                              int size)

newArray

public static char[] newArray(char[] model)

newArray

public static char[] newArray(char[] model,
                              int size)

newArray

public static short[] newArray(short[] model)

newArray

public static short[] newArray(short[] model,
                               int size)

newArray

public static long[] newArray(long[] model)

newArray

public static long[] newArray(long[] model,
                              int size)

newArray

public static float[] newArray(float[] model)

newArray

public static float[] newArray(float[] model,
                               int size)

newArray

public static double[] newArray(double[] model)

newArray

public static double[] newArray(double[] model,
                                int size)

newArray

public static boolean[] newArray(boolean[] model)

newArray

public static boolean[] newArray(boolean[] model,
                                 int size)

resetArray

public static boolean[] resetArray(boolean[] array)

resetArray

public static byte[] resetArray(byte[] array)

resetArray

public static short[] resetArray(short[] array)

resetArray

public static char[] resetArray(char[] array)

resetArray

public static int[] resetArray(int[] array)

resetArray

public static float[] resetArray(float[] array)

resetArray

public static long[] resetArray(long[] array)

resetArray

public static double[] resetArray(double[] array)

resetArray

public static <T> T[] resetArray(T[] array)

resetArray

public static Object resetArray(Object array)

subarray

public static <T> T[] subarray(T[] src,
                               int begin,
                               int end)

subarray

public static boolean[] subarray(boolean[] src,
                                 int begin,
                                 int end)

subarray

public static byte[] subarray(byte[] src,
                              int begin,
                              int end)

subarray

public static short[] subarray(short[] src,
                               int begin,
                               int end)

subarray

public static char[] subarray(char[] src,
                              int begin,
                              int end)

subarray

public static int[] subarray(int[] src,
                             int begin,
                             int end)

subarray

public static float[] subarray(float[] src,
                               int begin,
                               int end)

subarray

public static long[] subarray(long[] src,
                              int begin,
                              int end)

subarray

public static double[] subarray(double[] src,
                                int begin,
                                int end)

concat

public static <T> T[] concat(T[] a,
                             T t)

concat

public static <T> T[] concat(T[] a1,
                             T[] a2)

concat

public static <T> T[] concat(T[] a1,
                             T[] a2,
                             T[]... rest)

concat

public static int[] concat(int[] a1,
                           int[] a2)

concat

public static int[] concat(int[] a1,
                           int[] a2,
                           int[]... rest)

concat

public static boolean[] concat(boolean[] a1,
                               boolean[] a2)

concat

public static boolean[] concat(boolean[] a1,
                               boolean[] a2,
                               boolean[]... rest)

concat

public static byte[] concat(byte[] a1,
                            byte[] a2)

concat

public static byte[] concat(byte[] a1,
                            byte[] a2,
                            byte[]... rest)

concat

public static short[] concat(short[] a1,
                             short[] a2)

concat

public static short[] concat(short[] a1,
                             short[] a2,
                             short[]... rest)

concat

public static char[] concat(char[] a1,
                            char[] a2)

concat

public static char[] concat(char[] a1,
                            char[] a2,
                            char[]... rest)

concat

public static long[] concat(long[] a1,
                            long[] a2)

concat

public static long[] concat(long[] a1,
                            long[] a2,
                            long[]... rest)

concat

public static float[] concat(float[] a1,
                             float[] a2)

concat

public static float[] concat(float[] a1,
                             float[] a2,
                             float[]... rest)

concat

public static double[] concat(double[] a1,
                              double[] a2)

concat

public static double[] concat(double[] a1,
                              double[] a2,
                              double[]... rest)

fill

public static void fill(boolean element,
                        boolean[] array)

fill

public static void fill(byte element,
                        byte[] array)

fill

public static void fill(char element,
                        char[] array)

fill

public static void fill(short element,
                        short[] array)

fill

public static void fill(int element,
                        int[] array)

fill

public static void fill(float element,
                        float[] array)

fill

public static void fill(long element,
                        long[] array)

fill

public static void fill(double element,
                        double[] array)

fill

public static <T> void fill(T element,
                            T[] array)

reverse

public static boolean[] reverse(boolean[] a)

reverse

public static byte[] reverse(byte[] a)

reverse

public static char[] reverse(char[] a)

reverse

public static short[] reverse(short[] a)

reverse
```
public static int[] reverse(int[] a)
```

reverse

public static float[] reverse(float[] a)

reverse

public static long[] reverse(long[] a)

reverse

public static double[] reverse(double[] a)

reverse

public static Object[] reverse(Object[] a)

asPrimitive

public static boolean[] asPrimitive(Boolean[] oa)

asObject

public static Boolean[] asObject(boolean[] pa)

asPrimitive

public static byte[] asPrimitive(Byte[] oa)

asObject

public static Byte[] asObject(byte[] pa)

asPrimitive

public static char[] asPrimitive(Character[] oa)

asObject

public static Character[] asObject(char[] pa)

asPrimitive

public static short[] asPrimitive(Short[] oa)

asObject

public static Short[] asObject(short[] pa)

asPrimitive

public static int[] asPrimitive(Integer[] oa)

asObject

public static Integer[] asObject(int[] pa)

asPrimitive

public static long[] asPrimitive(Long[] oa)

asObject

public static Long[] asObject(long[] pa)

asPrimitive

public static float[] asPrimitive(Float[] oa)

asObject

public static Float[] asObject(float[] pa)

asPrimitive

public static double[] asPrimitive(Double[] oa)

asObject

public static Double[] asObject(double[] pa)

random
```
public static <T extends Enum> T random(Class<T> enumType)
```
Pickup a random enum value from the enum type.

Type Parameters:

T - the type parameter

Parameters:

enumType - the enum type

Returns:

the random enum value

random
```
@SafeVarargs
public static <T> T random(T t1,
                                        T... ta)
```
Returns a random element picked from t1 and elements in ta.

Type Parameters:

T - type parameter

Parameters:

t1 - the first element

ta - the rest elements

Returns:

the random picked up element.

secureRandom

public static <T> T secureRandom(T t1,
                                 T... ta)

The secure version of random(Object, Object[]).

random
```
public static int random(int[] a)
```

random
```
public static long random(long[] a)
```

random

public static boolean random(boolean[] a)

random

public static float random(float[] a)

random

public static double random(double[] a)

random

public static short random(short[] a)

random
```
public static byte random(byte[] a)
```

random
```
public static char random(char[] a)
```

random
```
public static <T> T random(T[] ta)
```
Returns a random element picked from elements in ta.

Type Parameters:

T - type parameter

Parameters:

ta - the elements

Returns:

the random picked up element.

secureRandom
```
public static <T> T secureRandom(T[] ta)
```
The secure version of random(Object[]).

random
```
public static <T> T random(List<T> list)
```
Returns a random element picked from elements in a list.

Type Parameters:

T - type parameter

Parameters:

list - the element list

Returns:

the random picked up element.

randomSubList
```
public static <T> List<T> randomSubList(List<T> list)
```
Create a list contains random selected elements in the list specified.

Type Parameters:

T - the type parameter

Parameters:

list - the list

Returns:

a list contains random selected elements in list

randomSubList
```
public static <T> List<T> randomSubList(List<T> list,
                                        int minSize)
```
Create a list contains random selected elements in the list specified.

Type Parameters:

T - the type parameter

Parameters:

list - the list

minSize - the minimum number of elements in the result list

Returns:

a list contains random selected elements in list

secureRandom

public static <T> T secureRandom(List<T> list)

The secure version of random(List).

random
```
public static <T> T random(C.Range<T> range)
```
Returns a random element picked from elements in a range.

Type Parameters:

T - type parameter

Parameters:

range - the range

Returns:

the random picked up element.

secureRandom

public static <T> T secureRandom(C.Range<T> range)

The secure version of random(C.Range).

randomStr
```
public static String randomStr()
```
Alias of S.random()

randomStr

public static String randomStr(int len)

Alias of S.random(int)

NPE
```
public static <T> T NPE(T o)
```

commonSuperTypeOf

public static Class<?> commonSuperTypeOf(Object o1,
                                         Object o2,
                                         Object... others)

commonSuperTypeOf

public static Class<?> commonSuperTypeOf(Collection<?> objects)

async
```
public static <T> Future<T> async(Lang.F0<T> callback,
                                  int milliseconds)
```
Execute callback asynchronously after delay specified

Type Parameters:

T - return type

Parameters:

callback - the callback function to be executed

milliseconds - the delay

Returns:

the result of the callback

contextLocal

public static <T> ContextLocal<T> contextLocal()

contextLocal

public static <T> ContextLocal<T> contextLocal(ContextLocal.InitialValueProvider<T> ivp)

evaluate
```
public static Map<String,Object> evaluate(Annotation anno)
```
Evaluate Annotation properties

Parameters:

anno - the annotation instance

Returns:

a Map contains annotation instance properties

clone
```
public static Lang._MappingStage clone(Object source)
```
Prepare a DataMapper.Semantic.DEEP_COPY from source to an new instance with the same time of source

Parameters:

source - the source object

Returns:

a Lang._MappingStage that are ready to do deep copy to new instance of source type

cloneOf
```
public static <T> T cloneOf(T source)
```
Returns clone of a given source object.

This is done by doing a DataMapper.Semantic.DEEP_COPY from source object to an new instance of source type

Type Parameters:

T - the type parameter of the object class

Parameters:

source - the object to be clone

Returns:

the clone of source

cloneOf

public static String[] cloneOf(String[] array)

cloneOf

public static boolean[] cloneOf(boolean[] array)

cloneOf

public static short[] cloneOf(short[] array)

cloneOf

public static byte[] cloneOf(byte[] array)

cloneOf

public static char[] cloneOf(char[] array)

cloneOf

public static int[] cloneOf(int[] array)

cloneOf

public static float[] cloneOf(float[] array)

cloneOf

public static long[] cloneOf(long[] array)

cloneOf

public static double[] cloneOf(double[] array)

cloneOf
```
public static <T> T cloneOf(T source,
                            Lang.Function<Class,?> instanceFactory)
```
Returns clone of a given source object.

This is done by doing a DataMapper.Semantic.DEEP_COPY from source object to an new instance of source type

Type Parameters:

T - the type parameter of the object class

Parameters:

source - the object to be clone

instanceFactory - A function that is used to create new instance of the clone

Returns:

the clone of source

copy
```
public static Lang._MappingStage copy(Object source)
```
Prepare a Mapping operation with shallow copy semantic

Parameters:

source - the source object

Returns:

a Lang._MappingStage

deepCopy
```
public static Lang._MappingStage deepCopy(Object source)
```
Prepare a Mapping operation with deep copy semantic

Parameters:

source - the source object

Returns:

a Lang._MappingStage

flatCopy
```
public static Lang._MappingStage flatCopy(Object source)
```
Prepare a Mapping operation with flat copy semantic

Parameters:

source - the source object

Returns:

a Lang._MappingStage

merge
```
public static Lang._MappingStage merge(Object source)
```
Prepare a Mapping operation with merge semantic

Parameters:

source - the source object

Returns:

a Lang._MappingStage

map
```
public static Lang._MappingStage map(Object source)
```
Prepare a Mapping operation with map semantic and keyword matching

Parameters:

source - the source object

Returns:

a Lang._MappingStage

mergeMap
```
public static Lang._MappingStage mergeMap(Object source)
```
Prepare a Mapping operation with merge map semantic and keyword matching

Parameters:

source - the source object

Returns:

a Lang._MappingStage

sleep
```
public static void sleep(long ms)
```
A convenient shortcut for Thread.sleep(long). It throws an RuntimeException version of InterruptedException when current thread is interrupted: UnexpectedInterruptedException

Parameters:

ms - the milliseconds to sleep the current thread

init
```
public static void init()
```

Class Lang

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

VERSION

INSTANCE

F0

F1

F2

F3

F4

F5

BREAK

NONE

DUMB

propertyHandlerFactory

conf

JAVA_VERSION

IS_SERVER

IS_64

OS

Constructor Detail

Lang

Method Detail

equals

hashCode

toString

factory

f0

f0

f1

f1

f1

f2

f2

f3

f3

f4

f4

f5

f5

comparator

comparator

predicate

generalPredicate

visitor

guardedVisitor

breakOut

indexGuardedVisitor

convert

Tuple

T2

Binary

Pair

T3

T4

T5

some

none

var

var

val

constant

constant

eq

eq2

eq

eq

eq

eq

eq

eq

eq

eq

ne

bool

bool