net.openhft.chronicle.core.util

Class ObjectUtils

java.lang.Object

net.openhft.chronicle.core.util.ObjectUtils

public final class ObjectUtils
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ObjectUtils.Immutability

Method Summary

Modifier and Type	Method and Description
static <T> T[]	addAll(T first, T... additional)
static @NotNull ClassCastException	asCCE(Exception e)
static <E> E	convertTo(@Nullable Class<E> eClass, @Nullable Object o)
static void	defaultObjectForInterface(ThrowingFunction<Class<?>,Class<?>,ClassNotFoundException> defaultObjectForInterface)
static Object	defaultValue(Class<?> type)
static Class<?>[]	getAllInterfaces(Object o)
static void	getAllInterfaces(Object o, Function<Class<?>,Boolean> accumulator)
static <E extends Enum<E>> E	getSingletonForEnum(Class<E> eClass)
static void	immutabile(Class<?> clazz, boolean isImmutable)
static <T> Class<T>	implementationToUse(Class<T> tClass)
static boolean	isConcreteClass(@NotNull Class<?> tClass)
static boolean	isFalse(CharSequence s)
static ObjectUtils.Immutability	isImmutable(@NotNull Class<?> clazz)
static boolean	isTrue(CharSequence s)
static boolean	matchingClass(@NotNull Class<?> base, @NotNull Class<?> toMatch)
static <T> T	newInstance(@NotNull Class<T> clazz)
static <T> T	newInstance(@NotNull String className)
static @Nullable Object	newInstanceOrNull(Class<?> type)
static <T> T	onMethodCall(@NotNull BiFunction<Method,Object[],Object> biFunction, @NotNull Class<T> tClass, Class<?>... additional)
static Class	primToWrapper(Class<?> eClass) If the class is a primitive type, change it to the equivalent wrapper.
static Object	readResolve(@NotNull Object o)
static <T> T	requireNonNull(T o) Standard mechanism to determine objects as not null.
static @Nullable Boolean	toBoolean(@Nullable String s)
static <E extends Enum<E>> E	valueOfIgnoreCase(@NotNull Class<E> eClass, @NotNull String name)

Methods inherited from class java.lang.Object

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

Method Detail

immutabile

public static void immutabile(Class<?> clazz,
                              boolean isImmutable)

isImmutable

public static ObjectUtils.Immutability isImmutable(@NotNull
                                                   @NotNull Class<?> clazz)

isTrue

public static boolean isTrue(CharSequence s)

isFalse

public static boolean isFalse(CharSequence s)

primToWrapper

public static Class primToWrapper(Class<?> eClass)

If the class is a primitive type, change it to the equivalent wrapper.

Parameters:

eClass - to check

Returns:

the wrapper class if eClass is a primitive type, or the eClass if not.

convertTo

@Nullable
public static <E> E convertTo(@Nullable
                                        @Nullable Class<E> eClass,
                                        @Nullable
                                        @Nullable Object o)
                                 throws ClassCastException,
                                        IllegalArgumentException

Throws:

ClassCastException

IllegalArgumentException

valueOfIgnoreCase

@NotNull
public static <E extends Enum<E>> E valueOfIgnoreCase(@NotNull
                                                               @NotNull Class<E> eClass,
                                                               @NotNull
                                                               @NotNull String name)

getSingletonForEnum

public static <E extends Enum<E>> E getSingletonForEnum(Class<E> eClass)

asCCE

@NotNull
public static @NotNull ClassCastException asCCE(Exception e)

newInstance

@NotNull
public static <T> T newInstance(@NotNull
                                         @NotNull String className)

newInstance

@NotNull
public static <T> T newInstance(@NotNull
                                         @NotNull Class<T> clazz)

newInstanceOrNull

@Nullable
public static @Nullable Object newInstanceOrNull(Class<?> type)

addAll

public static <T> T[] addAll(@NotNull
                             T first,
                             @NotNull
                             T... additional)

matchingClass

public static boolean matchingClass(@NotNull
                                    @NotNull Class<?> base,
                                    @NotNull
                                    @NotNull Class<?> toMatch)

defaultValue

public static Object defaultValue(Class<?> type)

onMethodCall

@NotNull
public static <T> T onMethodCall(@NotNull
                                          @NotNull BiFunction<Method,Object[],Object> biFunction,
                                          @NotNull
                                          @NotNull Class<T> tClass,
                                          Class<?>... additional)
                                   throws IllegalArgumentException

Throws:

IllegalArgumentException

isConcreteClass

public static boolean isConcreteClass(@NotNull
                                      @NotNull Class<?> tClass)

readResolve

public static Object readResolve(@NotNull
                                 @NotNull Object o)

toBoolean

@Nullable
public static @Nullable Boolean toBoolean(@Nullable
                                                    @Nullable String s)

getAllInterfaces

public static Class<?>[] getAllInterfaces(Object o)

getAllInterfaces

public static void getAllInterfaces(Object o,
                                    Function<Class<?>,Boolean> accumulator)
                             throws IllegalArgumentException

Throws:

IllegalArgumentException

defaultObjectForInterface

public static void defaultObjectForInterface(ThrowingFunction<Class<?>,Class<?>,ClassNotFoundException> defaultObjectForInterface)

implementationToUse

public static <T> Class<T> implementationToUse(Class<T> tClass)

requireNonNull

public static <T> T requireNonNull(@NotNull
                                   T o)

Standard mechanism to determine objects as not null. Same method contract as Objects.requireNonNull(Object) and also decorated with NotNull so that IntelliJ and other static analysis tools can work their magic.

Parameters:

o - reference to check for nullity

Throws:

NullPointerException - if o is null