com.helger.commons.lang.ClassHelper Java Examples

@Nullable
public static ECollectionBaseType getCollectionBaseTypeOfClass (@Nullable final Class <?> aClass)
{
  if (aClass != null)
  {
    // Query Set before Collection, because Set is derived from Collection!
    if (Set.class.isAssignableFrom (aClass))
      return ECollectionBaseType.SET;
    if (Collection.class.isAssignableFrom (aClass))
      return ECollectionBaseType.COLLECTION;
    if (Map.class.isAssignableFrom (aClass))
      return ECollectionBaseType.MAP;
    if (ClassHelper.isArrayClass (aClass))
      return ECollectionBaseType.ARRAY;
    if (Iterator.class.isAssignableFrom (aClass))
      return ECollectionBaseType.ITERATOR;
    if (Iterable.class.isAssignableFrom (aClass))
      return ECollectionBaseType.ITERABLE;
    if (Enumeration.class.isAssignableFrom (aClass))
      return ECollectionBaseType.ENUMERATION;
  }
  return null;
}
 

/**
 * Get the URL for the specified path using automatic class loader handling.
 * The class loaders are iterated in the following order:
 * <ol>
 * <li>Default class loader (usually the context class loader)</li>
 * <li>The class loader of this class</li>
 * <li>The system class loader</li>
 * </ol>
 *
 * @param sPath
 *        The path to be resolved. May neither be <code>null</code> nor empty.
 * @return <code>null</code> if the path could not be resolved.
 */
@Nullable
public static URL getClassPathURL (@Nonnull @Nonempty final String sPath)
{
  ValueEnforcer.notEmpty (sPath, "Path");

  // Use the default class loader. Returns null if not found
  URL ret = ClassLoaderHelper.getResource (ClassLoaderHelper.getDefaultClassLoader (), sPath);
  if (ret == null)
  {
    // This is essential if we're running as a web application!!!
    ret = ClassHelper.getResource (URLHelper.class, sPath);
    if (ret == null)
    {
      // this is a fix for a user that needed to have the application
      // loaded by the bootstrap class loader
      ret = ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sPath);
    }
  }
  return ret;
}
 

@Override
protected void postDestroy ()
{
  if (ScopeHelper.debugGlobalScopeLifeCycle (LOGGER))
    if (LOGGER.isInfoEnabled ())
      LOGGER.info ("Destroyed global scope '" + getID () + "' of class " + ClassHelper.getClassLocalName (this),
                   ScopeHelper.getDebugStackTrace ());
}
 

@Nullable
static String getErrorFieldName (@Nullable final IPSElement aSourceElement)
{
  if (aSourceElement == null)
    return null;
  String sField = ClassHelper.getClassLocalName (aSourceElement);
  if (aSourceElement instanceof IPSHasID && ((IPSHasID) aSourceElement).hasID ())
    sField += " [ID=" + ((IPSHasID) aSourceElement).getID () + "]";
  return sField;
}
 

public void registerTypeConverterRule (@Nonnull final ITypeConverterRule <?, ?> aTypeConverterRule)
{
  ValueEnforcer.notNull (aTypeConverterRule, "TypeConverterRule");

  m_aRWLock.writeLockedBoolean ( () -> m_aRules.computeIfAbsent (aTypeConverterRule.getSubType (),
                                                          x -> new CommonsArrayList <> ())
                                        .add (aTypeConverterRule));

  if (LOGGER.isTraceEnabled ())
    LOGGER.trace ("Registered type converter rule " +
                  ClassHelper.getClassLocalName (aTypeConverterRule) +
                  " with type " +
                  aTypeConverterRule.getSubType ());
}
 

/**
 * Convert the passed source value to the destination class, if a conversion
 * is necessary.
 *
 * @param <DSTTYPE>
 *        The destination type.
 * @param aTypeConverterProvider
 *        The type converter provider. May not be <code>null</code>.
 * @param aSrcValue
 *        The source value. May be <code>null</code>.
 * @param aDstClass
 *        The destination class to use.
 * @return <code>null</code> if the source value was <code>null</code>.
 * @throws TypeConverterException
 *         If no converter was found or if the converter returned a
 *         <code>null</code> object.
 * @throws RuntimeException
 *         If the converter itself throws an exception
 */
