java.lang.Object
- br.com.objectos.logging.Events

```
public final class Events
extends Object
```
Provides convenience static methods for creating Event instances.

Since:

2

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static Event0`	`debug(Class<?> source, String key)`	Creates a new DEBUG log event.
`static <T1> Event1<T1>`	`debug(Class<?> source, String key, TypeHint<T1> t1)`	Creates a new DEBUG log event requiring one argument of type `T1` given by the type hint `t1`.
`static <T1,T2> Event2<T1,T2>`	`debug(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2)`	Creates a new DEBUG log event requiring two arguments of types `T1` and `T2` given by the type hints `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`debug(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2, TypeHint<T3> t3)`	Creates a new DEBUG log event requiring two arguments of types `T1`, `T2` and `T3` given by the type hints `t1`, `t2` and `t3` respectively.
`static <T1> Event1<T1>`	`debug(Class<?> source, String key, Class<T1> t1)`	Creates a new DEBUG log event requiring one argument of type `T1` given by class `t1`.
`static <T1,T2> Event2<T1,T2>`	`debug(Class<?> source, String key, Class<T1> t1, Class<T2> t2)`	Creates a new DEBUG log event requiring two arguments of types `T1` and `T2` given by classes `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`debug(Class<?> source, String key, Class<T1> t1, Class<T2> t2, Class<T3> t3)`	Creates a new DEBUG log event requiring three arguments of types `T1`, `T2` and `T3` given by classes `t1`, `t2` and `t3` respectively.
`static Event0`	`error(Class<?> source, String key)`	Creates a new ERROR log event.
`static <T1> Event1<T1>`	`error(Class<?> source, String key, TypeHint<T1> t1)`	Creates a new ERROR log event requiring one argument of type `T1` given by the type hint `t1`.
`static <T1,T2> Event2<T1,T2>`	`error(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2)`	Creates a new ERROR log event requiring two arguments of types `T1` and `T2` given by the type hints `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`error(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2, TypeHint<T3> t3)`	Creates a new ERROR log event requiring two arguments of types `T1`, `T2` and `T3` given by the type hints `t1`, `t2` and `t3` respectively.
`static <T1> Event1<T1>`	`error(Class<?> source, String key, Class<T1> t1)`	Creates a new ERROR log event requiring one argument of type `T1` given by class `t1`.
`static <T1,T2> Event2<T1,T2>`	`error(Class<?> source, String key, Class<T1> t1, Class<T2> t2)`	Creates a new ERROR log event requiring two arguments of types `T1` and `T2` given by classes `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`error(Class<?> source, String key, Class<T1> t1, Class<T2> t2, Class<T3> t3)`	Creates a new ERROR log event requiring three arguments of types `T1`, `T2` and `T3` given by classes `t1`, `t2` and `t3` respectively.
`static Event0`	`info(Class<?> source, String key)`	Creates a new INFO log event.
`static <T1> Event1<T1>`	`info(Class<?> source, String key, TypeHint<T1> t1)`	Creates a new INFO log event requiring one argument of type `T1` given by the type hint `t1`.
`static <T1,T2> Event2<T1,T2>`	`info(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2)`	Creates a new INFO log event requiring two arguments of types `T1` and `T2` given by the type hints `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`info(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2, TypeHint<T3> t3)`	Creates a new INFO log event requiring two arguments of types `T1`, `T2` and `T3` given by the type hints `t1`, `t2` and `t3` respectively.
`static <T1> Event1<T1>`	`info(Class<?> source, String key, Class<T1> t1)`	Creates a new INFO log event requiring one argument of type `T1` given by class `t1`.
`static <T1,T2> Event2<T1,T2>`	`info(Class<?> source, String key, Class<T1> t1, Class<T2> t2)`	Creates a new INFO log event requiring two arguments of types `T1` and `T2` given by classes `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`info(Class<?> source, String key, Class<T1> t1, Class<T2> t2, Class<T3> t3)`	Creates a new INFO log event requiring three arguments of types `T1`, `T2` and `T3` given by classes `t1`, `t2` and `t3` respectively.
`static Event0`	`trace(Class<?> source, String key)`	Creates a new TRACE log event.
`static <T1> Event1<T1>`	`trace(Class<?> source, String key, TypeHint<T1> t1)`	Creates a new TRACE log event requiring one argument of type `T1` given by the type hint `t1`.
`static <T1,T2> Event2<T1,T2>`	`trace(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2)`	Creates a new TRACE log event requiring two arguments of types `T1` and `T2` given by the type hints `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`trace(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2, TypeHint<T3> t3)`	Creates a new TRACE log event requiring two arguments of types `T1`, `T2` and `T3` given by the type hints `t1`, `t2` and `t3` respectively.
`static <T1> Event1<T1>`	`trace(Class<?> source, String key, Class<T1> t1)`	Creates a new TRACE log event requiring one argument of type `T1` given by class `t1`.
`static <T1,T2> Event2<T1,T2>`	`trace(Class<?> source, String key, Class<T1> t1, Class<T2> t2)`	Creates a new TRACE log event requiring two arguments of types `T1` and `T2` given by classes `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`trace(Class<?> source, String key, Class<T1> t1, Class<T2> t2, Class<T3> t3)`	Creates a new TRACE log event requiring three arguments of types `T1`, `T2` and `T3` given by classes `t1`, `t2` and `t3` respectively.
`static Event0`	`warn(Class<?> source, String key)`	Creates a new WARN log event.
`static <T1> Event1<T1>`	`warn(Class<?> source, String key, TypeHint<T1> t1)`	Creates a new WARN log event requiring one argument of type `T1` given by the type hint `t1`.
`static <T1,T2> Event2<T1,T2>`	`warn(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2)`	Creates a new WARN log event requiring two arguments of types `T1` and `T2` given by the type hints `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`warn(Class<?> source, String key, TypeHint<T1> t1, TypeHint<T2> t2, TypeHint<T3> t3)`	Creates a new WARN log event requiring two arguments of types `T1`, `T2` and `T3` given by the type hints `t1`, `t2` and `t3` respectively.
`static <T1> Event1<T1>`	`warn(Class<?> source, String key, Class<T1> t1)`	Creates a new WARN log event requiring one argument of type `T1` given by class `t1`.
`static <T1,T2> Event2<T1,T2>`	`warn(Class<?> source, String key, Class<T1> t1, Class<T2> t2)`	Creates a new WARN log event requiring two arguments of types `T1` and `T2` given by classes `t1` and `t2` respectively.
`static <T1,T2,T3> Event3<T1,T2,T3>`	`warn(Class<?> source, String key, Class<T1> t1, Class<T2> t2, Class<T3> t3)`	Creates a new WARN log event requiring three arguments of types `T1`, `T2` and `T3` given by classes `t1`, `t2` and `t3` respectively.

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

