ClassUtils (JavaTypeResolver 0.1.0 API)

java.lang.Object
- ch.jalu.typeresolver.classutil.ClassUtils

```
public final class ClassUtils
extends Object
```
Various utilities to load and inspect Class objects.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> Optional<Class<? extends T>>`	`asSubclassIfPossible(Class<?> classToInspect, Class<T> parent)` Returns an Optional with the same class cast as subtype of the given `parent` if possible, otherwise returns an empty optional.
`static boolean`	`classExists(String name)` Returns whether the class exists and can be loaded by the current class loader.
`static String`	`getClassName(@Nullable Object object)` Returns the `class name` of the object null-safely, returning "null" if the object is null.
`static String`	`getSemanticName(@Nullable Class<?> clazz)` Returns a human-friendly string representation of the given class, or of the most meaningful associated type.
`static String`	`getSemanticName(@Nullable Object object)` Returns a human-friendly string representation of the given object, based on the `semantic type` of the given object.
`static @Nullable Class<?>`	`getSemanticType(@Nullable Object object)` Returns the "semantic type" of the given object.
`static ClassType`	`getType(Class<?> clazz)` Returns the type of the given class (see `ClassType`).
`static boolean`	`isRegularJavaClass(@Nullable Class<?> clazz)` Returns whether the given class is a "regular" Java class.
`static Class<?>`	`loadClassOrThrow(String name)` Loads a class or throws an `IllegalArgumentException`.
`static <R> R`	`processClassByType(@Nullable Class<?> clazz, ClassTypeCallback<? extends R> typeCallback)` Calls the method on the given `ClassTypeCallback` that corresponds to the given class's type and returns the result.
`static Optional<Class<?>>`	`tryLoadClass(String name)` Wraps `Class.forName(String)` and swallows the `ClassNotFoundException` it potentially throws: allows to load a class by name if possible, otherwise returns an empty optional.

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

- Method Detail
  - classExists
```
public static boolean classExists(String name)
```
    Returns whether the class exists and can be loaded by the current class loader.
    
    Parameters:
    
    name - the name of the class to try to load
    
    Returns:
    
    true if the class exists, false otherwise
  - tryLoadClass
```
public static Optional<Class<?>> tryLoadClass(String name)
```
    Wraps Class.forName(String) and swallows the ClassNotFoundException it potentially throws: allows to load a class by name if possible, otherwise returns an empty optional.
    Note that errors thrown by Class.forName(String) (e.g. LinkageError) are not caught as they typically indicate more severe issues.
    
    Parameters:
    
    name - the class name to try to load
    
    Returns:
    
    optional with the class if possible, otherwise an empty optional
  - loadClassOrThrow
```
public static Class<?> loadClassOrThrow(String name)
```
    Loads a class or throws an IllegalArgumentException. This method wraps Class.forName(String) to throw a runtime exception for convenience.
    
    Parameters:
    
    name - the class name to load
    
    Returns:
    
    the loaded class, never null
  - asSubclassIfPossible
```
public static <T> Optional<Class<? extends T>> asSubclassIfPossible(Class<?> classToInspect,
                                                                    Class<T> parent)
```
    Returns an Optional with the same class cast as subtype of the given parent if possible, otherwise returns an empty optional.
    Note that the behavior for primitive classes may be unintuitive:
```
   Optional<? extends Integer> result1 = asSubClassIfPossible(int.class, int.class); // Optional.of(int.class)
   Optional<? extends Integer> result2 = asSubClassIfPossible(int.class, Integer.class); // Optional.empty()
 
```
    See PrimitiveType#toReferenceType to unwrap primitive types.
    Type Parameters:
    
    T - the parent type
    
    Parameters:
    
    classToInspect - the class to process
    
    parent - the parent type to check if the class is an extension of
    
    Returns:
    
    optional with the class as extension of the parent, or empty optional if not possible
    
    See Also:
    
    Class.asSubclass(java.lang.Class<U>)
  - getClassName
```
public static String getClassName(@Nullable
                                  @Nullable Object object)