@Nullable
public static <DSTTYPE> DSTTYPE convert (@Nonnull final ITypeConverterProvider aTypeConverterProvider,
                                         @Nullable final Object aSrcValue,
                                         @Nonnull final Class <DSTTYPE> aDstClass)
{
  ValueEnforcer.notNull (aTypeConverterProvider, "TypeConverterProvider");
  ValueEnforcer.notNull (aDstClass, "DstClass");

  // Nothing to convert for null
  if (aSrcValue == null)
    return null;

  final Class <?> aSrcClass = aSrcValue.getClass ();
  final Class <?> aUsableDstClass = _getUsableClass (aDstClass);

  // First check if a direct cast is possible
  Object aRetVal;
  if (ClassHelper.areConvertibleClasses (aSrcClass, aUsableDstClass))
    aRetVal = aSrcValue;
  else
    aRetVal = _performConversion (aTypeConverterProvider, aSrcClass, aUsableDstClass, aSrcValue);

  // Done :)
  // Note: aUsableDstClass.cast (aRetValue) does not work on conversion from
  // "boolean" to "Boolean" whereas casting works
  return GenericReflection.uncheckedCast (aRetVal);
}
 

public FactoryNewInstance (@Nullable final Class <? extends DATATYPE> aClass, final boolean bCheckInstancable)
{
  if (bCheckInstancable)
    ValueEnforcer.isTrue (ClassHelper.isInstancableClass (aClass),
                          () -> "The passed class '" +
                                aClass +
                                "' is not instancable or doesn't have a public no-argument constructor!");
  m_aClass = aClass;
}
 

/**
 * Add or update an item. Must only be invoked inside a write-lock.
 *
 * @param aItem
 *        The item to be added or updated
 * @param eActionType
 *        The action type. Must be CREATE or UPDATE!
 * @throws IllegalArgumentException
 *         If on CREATE an item with the same ID is already contained. If on
 *         UPDATE an item with the provided ID does NOT exist.
 */
@MustBeLocked (ELockType.WRITE)
private void _addItem (@Nonnull final IMPLTYPE aItem, @Nonnull final EDAOActionType eActionType)
{
  ValueEnforcer.notNull (aItem, "Item");
  ValueEnforcer.isTrue (eActionType == EDAOActionType.CREATE || eActionType == EDAOActionType.UPDATE,
                        "Invalid action type provided!");

  final String sID = aItem.getID ();
  final IMPLTYPE aOldItem = m_aMap.get (sID);
  if (eActionType == EDAOActionType.CREATE)
  {
    if (aOldItem != null)
      throw new IllegalArgumentException (ClassHelper.getClassLocalName (getDataTypeClass ()) +
                                          " with ID '" +
                                          sID +
                                          "' is already in use and can therefore not be created again. Old item = " +
                                          aOldItem +
                                          "; New item = " +
                                          aItem);
  }
  else
  {
    // Update
    if (aOldItem == null)
      throw new IllegalArgumentException (ClassHelper.getClassLocalName (getDataTypeClass ()) +
                                          " with ID '" +
                                          sID +
                                          "' is not yet in use and can therefore not be updated! Updated item = " +
                                          aItem);
  }

  m_aMap.put (sID, aItem);
}
 

/**
 * Create a standard {@link ObjectName} using the default domain and only the
 * "type" property. The type property is the class local name of the specified
 * object.
 *
 * @param aObj
 *        The object from which the name is to be created.
 * @return The non-<code>null</code> {@link ObjectName}.
 */
@Nonnull
public static ObjectName createWithDefaultProperties (@Nonnull final Object aObj)
{
  ValueEnforcer.notNull (aObj, "Object");

  final Hashtable <String, String> aParams = new Hashtable <> ();
  aParams.put (CJMX.PROPERTY_TYPE, ClassHelper.getClassLocalName (aObj));
  return create (aParams);
}
 

