org.rapidoid.u

Class U

java.lang.Object

org.rapidoid.u.U

public class U
extends Object

Since:

2.0.0

Constructor Summary

Constructors

Constructor and Description
U()

Method Summary

Modifier and Type	Method and Description
static void	argMust(boolean expectedCondition, String message, Object... args)
static Object[]	array(Iterable<?> items)
static <T> T[]	array(T... items)
static <T> void	assign(Collection<T> destination, Collection<? extends T> source)
static <K,V> void	assign(Map<K,V> destination, Map<? extends K,? extends V> source)
static <K,V> Map<K,V>	autoExpandingMap(Class<?> clazz)
static <K,V> Map<K,V>	autoExpandingMap(Mapper<K,V> valueFactory)
static int	bounded(int min, int value, int max)
static void	bounds(int value, int min, int max)
static String	capitalized(String s)
static <T> T	cast(Object value) Simpler casts, less warnings.
static <T> int	compare(T val1, T val2)
static <K,V> ConcurrentMap<K,V>	concurrentMap()
static <K,V> ConcurrentMap<K,V>	concurrentMap(K key, V value)
static <K,V> ConcurrentMap<K,V>	concurrentMap(K key1, V value1, K key2, V value2)
static <K,V> ConcurrentMap<K,V>	concurrentMap(K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> ConcurrentMap<K,V>	concurrentMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <K,V> ConcurrentMap<K,V>	concurrentMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4, K key5, V value5)
static <K,V> ConcurrentMap<K,V>	concurrentMap(Map<? extends K,? extends V> src, boolean ignoreNullValues)
static <K,V> ConcurrentMap<K,V>	concurrentMap(Object... keysAndValues)
static <T> T	dynamic(Class<T> targetInterface, Dynamic dynamic)
static boolean	eq(Object a, Object b)
static boolean	exists(Callable<?> accessChain)
static <T> T	first(List<T> values)
static <T> T	first(T[] values)
static String	frmt(String format, Object... args)
static <K,V> V	get(Map<K,V> map, K key)
static <K,V> V	get(Map<K,V> map, K key, V defaultValue)
static IllegalArgumentException	illegalArg(String message, Object... args)
static String	insert(String target, int atIndex, String insertion)
static <T> Is<T>	is(T value)
static boolean	isCollection(Object obj)
static boolean	isEmpty(Collection<?> coll)
static boolean	isEmpty(Iterable<?> iter)
static boolean	isEmpty(Map<?,?> map)
static boolean	isEmpty(Object value)
static boolean	isEmpty(Object[] arr)
static boolean	isEmpty(String value)
static <T> boolean	isIn(T value, T... candidates)
static boolean	isList(Object obj)
static boolean	isMap(Object obj)
static boolean	isSet(Object obj)
static <T> Iterator<T>	iterator(T[] arr)
static String	join(String sep, char[][] items)
static String	join(String sep, Iterable<?> items)
static <T> String	join(String sep, T... items)
static <T> T	last(List<T> values)
static <T> T	last(T[] values)
static <T> List<T>	list()
static <T> List<T>	list(Iterable<? extends T> values)
static <T> List<T>	list(T... values)
static <K,V> Map<K,V>	map()
static <K,V> Map<K,V>	map(K key, V value)
static <K,V> Map<K,V>	map(K key1, V value1, K key2, V value2)
static <K,V> Map<K,V>	map(K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> Map<K,V>	map(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <K,V> Map<K,V>	map(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4, K key5, V value5)
static <K,V> Map<K,V>	map(Map<? extends K,? extends V> src)
static <K,V> Map<K,V>	map(Object... keysAndValues)
static <K,V> Map<K,List<V>>	mapOfLists()
static <K1,K2,V> Map<K1,Map<K2,V>>	mapOfMaps()
static <K,V> Map<K,Set<V>>	mapOfSets()
static String	mid(String s, int beginIndex, int endIndex)
static String	mul(String s, int n)
static boolean	must(boolean expectedCondition)
static boolean	must(boolean expectedCondition, String message)
static boolean	must(boolean expectedCondition, String message, long arg)
static boolean	must(boolean expectedCondition, String message, Object arg)
static boolean	must(boolean expectedCondition, String message, Object arg1, Object arg2)
static boolean	must(boolean expectedCondition, String message, Object arg1, Object arg2, Object arg3)
static boolean	notEmpty(Collection<?> coll)
static boolean	notEmpty(Iterable<?> iter)
static boolean	notEmpty(Map<?,?> map)
static boolean	notEmpty(Object value)
static boolean	notEmpty(Object[] arr)
static boolean	notEmpty(String value)
static RuntimeException	notExpected()
static <T> T	notNull(T value, String msgOrDesc, Object... descArgs)
static RuntimeException	notReady()
static RuntimeException	notSupported()
static int	num(String s)
static <T> T	or(T value, T fallback)
static <K,V> Map<K,V>	orderedMap()
static <K,V> Map<K,V>	orderedMap(K key, V value)
static <K,V> Map<K,V>	orderedMap(K key1, V value1, K key2, V value2)
static <K,V> Map<K,V>	orderedMap(K key1, V value1, K key2, V value2, K key3, V value3)
static <K,V> Map<K,V>	orderedMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4)
static <K,V> Map<K,V>	orderedMap(K key1, V value1, K key2, V value2, K key3, V value3, K key4, V value4, K key5, V value5)
static <K,V> Map<K,V>	orderedMap(Map<? extends K,? extends V> src, boolean ignoreNullValues)
static <K,V> Map<K,V>	orderedMap(Object... keysAndValues)
static <T> List<T>	page(Iterable<T> items, int page, int pageSize)
static String	path(String... parts)
static void	print(Object... values)
static <T> Queue<T>	queue()
static <T> BlockingQueue<T>	queue(int maxSize)
static <T> List<T>	range(Iterable<T> items, int fromIndex, int toIndex)
static String	render(Iterable<?> items, String itemFormat, String sep)
static String	render(Object[] items, String itemFormat, String sep)
static String	replace(String s, String[][] repls)
static String	replace(String s, String regex, Mapper<String[],String> replacer)
static RuntimeException	rte(String message)
static RuntimeException	rte(String message, Object... args)
static RuntimeException	rte(String message, Throwable cause)
static RuntimeException	rte(String message, Throwable cause, Object... args)
static RuntimeException	rte(Throwable cause)
static void	rteIf(boolean failureCondition, String msg)
static boolean	safe(Boolean b)
static byte	safe(Byte num)
static double	safe(Double num)
static float	safe(Float num)
static int	safe(Integer num)
static <T> List<T>	safe(List<T> list)
static long	safe(Long num)
static <K,V> Map<K,V>	safe(Map<K,V> map)
static Object[]	safe(Object[] arr)
static <T> Set<T>	safe(Set<T> set)
static String	safe(String s)
static void	secure(boolean condition, String msg)
static void	secure(boolean condition, String msg, Object arg)
static void	secure(boolean condition, String msg, Object arg1, Object arg2)
static <T> Set<T>	set()
static <T> Set<T>	set(Iterable<? extends T> values)
static <T> Set<T>	set(T... values)
static <T> T	single(Iterable<T> coll)
static <T> T	singleOrNone(Iterable<T> coll)
static void	sleep(long millis) Sleeps (calling Thread.sleep) for the specified period.
static String	str(Iterable<Object> coll)
static String	str(Iterator<?> it)
static String	str(Object obj)
static String	str(Object[] objs)
static <T> List<T>	synchronizedList()
static <K,V> Map<K,V>	synchronizedMap()
static <T> Set<T>	synchronizedSet()
static long	time()
static String	triml(String s, char prefix)
static String	triml(String s, String prefix)
static String	trimr(String s, char suffix)
static String	trimr(String s, String suffix)
static String	uncapitalized(String s)
static String	uri(String... parts)
static void	wait(CountDownLatch latch)
static void	wait(CountDownLatch latch, long timeout, TimeUnit unit)
static boolean	xor(boolean a, boolean b)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

U

public U()

Method Detail

str

public static String str(Object obj)

str

public static String str(Object[] objs)

str

public static String str(Iterable<Object> coll)

str

public static String str(Iterator<?> it)

frmt

public static String frmt(String format,
                          Object... args)

replace

public static String replace(String s,
                             String[][] repls)

replace

public static String replace(String s,
                             String regex,
                             Mapper<String[],String> replacer)

print

public static void print(Object... values)

join

public static <T> String join(String sep,
                              T... items)

join

public static String join(String sep,
                          Iterable<?> items)

join

public static String join(String sep,
                          char[][] items)

render

public static String render(Object[] items,
                            String itemFormat,
                            String sep)

render

public static String render(Iterable<?> items,
                            String itemFormat,
                            String sep)

iterator

public static <T> Iterator<T> iterator(T[] arr)

array

public static <T> T[] array(T... items)

array

public static Object[] array(Iterable<?> items)

synchronizedSet

public static <T> Set<T> synchronizedSet()

set

public static <T> Set<T> set()

set

public static <T> Set<T> set(Iterable<? extends T> values)

set

public static <T> Set<T> set(T... values)

synchronizedList

public static <T> List<T> synchronizedList()

list

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

list

public static <T> List<T> list(Iterable<? extends T> values)

list

public static <T> List<T> list(T... values)

map

public static <K,V> Map<K,V> map()

map

public static <K,V> Map<K,V> map(Map<? extends K,? extends V> src)

map

public static <K,V> Map<K,V> map(K key,
                                 V value)

map

public static <K,V> Map<K,V> map(K key1,
                                 V value1,
                                 K key2,
                                 V value2)

map

public static <K,V> Map<K,V> map(K key1,
                                 V value1,
                                 K key2,
                                 V value2,
                                 K key3,
                                 V value3)

map

public static <K,V> Map<K,V> map(K key1,
                                 V value1,
                                 K key2,
                                 V value2,
                                 K key3,
                                 V value3,
                                 K key4,
                                 V value4)

map

public static <K,V> Map<K,V> map(K key1,
                                 V value1,
                                 K key2,
                                 V value2,
                                 K key3,
                                 V value3,
                                 K key4,
                                 V value4,
                                 K key5,
                                 V value5)

map

public static <K,V> Map<K,V> map(Object... keysAndValues)

concurrentMap

public static <K,V> ConcurrentMap<K,V> concurrentMap()

concurrentMap

public static <K,V> ConcurrentMap<K,V> concurrentMap(Map<? extends K,? extends V> src,
                                                     boolean ignoreNullValues)

concurrentMap

public static <K,V> ConcurrentMap<K,V> concurrentMap(K key,
                                                     V value)

concurrentMap

public static <K,V> ConcurrentMap<K,V> concurrentMap(K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2)

concurrentMap

public static <K,V> ConcurrentMap<K,V> concurrentMap(K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2,
                                                     K key3,
                                                     V value3)

concurrentMap

public static <K,V> ConcurrentMap<K,V> concurrentMap(K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2,
                                                     K key3,
                                                     V value3,
                                                     K key4,
                                                     V value4)

concurrentMap

public static <K,V> ConcurrentMap<K,V> concurrentMap(K key1,
                                                     V value1,
                                                     K key2,
                                                     V value2,
                                                     K key3,
                                                     V value3,
                                                     K key4,
                                                     V value4,
                                                     K key5,
                                                     V value5)

concurrentMap

public static <K,V> ConcurrentMap<K,V> concurrentMap(Object... keysAndValues)

orderedMap

public static <K,V> Map<K,V> orderedMap()

orderedMap

public static <K,V> Map<K,V> orderedMap(Map<? extends K,? extends V> src,
                                        boolean ignoreNullValues)

orderedMap

public static <K,V> Map<K,V> orderedMap(K key,
                                        V value)

orderedMap

public static <K,V> Map<K,V> orderedMap(K key1,
                                        V value1,
                                        K key2,
                                        V value2)

orderedMap

public static <K,V> Map<K,V> orderedMap(K key1,
                                        V value1,
                                        K key2,
                                        V value2,
                                        K key3,
                                        V value3)

orderedMap

public static <K,V> Map<K,V> orderedMap(K key1,
                                        V value1,
                                        K key2,
                                        V value2,
                                        K key3,
                                        V value3,
                                        K key4,
                                        V value4)

orderedMap

public static <K,V> Map<K,V> orderedMap(K key1,
                                        V value1,
                                        K key2,
                                        V value2,
                                        K key3,
                                        V value3,
                                        K key4,
                                        V value4,
                                        K key5,
                                        V value5)

orderedMap

public static <K,V> Map<K,V> orderedMap(Object... keysAndValues)

synchronizedMap

public static <K,V> Map<K,V> synchronizedMap()

queue

public static <T> Queue<T> queue()

queue

public static <T> BlockingQueue<T> queue(int maxSize)

or

public static <T> T or(T value,
                       T fallback)

safe

public static String safe(String s)

safe

public static boolean safe(Boolean b)

safe

public static int safe(Integer num)

safe

public static long safe(Long num)

safe

public static byte safe(Byte num)

safe

public static float safe(Float num)

safe

public static double safe(Double num)

safe

public static Object[] safe(Object[] arr)

safe

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

safe

public static <T> Set<T> safe(Set<T> set)

safe

public static <K,V> Map<K,V> safe(Map<K,V> map)

time

public static long time()

xor

public static boolean xor(boolean a,
                          boolean b)

eq

public static boolean eq(Object a,
                         Object b)

rte

public static RuntimeException rte(String message)

rte

public static RuntimeException rte(String message,
                                   Throwable cause)

rte

public static RuntimeException rte(Throwable cause)

rte

public static RuntimeException rte(String message,
                                   Object... args)

notExpected

public static RuntimeException notExpected()

notReady

public static RuntimeException notReady()

notSupported

public static RuntimeException notSupported()

rteIf

public static void rteIf(boolean failureCondition,
                         String msg)

must

public static boolean must(boolean expectedCondition,
                           String message)

rte

public static RuntimeException rte(String message,
                                   Throwable cause,
                                   Object... args)

must

public static boolean must(boolean expectedCondition)

must

public static boolean must(boolean expectedCondition,
                           String message,
                           long arg)

must

public static boolean must(boolean expectedCondition,
                           String message,
                           Object arg)

must

public static boolean must(boolean expectedCondition,
                           String message,
                           Object arg1,
                           Object arg2)

must

public static boolean must(boolean expectedCondition,
                           String message,
                           Object arg1,
                           Object arg2,
                           Object arg3)

illegalArg

public static IllegalArgumentException illegalArg(String message,
                                                  Object... args)

secure

public static void secure(boolean condition,
                          String msg)

secure

public static void secure(boolean condition,
                          String msg,
                          Object arg)

secure

public static void secure(boolean condition,
                          String msg,
                          Object arg1,
                          Object arg2)

bounds

public static void bounds(int value,
                          int min,
                          int max)

notNull

public static <T> T notNull(T value,
                            String msgOrDesc,
                            Object... descArgs)

isEmpty

public static boolean isEmpty(String value)

isEmpty

public static boolean isEmpty(Object[] arr)

isEmpty

public static boolean isEmpty(Collection<?> coll)

isEmpty

public static boolean isEmpty(Iterable<?> iter)

isEmpty

public static boolean isEmpty(Map<?,?> map)

isEmpty

public static boolean isEmpty(Object value)

notEmpty

public static boolean notEmpty(String value)

notEmpty

public static boolean notEmpty(Object[] arr)

notEmpty

public static boolean notEmpty(Collection<?> coll)

notEmpty

public static boolean notEmpty(Iterable<?> iter)

notEmpty

public static boolean notEmpty(Map<?,?> map)

notEmpty

public static boolean notEmpty(Object value)

capitalized

public static String capitalized(String s)

uncapitalized

public static String uncapitalized(String s)

mul

public static String mul(String s,
                         int n)

mid

public static String mid(String s,
                         int beginIndex,
                         int endIndex)

insert

public static String insert(String target,
                            int atIndex,
                            String insertion)

num

public static int num(String s)

bounded

public static int bounded(int min,
                          int value,
                          int max)

single

public static <T> T single(Iterable<T> coll)

singleOrNone

public static <T> T singleOrNone(Iterable<T> coll)

first

public static <T> T first(T[] values)

first

public static <T> T first(List<T> values)

last

public static <T> T last(T[] values)

last

public static <T> T last(List<T> values)

compare

public static <T> int compare(T val1,
                              T val2)

range

public static <T> List<T> range(Iterable<T> items,
                                int fromIndex,
                                int toIndex)

page

public static <T> List<T> page(Iterable<T> items,
                               int page,
                               int pageSize)

trimr

public static String trimr(String s,
                           char suffix)

trimr

public static String trimr(String s,
                           String suffix)

triml

public static String triml(String s,
                           char prefix)

triml

public static String triml(String s,
                           String prefix)

argMust

public static void argMust(boolean expectedCondition,
                           String message,
                           Object... args)

sleep

public static void sleep(long millis)

Sleeps (calling Thread.sleep) for the specified period. If the thread is interrupted while sleeping, throws CancellationException to propagate the interruption.

Parameters:

millis - the length of time to sleep in milliseconds.

autoExpandingMap

public static <K,V> Map<K,V> autoExpandingMap(Class<?> clazz)

autoExpandingMap

public static <K,V> Map<K,V> autoExpandingMap(Mapper<K,V> valueFactory)

mapOfMaps

public static <K1,K2,V> Map<K1,Map<K2,V>> mapOfMaps()

mapOfLists

public static <K,V> Map<K,List<V>> mapOfLists()

mapOfSets

public static <K,V> Map<K,Set<V>> mapOfSets()

cast

public static <T> T cast(Object value)

Simpler casts, less warnings.

wait

public static void wait(CountDownLatch latch)

wait

public static void wait(CountDownLatch latch,
                        long timeout,
                        TimeUnit unit)

dynamic

public static <T> T dynamic(Class<T> targetInterface,
                            Dynamic dynamic)

isIn

public static <T> boolean isIn(T value,
                               T... candidates)

is

public static <T> Is<T> is(T value)

exists

public static boolean exists(Callable<?> accessChain)

uri

public static String uri(String... parts)

path

public static String path(String... parts)

isMap

public static boolean isMap(Object obj)

isList

public static boolean isList(Object obj)

isSet

public static boolean isSet(Object obj)

isCollection

public static boolean isCollection(Object obj)

assign

public static <T> void assign(Collection<T> destination,
                              Collection<? extends T> source)

assign

public static <K,V> void assign(Map<K,V> destination,
                                Map<? extends K,? extends V> source)

get

public static <K,V> V get(Map<K,V> map,
                          K key)

get

public static <K,V> V get(Map<K,V> map,
                          K key,
                          V defaultValue)