Method Detail

debug
```
public static Event0 debug(Class<?> source,
                           String key)
```
Creates a new DEBUG log event.

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

Returns:

a new DEBUG log event

debug
```
public static <T1> Event1<T1> debug(Class<?> source,
                                    String key,
                                    Class<T1> t1)
```
Creates a new DEBUG log event requiring one argument of type T1 given by class t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the event type argument

Returns:

a new DEBUG log event

debug
```
public static <T1,T2> Event2<T1,T2> debug(Class<?> source,
                                                      String key,
                                                      Class<T1> t1,
                                                      Class<T2> t2)
```
Creates a new DEBUG log event requiring two arguments of types T1 and T2 given by classes t1 and t2 respectively.

Type Parameters:

T1 - the type of the first log argument

T2 - the type of the second log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the first event type parameter

t2 - the class of the second event type parameter

Returns:

a new DEBUG log event

debug

public static <T1,T2,T3> Event3<T1,T2,T3> debug(Class<?> source,
                                                                        String key,
                                                                        Class<T1> t1,
                                                                        Class<T2> t2,
                                                                        Class<T3> t3)

Creates a new DEBUG log event requiring three arguments of types T1, T2 and T3 given by classes t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the class of the first event type parameter; t2 - the class of the second event type parameter; t3 - the class of the third event type parameter
Returns:: a new DEBUG log event