@Override
protected void preDestroy ()
{
  if (ScopeHelper.debugGlobalScopeLifeCycle (LOGGER))
    if (LOGGER.isInfoEnabled ())
      LOGGER.info ("Destroying global scope '" + getID () + "' of class " + ClassHelper.getClassLocalName (this),
                   ScopeHelper.getDebugStackTrace ());
}
 

@Override
protected void preDestroy ()
{
  if (ScopeHelper.debugSessionScopeLifeCycle (LOGGER))
    if (LOGGER.isInfoEnabled ())
      LOGGER.info ("Destroying session scope '" + getID () + "' of class " + ClassHelper.getClassLocalName (this),
                   ScopeHelper.getDebugStackTrace ());
}
 

@Override
protected void postDestroy ()
{
  if (ScopeHelper.debugSessionScopeLifeCycle (LOGGER))
    if (LOGGER.isInfoEnabled ())
      LOGGER.info ("Destroyed session scope '" + getID () + "' of class " + ClassHelper.getClassLocalName (this),
                   ScopeHelper.getDebugStackTrace ());
}
 

@Override
protected void preDestroy ()
{
  if (ScopeHelper.debugRequestScopeLifeCycle (LOGGER))
    if (LOGGER.isInfoEnabled ())
      LOGGER.info ("Destroying request scope '" + getID () + "' of class " + ClassHelper.getClassLocalName (this),
                   ScopeHelper.getDebugStackTrace ());
}
 

@Override
protected void postDestroy ()
{
  if (ScopeHelper.debugRequestScopeLifeCycle (LOGGER))
    if (LOGGER.isInfoEnabled ())
      LOGGER.info ("Destroyed request scope '" + getID () + "' of class " + ClassHelper.getClassLocalName (this),
                   ScopeHelper.getDebugStackTrace ());
}
 

@Override
public String toString ()
{
  return new ToStringGenerator (this).append ("Value", m_aValue)
                                     .append ("ValueClass", ClassHelper.getClassLocalName (m_aValue))
                                     .getToString ();
}
 

/**
 * Create a standard {@link ObjectName} using the default domain and the
 * "type" and "name" properties. The type property is the class local name of
 * the specified object.
 *
 * @param aObj
 *        The object from which the name is to be created.
 * @param sName
 *        The value of the "name" JMX property
 * @return The non-<code>null</code> {@link ObjectName}.
 */
@Nonnull
public static ObjectName createWithDefaultProperties (@Nonnull final Object aObj, @Nonnull final String sName)
{
  ValueEnforcer.notNull (aObj, "Object");
  ValueEnforcer.notNull (sName, "Name");

  final Hashtable <String, String> aParams = new Hashtable <> ();
  aParams.put (CJMX.PROPERTY_TYPE, ClassHelper.getClassLocalName (aObj));
  aParams.put (CJMX.PROPERTY_NAME, getCleanPropertyValue (sName));
  return create (aParams);
}
 

