Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source.
   * Copyright 2006, Red Hat Middleware LLC, and individual contributors
   * as indicated by the @author tags. See the copyright.txt file in the
   * distribution for a full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 package org.jboss.ws.common;
 
 import static org.jboss.ws.common.Loggers.ROOT_LOGGER;
 import static org.jboss.ws.common.Messages.MESSAGES;
 
Java utilities

Author(s):
Thomas.Diesler@jboss.org
Since:
22-Dec-2004
 
 public class JavaUtils
 {
    private static final HashMap<StringClass<?>> primitiveNames = new HashMap<StringClass<?>>();
    private static final HashMap<StringStringprimitiveNameDescriptors = new HashMap<StringString>();
    private static final HashSet<StringreservedKeywords = new HashSet<String>(64,0.8f);
 
    static
    {
       .put("int"int.class);
       .put("short"short.class);
       .put("boolean"boolean.class);
       .put("byte"byte.class);
       .put("long"long.class);
       .put("double"double.class);
       .put("float"float.class);
       .put("char"char.class);
 
       .put("int""I");
       .put("short""S");
       .put("boolean""Z");
       .put("byte""B");
       .put("long""J");
       .put("double""D");
       .put("float""F");
       .put("char""C");
 
       .add("abstract");
       .add("continue");
       .add("for");
       .add("new");
       .add("switch");
       .add("assert");
       .add("default");
       .add("if");
       .add("package");
       .add("synchronized");
       .add("boolean");
       .add("do");
       .add("goto");
       .add("private");
       .add("this");
       .add("break");
       .add("double");
       .add("implements");
       .add("protected");
       .add("throw");
       .add("byte");
       .add("else");
       .add("import");
       .add("public");
       .add("throws");
       .add("case");
       .add("enum");
       .add("instanceof");
       .add("return");
       .add("transient");
      .add("catch");
      .add("extends");
      .add("int");
      .add("short");
      .add("try");
      .add("char");
      .add("final");
      .add("interface");
      .add("static");
      .add("void");
      .add("class");
      .add("finally");
      .add("long");
      .add("strictfp");
      .add("volatile");
      .add("const");
      .add("float");
      .add("native");
      .add("super");
      .add("while");
   }

   
Load a Java type from a given class loader.

Parameters:
typeName maybe the source notation of a primitve, class name, array of both
   public static Class<?> loadJavaType(String typeNamethrows ClassNotFoundException
   {
      return loadJavaType(typeNamenull);
   }

   
Load a Java type from a given class loader.

Parameters:
typeName maybe the source notation of a primitve, class name, array of both
   public static Class<?> loadJavaType(String typeNameClassLoader classLoaderthrows ClassNotFoundException
   {
      if (classLoader == null)
         classLoader = getContextClassLoader();
      Class<?> javaType = .get(typeName);
      if (javaType == null)
         javaType = getArray(typeNameclassLoader);
      if (javaType == null)
         javaType = classLoader.loadClass(typeName);
      return javaType;
   }
   
   private static ClassLoader getContextClassLoader()
   {
      SecurityManager sm = System.getSecurityManager();
      if (sm == null)
      {
         return Thread.currentThread().getContextClassLoader();
      }
      else
      {
         return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
            public ClassLoader run()
            {
               return Thread.currentThread().getContextClassLoader();
            }
         });
      }
   }

   
True if the given type name is the source notation of a primitive or array of which.
   public static boolean isPrimitive(String javaType)
   {
      return getPrimitiveType(javaType) != null;
   }

   
True if the given class is a primitive or array of which.
   public static boolean isPrimitive(Class<?> javaType)
   {
      return javaType.isPrimitive() || (javaType.isArray() && isPrimitive(javaType.getComponentType()));
   }
   public static Class<?> getPrimitiveType(String javaType)
   {
      Class<?> type = .get(javaType);
      if (type != null)
         return type;
      try
      {
         // null loader = primitive only
         type = getArray(javaTypenull);
      }
      catch (ClassNotFoundException e)
      {
         // This will actually never be thrown since is null
      }
      return type;
   }
   private static Class<?> getArray(String javaTypeClassLoader loaderthrows ClassNotFoundException
   {
      if (javaType.charAt(0) == '[')
         return getArrayFromJVMName(javaTypeloader);
      if (javaType.endsWith("[]"))
         return getArrayFromSourceName(javaTypeloader);
      return null;
   }
   private static Class<?> getArrayFromJVMName(String javaTypeClassLoader loaderthrows ClassNotFoundException
   {
      Class<?> componentType;
      int componentStart = javaType.lastIndexOf('[') + 1;
      switch (javaType.charAt(componentStart))
      {
         case 'I'componentType = int.classbreak;
         case 'S'componentType = short.classbreak;
         case 'Z'componentType = boolean.classbreak;
         case 'B'componentType = byte.classbreak;
         case 'J'componentType = long.classbreak;
         case 'D'componentType = double.classbreak;
         case 'F'componentType = float.classbreak;
         case 'C'componentType = char.classbreak;
         case 'L':
            if (loader == null)
               return null;
            String name = javaType.substring(componentStart + 1, javaType.length() - 1);
            componentType = loader.loadClass(name);
            break;
         default:
            throw .invalidBinaryComponentForArray(javaType);
      }
      // componentStart doubles as the number of '['s which is the number of dimensions
      return Array.newInstance(componentTypenew int[componentStart]).getClass();
   }
   private static Class<?> getArrayFromSourceName(String javaTypeClassLoader loaderthrows ClassNotFoundException
   {
      int arrayStart = javaType.indexOf('[');
      String componentName = javaType.substring(0, arrayStart);
      Class<?> componentType = .get(componentName);
      if (componentType == null)
      {
         if (loader == null)
            return null;
         componentType = loader.loadClass(componentName);
      }
      // [][][][] divided by 2
      int dimensions = (javaType.length() - arrayStart) >> 1;
      return Array.newInstance(componentTypenew int[dimensions]).getClass();
   }
   
   
Given a class, strip out the package name

Parameters:
cls
Returns:
just the classname
   public static String getJustClassName(Class<?> cls)
   {
      if (cls == null)
         return null;
      if (cls.isArray())
      {
         Class<?> c = cls.getComponentType();
         return getJustClassName(c.getName());
      }
      return getJustClassName(cls.getName());
   }
   
   
Given a FQN of a class, strip out the package name

Parameters:
classname
Returns:
just the classname
   public static String getJustClassName(String classname)
   {
      int index = classname.lastIndexOf('.');
      if (index < 0)
         index = 0;
      else index = index + 1;
      return classname.substring(index);
   }

   
Get the corresponding primitive for a give wrapper type. Also handles arrays of which.
   public static Class<?> getPrimitiveType(Class<?> javaType)
   {
      if (javaType == Integer.class)
         return int.class;
      if (javaType == Short.class)
         return short.class;
      if (javaType == Boolean.class)
         return boolean.class;
      if (javaType == Byte.class)
         return byte.class;
      if (javaType == Long.class)
         return long.class;
      if (javaType == Double.class)
         return double.class;
      if (javaType == Float.class)
         return float.class;
      if (javaType == Character.class)
         return char.class;
      if (javaType == Integer[].class)
         return int[].class;
      if (javaType == Short[].class)
         return short[].class;
      if (javaType == Boolean[].class)
         return boolean[].class;
      if (javaType == Byte[].class)
         return byte[].class;
      if (javaType == Long[].class)
         return long[].class;
      if (javaType == Double[].class)
         return double[].class;
      if (javaType == Float[].class)
         return float[].class;
      if (javaType == Character[].class)
         return char[].class;
      if (javaType.isArray() && javaType.getComponentType().isArray())
      {
         Class<?> compType = getPrimitiveType(javaType.getComponentType());
         return Array.newInstance(compType, 0).getClass();
      }
      return javaType;
   }

   
Converts an n-dimensional array of wrapper types to primitive types
   public static Object getPrimitiveValueArray(Object value)
   {
      if (value == null)
         return null;
      Class<?> javaType = value.getClass();
      if (javaType.isArray())
      {
         int length = Array.getLength(value);
         Object destArr = Array.newInstance(getPrimitiveType(javaType.getComponentType()), length);
         for (int i = 0; i < lengthi++)
         {
            Object srcObj = Array.get(valuei);
            Array.set(destArrigetPrimitiveValueArray(srcObj));
         }
         return destArr;
      }
      return value;
   }

   
Get the corresponding wrapper type for a give primitive. Also handles arrays of which.
   public static Class<?> getWrapperType(Class<?> javaType)
   {
      if (javaType == int.class)
         return Integer.class;
      if (javaType == short.class)
         return Short.class;
      if (javaType == boolean.class)
         return Boolean.class;
      if (javaType == byte.class)
         return Byte.class;
      if (javaType == long.class)
         return Long.class;
      if (javaType == double.class)
         return Double.class;
      if (javaType == float.class)
         return Float.class;
      if (javaType == char.class)
         return Character.class;
      if (javaType == int[].class)
         return Integer[].class;
      if (javaType == short[].class)
         return Short[].class;
      if (javaType == boolean[].class)
         return Boolean[].class;
      if (javaType == byte[].class)
         return Byte[].class;
      if (javaType == long[].class)
         return Long[].class;
      if (javaType == double[].class)
         return Double[].class;
      if (javaType == float[].class)
         return Float[].class;
      if (javaType == char[].class)
         return Character[].class;
      if (javaType.isArray() && javaType.getComponentType().isArray())
      {
         Class<?> compType = getWrapperType(javaType.getComponentType());
         return Array.newInstance(compType, 0).getClass();
      }
      return javaType;
   }

   
Converts an n-dimensional array of primitive types to wrapper types
   public static Object getWrapperValueArray(Object value)
   {
      if (value == null)
         return null;
      Class<?> javaType = value.getClass();
      if (javaType.isArray())
      {
         int length = Array.getLength(value);
         Object destArr = Array.newInstance(getWrapperType(javaType.getComponentType()), length);
         for (int i = 0; i < lengthi++)
         {
            Object srcObj = Array.get(valuei);
            Array.set(destArrigetWrapperValueArray(srcObj));
         }
         return destArr;
      }
      return value;
   }
   public static Object syncArray(Object arrayClass<?> target)
   {
      return (JavaUtils.isPrimitive(target)) ? JavaUtils.getPrimitiveValueArray(array) : JavaUtils.getWrapperValueArray(array);
   }

   
Return true if the dest class is assignable from the src. Also handles arrays and primitives.
   public static boolean isAssignableFrom(Class<?> destClass<?> src)
   {
      if (dest == null || src == null)
         throw .cannotCheckClassIsAssignableFrom(destsrc);
      boolean isAssignable = dest.isAssignableFrom(src);
      if (isAssignable == false && dest.getName().equals(src.getName()))
      {
         ClassLoader destLoader = dest.getClassLoader();
         ClassLoader srcLoader = src.getClassLoader();
         if (.isTraceEnabled()) .notAssignableDueToConflictingClassLoaders(destsrcdestLoadersrcLoader);
      }
      if (isAssignable == false && isPrimitive(dest))
      {
         dest = getWrapperType(dest);
         isAssignable = dest.isAssignableFrom(src);
      }
      if (isAssignable == false && isPrimitive(src))
      {
         src = getWrapperType(src);
         isAssignable = dest.isAssignableFrom(src);
      }
      return isAssignable;
   }
   public static String convertJVMNameToSourceName(String typeNameClassLoader loader)
   {
      // TODO Don't use a ClassLoader for this, we need to just convert it
      try
      {
         Class<?> javaType = loadJavaType(typeNameloader);
         typeName = getSourceName(javaType);
      }
      catch (Exception e)
      {
      }
      return typeName;
   }

   
Converts a JVM external name to a JVM signature name. An external name is that which is returned from java.lang.Class.getName() A signature name is the name in class file format.

For example:

[java.lang.Object

becomes:

[Ljava/lang/Object;

Parameters:
externalName
Returns:
   public static String toSignature(String externalName)
   {
      if (externalName == null)
         return null;
      String ret = .get(externalName);
      if (ret != null)
         return ret;
      ret = externalName.replace('.''/');
      return (ret.charAt(0) == '[') ? ret : "L" + ret + ";";
   }
   public static String printArray(Object[] val)
   {
      if (val == null)
         return "null";
      StringBuilder out = new StringBuilder("[");
      for (int i = 0; i < val.lengthi++)
      {
         if (i > 0)
         {
            out.append(",");
         }
         out.append(val[i].getClass().isArray() ? printArray((Object[])val[i]) : val[i]);
      }
      return out.append("]").toString();
   }
   public static String getSourceName(Class<?> type)
   {
      if (! type.isArray())
         return type.getName();
      StringBuilder arrayNotation = new StringBuilder();
      Class<?> component = type;
      while(component.isArray())
      {
         component = component.getComponentType();
         arrayNotation.append("[]");
      }
      return component.getName() + arrayNotation.toString();
   }
   public static String capitalize(String source)
   {
      if (source == null)
         return null;
      if (source.length() == 0)
         return source;
      if (Character.isUpperCase(source.charAt(0)))
         return source;
      char c = Character.toUpperCase(source.charAt(0));
      return c + source.substring(1);
   }
   public static boolean isLoaded(String classNameClassLoader loader)
   {
      try
      {
         loadJavaType(classNameloader);
      }
      catch (ClassNotFoundException e)
      {
         return false;
      }
      return true;
   }
   public static String getPackageName(Class<?> clazz)
   {
      String fullName = clazz.getName();
      int dotIndex = fullName.lastIndexOf(".");
      return dotIndex == -1 ? "" : fullName.substring(0, dotIndex);
   }
   public static boolean isReservedKeyword(String keyword)
   {
      return .contains(keyword);
   }

   
Erases a type according to the JLS type erasure rules

Parameters:
t type to erase
Returns:
erased type
   public static Class<?> erasure(Type type)
   {
      if (type instanceof ParameterizedType)
      {
         return erasure(((ParameterizedType)type).getRawType());
      }
      if (type instanceof TypeVariable<?>)
      {
         return erasure(((TypeVariable<?>)type).getBounds()[0]);
      }
      if (type instanceof WildcardType)
      {
         return erasure(((WildcardType)type).getUpperBounds()[0]);
      }
      if (type instanceof GenericArrayType)
      {
         return Array.newInstance(erasure(((GenericArrayType)type).getGenericComponentType()), 0).getClass();
      }
      // Only type left is class
      return (Class<?>)type;
   }
   {
      Type[] arguments = type.getActualTypeArguments();
      String[] ret = new String[arguments.length];
      for (int i = 0; i < arguments.lengthi++)
      {
         Class<?> raw = erasure(arguments[i]);
         ret[i] = raw.getName();
      }
      return ret;
   }

   
This method tests for retro translation by searching for a known problem where Class does not implement Type. If this is true, then code must never cast a Class to a Type.

Returns:
true if we are in retro
   public static boolean isRetro14()
   {
      return !(String.class instanceof java.lang.reflect.Type);
   }

   
Tests if this class loader is a JBoss RepositoryClassLoader

Parameters:
loader
Returns:
   public static boolean isJBossRepositoryClassLoader(ClassLoader loader)
   {
      Class<?> clazz = loader.getClass();
      while (!clazz.getName().startsWith("java"))
      {
         if ("org.jboss.mx.loading.RepositoryClassLoader".equals(clazz.getName()))
            return true;
         clazz = clazz.getSuperclass();
      }
      return false;
   }

   
Clears black lists on a JBoss RepositoryClassLoader. This is somewhat of a hack, and could be replaced with an integration module. This is needed when the following order of events occur.
  1. loadClass() returns not found
  2. Some call to defineClass()
    1. The CNFE triggers a black list addition, which cause the class never again to be found.

      Parameters:
      loader the loader to clear black lists for
   public static void clearBlacklists(ClassLoader loader)
   {
      if (isJBossRepositoryClassLoader(loader))
      {
			for(Method m : loader.getClass().getMethods())
			{
				if("clearBlackLists".equalsIgnoreCase(m.getName()))
				{
					try
					{
						m.invoke(loader);
					}
					catch (Exception e)
					{
					}
				}
			}			
      }
   }
New to GrepCode? Check out our FAQ X