debug
```
public static <T1> Event1<T1> debug(Class<?> source,
                                    String key,
                                    TypeHint<T1> t1)
```
Creates a new DEBUG log event requiring one argument of type T1 given by the type hint t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the type hint of the log argument

Returns:

a new DEBUG log event

See Also:

TypeHint

debug

public static <T1,T2> Event2<T1,T2> debug(Class<?> source,
                                                      String key,
                                                      TypeHint<T1> t1,
                                                      TypeHint<T2> t2)

Creates a new DEBUG log event requiring two arguments of types T1 and T2 given by the type hints t1 and t2 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the type hint of the first log argument; t2 - the type hint of the second log argument
Returns:: a new DEBUG log event

debug

public static <T1,T2,T3> Event3<T1,T2,T3> debug(Class<?> source,
                                                                        String key,
                                                                        TypeHint<T1> t1,
                                                                        TypeHint<T2> t2,
                                                                        TypeHint<T3> t3)

Creates a new DEBUG log event requiring two arguments of types T1, T2 and T3 given by the type hints t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the type hint of the first log argument; t2 - the type hint of the second log argument; t3 - the type hint of the third log argument
Returns:: a new DEBUG log event

error
```
public static Event0 error(Class<?> source,
                           String key)
```
Creates a new ERROR log event.

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

Returns:

a new ERROR log event

error
```
public static <T1> Event1<T1> error(Class<?> source,
                                    String key,
                                    Class<T1> t1)
```
Creates a new ERROR log event requiring one argument of type T1 given by class t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the event type argument

Returns:

a new ERROR log event

error
```
public static <T1,T2> Event2<T1,T2> error(Class<?> source,
                                                      String key,
                                                      Class<T1> t1,
                                                      Class<T2> t2)
```
Creates a new ERROR log event requiring two arguments of types T1 and T2 given by classes t1 and t2 respectively.

Type Parameters:

T1 - the type of the first log argument

T2 - the type of the second log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the first event type parameter

t2 - the class of the second event type parameter

Returns:

a new ERROR log event

error

public static <T1,T2,T3> Event3<T1,T2,T3> error(Class<?> source,
                                                                        String key,
                                                                        Class<T1> t1,
                                                                        Class<T2> t2,
                                                                        Class<T3> t3)

Creates a new ERROR log event requiring three arguments of types T1, T2 and T3 given by classes t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the class of the first event type parameter; t2 - the class of the second event type parameter; t3 - the class of the third event type parameter
Returns:: a new ERROR log event

error
```
public static <T1> Event1<T1> error(Class<?> source,
                                    String key,
                                    TypeHint<T1> t1)
```
Creates a new ERROR log event requiring one argument of type T1 given by the type hint t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the type hint of the log argument

Returns:

a new ERROR log event

See Also:

TypeHint

error

public static <T1,T2> Event2<T1,T2> error(Class<?> source,
                                                      String key,
                                                      TypeHint<T1> t1,
                                                      TypeHint<T2> t2)

Creates a new ERROR log event requiring two arguments of types T1 and T2 given by the type hints t1 and t2 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the type hint of the first log argument; t2 - the type hint of the second log argument
Returns:: a new ERROR log event

error

public static <T1,T2,T3> Event3<T1,T2,T3> error(Class<?> source,
                                                                        String key,
                                                                        TypeHint<T1> t1,
                                                                        TypeHint<T2> t2,
                                                                        TypeHint<T3> t3)

Creates a new ERROR log event requiring two arguments of types T1, T2 and T3 given by the type hints t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the type hint of the first log argument; t2 - the type hint of the second log argument; t3 - the type hint of the third log argument
Returns:: a new ERROR log event

info
```
public static Event0 info(Class<?> source,
                          String key)
```
Creates a new INFO log event.

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

Returns:

a new INFO log event

info
```
public static <T1> Event1<T1> info(Class<?> source,
                                   String key,
                                   Class<T1> t1)
```
Creates a new INFO log event requiring one argument of type T1 given by class t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the event type argument

