ObjectUtils (OpenHFT/Chronicle-Core 2.24ea22 API)

java.lang.Object
- net.openhft.chronicle.core.util.ObjectUtils

```
public final class ObjectUtils
extends Object
```
A utility class providing various static methods to perform common operations on objects, such as instantiation, type conversion, class/interface handling, and more. This class cannot be instantiated and is meant to serve as a collection of utility functions.
Some of the key features provided by this utility class include:
- Creating new instances of classes
- Retrieving default values for given types
- Checking if a class is concrete
- Performing conversions among types including numbers and booleans
- Handling interfaces and obtaining all interfaces implemented by given objects or classes
- Utility methods for handling exceptions
- Creating dynamic proxies for method calls
Note: This class is a part of the Chronicle core library and is intended to be used by developers who need to perform various common operations on objects and classes within their Java applications.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ObjectUtils.Immutability

Nested Classes
Modifier and Type	Class and Description
`static class`	`ObjectUtils.Immutability`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> T[]`	`addAll(T first, T... additional)` Creates an array containing the given element followed by the elements of the additional array.
`static @NotNull ClassCastException`	`asCCE(Exception e)` Wraps the provided exception in a ClassCastException.
`static <E> E`	`convertTo(@Nullable Class<E> eClass, @Nullable Object o)` Converts an object to the desired class if possible.
`static void`	`defaultObjectForInterface(ThrowingFunction<Class<?>,Class<?>,ClassNotFoundException> defaultObjectForInterface)` Sets a default implementation to be used for interfaces.
`static Object`	`defaultValue(Class<?> type)` Returns the default value for the given class.
`static Class<?>[]`	`getAllInterfaces(Object o)` Retrieves all the interfaces implemented by the given object or class.
`static void`	`getAllInterfaces(Object o, Function<Class<?>,Boolean> accumulator)` Recursively accumulates all interfaces implemented by the given object or class.
`static <E extends Enum<E>> E`	`getSingletonForEnum(Class<E> eClass)` Returns the single enum constant from the specified enum class, or the first one if there are multiple.
`static void`	`immutabile(Class<?> clazz, boolean isImmutable)` Deprecated.
`static void`	`immutable(Class<?> clazz, boolean isImmutable)` Registers the immutability status of a class.
`static <T> Class<T>`	`implementationToUse(Class<T> tClass)` Retrieves the implementation class to use for a given class.
`static boolean`	`isConcreteClass(@NotNull Class<?> tClass)` Checks if the given class is a concrete class (not abstract or interface).
`static boolean`	`isFalse(CharSequence s)` Checks if the given CharSequence is considered 'false'.
`static ObjectUtils.Immutability`	`isImmutable(@NotNull Class<?> clazz)` Checks if a class is immutable.
`static boolean`	`isTrue(CharSequence s)` Checks if the given CharSequence is considered 'true'.
`static boolean`	`matchingClass(@NotNull Class<?> base, @NotNull Class<?> toMatch)` Checks if two classes are matching.
`static <T> T`	`newInstance(@NotNull Class<T> clazz)` Creates a new instance of the specified class.
`static <T> T`	`newInstance(@NotNull String className)` Creates a new instance of the class with the given class name.
`static @Nullable Object`	`newInstanceOrNull(Class<?> type)` Creates a new instance of the specified class, returning null if instantiation fails.
`static <T> T`	`onMethodCall(@NotNull BiFunction<Method,Object[],Object> biFunction, @NotNull Class<T> tClass, Class<?>... additional)` Creates a dynamic proxy instance that delegates method calls to the provided BiFunction.
`static Class`	`primToWrapper(Class<?> eClass)` If the class is a primitive type, change it to the equivalent wrapper.
`static Object`	`readResolve(@NotNull Object o)` Invokes the readResolve method on the given object if it exists.
`static <T> T`	`requireNonNull(T o)` Standard mechanism to determine objects as not null.
`static @Nullable Boolean`	`toBoolean(@Nullable String s)` Converts a string to a Boolean.
`static <E extends Enum<E>> E`	`valueOfIgnoreCase(@NotNull Class<E> eClass, @NotNull String name)` Returns the enum constant of the specified enum class with the specified name, case is ignored.

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

- Method Detail
  - immutable
```
public static void immutable(Class<?> clazz,
                             boolean isImmutable)
