| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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 freemarker.template.utility; |
| |
| import java.util.HashSet; |
| import java.util.Set; |
| |
| import freemarker.core.Environment; |
| import freemarker.core.Macro; |
| import freemarker.core.TemplateMarkupOutputModel; |
| import freemarker.core._CoreAPI; |
| import freemarker.ext.beans.BeanModel; |
| import freemarker.ext.beans.BooleanModel; |
| import freemarker.ext.beans.CollectionModel; |
| import freemarker.ext.beans.DateModel; |
| import freemarker.ext.beans.EnumerationModel; |
| import freemarker.ext.beans.IteratorModel; |
| import freemarker.ext.beans.MapModel; |
| import freemarker.ext.beans.NumberModel; |
| import freemarker.ext.beans.OverloadedMethodsModel; |
| import freemarker.ext.beans.SimpleMethodModel; |
| import freemarker.ext.beans.StringModel; |
| import freemarker.ext.util.WrapperTemplateModel; |
| import freemarker.template.AdapterTemplateModel; |
| import freemarker.template.TemplateBooleanModel; |
| import freemarker.template.TemplateCollectionModel; |
| import freemarker.template.TemplateCollectionModelEx; |
| import freemarker.template.TemplateDateModel; |
| import freemarker.template.TemplateDirectiveModel; |
| import freemarker.template.TemplateHashModel; |
| import freemarker.template.TemplateHashModelEx; |
| import freemarker.template.TemplateMethodModel; |
| import freemarker.template.TemplateMethodModelEx; |
| import freemarker.template.TemplateModel; |
| import freemarker.template.TemplateModelIterator; |
| import freemarker.template.TemplateNodeModel; |
| import freemarker.template.TemplateNumberModel; |
| import freemarker.template.TemplateScalarModel; |
| import freemarker.template.TemplateSequenceModel; |
| import freemarker.template.TemplateTransformModel; |
| |
| /** |
| */ |
| public class ClassUtil { |
| private ClassUtil() { |
| } |
| |
| /** |
| * Similar to {@link Class#forName(java.lang.String)}, but attempts to load |
| * through the thread context class loader. Only if thread context class |
| * loader is inaccessible, or it can't find the class will it attempt to |
| * fall back to the class loader that loads the FreeMarker classes. |
| */ |
| public static Class forName(String className) |
| throws ClassNotFoundException { |
| try { |
| ClassLoader ctcl = Thread.currentThread().getContextClassLoader(); |
| if (ctcl != null) { // not null: we don't want to fall back to the bootstrap class loader |
| return Class.forName(className, true, ctcl); |
| } |
| } catch (ClassNotFoundException e) { |
| ;// Intentionally ignored |
| } catch (SecurityException e) { |
| ;// Intentionally ignored |
| } |
| // Fall back to the defining class loader of the FreeMarker classes |
| return Class.forName(className); |
| } |
| |
| /** |
| * Same as {@link #getShortClassName(Class, boolean) getShortClassName(pClass, false)}. |
| * |
| * @since 2.3.20 |
| */ |
| public static String getShortClassName(Class pClass) { |
| return getShortClassName(pClass, false); |
| } |
| |
| /** |
| * Returns a class name without "java.lang." and "java.util." prefix, also shows array types in a format like |
| * {@code int[]}; useful for printing class names in error messages. |
| * |
| * @param pClass can be {@code null}, in which case the method returns {@code null}. |
| * @param shortenFreeMarkerClasses if {@code true}, it will also shorten FreeMarker class names. The exact rules |
| * aren't specified and might change over time, but right now, {@code freemarker.ext.beans.NumberModel} for |
| * example becomes to {@code f.e.b.NumberModel}. |
| * |
| * @since 2.3.20 |
| */ |
| public static String getShortClassName(Class pClass, boolean shortenFreeMarkerClasses) { |
| if (pClass == null) { |
| return null; |
| } else if (pClass.isArray()) { |
| return getShortClassName(pClass.getComponentType()) + "[]"; |
| } else { |
| String cn = pClass.getName(); |
| if (cn.startsWith("java.lang.") || cn.startsWith("java.util.")) { |
| return cn.substring(10); |
| } else { |
| if (shortenFreeMarkerClasses) { |
| if (cn.startsWith("freemarker.template.")) { |
| return "f.t" + cn.substring(19); |
| } else if (cn.startsWith("freemarker.ext.beans.")) { |
| return "f.e.b" + cn.substring(20); |
| } else if (cn.startsWith("freemarker.core.")) { |
| return "f.c" + cn.substring(15); |
| } else if (cn.startsWith("freemarker.ext.")) { |
| return "f.e" + cn.substring(14); |
| } else if (cn.startsWith("freemarker.")) { |
| return "f" + cn.substring(10); |
| } |
| // Falls through |
| } |
| return cn; |
| } |
| } |
| } |
| |
| /** |
| * Same as {@link #getShortClassNameOfObject(Object, boolean) getShortClassNameOfObject(pClass, false)}. |
| * |
| * @since 2.3.20 |
| */ |
| public static String getShortClassNameOfObject(Object obj) { |
| return getShortClassNameOfObject(obj, false); |
| } |
| |
| /** |
| * {@link #getShortClassName(Class, boolean)} called with {@code object.getClass()}, but returns the fictional |
| * class name {@code Null} for a {@code null} value. |
| * |
| * @since 2.3.20 |
| */ |
| public static String getShortClassNameOfObject(Object obj, boolean shortenFreeMarkerClasses) { |
| if (obj == null) { |
| return "Null"; |
| } else { |
| return ClassUtil.getShortClassName(obj.getClass(), shortenFreeMarkerClasses); |
| } |
| } |
| |
| /** |
| * Returns the {@link TemplateModel} interface that is the most characteristic of the object, or {@code null}. |
| */ |
| private static Class getPrimaryTemplateModelInterface(TemplateModel tm) { |
| if (tm instanceof BeanModel) { |
| if (tm instanceof CollectionModel) { |
| return TemplateSequenceModel.class; |
| } else if (tm instanceof IteratorModel || tm instanceof EnumerationModel) { |
| return TemplateCollectionModel.class; |
| } else if (tm instanceof MapModel) { |
| return TemplateHashModelEx.class; |
| } else if (tm instanceof NumberModel) { |
| return TemplateNumberModel.class; |
| } else if (tm instanceof BooleanModel) { |
| return TemplateBooleanModel.class; |
| } else if (tm instanceof DateModel) { |
| return TemplateDateModel.class; |
| } else if (tm instanceof StringModel) { |
| Object wrapped = ((BeanModel) tm).getWrappedObject(); |
| return wrapped instanceof String |
| ? TemplateScalarModel.class |
| : (tm instanceof TemplateHashModelEx ? TemplateHashModelEx.class : null); |
| } else { |
| return null; |
| } |
| } else if (tm instanceof SimpleMethodModel || tm instanceof OverloadedMethodsModel) { |
| return TemplateMethodModelEx.class; |
| } else { |
| return null; |
| } |
| } |
| |
| private static void appendTemplateModelTypeName(StringBuilder sb, Set typeNamesAppended, Class cl) { |
| int initalLength = sb.length(); |
| |
| if (TemplateNodeModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "node"); |
| } |
| |
| if (TemplateDirectiveModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "directive"); |
| } else if (TemplateTransformModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "transform"); |
| } |
| |
| if (TemplateSequenceModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "sequence"); |
| } else if (TemplateCollectionModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, |
| TemplateCollectionModelEx.class.isAssignableFrom(cl) ? "extended_collection" : "collection"); |
| } else if (TemplateModelIterator.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "iterator"); |
| } |
| |
| if (TemplateMethodModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "method"); |
| } |
| |
| if (Environment.Namespace.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "namespace"); |
| } else if (TemplateHashModelEx.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "extended_hash"); |
| } else if (TemplateHashModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "hash"); |
| } |
| |
| if (TemplateNumberModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "number"); |
| } |
| |
| if (TemplateDateModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "date_or_time_or_datetime"); |
| } |
| |
| if (TemplateBooleanModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "boolean"); |
| } |
| |
| if (TemplateScalarModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "string"); |
| } |
| |
| if (TemplateMarkupOutputModel.class.isAssignableFrom(cl)) { |
| appendTypeName(sb, typeNamesAppended, "markup_output"); |
| } |
| |
| if (sb.length() == initalLength) { |
| appendTypeName(sb, typeNamesAppended, "misc_template_model"); |
| } |
| } |
| |
| private static Class getUnwrappedClass(TemplateModel tm) { |
| Object unwrapped; |
| try { |
| if (tm instanceof WrapperTemplateModel) { |
| unwrapped = ((WrapperTemplateModel) tm).getWrappedObject(); |
| } else if (tm instanceof AdapterTemplateModel) { |
| unwrapped = ((AdapterTemplateModel) tm).getAdaptedObject(Object.class); |
| } else { |
| unwrapped = null; |
| } |
| } catch (Throwable e) { |
| unwrapped = null; |
| } |
| return unwrapped != null ? unwrapped.getClass() : null; |
| } |
| |
| private static void appendTypeName(StringBuilder sb, Set typeNamesAppended, String name) { |
| if (!typeNamesAppended.contains(name)) { |
| if (sb.length() != 0) sb.append("+"); |
| sb.append(name); |
| typeNamesAppended.add(name); |
| } |
| } |
| |
| /** |
| * Returns the type description of a value with FTL terms (not plain class name), as it should be used in |
| * type-related error messages and for debugging purposes. The exact format is not specified and might change over |
| * time, but currently it's something like {@code "string (wrapper: f.t.SimpleScalar)"} or |
| * {@code "sequence+hash+string (ArrayList wrapped into f.e.b.CollectionModel)"}. |
| * |
| * @since 2.3.20 |
| */ |
| public static String getFTLTypeDescription(TemplateModel tm) { |
| if (tm == null) { |
| return "Null"; |
| } else { |
| Set typeNamesAppended = new HashSet(); |
| |
| StringBuilder sb = new StringBuilder(); |
| |
| Class primaryInterface = getPrimaryTemplateModelInterface(tm); |
| if (primaryInterface != null) { |
| appendTemplateModelTypeName(sb, typeNamesAppended, primaryInterface); |
| } |
| |
| if (_CoreAPI.isBoundCallable(tm)) { |
| appendTypeName(sb, typeNamesAppended, ((Macro) tm).isFunction() ? "function" : "macro"); |
| } |
| |
| appendTemplateModelTypeName(sb, typeNamesAppended, tm.getClass()); |
| |
| String javaClassName; |
| Class unwrappedClass = getUnwrappedClass(tm); |
| if (unwrappedClass != null) { |
| javaClassName = getShortClassName(unwrappedClass, true); |
| } else { |
| javaClassName = null; |
| } |
| |
| sb.append(" ("); |
| String modelClassName = getShortClassName(tm.getClass(), true); |
| if (javaClassName == null) { |
| sb.append("wrapper: "); |
| sb.append(modelClassName); |
| } else { |
| sb.append(javaClassName); |
| sb.append(" wrapped into "); |
| sb.append(modelClassName); |
| } |
| sb.append(")"); |
| |
| return sb.toString(); |
| } |
| } |
| |
| /** |
| * Gets the wrapper class for a primitive class, like {@link Integer} for {@code int}, also returns {@link Void} |
| * for {@code void}. |
| * |
| * @param primitiveClass A {@link Class} like {@code int.type}, {@code boolean.type}, etc. If it's not a primitive |
| * class, or it's {@code null}, then the parameter value is returned as is. Note that performance-wise the |
| * method assumes that it's a primitive class. |
| * |
| * @since 2.3.21 |
| */ |
| public static Class primitiveClassToBoxingClass(Class primitiveClass) { |
| // Tried to sort these with decreasing frequency in API-s: |
| if (primitiveClass == int.class) return Integer.class; |
| if (primitiveClass == boolean.class) return Boolean.class; |
| if (primitiveClass == long.class) return Long.class; |
| if (primitiveClass == double.class) return Double.class; |
| if (primitiveClass == char.class) return Character.class; |
| if (primitiveClass == float.class) return Float.class; |
| if (primitiveClass == byte.class) return Byte.class; |
| if (primitiveClass == short.class) return Short.class; |
| if (primitiveClass == void.class) return Void.class; // not really a primitive, but we normalize it |
| return primitiveClass; |
| } |
| |
| /** |
| * The exact reverse of {@link #primitiveClassToBoxingClass}. |
| * |
| * @since 2.3.21 |
| */ |
| public static Class boxingClassToPrimitiveClass(Class boxingClass) { |
| // Tried to sort these with decreasing frequency in API-s: |
| if (boxingClass == Integer.class) return int.class; |
| if (boxingClass == Boolean.class) return boolean.class; |
| if (boxingClass == Long.class) return long.class; |
| if (boxingClass == Double.class) return double.class; |
| if (boxingClass == Character.class) return char.class; |
| if (boxingClass == Float.class) return float.class; |
| if (boxingClass == Byte.class) return byte.class; |
| if (boxingClass == Short.class) return short.class; |
| if (boxingClass == Void.class) return void.class; // not really a primitive, but we normalize to it |
| return boxingClass; |
| } |
| |
| /** |
| * Tells if a type is numerical; works both for primitive types and classes. |
| * |
| * @param type can't be {@code null} |
| * |
| * @since 2.3.21 |
| */ |
| public static boolean isNumerical(Class type) { |
| return Number.class.isAssignableFrom(type) |
| || type.isPrimitive() && type != Boolean.TYPE && type != Character.TYPE && type != Void.TYPE; |
| } |
| |
| } |