@Nullable
public <T> IHashCodeImplementation <T> getBestMatchingHashCodeImplementation (@Nullable final Class <T> aClass)
{
  if (aClass != null)
  {
    IHashCodeImplementation <T> aMatchingImplementation = null;
    Class <?> aMatchingClass = null;

    // No check required?
    if (_isUseDirectHashCode (aClass))
      return null;

    m_aRWLock.readLock ().lock ();
    try
    {
      // Check for an exact match first
      aMatchingImplementation = GenericReflection.uncheckedCast (m_aMap.get (aClass));
      if (aMatchingImplementation != null)
        aMatchingClass = aClass;
      else
      {
        // Scan hierarchy in efficient way
        for (final WeakReference <Class <?>> aCurWRClass : ClassHierarchyCache.getClassHierarchyIterator (aClass))
        {
          final Class <?> aCurClass = aCurWRClass.get ();
          if (aCurClass != null)
          {
            final IHashCodeImplementation <?> aImpl = m_aMap.get (aCurClass);
            if (aImpl != null)
            {
              aMatchingImplementation = GenericReflection.uncheckedCast (aImpl);
              aMatchingClass = aCurClass;
              if (LOGGER.isDebugEnabled ())
                LOGGER.debug ("Found hierarchical match with class " +
                              aMatchingClass +
                              " when searching for " +
                              aClass);
              break;
            }
          }
        }
      }
    }
    finally
    {
      m_aRWLock.readLock ().unlock ();
    }

    // Do this outside of the lock for performance reasons
    if (aMatchingImplementation != null)
    {
      // If the matching implementation is for an interface and the
      // implementation class implements hashCode, use the one from the class
      // Example: a converter for "Map" is registered, but "LRUCache" comes
      // with its own "hashCode" implementation
      if (ClassHelper.isInterface (aMatchingClass) && _implementsHashCodeItself (aClass))
      {
        // Remember to use direct implementation
        m_aDirectHashCode.setAnnotation (aClass, true);
        return null;
      }

      if (!aMatchingClass.equals (aClass))
      {
        // We found a match by walking the hierarchy -> put that match in the
        // direct hit list for further speed up
        registerHashCodeImplementation (aClass, aMatchingImplementation);
      }

      return aMatchingImplementation;
    }

    // Handle arrays specially, because we cannot register a converter for
    // every potential array class (but we allow for special implementations)
    if (ClassHelper.isArrayClass (aClass))
      return x -> Arrays.deepHashCode ((Object []) x);

    // Remember to use direct implementation
    m_aDirectHashCode.setAnnotation (aClass, true);
  }

  // No special handler found
  if (LOGGER.isTraceEnabled ())
    LOGGER.trace ("Found no hashCode implementation for " + aClass);

  // Definitely no special implementation
  return null;
}
 

/**
 * Register a default type converter.
 *
 * @param aSrcClass
 *        A non-<code>null</code> source class to convert from. Must be an
 *        instancable class.
 * @param aDstClass
 *        A non-<code>null</code> destination class to convert to. Must be an
 *        instancable class. May not equal the source class.
 * @param aConverter
 *        The convert to use. May not be <code>null</code>.
 */
private void _registerTypeConverter (@Nonnull final Class <?> aSrcClass,
                                     @Nonnull final Class <?> aDstClass,
                                     @Nonnull final ITypeConverter <?, ?> aConverter)
{
  ValueEnforcer.notNull (aSrcClass, "SrcClass");
  ValueEnforcer.isTrue (ClassHelper.isPublic (aSrcClass), () -> "Source " + aSrcClass + " is no public class!");
  ValueEnforcer.notNull (aDstClass, "DstClass");
  ValueEnforcer.isTrue (ClassHelper.isPublic (aDstClass), () -> "Destination " + aDstClass + " is no public class!");
  ValueEnforcer.isFalse (aSrcClass.equals (aDstClass),
                         "Source and destination class are equal and therefore no converter is required.");
  ValueEnforcer.notNull (aConverter, "Converter");
  ValueEnforcer.isFalse (aConverter instanceof ITypeConverterRule,
                         "Type converter rules must be registered via registerTypeConverterRule");
  if (ClassHelper.areConvertibleClasses (aSrcClass, aDstClass))
    if (LOGGER.isWarnEnabled ())
      LOGGER.warn ("No type converter needed between " +
                   aSrcClass +
                   " and " +
                   aDstClass +
                   " because types are convertible!");

  // The main class should not already be registered
  final Map <Class <?>, ITypeConverter <?, ?>> aSrcMap = _getOrCreateConverterMap (aSrcClass);
  if (aSrcMap.containsKey (aDstClass))
    throw new IllegalArgumentException ("A mapping from " + aSrcClass + " to " + aDstClass + " is already defined!");

  m_aRWLock.writeLocked ( () -> {
    // Automatically register the destination class, and all parent
    // classes/interfaces
    for (final WeakReference <Class <?>> aCurWRDstClass : ClassHierarchyCache.getClassHierarchyIterator (aDstClass))
    {
      final Class <?> aCurDstClass = aCurWRDstClass.get ();
      if (aCurDstClass != null)
        if (!aSrcMap.containsKey (aCurDstClass))
        {
          if (aSrcMap.put (aCurDstClass, aConverter) != null)
          {
            if (LOGGER.isWarnEnabled ())
              LOGGER.warn ("Overwriting converter from " + aSrcClass + " to " + aCurDstClass);
          }
          else
          {
            if (LOGGER.isTraceEnabled ())
              LOGGER.trace ("Registered type converter from '" +
                            aSrcClass.toString () +
                            "' to '" +
                            aCurDstClass.toString () +
                            "'");
          }
        }
    }
  });
}
 