```
    Registers the immutability status of a class.
    
    Parameters:
    
    clazz - The class whose immutability status is to be registered.
    
    isImmutable - True if the class is immutable, false otherwise.
  - immutabile
```
@Deprecated
public static void immutabile(Class<?> clazz,
                                          boolean isImmutable)
```
    Deprecated.
  - isImmutable
```
public static ObjectUtils.Immutability isImmutable(@NotNull
                                                   @NotNull Class<?> clazz)
```
    Checks if a class is immutable.
    
    Parameters:
    
    clazz - The class to check.
    
    Returns:
    
    The immutability status of the class.
  - isTrue
```
public static boolean isTrue(CharSequence s)
```
    Checks if the given CharSequence is considered 'true'.
    
    Parameters:
    
    s - The CharSequence to check.
    
    Returns:
    
    True if the CharSequence is considered 'true', false otherwise.
  - isFalse
```
public static boolean isFalse(CharSequence s)
```
    Checks if the given CharSequence is considered 'false'.
    
    Parameters:
    
    s - The CharSequence to check.
    
    Returns:
    
    True if the CharSequence is considered 'false', false otherwise.
  - 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
```
    Converts an object to the desired class if possible.
    
    Type Parameters:
    
    E - The type of the target class.
    
    Parameters:
    
    eClass - The target class to convert to.
    
    o - The object to be converted.
    
    Returns:
    
    The converted object or null if the input object is null.
    
    Throws:
    
    ClassCastException - if the object cannot be cast to the target class.
    
    IllegalArgumentException - if an illegal argument is provided.
  - valueOfIgnoreCase
```
@NotNull
public static <E extends Enum<E>> E valueOfIgnoreCase(@NotNull
                                                               @NotNull Class<E> eClass,
                                                               @NotNull
                                                               @NotNull String name)
```
    Returns the enum constant of the specified enum class with the specified name, case is ignored.
    
    Type Parameters:
    
    E - The type of the enum.
    
    Parameters:
    
    eClass - The enum class.
    
    name - The name of the enum constant to be returned.
    
    Returns:
    
    The enum constant of the specified enum class with the specified name.
  - getSingletonForEnum
```
public static <E extends Enum<E>> E getSingletonForEnum(Class<E> eClass)
```
    Returns the single enum constant from the specified enum class, or the first one if there are multiple.
    
    Type Parameters:
    
    E - The type of the enum.
    
    Parameters:
    
    eClass - The enum class.
    
    Returns:
    
    The single enum constant or the first one if multiple exist.
  - asCCE
```
@NotNull
public static @NotNull ClassCastException asCCE(Exception e)
```
    Wraps the provided exception in a ClassCastException.
    
    Parameters:
    
    e - The exception to be wrapped.
    
    Returns:
    
    A ClassCastException with the provided exception set as its cause.
  - newInstance
```
@NotNull
public static <T> T newInstance(@NotNull
                                         @NotNull String className)
```
    Creates a new instance of the class with the given class name.
    
    Type Parameters:
    
    T - The type of the class to be instantiated.
    
    Parameters:
    
    className - The fully qualified name of the class to be instantiated.
    
    Returns:
    
    A new instance of the specified class.
    
    Throws:
    
    ClassCastException, - if the class cannot be cast to the type T.
  - newInstance
```
@NotNull
public static <T> T newInstance(@NotNull
                                         @NotNull Class<T> clazz)
```
    Creates a new instance of the specified class.
    
    Type Parameters:
    
    T - The type of the class to be instantiated.
    
    Parameters:
    
    clazz - The class to be instantiated.
    
    Returns:
    
    A new instance of the specified class.
  - newInstanceOrNull
```
@Nullable
public static @Nullable Object newInstanceOrNull(Class<?> type)
```
    Creates a new instance of the specified class, returning null if instantiation fails.
    
    Parameters:
    
    type - The class to be instantiated.
    
    Returns:
    
    A new instance of the specified class or null if instantiation fails.
  - addAll
```
public static <T> T[] addAll(@NotNull
                             T first,
                             @NotNull
                             T... additional)
```
    Creates an array containing the given element followed by the elements of the additional array.
    
    Type Parameters:
    
    T - The type of the elements in the arrays.
    
    Parameters:
    
    first - The first element to be added to the array.
    
    additional - Additional elements to be added after the first element.
    
    Returns:
    
    An array containing all the given elements.
  - matchingClass
