Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2008, Red Hat, Inc., and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
  * http://www.apache.org/licenses/LICENSE-2.0
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.jboss.weld.util.reflection;
 
 import java.util.List;
 
 
Utility class to produce friendly names e.g. for debugging

Author(s):
Pete Muir
Nicklas Karlsson
Jozef Hartinger
 
 public class Formats {
 
     private static final String SNAPSHOT = "SNAPSHOT";
     private static final String NULL = "null";
 
     private Formats() {
     }
 
     // see WELD-1454
     public static String formatAsStackTraceElement(InjectionPoint ij) {
         Member member;
         if (ij.getAnnotated() instanceof AnnotatedField) {
             AnnotatedField annotatedField = (AnnotatedFieldij.getAnnotated();
             member = annotatedField.getJavaMember();
         } else if (ij.getAnnotated() instanceof AnnotatedParameter<?>) {
             AnnotatedParameter<?> annotatedParameter = (AnnotatedParameter<?>) ij.getAnnotated();
             member = annotatedParameter.getDeclaringCallable().getJavaMember();
         } else {
             // Not throwing an exception, because this method is invoked when an exception is already being thrown.
             // Throwing an exception here would hide the original exception.
             return "-";
         }
         return member.getDeclaringClass().getName()
             + "." + (member instanceof Constructor<?> ? "<init>" : member.getName())
             + "(" + getFileName(member.getDeclaringClass()) + ":" + getLineNumber(member) + ")";
     }
 
     private static int getLineNumber(Member member) {
         // TODO find the actual line number where the member is declared
         return 0;
     }
 
     private static String getFileName(Class<?> clazz) {
         // TODO find the actual file name the class is declared in
         return clazz.getSimpleName() + ".java";
     }

    
A transformation from one object to a String.

Parameters:
<F> the type of the function input
 
     private interface Function<F> {
        
Applies the function to an object of type F, resulting in an object of type String.

Parameters:
from the source object
position the position in the list the object is at
Returns:
the resulting object
 
         String apply(F fromint position);
 
     }
 
    private static final Function<?> SPACE_DELIMITER_FUNCTION = new Function<Object>() {
        @Override
        public String apply(Object fromint position) {
            if (position > 0) {
                return " " + (from == null ?  : from.toString());
            } else {
                return from == null ?  : from.toString();
            }
        }
    };
    private static final Function<?> COMMA_DELIMITER_FUNCTION = new Function<Object>() {
        @Override
        public String apply(Object fromint position) {
            if (position > 0) {
                return ", " + (from == null ?  : from.toString());
            } else {
                return from == null ?  : from.toString();
            }
        }
    };
    private static final Function<AnnotationANNOTATION_LIST_FUNCTION = new Function<Annotation>() {
        @Override
        public String apply(Annotation fromint position) {
            return spaceDelimiterFunction().apply("@" + from.annotationType().getSimpleName(), position);
        }
    };
    @SuppressWarnings("unchecked")
    private static <T> Function<T> spaceDelimiterFunction() {
        return (Function<T>) ;
    }
    @SuppressWarnings("unchecked")
    private static <T> Function<T> commaDelimiterFunction() {
        return (Function<T>) ;
    }
    public static String formatInjectionPointType(Type type) {
        if (type instanceof Class<?>) {
            return ((Classtype).getSimpleName();
        } else {
            return Formats.formatType(type);
        }
    }
    public static String formatType(Type baseType) {
        if (baseType == null) {
            return ;
        } else {
            Class<?> rawType = Reflections.getRawType(baseType);
            if (rawType != null) {
                return rawType.getSimpleName() + formatActualTypeArguments(Reflections.getActualTypeArguments(baseType));
            } else {
                return baseType.toString();
            }
        }
    }
    public static String formatTypes(Iterable<? extends TypebaseTypes) {
        return formatIterable(baseTypesnew Function<Type>() {
            @Override
            public String apply(Type fromint position) {
                return commaDelimiterFunction().apply(formatType(from), position);
            }
        });
    }
    public static String formatBusinessInterfaceDescriptors(Iterable<? extends BusinessInterfaceDescriptor<?>> businessInterfaceDescriptors) {
        return formatIterable(businessInterfaceDescriptorsnew Function<BusinessInterfaceDescriptor<?>>() {
            @Override
            public String apply(BusinessInterfaceDescriptor<?> fromint position) {
                return commaDelimiterFunction().apply(formatType(from.getInterface()), position);
            }
        });
    }
    public static String addSpaceIfNeeded(String string) {
        if (string.length() > 0) {
            return string + " ";
        } else {
            return string;
        }
    }
    public static String formatAsFormalParameterList(Iterable<? extends AnnotatedParameter<?>> parameters) {
        return "(" + formatIterable(parametersnew Function<AnnotatedParameter<?>>() {
            @Override
            public String apply(AnnotatedParameter<?> fromint position) {
                return commaDelimiterFunction().apply(formatParameter(from), position);
            }
        }) + ")";
    }
    public static String formatParameter(AnnotatedParameter<?> parameter) {
        return addSpaceIfNeeded(formatAnnotations(parameter.getAnnotations())) + formatType(parameter.getBaseType());
    }
    public static String formatModifiers(int modifiers) {
        return formatIterable(parseModifiers(modifiers), spaceDelimiterFunction());
    }
    private static <F> String formatIterable(Iterable<? extends F> itemsFunction<F> function) {
        if (items == null) {
            return "";
        }
        StringBuilder stringBuilder = new StringBuilder();
        int i = 0;
        for (F item : items) {
            stringBuilder.append(function.apply(itemi));
            i++;
        }
        return stringBuilder.toString();
    }
    private static <F> String formatIterable(F[] itemsFunction<F> function) {
        StringBuilder stringBuilder = new StringBuilder();
        int i = 0;
        for (F item : items) {
            stringBuilder.append(function.apply(itemi));
            i++;
        }
        return stringBuilder.toString();
    }

    
Parses a reflection modifier to a list of string

Parameters:
modifiers The modifier to parse
Returns:
The resulting string list
    private static List<StringparseModifiers(int modifiers) {
        List<Stringresult = new ArrayList<String>();
        if (Modifier.isPrivate(modifiers)) {
            result.add("private");
        }
        if (Modifier.isProtected(modifiers)) {
            result.add("protected");
        }
        if (Modifier.isPublic(modifiers)) {
            result.add("public");
        }
        if (Modifier.isAbstract(modifiers)) {
            result.add("abstract");
        }
        if (Modifier.isFinal(modifiers)) {
            result.add("final");
        }
        if (Modifier.isNative(modifiers)) {
            result.add("native");
        }
        if (Modifier.isStatic(modifiers)) {
            result.add("static");
        }
        if (Modifier.isStrict(modifiers)) {
            result.add("strict");
        }
        if (Modifier.isSynchronized(modifiers)) {
            result.add("synchronized");
        }
        if (Modifier.isTransient(modifiers)) {
            result.add("transient");
        }
        if (Modifier.isVolatile(modifiers)) {
            result.add("volatile");
        }
        if (Modifier.isInterface(modifiers)) {
            result.add("interface");
        }
        return result;
    }
    public static String formatActualTypeArguments(Type type) {
        if (type instanceof ParameterizedType) {
            return formatActualTypeArguments(ParameterizedType.class.cast(type).getActualTypeArguments());
        }
        return "";
    }
    public static String formatActualTypeArguments(Type[] actualTypeArguments) {
        return wrapIfNecessary(formatIterable(actualTypeArgumentsnew Function<Type>() {
            @Override
            public String apply(Type fromint position) {
                return commaDelimiterFunction().apply(formatType(from), position);
            }
        }), "<"">");
    }
    public static String wrapIfNecessary(String stringString prependString append) {
        if (string != null && string.length() > 0) {
            return prepend + string + append;
        } else {
            return string;
        }
    }
    public static String formatAnnotations(Iterable<Annotationannotations) {
        return formatIterable(annotations);
    }

    
Gets a string representation from an array of annotations

Parameters:
annotations The annotations
Returns:
The string representation
    public static String formatAnnotations(Annotation[] annotations) {
        return formatIterable(annotations);
    }
    public static String version(Package pkg) {
        if (pkg == null) {
            throw new IllegalArgumentException("Package can not be null");
        } else {
            return version(pkg.getSpecificationVersion(), pkg.getImplementationVersion());
        }
    }
    @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "NP_NULL_ON_SOME_PATH_MIGHT_BE_INFEASIBLE", justification = "False positive.")
    public static String version(String versionString timestamp) {
        if (version == null && timestamp != null) {
            return timestamp;
        } else if (version == null && timestamp == null) {
            return ;
        }
        String major = null;
        String minor = null;
        String micro = null;
        String qualifier = null;
        List<Stringsplit = new ArrayList<String>(Arrays.asList(version.split("\\.")));
        String[] split2 = split.get(split.size() - 1).split("\\-");
        if (split2.length > 1) {
            // We split it, so swap out the last digit
            split.remove(split.size() - 1);
            split.add(split.size(), split2[0]);
            qualifier = split2[1];
        } else if (split2.length > 0) {
            // We didn't split it
            split.remove(split.size() - 1);
            qualifier = split2[0];
        }
        if (split.size() > 0) {
            major = split.get(0);
        }
        if (split.size() > 1) {
            minor = split.get(1);
        }
        if (split.size() > 2) {
            micro = split.get(2);
        }
        if (major == null && timestamp != null) {
            // Handle the case we only have a timestamp
            return timestamp;
        }
        if (major == null && timestamp == null) {
            // Handle the case we have nothing
            return ;
        }
        StringBuilder builder = new StringBuilder();
        builder.append(major);
        if (minor != null) {
            builder.append(".").append(minor);
        }
        if (minor != null && micro != null) {
            builder.append(".").append(micro);
        }
        if (qualifier != null) {
            builder.append(" (");
            if (qualifier.equals() && timestamp != null) {
                builder.append(timestamp);
            } else {
                builder.append(qualifier);
            }
            builder.append(")");
        }
        return builder.toString();
    }
    public static String formatSimpleClassName(Object object) {
        return formatSimpleClassName(object.getClass());
    }
    public static String formatSimpleClassName(Class<?> javaClass) {
        String simpleName = javaClass.getSimpleName();
        StringBuilder builder = new StringBuilder(simpleName.length() + 2);
        builder.append("[");
        builder.append(simpleName);
        builder.append("]");
        return builder.toString();
    }
    public static String formatAnnotatedType(AnnotatedType<?> type) {
        return Formats.formatSimpleClassName(type) + " " + Formats.addSpaceIfNeeded(Formats.formatModifiers(type.getJavaClass().getModifiers()))
                + Formats.formatAnnotations(type.getAnnotations()) + " class " + type.getJavaClass().getName() + Formats.formatActualTypeArguments(type.getBaseType());
    }
    public static String formatAnnotatedConstructor(AnnotatedConstructor<?> constructor) {
        return Formats.formatSimpleClassName(constructor) + " " + Formats.addSpaceIfNeeded(Formats.formatAnnotations(constructor.getAnnotations()))
                + Formats.addSpaceIfNeeded(Formats.formatModifiers(constructor.getJavaMember().getModifiers())) + constructor.getDeclaringType().getJavaClass().getName()
                + Formats.formatAsFormalParameterList(constructor.getParameters());
    }
    public static String formatAnnotatedField(AnnotatedField<?> field) {
        return Formats.formatSimpleClassName(field) + " " + Formats.addSpaceIfNeeded(Formats.formatAnnotations(field.getAnnotations()))
                + Formats.addSpaceIfNeeded(Formats.formatModifiers(field.getJavaMember().getModifiers())) + field.getDeclaringType().getJavaClass().getName() + "."
                + field.getJavaMember().getName();
    }
    public static String formatAnnotatedMethod(AnnotatedMethod<?> method) {
        return Formats.formatSimpleClassName(method) + " " + Formats.addSpaceIfNeeded(Formats.formatAnnotations(method.getAnnotations()))
                + Formats.addSpaceIfNeeded(Formats.formatModifiers(method.getJavaMember().getModifiers())) + method.getDeclaringType().getJavaClass().getName() + "."
                + method.getJavaMember().getName() + Formats.formatAsFormalParameterList(method.getParameters());
    }
    public static String formatAnnotatedParameter(AnnotatedParameter<?> parameter) {
        return Formats.formatSimpleClassName(parameter) + " Parameter " + (parameter.getPosition() + 1) + " of " + parameter.getDeclaringCallable().toString();
    }

    
Attempts to extract a name of a missing class loader dependency from an exception such as java.lang.NoClassDefFoundError or java.lang.ClassNotFoundException.
        if (e instanceof NoClassDefFoundError) {
            // NoClassDefFoundError sometimes includes CNFE as the cause. Since CNFE has a better formatted class name
            // and may also include classloader info, we prefer CNFE's over NCDFE's message.
            if (e.getCause() instanceof ClassNotFoundException) {
                return getNameOfMissingClassLoaderDependency(e.getCause());
            }
            if (e.getMessage() != null) {
                return e.getMessage().replace('/''.');
            }
        }
        if (e instanceof ClassNotFoundException) {
            if (e.getMessage() != null) {
                return e.getMessage();
            }
        }
        if (e.getCause() != null) {
            return getNameOfMissingClassLoaderDependency(e.getCause());
        } else {
            return "[unknown]";
        }
    }
New to GrepCode? Check out our FAQ X