```
    Returns the class name of the object null-safely, returning "null" if the object is null. Use getSemanticName(Object) to generate a null-safe, more user-appropriate name of the object's type.
    
    Parameters:
    
    object - the object whose type should be returned as string
    
    Returns:
    
    the object's class name, or "null" if the object was null
  - getSemanticType
```
@Nullable
public static @Nullable Class<?> getSemanticType(@Nullable
                                                           @Nullable Object object)
```
    Returns the "semantic type" of the given object. The semantic type is the type that identifies the object with the most semantic meaning; concretely, it ensures that for enum entries, the enum class is always returned, and that the annotation type is returned for objects representing annotations.
    Examples:
```
   getSemanticType(null) = null

   NumericShaper.Range.ETHIOPIC.getClass()       = NumericShaper$Range$1.class // or similar
   getSemanticType(NumericShaper.Range.ETHIOPIC) = NumericShaper$Range.class

   FunctionalInterface fiAnnotation = Runnable.class.getAnnotation(FunctionalInterface.class);
   fiAnnotation.getClass()          = $Proxy12.class // or similar
   getSemanticType(fiAnnotation)    = FunctionalInterface.class
 
```
    Parameters:
    
    object - the object to inspect, or null
    
    Returns:
    
    the semantic type (only null if the object was null)
  - getSemanticName
```
public static String getSemanticName(@Nullable
                                     @Nullable Object object)
```
    Returns a human-friendly string representation of the given object, based on the semantic type of the given object. Returns the string "null" if the object is null. The returned class names do not include the package. Annotations are prefixed by "@". Strings of array classes are constructed by adding [] at the end of the component type (e.g. "String[]").
    Inner classes and anonymous classes contain the name as given by Class.getName() with the package removed. For example, a Map.Entry object is returned as "Map$Entry".
    
    Parameters:
    
    object - the object to provide a user-friendly string for of its type
    
    Returns:
    
    most relevant type of the object as class name, or "null" as string (never null itself)
  - getSemanticName
```
public static String getSemanticName(@Nullable
                                     @Nullable Class<?> clazz)
```
    Returns a human-friendly string representation of the given class, or of the most meaningful associated type. Concretely, this means any synthetic classes for enum entries are replaced by the enum type itself, as returned by EnumUtils.getAssociatedEnumType(java.lang.Class<?>).
    Prefer using getSemanticName(Object) whenever possible, as more semantic types can be inferred based on an object.
    
    Parameters:
    
    clazz - the class to provide a user-friendly string for of its type
    
    Returns:
    
    semantic type as class name, or "null" as string (never null itself)
  - isRegularJavaClass
```
public static boolean isRegularJavaClass(@Nullable
                                         @Nullable Class<?> clazz)
```
    Returns whether the given class is a "regular" Java class. The intention of this method is to match only classes that are declared with the class or record keyword. This is done by exclusion: the class is considered as a "regular class" if it is not: an interface, an enum, an array, an annotation, a proxy class, a primitive type or void.class.
    To handle more types, use getType(Class).
    
    Parameters:
    
    clazz - the class to inspect, or null
    
    Returns:
    
    true if the class is a "regular Java class"
  - getType
```
public static ClassType getType(Class<?> clazz)
```
    Returns the type of the given class (see ClassType). A class is considered as a regular class if no other ClassType entry applies to it.
    
    Parameters:
    
    clazz - the class to inspect, or null
    
    Returns:
    
    the type of the class, or null if the class was null
  - processClassByType
```
@Nullable
public static <R> R processClassByType(@Nullable
                                                 @Nullable Class<?> clazz,
                                                 ClassTypeCallback<? extends R> typeCallback)
```
    Calls the method on the given ClassTypeCallback that corresponds to the given class's type and returns the result.
    
    Type Parameters:
    
    R - the callback's result type
    
    Parameters:
    
    clazz - the class to inspect and process
    
    typeCallback - the type callback to generate a result with
    
    Returns:
    
    the result from the callback (may be null)

Class ClassUtils

Method Summary

Methods inherited from class java.lang.Object

Method Detail

classExists

tryLoadClass

loadClassOrThrow

asSubclassIfPossible

getClassName

getSemanticType

getSemanticName

getSemanticName

isRegularJavaClass

getType

processClassByType