@Nullable
public <T> IEqualsImplementation <T> getBestMatchingEqualsImplementation (@Nullable final Class <T> aClass)
{
  if (aClass != null)
  {
    IEqualsImplementation <T> aMatchingImplementation = null;
    Class <?> aMatchingClass = null;

    // No check required?
    if (_isUseDirectEquals (aClass))
      return null;

    m_aRWLock.readLock ().lock ();
    try
    {
      // Check for an exact match first
      aMatchingImplementation = GenericReflection.uncheckedCast (m_aMap.get (aClass));
      if (aMatchingImplementation != null)
        aMatchingClass = aClass;
      else
      {
        // Scan hierarchy in most efficient way
        for (final WeakReference <Class <?>> aCurWRClass : ClassHierarchyCache.getClassHierarchyIterator (aClass))
        {
          final Class <?> aCurClass = aCurWRClass.get ();
          if (aCurClass != null)
          {
            final IEqualsImplementation <?> aImpl = m_aMap.get (aCurClass);
            if (aImpl != null)
            {
              aMatchingImplementation = GenericReflection.uncheckedCast (aImpl);
              aMatchingClass = aCurClass;
              if (LOGGER.isDebugEnabled ())
                LOGGER.debug ("Found hierarchical match with class " + aMatchingClass + " when searching for " + aClass);
              break;
            }
          }
        }
      }
    }
    finally
    {
      m_aRWLock.readLock ().unlock ();
    }

    // Do this outside of the lock for performance reasons
    if (aMatchingImplementation != null)
    {
      // If the matching implementation is for an interface and the
      // implementation class implements equals, use the one from the class
      // Example: a converter for "Map" is registered, but "LRUCache" comes
      // with its own "equals" implementation
      if (aMatchingImplementation.implementationEqualsOverridesInterface () &&
          ClassHelper.isInterface (aMatchingClass) &&
          _implementsEqualsItself (aClass))
      {
        // Remember to use direct implementation
        m_aDirectEquals.setAnnotation (aClass, true);
        return null;
      }

      if (!aMatchingClass.equals (aClass))
      {
        // We found a match by walking the hierarchy -> put that match in the
        // direct hit list for further speed up
        registerEqualsImplementation (aClass, aMatchingImplementation);
      }

      return aMatchingImplementation;
    }

    // Handle arrays specially, because we cannot register a converter for
    // every potential array class (but we allow for special implementations)
    if (ClassHelper.isArrayClass (aClass))
      return GenericReflection.uncheckedCast (new ArrayEqualsImplementation ());

    // Remember to use direct implementation
    m_aDirectEquals.setAnnotation (aClass, true);
  }

  // No special handler found
  if (LOGGER.isTraceEnabled ())
    LOGGER.trace ("Found no equals implementation for " + aClass);

  // Definitely no special implementation
  return null;
}
 

@Override
public String toString ()
{
  return ClassHelper.getClassLocalName (m_aParamClass) + ":" + m_sParamName;
}
 

@Test
public void testGetResourceThisProject ()
{
  final String sWithoutSlash = "classldr/test1.txt";
  final String sWithSlash = "/" + sWithoutSlash;

  // Context class loader
  assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  // Current class
  assertNull (JavaClassLoaderFuncTest.class.getResource (sWithoutSlash));
  assertNotNull (JavaClassLoaderFuncTest.class.getResource (sWithSlash));

  _assertNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithoutSlash));
  _assertNotNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithoutSlash));
  assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithSlash));

  _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithoutSlash));
  _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithSlash));

  // Current class class loader
  assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                   .getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                .getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                         sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                         sWithSlash));

  // System class loader
  assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));
}
 

