Package com.fasterxml.jackson.databind.util

Class ClassUtil

  • public final class ClassUtil
extends Object

    • Constructor Detail

      • ClassUtil

        public ClassUtil()

    • Method Detail

      • emptyIterator

        public static <T> Iterator<T> emptyIterator()
        Since:
        2.7

      • findSuperTypes

        public static List<JavaType> findSuperTypes​(JavaType type,
                                            Class<?> endBefore,
                                            boolean addClassItself)
        Method that will find all sub-classes and implemented interfaces of a given class or interface. Classes are listed in order of precedence, starting with the immediate super-class, followed by interfaces class directly declares to implemented, and then recursively followed by parent of super-class and so forth. Note that Object.class is not included in the list regardless of whether endBefore argument is defined or not.
        Parameters:
        endBefore - Super-type to NOT include in results, if any; when encountered, will be ignored (and no super types are checked).
        Since:
        2.7

      • findRawSuperTypes

        public static List<Class<?>> findRawSuperTypes​(Class<?> cls,
                                               Class<?> endBefore,
                                               boolean addClassItself)
        Since:
        2.7

      • findSuperClasses

        public static List<Class<?>> findSuperClasses​(Class<?> cls,
                                              Class<?> endBefore,
                                              boolean addClassItself)
        Method for finding all super classes (but not super interfaces) of given class, starting with the immediate super class and ending in the most distant one. Class itself is included if addClassItself is true.

        NOTE: mostly/only called to resolve mix-ins as that's where we do not care about fully-resolved types, just associated annotations.

        Since:
        2.7

      • canBeABeanType

        public static String canBeABeanType​(Class<?> type)
        Returns:
        Null if class might be a bean; type String (that identifies why it's not a bean) if not

      • isLocalType

        public static String isLocalType​(Class<?> type,
                                 boolean allowNonStatic)

      • getOuterClass

        public static Class<?> getOuterClass​(Class<?> type)
        Method for finding enclosing class for non-static inner classes

      • isProxyType

        public static boolean isProxyType​(Class<?> type)
        Helper method used to weed out dynamic Proxy types; types that do not expose concrete method API that we could use to figure out automatic Bean (property) based serialization.

      • isConcrete

        public static boolean isConcrete​(Class<?> type)
        Helper method that checks if given class is a concrete one; that is, not an interface or abstract class.

      • isConcrete

        public static boolean isConcrete​(Member member)

      • isCollectionMapOrArray

        public static boolean isCollectionMapOrArray​(Class<?> type)

      • isBogusClass

        public static boolean isBogusClass​(Class<?> cls)

      • isObjectOrPrimitive

        public static boolean isObjectOrPrimitive​(Class<?> cls)
        Since:
        2.7

      • hasClass

        public static boolean hasClass​(Object inst,
                               Class<?> raw)
        Since:
        2.9

      • verifyMustOverride

        public static void verifyMustOverride​(Class<?> expType,
                                      Object instance,
                                      String method)
        Since:
        2.9

      • hasGetterSignature

        @Deprecated
public static boolean hasGetterSignature​(Method m)
        Deprecated.
        Since 2.6 not used; may be removed before 3.x

      • throwIfError

        public static Throwable throwIfError​(Throwable t)
        Helper method that will check if argument is an Error, and if so, (re)throw it; otherwise just return
        Since:
        2.9

      • throwIfRTE

        public static Throwable throwIfRTE​(Throwable t)
        Helper method that will check if argument is an RuntimeException, and if so, (re)throw it; otherwise just return
        Since:
        2.9

      • getRootCause

        public static Throwable getRootCause​(Throwable t)
        Method that can be used to find the "root cause", innermost of chained (wrapped) exceptions.

      • throwAsIAE

        public static void throwAsIAE​(Throwable t)
        Method that will wrap 't' as an IllegalArgumentException if it is a checked exception; otherwise (runtime exception or error) throw as is

      • throwAsIAE

        public static void throwAsIAE​(Throwable t,
                              String msg)
        Method that will wrap 't' as an IllegalArgumentException (and with specified message) if it is a checked exception; otherwise (runtime exception or error) throw as is

      • unwrapAndThrowAsIAE

        public static void unwrapAndThrowAsIAE​(Throwable t)
        Method that will locate the innermost exception for given Throwable; and then wrap it as an IllegalArgumentException if it is a checked exception; otherwise (runtime exception or error) throw as is

      • unwrapAndThrowAsIAE

        public static void unwrapAndThrowAsIAE​(Throwable t,
                                       String msg)
        Method that will locate the innermost exception for given Throwable; and then wrap it as an IllegalArgumentException if it is a checked exception; otherwise (runtime exception or error) throw as is

      • closeOnFailAndThrowAsIOE

        public static void closeOnFailAndThrowAsIOE​(JsonGenerator g,
                                            Exception fail)
                                     throws IOException
        Helper method that encapsulate logic in trying to close output generator in case of failure; useful mostly in forcing flush()ing as otherwise error conditions tend to be hard to diagnose. However, it is often the case that output state may be corrupt so we need to be prepared for secondary exception without masking original one.
        Throws:
        IOException
        Since:
        2.8

      • closeOnFailAndThrowAsIOE

        public static void closeOnFailAndThrowAsIOE​(JsonGenerator g,
                                            Closeable toClose,
                                            Exception fail)
                                     throws IOException
        Helper method that encapsulate logic in trying to close given Closeable in case of failure; useful mostly in forcing flush()ing as otherwise error conditions tend to be hard to diagnose. However, it is often the case that output state may be corrupt so we need to be prepared for secondary exception without masking original one.
        Throws:
        IOException
        Since:
        2.8

      • createInstance

        public static <T> T createInstance​(Class<T> cls,
                                   boolean canFixAccess)
                            throws IllegalArgumentException
        Method that can be called to try to create an instantiate of specified type. Instantiation is done using default no-argument constructor.
        Parameters:
        canFixAccess - Whether it is possible to try to change access rights of the default constructor (in case it is not publicly accessible) or not.
        Throws:
        IllegalArgumentException - If instantiation fails for any reason; except for cases where constructor throws an unchecked exception (which will be passed as is)

      • classOf

        public static Class<?> classOf​(Object inst)
        Since:
        2.9

      • rawClass

        public static Class<?> rawClass​(JavaType t)
        Since:
        2.9

      • nonNull

        public static <T> T nonNull​(T valueOrNull,
                            T defaultValue)
        Since:
        2.9

      • nullOrToString

        public static String nullOrToString​(Object value)
        Since:
        2.9

      • nonNullString

        public static String nonNullString​(String str)
        Since:
        2.9

      • quotedOr

        public static String quotedOr​(Object str,
                              String forNull)
        Returns either quoted value (with double-quotes) -- if argument non-null String -- or String NULL (no quotes) (if null).
        Since:
        2.9

      • getClassDescription

        public static String getClassDescription​(Object classOrInstance)
        Helper method used to construct appropriate description when passed either type (Class) or an instance; in latter case, class of instance is to be used.

      • getTypeDescription

        public static String getTypeDescription​(JavaType fullType)
        Helper method to create and return "backticked" description of given resolved type (or, "null" if null passed), similar to return vaue of getClassDescription(Object).
        Parameters:
        fullType - Fully resolved type or null
        Returns:
        String description of type including generic type parameters, surrounded by backticks, if type passed; or string "null" if {code null} passed
        Since:
        2.10

      • classNameOf

        public static String classNameOf​(Object inst)
        Helper method used to construct appropriate description when passed either type (Class) or an instance; in latter case, class of instance is to be used.
        Since:
        2.9

      • nameOf

        public static String nameOf​(Class<?> cls)
        Returns either `cls.getName()` (if `cls` not null), or "[null]" if `cls` is null.
        Since:
        2.9

      • nameOf

        public static String nameOf​(Named named)
        Returns either backtick-quoted `named.getName()` (if `named` not null), or "[null]" if `named` is null.
        Since:
        2.9

      • backticked

        public static String backticked​(String text)
        Returns either `text` or [null].
        Since:
        2.9

      • exceptionMessage

        public static String exceptionMessage​(Throwable t)
        Helper method that returns Throwable.getMessage() for all other exceptions except for JsonProcessingException, for which getOriginalMessage() is returned instead. Method is used to avoid accidentally including trailing location information twice in message when wrapping exceptions.
        Since:
        2.9.7

      • defaultValue

        public static Object defaultValue​(Class<?> cls)
        Helper method used to get default value for wrappers used for primitive types (0 for Integer etc)

      • wrapperType

        public static Class<?> wrapperType​(Class<?> primitiveType)
        Helper method for finding wrapper type for given primitive type (why isn't there one in JDK?)

      • primitiveType

        public static Class<?> primitiveType​(Class<?> type)
        Method that can be used to find primitive type for given class if (but only if) it is either wrapper type or primitive type; returns `null` if type is neither.
        Since:
        2.7

      • checkAndFixAccess

        @Deprecated
public static void checkAndFixAccess​(Member member)
        Deprecated.
        Since 2.7 call variant that takes boolean flag.
        Equivalent to call: 
           checkAndFixAccess(member, false);

      • checkAndFixAccess

        public static void checkAndFixAccess​(Member member,
                                     boolean force)
        Method that is called if a Member may need forced access, to force a field, method or constructor to be accessible: this is done by calling AccessibleObject.setAccessible(boolean).
        Parameters:
        member - Accessor to call setAccessible() on.
        force - Whether to always try to make accessor accessible (true), or only if needed as per access rights (false)
        Since:
        2.7

      • isEnumType

        public static boolean isEnumType​(Class<?> rawType)
        Helper method that encapsulates reliable check on whether given raw type "is an Enum", that is, is or extends Enum.
        Since:
        2.10.1

      • findEnumType

        public static Class<? extends Enum<?>> findEnumType​(EnumSet<?> s)
        Helper method that can be used to dynamically figure out enumeration type of given EnumSet, without having access to its declaration. Code is needed to work around design flaw in JDK.

      • findEnumType

        public static Class<? extends Enum<?>> findEnumType​(EnumMap<?,​?> m)
        Helper method that can be used to dynamically figure out enumeration type of given EnumSet, without having access to its declaration. Code is needed to work around design flaw in JDK.

      • findEnumType

        public static Class<? extends Enum<?>> findEnumType​(Enum<?> en)
        Helper method that can be used to dynamically figure out formal enumeration type (class) for given enumeration. This is either class of enum instance (for "simple" enumerations), or its superclass (for enums with instance fields or methods)

      • findEnumType

        public static Class<? extends Enum<?>> findEnumType​(Class<?> cls)
        Helper method that can be used to dynamically figure out formal enumeration type (class) for given class of an enumeration value. This is either class of enum instance (for "simple" enumerations), or its superclass (for enums with instance fields or methods)

      • findFirstAnnotatedEnumValue

        public static <T extends Annotation> Enum<?> findFirstAnnotatedEnumValue​(Class<Enum<?>> enumClass,
                                                                         Class<T> annotationClass)
        A method that will look for the first Enum value annotated with the given Annotation.

        If there's more than one value annotated, the first one found will be returned. Which one exactly is used is undetermined.

        Parameters:
        enumClass - The Enum class to scan for a value with the given annotation
        annotationClass - The annotation to look for.
        Returns:
        the Enum value annotated with the given Annotation or null if none is found.
        Throws:
        IllegalArgumentException - if there's a reflection issue accessing the Enum
        Since:
        2.8

      • isJacksonStdImpl

        public static boolean isJacksonStdImpl​(Object impl)
        Method that can be called to determine if given Object is the default implementation Jackson uses; as opposed to a custom serializer installed by a module or calling application. Determination is done using JacksonStdImpl annotation on handler (serializer, deserializer etc) class.

        NOTE: passing `null` is legal, and will result in true being returned.

      • isJacksonStdImpl

        public static boolean isJacksonStdImpl​(Class<?> implClass)

      • isJDKClass

        public static boolean isJDKClass​(Class<?> rawType)
        Some aspects of handling need to be changed for JDK types (and possibly some extensions under javax.?): for example, forcing of access will not work well for future JDKs (12 and later).
        Since:
        2.11

      • isNonStaticInnerClass

        public static boolean isNonStaticInnerClass​(Class<?> cls)

      • getPackageName

        public static String getPackageName​(Class<?> cls)
        Since:
        2.7

      • hasEnclosingMethod

        public static boolean hasEnclosingMethod​(Class<?> cls)
        Since:
        2.7

      • getDeclaredFields

        @Deprecated
public static Field[] getDeclaredFields​(Class<?> cls)
        Deprecated.
        since 2.11 (just call Class method directly)

      • getDeclaredMethods

        @Deprecated
public static Method[] getDeclaredMethods​(Class<?> cls)
        Deprecated.
        since 2.11 (just call Class method directly)

      • findClassAnnotations

        public static Annotation[] findClassAnnotations​(Class<?> cls)
        Since:
        2.7

      • getClassMethods

        public static Method[] getClassMethods​(Class<?> cls)
        Helper method that gets methods declared in given class; usually a simple thing, but sometimes (as per [databind#785]) more complicated, depending on classloader setup.
        Since:
        2.9

      • getConstructors

        public static ClassUtil.Ctor[] getConstructors​(Class<?> cls)
        Since:
        2.7

      • getDeclaringClass

        public static Class<?> getDeclaringClass​(Class<?> cls)
        Since:
        2.7

      • getGenericSuperclass

        public static Type getGenericSuperclass​(Class<?> cls)
        Since:
        2.7

      • getGenericInterfaces

        public static Type[] getGenericInterfaces​(Class<?> cls)
        Since:
        2.7

      • getEnclosingClass

        public static Class<?> getEnclosingClass​(Class<?> cls)
        Since:
        2.7