Returns:

a new INFO log event

info
```
public static <T1,T2> Event2<T1,T2> info(Class<?> source,
                                                     String key,
                                                     Class<T1> t1,
                                                     Class<T2> t2)
```
Creates a new INFO log event requiring two arguments of types T1 and T2 given by classes t1 and t2 respectively.

Type Parameters:

T1 - the type of the first log argument

T2 - the type of the second log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the first event type parameter

t2 - the class of the second event type parameter

Returns:

a new INFO log event

info

public static <T1,T2,T3> Event3<T1,T2,T3> info(Class<?> source,
                                                                       String key,
                                                                       Class<T1> t1,
                                                                       Class<T2> t2,
                                                                       Class<T3> t3)

Creates a new INFO log event requiring three arguments of types T1, T2 and T3 given by classes t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the class of the first event type parameter; t2 - the class of the second event type parameter; t3 - the class of the third event type parameter
Returns:: a new INFO log event

info
```
public static <T1> Event1<T1> info(Class<?> source,
                                   String key,
                                   TypeHint<T1> t1)
```
Creates a new INFO log event requiring one argument of type T1 given by the type hint t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the type hint of the log argument

Returns:

a new INFO log event

See Also:

TypeHint

info
```
public static <T1,T2> Event2<T1,T2> info(Class<?> source,
                                                     String key,
                                                     TypeHint<T1> t1,
                                                     TypeHint<T2> t2)
```
Creates a new INFO log event requiring two arguments of types T1 and T2 given by the type hints t1 and t2 respectively.

Type Parameters:

T1 - the type of the first log argument

T2 - the type of the second log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the type hint of the first log argument

t2 - the type hint of the second log argument

Returns:

a new INFO log event

info

public static <T1,T2,T3> Event3<T1,T2,T3> info(Class<?> source,
                                                                       String key,
                                                                       TypeHint<T1> t1,
                                                                       TypeHint<T2> t2,
                                                                       TypeHint<T3> t3)

Creates a new INFO log event requiring two arguments of types T1, T2 and T3 given by the type hints t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the type hint of the first log argument; t2 - the type hint of the second log argument; t3 - the type hint of the third log argument
Returns:: a new INFO log event

trace
```
public static Event0 trace(Class<?> source,
                           String key)
```
Creates a new TRACE log event.

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

Returns:

a new TRACE log event

trace
```
public static <T1> Event1<T1> trace(Class<?> source,
                                    String key,
                                    Class<T1> t1)
```
Creates a new TRACE log event requiring one argument of type T1 given by class t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the event type argument

Returns:

a new TRACE log event

trace
```
public static <T1,T2> Event2<T1,T2> trace(Class<?> source,
                                                      String key,
                                                      Class<T1> t1,
                                                      Class<T2> t2)
```
Creates a new TRACE log event requiring two arguments of types T1 and T2 given by classes t1 and t2 respectively.

Type Parameters:

T1 - the type of the first log argument

T2 - the type of the second log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the first event type parameter

t2 - the class of the second event type parameter

Returns:

a new TRACE log event

trace

public static <T1,T2,T3> Event3<T1,T2,T3> trace(Class<?> source,
                                                                        String key,
                                                                        Class<T1> t1,
                                                                        Class<T2> t2,
                                                                        Class<T3> t3)

Creates a new TRACE log event requiring three arguments of types T1, T2 and T3 given by classes t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the class of the first event type parameter; t2 - the class of the second event type parameter; t3 - the class of the third event type parameter
Returns:: a new TRACE log event

trace
```
public static <T1> Event1<T1> trace(Class<?> source,
                                    String key,
                                    TypeHint<T1> t1)
```
Creates a new TRACE log event requiring one argument of type T1 given by the type hint t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the type hint of the log argument

Returns:

a new TRACE log event

See Also:

TypeHint

trace

public static <T1,T2> Event2<T1,T2> trace(Class<?> source,
                                                      String key,
                                                      TypeHint<T1> t1,
                                                      TypeHint<T2> t2)