```
public static boolean matchingClass(@NotNull
                                    @NotNull Class<?> base,
                                    @NotNull
                                    @NotNull Class<?> toMatch)
```
    Checks if two classes are matching.
    
    Parameters:
    
    base - The base class to be compared.
    
    toMatch - The class to be matched against the base class.
    
    Returns:
    
    true if the classes match, false otherwise.
  - defaultValue
```
public static Object defaultValue(Class<?> type)
```
    Returns the default value for the given class.
    
    Parameters:
    
    type - The class for which to return the default value.
    
    Returns:
    
    The default value for the given class.
  - onMethodCall
```
@NotNull
public static <T> T onMethodCall(@NotNull
                                          @NotNull BiFunction<Method,Object[],Object> biFunction,
                                          @NotNull
                                          @NotNull Class<T> tClass,
                                          Class<?>... additional)
                                   throws IllegalArgumentException
```
    Creates a dynamic proxy instance that delegates method calls to the provided BiFunction.
    
    Type Parameters:
    
    T - The type of the proxy instance.
    
    Parameters:
    
    biFunction - The BiFunction to which method calls will be delegated.
    
    tClass - The primary interface to be implemented by the proxy instance.
    
    additional - Additional interfaces to be implemented by the proxy instance.
    
    Returns:
    
    A dynamic proxy instance implementing the specified interfaces.
    
    Throws:
    
    IllegalArgumentException - If the arguments are invalid.
  - isConcreteClass
```
public static boolean isConcreteClass(@NotNull
                                      @NotNull Class<?> tClass)
```
    Checks if the given class is a concrete class (not abstract or interface).
    
    Parameters:
    
    tClass - The class to check.
    
    Returns:
    
    true if the class is concrete, false otherwise.
  - readResolve
```
public static Object readResolve(@NotNull
                                 @NotNull Object o)
```
    Invokes the readResolve method on the given object if it exists.
    
    Parameters:
    
    o - The object on which to invoke readResolve.
    
    Returns:
    
    The result of the readResolve method, or the original object if readResolve does not exist.
  - toBoolean
```
@Nullable
public static @Nullable Boolean toBoolean(@Nullable
                                                    @Nullable String s)
```
    Converts a string to a Boolean.
    
    Parameters:
    
    s - The string to be converted.
    
    Returns:
    
    Boolean.TRUE if the string is "true", Boolean.FALSE if the string is "false", null otherwise.
  - getAllInterfaces
```
public static Class<?>[] getAllInterfaces(Object o)
```
    Retrieves all the interfaces implemented by the given object or class.
    
    Parameters:
    
    o - The object or class for which to retrieve the implemented interfaces.
    
    Returns:
    
    An array of Class objects representing all the interfaces implemented by the given object or class.
    
    Throws:
    
    AssertionError - If an illegal argument is encountered.
  - getAllInterfaces
```
public static void getAllInterfaces(Object o,
                                    Function<Class<?>,Boolean> accumulator)
                             throws IllegalArgumentException
```
    Recursively accumulates all interfaces implemented by the given object or class.
    
    Parameters:
    
    o - The object or class for which to retrieve the implemented interfaces.
    
    accumulator - A function that accumulates the interfaces.
    
    Throws:
    
    IllegalArgumentException - If the accumulator is null.
  - defaultObjectForInterface
```
public static void defaultObjectForInterface(ThrowingFunction<Class<?>,Class<?>,ClassNotFoundException> defaultObjectForInterface)
```
    Sets a default implementation to be used for interfaces.
    
    Parameters:
    
    defaultObjectForInterface - A function that takes a class and returns a default implementation for it.
  - implementationToUse
```
public static <T> Class<T> implementationToUse(Class<T> tClass)
```
    Retrieves the implementation class to use for a given class.
    
    Type Parameters:
    
    T - The type of the class.
    
    Parameters:
    
    tClass - The class for which to retrieve the implementation.
    
    Returns:
    
    The implementation class to use.
  - 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

Class ObjectUtils

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

immutable

immutabile

isImmutable

isTrue

isFalse

primToWrapper

convertTo

valueOfIgnoreCase

getSingletonForEnum

asCCE

newInstance

newInstance

newInstanceOrNull

addAll

matchingClass

defaultValue

onMethodCall

isConcreteClass

readResolve

toBoolean

getAllInterfaces

getAllInterfaces

defaultObjectForInterface

implementationToUse

requireNonNull