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

• findSuperTypes

  @Deprecated
  public static List<Class<?>> findSuperTypes(Class<?> cls,
                                                          Class<?> endBefore)

  Deprecated. 

• findSuperTypes

  @Deprecated
  public static List<Class<?>> findSuperTypes(Class<?> cls,
                                                          Class<?> endBefore,
                                                          List<Class<?>> result)

  Deprecated. 

• 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)

• isNonStaticInnerClass

  public static boolean isNonStaticInnerClass(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

• throwIfIOE

  public static Throwable throwIfIOE(Throwable t)
                              throws IOException

  Helper method that will check if argument is an IOException, and if so, (re)throw it; otherwise just return

  Throws:

  IOException

  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.

• throwRootCauseIfIOE

  public static Throwable throwRootCauseIfIOE(Throwable t)
                                       throws IOException

  Method that works like by calling getRootCause(java.lang.Throwable) and then either throwing it (if instanceof IOException), or return.

  Throws:

  IOException

  Since:

  2.8

• 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

• throwAsMappingException

  public static <T> T throwAsMappingException(DeserializationContext ctxt,
                                              IOException e0)
                                       throws JsonMappingException

  Throws:

  JsonMappingException

  Since:

  2.9

• 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)

• findConstructor

  public static <T> Constructor<T> findConstructor(Class<T> cls,
                                                   boolean forceAccess)
                                            throws IllegalArgumentException

  Throws:

  IllegalArgumentException

• 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)

• getPackageName

  public static String getPackageName(Class<?> cls)

  Since:

  2.7

• hasEnclosingMethod

  public static boolean hasEnclosingMethod(Class<?> cls)

  Since:

  2.7

• getDeclaredFields

  public static Field[] getDeclaredFields(Class<?> cls)

  Since:

  2.7

• getDeclaredMethods

  public static Method[] getDeclaredMethods(Class<?> cls)

  Since:

  2.7

• 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