Creates a new TRACE log event requiring two arguments of types T1 and T2 given by the type hints t1 and t2 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the type hint of the first log argument; t2 - the type hint of the second log argument
Returns:: a new TRACE log event

trace

public static <T1,T2,T3> Event3<T1,T2,T3> trace(Class<?> source,
                                                                        String key,
                                                                        TypeHint<T1> t1,
                                                                        TypeHint<T2> t2,
                                                                        TypeHint<T3> t3)

Creates a new TRACE log event requiring two arguments of types T1, T2 and T3 given by the type hints t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the type hint of the first log argument; t2 - the type hint of the second log argument; t3 - the type hint of the third log argument
Returns:: a new TRACE log event

warn
```
public static Event0 warn(Class<?> source,
                          String key)
```
Creates a new WARN log event.

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

Returns:

a new WARN log event

warn
```
public static <T1> Event1<T1> warn(Class<?> source,
                                   String key,
                                   Class<T1> t1)
```
Creates a new WARN log event requiring one argument of type T1 given by class t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the event type argument

Returns:

a new WARN log event

warn
```
public static <T1,T2> Event2<T1,T2> warn(Class<?> source,
                                                     String key,
                                                     Class<T1> t1,
                                                     Class<T2> t2)
```
Creates a new WARN log event requiring two arguments of types T1 and T2 given by classes t1 and t2 respectively.

Type Parameters:

T1 - the type of the first log argument

T2 - the type of the second log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the class of the first event type parameter

t2 - the class of the second event type parameter

Returns:

a new WARN log event

warn

public static <T1,T2,T3> Event3<T1,T2,T3> warn(Class<?> source,
                                                                       String key,
                                                                       Class<T1> t1,
                                                                       Class<T2> t2,
                                                                       Class<T3> t3)

Creates a new WARN log event requiring three arguments of types T1, T2 and T3 given by classes t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the class of the first event type parameter; t2 - the class of the second event type parameter; t3 - the class of the third event type parameter
Returns:: a new WARN log event

warn
```
public static <T1> Event1<T1> warn(Class<?> source,
                                   String key,
                                   TypeHint<T1> t1)
```
Creates a new WARN log event requiring one argument of type T1 given by the type hint t1.

Type Parameters:

T1 - the type of the log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the type hint of the log argument

Returns:

a new WARN log event

See Also:

TypeHint

warn
```
public static <T1,T2> Event2<T1,T2> warn(Class<?> source,
                                                     String key,
                                                     TypeHint<T1> t1,
                                                     TypeHint<T2> t2)
```
Creates a new WARN log event requiring two arguments of types T1 and T2 given by the type hints t1 and t2 respectively.

Type Parameters:

T1 - the type of the first log argument

T2 - the type of the second log argument

Parameters:

source - the class this event is bound to

key - a key that uniquely identifies this event within the given source class

t1 - the type hint of the first log argument

t2 - the type hint of the second log argument

Returns:

a new WARN log event

warn

public static <T1,T2,T3> Event3<T1,T2,T3> warn(Class<?> source,
                                                                       String key,
                                                                       TypeHint<T1> t1,
                                                                       TypeHint<T2> t2,
                                                                       TypeHint<T3> t3)

Creates a new WARN log event requiring two arguments of types T1, T2 and T3 given by the type hints t1, t2 and t3 respectively.

Type Parameters:: T1 - the type of the first log argument; T2 - the type of the second log argument; T3 - the type of the third log argument
Parameters:: source - the class this event is bound to; key - a key that uniquely identifies this event within the given source class; t1 - the type hint of the first log argument; t2 - the type hint of the second log argument; t3 - the type hint of the third log argument
Returns:: a new WARN log event

Class Events

Method Summary

Methods inherited from class java.lang.Object

Method Detail

debug

debug

debug

debug

debug

debug

debug

error

error

error

error

error

error

error

info

info

info

info

info

info

info

trace

trace

trace

trace

trace

trace

trace

warn

warn

warn

warn

warn

warn

warn