@Test
public void testGetDirectoryThisProject ()
{
  final String sWithoutSlash = "classldr/";
  final String sWithSlash = "/" + sWithoutSlash;

  // Context class loader
  assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  // Current class
  assertNull (JavaClassLoaderFuncTest.class.getResource (sWithoutSlash));
  assertNotNull (JavaClassLoaderFuncTest.class.getResource (sWithSlash));

  _assertNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithoutSlash));
  _assertNotNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithoutSlash));
  assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithSlash));

  _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithoutSlash));
  _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithSlash));

  // Current class class loader
  assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                   .getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                .getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                         sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                         sWithSlash));

  // System class loader
  assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));
}
 

@Test
public void testGetResourceLinkedProject ()
{
  final String sWithoutSlash = "org/junit/Assert.class";
  final String sWithSlash = "/" + sWithoutSlash;

  // Context class loader
  assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  // Current class
  assertNull (JavaClassLoaderFuncTest.class.getResource (sWithoutSlash));
  assertNotNull (JavaClassLoaderFuncTest.class.getResource (sWithSlash));

  _assertNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithoutSlash));
  _assertNotNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithoutSlash));
  assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithSlash));

  _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithoutSlash));
  _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithSlash));

  // Current class class loader
  assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                   .getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                .getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                         sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                         sWithSlash));

  // System class loader
  assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));
}
 

@Test
public void testGetDirectoryLinkedProject_TrailingSlash ()
{
  final String sWithoutSlash = "org/junit/";
  final String sWithSlash = "/" + sWithoutSlash;

  // Context class loader
  assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  // Current class
  assertNull (JavaClassLoaderFuncTest.class.getResource (sWithoutSlash));
  assertNotNull (JavaClassLoaderFuncTest.class.getResource (sWithSlash));

  _assertNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithoutSlash));
  _assertNotNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithoutSlash));
  assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithSlash));

  _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithoutSlash));
  _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithSlash));

  // Current class class loader
  assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                   .getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                .getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                         sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                         sWithSlash));

  // System class loader
  assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithSlash));

  _assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));

  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));
}
 

@Test
public void testGetResourceRuntime ()
{
  // This test does not work with JDK 1.9 or higher because of the new module
  // system
  if (EJavaVersion.getCurrentVersion ().isOlderOrEqualsThan (EJavaVersion.JDK_1_8))
  {
    final String sWithoutSlash = "java/lang/String.class";
    final String sWithSlash = "/" + sWithoutSlash;

    // Context class loader
    assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithoutSlash));
    assertNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithSlash));

    _assertNotNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithoutSlash));
    _assertNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithSlash));

    // This is the work around to be used
    assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
    assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

    _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (),
                                                           sWithoutSlash));
    _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

    // Current class
    assertNull (JavaClassLoaderFuncTest.class.getResource (sWithoutSlash));
    assertNotNull (JavaClassLoaderFuncTest.class.getResource (sWithSlash));

    _assertNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithoutSlash));
    _assertNotNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithSlash));

    // This is the work around to be used
    assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithoutSlash));
    assertNotNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithSlash));

    _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithoutSlash));
    _assertNotNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithSlash));

    // Current class class loader
    assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithoutSlash));
    assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithSlash));

    _assertNotNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                     .getResourceAsStream (sWithoutSlash));
    _assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                  .getResourceAsStream (sWithSlash));

    // This is the work around to be used
    assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                  sWithoutSlash));
    assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                  sWithSlash));

    _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                           sWithoutSlash));
    _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                           sWithSlash));

    // System class loader
    assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithoutSlash));
    assertNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithSlash));

    _assertNotNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithoutSlash));
    _assertNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithSlash));

    // This is the work around to be used
    assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
    assertNotNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));

    _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
    _assertNotNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));
  }
}
 

