Osgl (Java Tool 1.2.2 API)

java.lang.Object
- org.osgl.Osgl

All Implemented Interfaces:

Serializable

Direct Known Subclasses:

$
```
public class Osgl
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 Osgl.F namespace
More about function interface

Under Osgl, there are six function interfaces defined, from Osgl.Func0 to Osgl.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 Osgl.F0 to Osgl.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 Osgl.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(Osgl.Func2<Integer, String> f) {
         F2<Integer, String> newF = Osgl.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 Osgl.F0 to Osgl.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, Osgl.f0() to Osgl.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 interface`	`Osgl.Bijection<X,Y>` See http://en.wikipedia.org/wiki/Bijection.
`static class`	`Osgl.Break` A Break is used to shortcut a sequence of function executions
`static class`	`Osgl.Comparator<T>` Adapt JDK Comparator (since 1.2) to Functional programming.
`static class`	`Osgl.Conf` Namespace to configure or extend OSGL _ utilities
`static class`	`Osgl.F` The namespace to aggregate predefined core functions
`static class`	`Osgl.F0<R>` Default implementation for `Osgl.Func0`.
`static class`	`Osgl.F1<P1,R>` Base implementation of `Osgl.Function` function.
`static class`	`Osgl.F2<P1,P2,R>` Base implementation of `Osgl.Func2` function.
`static class`	`Osgl.F3<P1,P2,P3,R>` Base implementation of `Osgl.Func3` function.
`static class`	`Osgl.F4<P1,P2,P3,P4,R>` Base implementation of `Osgl.Func4` function.
`static class`	`Osgl.F5<P1,P2,P3,P4,P5,R>` Base implementation of `Osgl.Func5` function.
`static class`	`Osgl.Factory<T>` The class adapt traditional Factory to Function
`static interface`	`Osgl.Func0<R>` Define a function that apply to no parameter (strictly this is not a function)
`static interface`	`Osgl.Func1<P1,R>` Alias of `Osgl.Function`
`static interface`	`Osgl.Func2<P1,P2,R>` Define a function structure that accept two parameter
`static interface`	`Osgl.Func3<P1,P2,P3,R>` Define a function structure that accept three parameter
`static interface`	`Osgl.Func4<P1,P2,P3,P4,R>` Define a function structure that accept four parameter
`static interface`	`Osgl.Func5<P1,P2,P3,P4,P5,R>` Define a function structure that accept five parameter
`static class`	`Osgl.FuncBase` The base for all Fx function class implemention
`static interface`	`Osgl.Function<T,U>` Define a function structure that accept one parameter.
`static class`	`Osgl.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`	`Osgl.Meta<T>`
`static interface`	`Osgl.MultiplicableFunction<P1,R>` A `Osgl.Function` function that support `Osgl.MultiplicableFunction.times(int)` operation
`static class`	`Osgl.None<T>`
`static class`	`Osgl.Operator<T>`
`static class`	`Osgl.Option<T>` Defines an option of element `T`.
`static class`	`Osgl.Predicate<T>` `Predicate` is a predefined `Function<Boolean, T>` typed function with a set of utilities dealing with boolean operations.
`static class`	`Osgl.Processor<T>` Define a processor function which applied to one parameter and return the parameter instance after processing on the parameter
`static class`	`Osgl.Some<T>`
`static class`	`Osgl.T2<A,B>`
`static class`	`Osgl.T3<A,B,C>`
`static class`	`Osgl.T4<A,B,C,D>`
`static class`	`Osgl.T5<A,B,C,D,E>`
`static class`	`Osgl.Transformer<FROM,TO>` A Transformer is literally a kind of `Osgl.F1` function
`static class`	`Osgl.Tuple<A,B>`
`static class`	`Osgl.V1<P1>`
`static class`	`Osgl.V2<P1,P2>`
`static class`	`Osgl.V3<P1,P2,P3>`
`static class`	`Osgl.V4<P1,P2,P3,P4>`
`static class`	`Osgl.V5<P1,P2,P3,P4,P5>`
`static class`	`Osgl.Val<T>`
`static class`	`Osgl.Var<T>`
`static class`	`Osgl.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 Osgl.Break`	`BREAK` A predefined Break instance without payload
`static Osgl.Conf`	`conf`
`static Osgl.F0`	`F0` A dumb function for `Osgl.Func0` that does nothing and return `null`
`static Osgl.F1`	`F1` A dumb `Osgl.Function` implementation that does nothing and return null
`static Osgl.F2`	`F2` A dumb `Osgl.Func2` implementation that does nothing and return null
`static Osgl.F3`	`F3` A dumb `Osgl.Func3` implementation that does nothing and return null
`static Osgl.F4`	`F4` A dumb `Osgl.Func4` implementation that does nothing and return null
`static Osgl.F5`	`F5` A dumb `Osgl.Func5` implementation that does nothing and return null
`static Osgl`	`INSTANCE`
`static boolean`	`IS_64`
`static boolean`	`IS_SERVER`
`static int`	`JAVA_VERSION`
`static Osgl.None`	`NONE`
`static OS`	`OS`
`static PropertyHandlerFactory`	`propertyHandlerFactory`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Osgl()

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`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 caseSensitive)` 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(Osgl.F0<T> callback, int milliseconds)` Execute callback asynchronously after delay specified
`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(long v)` Do bool evaluation on a long value
`static boolean`	`bool(Object v)` Evaluate an object's bool value.
`static boolean`	`bool(Osgl.Func0<?> v)` Do bool evaluation on an `Osgl.Func0` instance.
`static boolean`	`bool(String s)` Do bool evaluation on a String.
`static <T> Osgl.Break`	`breakOut(T e)` A utility method to throw out a Break with payload
`static <T> T`	`cast(Object o)`
`static <T> Osgl.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 <T> Osgl.Comparator<T>`	`comparator(Comparator<? super T> c)` Adapt a jdk `Comparator` into `osgl Comparator`
`static <T> Osgl.Comparator<T>`	`comparator(Osgl.Func2<? super T,? super T,Integer> f)` Adapt a general `Osgl.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 <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, List<T> defs)`
`static <T> T`	`ensureGet(T t1, Osgl.F0<T> def1)`
`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> Osgl.F0<T>`	`f0()` Return a dumb function for `Osgl.Func0`.
`static <R> Osgl.F0<R>`	`f0(Osgl.Func0<? extends R> f0)` Convert a general `Osgl.Func0` typed function to `Osgl.F0` type
`static <P1,R> Osgl.F1<P1,R>`	`f1()` The type-safe version of `F1`
`static <X,Y> Osgl.F1<X,Y>`	`f1(Osgl.Bijection<X,Y> f1)`
`static <P1,R> Osgl.F1<P1,R>`	`f1(Osgl.Function<? super P1,? extends R> f1)` Convert a general `Osgl.Function` function into a `Osgl.F1` typed function
`static <P1,P2,R> Osgl.F2<P1,P2,R>`	`f2()` The type-safe version of `F2`
`static <P1,P2,R> Osgl.F2<P1,P2,R>`	`f2(Osgl.Func2<? super P1,? super P2,? extends R> f2)` Convert a general `Osgl.Func2` function into a `Osgl.F2` typed function
`static <P1,P2,P3,R> Osgl.F3<P1,P2,P3,R>`	`f3()` The type-safe version of `F3`
`static <P1,P2,P3,R> Osgl.F3<P1,P2,P3,R>`	`f3(Osgl.Func3<? super P1,? super P2,? super P3,? extends R> f3)` Convert a general `Osgl.Func3` function into a `Osgl.F3` typed function
`static <P1,P2,P3,P4,R> Osgl.F4<P1,P2,P3,P4,R>`	`f4()` The type-safe version of `F4`
`static <P1,P2,P3,P4,R> Osgl.F4<P1,P2,P3,P4,R>`	`f4(Osgl.Func4<? super P1,? super P2,? super P3,? super P4,? extends R> f4)` Convert a general `Osgl.Func4` function into a `Osgl.F4` typed function
`static <P1,P2,P3,P4,P5,R> Osgl.F5<P1,P2,P3,P4,P5,R>`	`f5()` The type-safe version of `F5`
`static <P1,P2,P3,P4,P5,R> Osgl.F5<P1,P2,P3,P4,P5,R>`	`f5(Osgl.Func5<? super P1,? super P2,? super P3,? super P4,? super P5,? extends R> f5)` Convert a general `Osgl.Func5` function into a `Osgl.F5` typed function
`static <T> Osgl.Factory<T>`	`factory(Osgl.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, Osgl.Function<Field,Boolean> filter)` Returns all fields of a class and all super classes until root class.
`static List<Field>`	`fieldsOf(Class<?> c, Osgl.Function<Class<?>,Boolean> classFilter, Osgl.Function<Field,Boolean> fieldFilter)`
`static List<Field>`	`fieldsOf(Class<?> c, Osgl.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 String`	`fmt(String tmpl, Object... args)` Alias of `S.fmt(String, Object...)`
`static <T> Osgl.Predicate<T>`	`generalPredicate(Osgl.Function<? super T,?> f)` Convert a general `Function<T, ?>` typed function to `Predicate<T>` function.
`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> Osgl.Visitor<T>`	`guardedVisitor(Osgl.Function<? super T,Boolean> predicate, Osgl.Function<? super T,?> visitor)` Return a composed visitor function that only applies when the guard predicate test returns `true`
`int`	`hashCode()`
`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, Osgl.F0<T> def1)`
`static <T> T`	`ifNullThen(T t1, T def1)`
`static <K,T> Osgl.IndexedVisitor<K,T>`	`indexGuardedVisitor(Osgl.Function<? super K,Boolean> guard, Osgl.Visitor<? super T> visitor)`
`static <T,R> R`	`invokeStatic(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`	`invokeStatic(Osgl.Var<Method> methodBag, Class<T> c, String methodName, Object... pa)` Invoke a static method by name and parameters.
`static <T,R> R`	`invokeVirtual(Osgl.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 boolean`	`isNull(Object o)` Check if an object is `null` or `NONE`
`static boolean`	`isSimpleType(Class<?> c)` Check if a give class `c` is a simple type.
`static int`	`iterableHashCode(Iterable<?> it)`
`static <T> T`	`materialize(byte[] ba)`
`static <T> T`	`materialize(byte[] ba, Class<T> c)`
`static <T> Osgl.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> Osgl.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(long v)` Returns negative of `bool(long)`
`static boolean`	`not(Object o)` Returns negative of `bool(java.lang.Object)`
`static boolean`	`not(Osgl.Func0<?> f)` Returns negative of `bool(Osgl.Func0)`
`static boolean`	`not(String s)` Returns negative of `bool(java.lang.String)`
`static <T> T`	`notNull(T o)`
`static <T> T`	`NPE(T o)`
`static long`	`ns()` Return `current nano time`
`static <T> Osgl.Predicate<T>`	`predicate(Osgl.Function<? super T,Boolean> f)` Convert a `Function<T, Boolean>` typed function to `Predicate<T>` function.
`static Class`	`primitiveTypeOf(Class c)`
`static <T> T`	`random(C.Range<T> range)`
`static <T> T`	`random(List<T> list)`
`static <T> T`	`random(T[] ta)`
`static <T> T`	`random(T t1, T... ta)`
`static String`	`randomStr()`
`static String`	`randomStr(int len)`
`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> Osgl.Option<Class<T>>`	`safeClassForName(String className)`
`static <T> Osgl.Option<Class<T>>`	`safeClassForName(String className, ClassLoader classLoader)`
`static <T> Osgl.Option<T>`	`safeNewInstance(String className)`
`static <T> int`	`search(T element, T... elements)` Search an element in a array
`static <T> byte[]`	`serialize(T obj)`
`static <T,F> T`	`setField(String fieldName, T obj, F val)` Set an object field value using reflection.
`static void`	`setProperty(CacheService cache, Object entity, Object val, String property)`
`static void`	`setProperty(Object entity, Object val, String property)`
`static <T> Osgl.Option<T>`	`some(T a)`
`static <A,B> Osgl.T2<A,B>`	`T2(A a, B b)`
`static <A,B,C> Osgl.T3<A,B,C>`	`T3(A a, B b, C c)`
`static <A,B,C,D> Osgl.T4<A,B,C,D>`	`T4(A a, B b, C c, D d)`
`static <A,B,C,D,E> Osgl.T5<A,B,C,D,E>`	`T5(A a, B b, C c, D d, E e)`
`static <T> T`	`times(Osgl.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> Osgl.Tuple<P1,P2>`	`Tuple(P1 a, P2 b)`
`static <T> Osgl.Val<T>`	`val(T t)`
`static <T> Osgl.Var<T>`	`var()`
`static <T> Osgl.Var<T>`	`var(T t)`
`static <T> Osgl.Visitor<T>`	`visitor(Osgl.Function<? super T,?> f)` Convert a `Function<? super T, Void>` function into a `Osgl.Visitor`
`static Class`	`wrapperClassOf(Class c)`

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

Field Detail
- INSTANCE
```
public static final Osgl INSTANCE
```
- F0
```
public static final Osgl.F0 F0
```
  A dumb function for Osgl.Func0 that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f0()
- F1
```
public static final Osgl.F1 F1
```
  A dumb Osgl.Function implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f1()
- F2
```
public static final Osgl.F2 F2
```
  A dumb Osgl.Func2 implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f2()
- F3
```
public static final Osgl.F3 F3
```
  A dumb Osgl.Func3 implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f3()
- F4
```
public static final Osgl.F4 F4
```
  A dumb Osgl.Func4 implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f4()
- F5
```
public static final Osgl.F5 F5
```
  A dumb Osgl.Func5 implementation that does nothing and return null
  
  Since:
  
  0.2
  
  See Also:
  
  f5()
- BREAK
```
public static final Osgl.Break BREAK
```
  A predefined Break instance without payload
- NONE
```
public static final Osgl.None NONE
```
- propertyHandlerFactory
```
public static PropertyHandlerFactory propertyHandlerFactory
```
- conf
```
public static final Osgl.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
- Osgl
```
protected Osgl()
```

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> Osgl.Factory<T> factory(Osgl.Func0<T> func)

f0
```
public static <T> Osgl.F0<T> f0()
```
Return a dumb function for Osgl.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> Osgl.F0<R> f0(Osgl.Func0<? extends R> f0)
```
Convert a general Osgl.Func0 typed function to Osgl.F0 type

Type Parameters:

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

Parameters:

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

Returns:

a Osgl.F0 type that is equaivlent to function f0

Since:

0.2

f1
```
public static <P1,R> Osgl.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> Osgl.F1<P1,R> f1(Osgl.Function<? super P1,? extends R> f1)
```
Convert a general Osgl.Function function into a Osgl.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> Osgl.F1<X,Y> f1(Osgl.Bijection<X,Y> f1)

f2
```
public static <P1,P2,R> Osgl.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> Osgl.F2<P1,P2,R> f2(Osgl.Func2<? super P1,? super P2,? extends R> f2)
```
Convert a general Osgl.Func2 function into a Osgl.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> Osgl.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> Osgl.F3<P1,P2,P3,R> f3(Osgl.Func3<? super P1,? super P2,? super P3,? extends R> f3)
```
Convert a general Osgl.Func3 function into a Osgl.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> Osgl.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> Osgl.F4<P1,P2,P3,P4,R> f4(Osgl.Func4<? super P1,? super P2,? super P3,? super P4,? extends R> f4)
```
Convert a general Osgl.Func4 function into a Osgl.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 Osgl.F4 type that is equivalent to function f4

Since:

0.2

f5
```
public static <P1,P2,P3,P4,P5,R> Osgl.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> Osgl.F5<P1,P2,P3,P4,P5,R> f5(Osgl.Func5<? super P1,? super P2,? super P3,? super P4,? super P5,? extends R> f5)
```
Convert a general Osgl.Func5 function into a Osgl.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 Osgl.F5 type that is equivalent to function f5

Since:

0.2

comparator
```
public static <T> Osgl.Comparator<T> comparator(Osgl.Func2<? super T,? super T,Integer> f)
```
Adapt a general Osgl.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> Osgl.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> Osgl.Predicate<T> predicate(Osgl.Function<? super T,Boolean> f)
```
Convert a Function<T, Boolean> typed function to Predicate<T> function.
If the function specified is already a Osgl.Predicate, then the function itself is returned

Type Parameters:

T - the argument type

Parameters:

f - the function to be converted

Returns:

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

Since:

0.2

generalPredicate
```
public static <T> Osgl.Predicate<T> generalPredicate(Osgl.Function<? 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 Osgl.Predicate, then the function itself is returned

Type Parameters:

T - the argument type

Parameters:

f - the function

Returns:

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

Since:

0.2

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

Type Parameters:

T - the argument type

Parameters:

f - the function to be cast

Returns:

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

Since:

0.2

guardedVisitor
```
public static <T> Osgl.Visitor<T> guardedVisitor(Osgl.Function<? super T,Boolean> predicate,
                                                 Osgl.Function<? 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> Osgl.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> Osgl.IndexedVisitor<K,T> indexGuardedVisitor(Osgl.Function<? super K,Boolean> guard,
                                                                 Osgl.Visitor<? super T> visitor)

Tuple

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

T2

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

T3

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

T4

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

T5

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

some

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

none

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

var

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

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

val

public static <T> Osgl.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()`
`Osgl.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.

Parameters:

s - the string to be evaluated

Returns:

true if s is not empty

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(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(Osgl.Func0<?> v)
```
Do bool evaluation on an Osgl.Func0 instance. This will call the Osgl.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(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(Osgl.Func0<?> f)
```
Returns negative of bool(Osgl.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

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

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 Osgl.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(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 caseSensitive)
```
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

caseSensitive - specify whether it should do case sensitive lookup or case insensitive 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,
                               Osgl.F0<T> def1)

ensureGet

public static <T> T ensureGet(T t1,
                              Osgl.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(Osgl.Function<T,T> func,
                          T initVal,
                          int n)

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> Osgl.Option<Class<T>> safeClassForName(String className)

safeClassForName

public static <T> Osgl.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> Osgl.Option<T> safeNewInstance(String className)

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,
                                   Osgl.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,
                                   Osgl.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 what field should be put into the list if not `null`

Returns:

the list of fields

fieldsOf

public static List<Field> fieldsOf(Class<?> c,
                                   Osgl.Function<Class<?>,Boolean> classFilter,
                                   Osgl.Function<Field,Boolean> fieldFilter)

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

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> T random(T t1,
                           T... ta)

random
```
public static <T> T random(T[] ta)
```

random

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

random

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

randomStr
```
public static String randomStr()
```

randomStr

public static String randomStr(int len)

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

async
```
public static <T> Future<T> async(Osgl.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

Class Osgl

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INSTANCE

F0

F1

F2

F3

F4

F5

BREAK

NONE

propertyHandlerFactory

conf

JAVA_VERSION

IS_SERVER

IS_64

OS

Constructor Detail

Osgl

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

Tuple

T2

T3

T4

T5

some

none

var

var

val

constant

constant

eq

eq2

eq

eq

eq

eq

eq

eq

eq

eq

ne

bool

bool

bool

bool

bool

bool

bool