@Nonnull public static ClassLoader getDefaultClassLoader () { ClassLoader ret = null; try { ret = getContextClassLoader (); } catch (final Exception ex) // NOPMD { // e.g. security exception } // Fallback to class loader of this class if (ret == null) ret = getClassClassLoader (ClassHelper.class); return ret; }
@Nonnull private static ClassLoader _getDefaultClassLoader () { return ClassHelper.getDefaultClassLoader (); }
@Nullable private static JSType _autoDetectJSType (final Class <?> aClass) { if (ClassHelper.isStringClass (aClass) || IPredefinedLocaleTextProvider.class.isAssignableFrom (aClass)) return JSType.STRING; if (ClassHelper.isCharacterClass (aClass)) return JSType.STRING; if (ClassHelper.isBooleanClass (aClass)) return JSType.BOOLEAN; if (ClassHelper.isFloatingPointClass (aClass)) return JSType.DOUBLE; if (ClassHelper.isIntegerClass (aClass)) return JSType.INT; if (ClassHelper.isArrayClass (aClass)) return new JSArrayType (JSType.AUTO_DETECT); if (IJSCodeProvider.class.isAssignableFrom (aClass)) return JSType.JS; if (Map.class.isAssignableFrom (aClass)) return new JSMapType (JSType.AUTO_DETECT, JSType.AUTO_DETECT); if (Collection.class.isAssignableFrom (aClass)) return new JSListType (JSType.AUTO_DETECT); if (IJSON.class.isAssignableFrom (aClass)) return JSType.JSON; s_aLogger.warn ("Failed to detect JS type of class " + aClass); return null; }
public static boolean isPublicClass (@Nullable final Class <?> aClass) { if (aClass == null) return false; // Interfaces or annotations are not allowed if (aClass.isInterface () || aClass.isAnnotation ()) return false; // Only public classes are allowed if (!isPublic (aClass)) return false; // Abstract classes are not allowed if (isAbstractClass (aClass)) return false; return true; }
if (ClassHelper.isInterface (aMatchingClass) && _implementsHashCodeItself (aClass)) if (ClassHelper.isArrayClass (aClass)) return new ArrayHashCodeImplementation ();
public FactoryNewInstance (@Nullable final Class <? extends DATATYPE> aClass, final boolean bCheckInstancable) { if (bCheckInstancable && !ClassHelper.isInstancableClass (aClass)) throw new IllegalArgumentException ("The passed class '" + aClass + "' is not instancable or doesn't have a no-argument constructor!"); m_aClass = aClass; }
aSH.getAsMatching (SystemHelper.getTotalMemory (), 2)); aTable.addBodyRow ().addCells (EText.MSG_CONTEXT_CLASSLOADER.getDisplayText (aDisplayLocale), ClassHelper.getContextClassLoader ().toString ()); aTable.addBodyRow ().addCells (EText.MSG_SYSTEM_CLASSLOADER.getDisplayText (aDisplayLocale), ClassHelper.getSystemClassLoader ().toString ());
/** * Check if the passed object is an array or not. * * @param aObject * The object to be checked. May be <code>null</code>. * @return <code>true</code> if the passed object is not <code>null</code> and * represents an array. */ public static boolean isArray (@Nullable final Object aObject) { return aObject != null && ClassHelper.isArrayClass (aObject.getClass ()); }
/** * Check if the passed classes are convertible. Includes conversion checks * between primitive types and primitive wrapper types. * * @param aSrcClass * First class. May not be <code>null</code>. * @param aDstClass * Second class. May not be <code>null</code>. * @return <code>true</code> if the classes are directly convertible. */ public static boolean areConvertibleClasses (@Nonnull final Class <?> aSrcClass, @Nonnull final Class <?> aDstClass) { ValueEnforcer.notNull (aSrcClass, "SrcClass"); ValueEnforcer.notNull (aDstClass, "DstClass"); // Same class? if (aDstClass.equals (aSrcClass)) return true; // Default assignable if (aDstClass.isAssignableFrom (aSrcClass)) return true; // Special handling for "int.class" == "Integer.class" etc. if (aDstClass == getPrimitiveWrapperClass (aSrcClass)) return true; if (aDstClass == getPrimitiveClass (aSrcClass)) return true; // Not convertible return false; }
if (!ClassHelper.isPublic (aSrcClass)) throw new IllegalArgumentException ("Source " + aSrcClass + " is no public class!"); ValueEnforcer.notNull (aDstClass, "DstClass"); if (!ClassHelper.isPublic (aDstClass)) throw new IllegalArgumentException ("Destination " + aDstClass + " is no public class!"); if (aSrcClass.equals (aDstClass)) if (aConverter instanceof ITypeConverterRule) throw new IllegalArgumentException ("Type converter rules must be registered via registerTypeConverterRule"); if (ClassHelper.areConvertibleClasses (aSrcClass, aDstClass)) s_aLogger.warn ("No type converter needed between " + aSrcClass +
/** * Get the class to use. In case the passed class is a primitive type, the * corresponding wrapper class is used. * * @param aClass * The class to check. Can be <code>null</code> but should not be * <code>null</code>. * @return <code>null</code> if the parameter is <code>null</code>. */ @Nullable private static Class <?> _getUsableClass (@Nullable final Class <?> aClass) { final Class <?> aPrimitiveWrapperType = ClassHelper.getPrimitiveWrapperClass (aClass); return aPrimitiveWrapperType != null ? aPrimitiveWrapperType : aClass; }
if (ClassHelper.areConvertibleClasses (aSrcClass, aUsableDstClass)) aRetVal = aSrcValue; else
if (ClassHelper.isInterface (aMatchingClass) && _implementsEqualsItself (aClass)) if (ClassHelper.isArrayClass (aClass)) return new ArrayEqualsImplementation ();
public <DATATYPE extends IAggregator <?, ?>> AggregatorFactoryNewInstance (@Nonnull final Class <DATATYPE> aClass) { ValueEnforcer.notNull (aClass, "aClass"); if (!ClassHelper.isInstancableClass (aClass)) throw new IllegalArgumentException ("Class " + aClass + " is not instancable!"); m_aClass = aClass; }
@Nullable public static EContainerType getContainerTypeOfClass (@Nullable final Class <?> aClass) { if (aClass != null) { // Query Set before Collection, because Set is derived from Collection! if (Set.class.isAssignableFrom (aClass)) return EContainerType.SET; if (Collection.class.isAssignableFrom (aClass)) return EContainerType.COLLECTION; if (Map.class.isAssignableFrom (aClass)) return EContainerType.MAP; if (ClassHelper.isArrayClass (aClass)) return EContainerType.ARRAY; if (Iterator.class.isAssignableFrom (aClass)) return EContainerType.ITERATOR; if (Iterable.class.isAssignableFrom (aClass)) return EContainerType.ITERABLE; if (Enumeration.class.isAssignableFrom (aClass)) return EContainerType.ENUMERATION; } return null; }
/** * Clear the complete resource bundle cache using the default class loader! */ public static void clearCache () { clearCache (ClassHelper.getDefaultClassLoader ()); }
@Nonnull private static <T extends AbstractSingleton> T _instantiateSingleton (@Nonnull final Class <T> aClass, @Nonnull final IScope aScope) { // create new object in passed scope try { if (s_aLogger.isDebugEnabled ()) s_aLogger.debug ("Created singleton for '" + aClass + "' in scope " + aScope.toString ()); // Check if class is public, non-abstract etc. if (!ClassHelper.isInstancableClass (aClass)) throw new IllegalStateException ("Class " + aClass + " is not instancable!"); // Find the now-argument constructor final Constructor <T> aCtor = aClass.getDeclaredConstructor ((Class <?> []) null); // Ubuntu: java.security.AccessControlException: access denied // (java.lang.reflect.ReflectPermission suppressAccessChecks) if (false) AccessController.doPrivileged (new PrivilegedActionAccessibleObjectSetAccessible (aCtor)); // Invoke default ctor final T ret = aCtor.newInstance ((Object []) null); return ret; } catch (final Throwable t) { throw LoggedRuntimeException.newException (t); } }
@Nullable public static ResourceBundle getResourceBundle (@Nonnull final String sBundleName, @Nonnull final Locale aContentLocale, @Nonnull final ClassLoader aClassLoader) { try { return ResourceBundle.getBundle (sBundleName, aContentLocale, aClassLoader); } catch (final MissingResourceException ex) { return null; } }
@Nullable public static ResourceBundle getUtf8ResourceBundle (@Nonnull final String sBundleName, @Nonnull final Locale aContentLocale, @Nonnull final ClassLoader aClassLoader) { try { return Utf8ResourceBundle.getBundle (sBundleName, aContentLocale, aClassLoader); } catch (final MissingResourceException ex) { return null; } }
@Nonnull @ReturnsMutableCopy public static Map <URI, ChangeLog> readAllChangeLogs (@Nonnull final INonThrowingRunnableWithParameter <String> aErrorCallback) { return readAllChangeLogs (aErrorCallback, ClassHelper.getDefaultClassLoader ()); }