@Test
@DevelopersNote ("Very special case!")
public void testGetDirectoryRuntime ()
{
  final String sWithoutSlash = "java/lang";
  final String sWithSlash = "/" + sWithoutSlash;

  // Context class loader
  assertNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getContextClassLoader ().getResource (sWithSlash));

  _assertNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getContextClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  assertNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  _assertNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithoutSlash));
  _assertNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getContextClassLoader (), sWithSlash));

  // Current class
  assertNull (JavaClassLoaderFuncTest.class.getResource (sWithoutSlash));
  assertNull (JavaClassLoaderFuncTest.class.getResource (sWithSlash));

  _assertNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithoutSlash));
  _assertNull (JavaClassLoaderFuncTest.class.getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithoutSlash));
  assertNull (ClassHelper.getResource (JavaClassLoaderFuncTest.class, sWithSlash));

  _assertNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithoutSlash));
  _assertNull (ClassHelper.getResourceAsStream (JavaClassLoaderFuncTest.class, sWithSlash));

  // Current class class loader
  assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class).getResource (sWithSlash));

  _assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                .getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class)
                                .getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                             sWithoutSlash));
  assertNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                             sWithSlash));

  _assertNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                      sWithoutSlash));
  _assertNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getClassClassLoader (JavaClassLoaderFuncTest.class),
                                                      sWithSlash));

  // System class loader
  assertNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithoutSlash));
  assertNull (ClassLoaderHelper.getSystemClassLoader ().getResource (sWithSlash));

  _assertNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithoutSlash));
  _assertNull (ClassLoaderHelper.getSystemClassLoader ().getResourceAsStream (sWithSlash));

  // This is the work around to be used
  assertNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  assertNull (ClassLoaderHelper.getResource (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));

  _assertNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithoutSlash));
  _assertNull (ClassLoaderHelper.getResourceAsStream (ClassLoaderHelper.getSystemClassLoader (), sWithSlash));
}
 

protected static void append (@Nonnull final IJAXBDocumentType e,
                              @Nonnull final EPhase ePhase,
                              @Nonnull final StringBuilder aSB,
                              @Nonnull final String sBuilderClass)
{
  final String sType = ClassHelper.getClassLocalName (e.getImplementationClass ());
  final String sName = StringHelper.trimEnd (sType, "Type");
  final String sBuilderMethodName = Character.toLowerCase (sName.charAt (0)) + sName.substring (1);

  switch (ePhase)
  {
    case READ:
      // Builder<T> read ()
      aSB.append ("/** Create a reader builder for " +
                  sName +
                  ".\n" +
                  "@return The builder and never <code>null</code> */\n");
      aSB.append ("@Nonnull public static ")
         .append (sBuilderClass)
         .append ('<')
         .append (sType)
         .append ("> ")
         .append (sBuilderMethodName)
         .append ("(){return ")
         .append (sBuilderClass)
         .append (".create(")
         .append (sType)
         .append (".class);}\n");
      break;
    case WRITE:
      // Builder<T> write ()
      aSB.append ("/** Create a writer builder for " +
                  sName +
                  ".\n" +
                  "@return The builder and never <code>null</code> */\n");
      aSB.append ("@Nonnull public static ")
         .append (sBuilderClass)
         .append ('<')
         .append (sType)
         .append ("> ")
         .append (sBuilderMethodName)
         .append ("(){return ")
         .append (sBuilderClass)
         .append (".create(")
         .append (sType)
         .append (".class);}\n");
      break;
    case VALIDATE:
      // Builder<T> validate ()
      aSB.append ("/** Create a validation builder for " +
                  sName +
                  ".\n" +
                  "@return The builder and never <code>null</code> */\n");
      aSB.append ("@Nonnull public static ")
         .append (sBuilderClass)
         .append ('<')
         .append (sType)
         .append ("> ")
         .append (sBuilderMethodName)
         .append ("(){return ")
         .append (sBuilderClass)
         .append (".create(")
         .append (sType)
         .append (".class);}\n");
      break;
  }
}
 

/**
 * 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;
}
 

/**
 * 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 ());
}