private void addCallableMemberDescriptor(ReflectionCallableMemberDescriptor memberDesc) { // Note: "varargs" methods are always callable as fixed args, with a sequence (array) as the last parameter. fixArgMethods.addCallableMemberDescriptor(memberDesc); if (memberDesc.isVarargs()) { if (varargMethods == null) { varargMethods = new OverloadedVarArgsMethods(bugfixed); } varargMethods.addCallableMemberDescriptor(memberDesc); } }
void setMethodSorter(MethodSorter methodSorter) { checkModifiable(); if (classIntrospector.getMethodSorter() != methodSorter) { ClassIntrospectorBuilder builder = classIntrospector.createBuilder(); builder.setMethodSorter(methodSorter); replaceClassIntrospector(builder); } }
@Override protected TemplateModel createModel(Class clazz) throws TemplateModelException { return new StaticModel(clazz, getWrapper()); } }
public BeansWrapper getObjectWrapper() { if (objectWrapper == null) { objectWrapper = new BeansWrapper(Configuration.VERSION_2_3_21); } return objectWrapper; }
/** * Used to tweak certain aspects of how methods appear in the data-model; * see {@link MethodAppearanceFineTuner} for more. */ public void setMethodAppearanceFineTuner(MethodAppearanceFineTuner methodAppearanceFineTuner) { checkModifiable(); if (classIntrospector.getMethodAppearanceFineTuner() != methodAppearanceFineTuner) { ClassIntrospectorBuilder builder = classIntrospector.createBuilder(); builder.setMethodAppearanceFineTuner(methodAppearanceFineTuner); replaceClassIntrospector(builder); } }
/** * Invokes the method, passing it the arguments from the list. */ public Object exec(List arguments) throws TemplateModelException { try { return wrapper.invokeMethod(object, (Method) getMember(), unwrapArguments(arguments, wrapper)); } catch (TemplateModelException e) { throw e; } catch (Exception e) { throw _MethodUtil.newInvocationTemplateModelException(object, getMember(), e); } }
/** * Sets the method exposure level. By default, set to <code>EXPOSE_SAFE</code>. * @param exposureLevel can be any of the <code>EXPOSE_xxx</code> * constants. */ public void setExposureLevel(int exposureLevel) { checkModifiable(); if (classIntrospector.getExposureLevel() != exposureLevel) { ClassIntrospectorBuilder builder = classIntrospector.createBuilder(); builder.setExposureLevel(exposureLevel); replaceClassIntrospector(builder); } }
private Object[] toErrorMessage(EmptyMemberAndArguments res, List/*<TemplateModel>*/ tmArgs) { final Object[] unwrappedArgs = res.getUnwrappedArguments(); return new Object[] { res.getErrorDescription(), tmArgs != null ? new Object[] { "\nThe FTL type of the argument values were: ", getTMActualParameterTypes(tmArgs), "." } : (Object) "", unwrappedArgs != null ? new Object[] { "\nThe Java type of the argument values were: ", getUnwrappedActualParameterTypes(unwrappedArgs) + "." } : (Object) ""}; }
public void process( MethodAppearanceDecisionInput in, MethodAppearanceDecision out) { BeansWrapper.this.finetuneMethodAppearance(in.getContainingClass(), in.getMethod(), out); }
public static TemplateModelException newInvocationTemplateModelException(Object object, CallableMemberDescriptor callableMemberDescriptor, Throwable e) { return newInvocationTemplateModelException( object, new _DelayedConversionToString(callableMemberDescriptor) { @Override protected String doConversion(Object callableMemberDescriptor) { return ((CallableMemberDescriptor) callableMemberDescriptor).getDeclaration(); } }, callableMemberDescriptor.isStatic(), callableMemberDescriptor.isConstructor(), e); }
@Override TemplateModel invokeMethod(BeansWrapper bw, Object obj, Object[] args) throws TemplateModelException, InvocationTargetException, IllegalAccessException { convertArgsToReflectionCompatible(bw, args); return callableMemberDesc.invokeMethod(bw, obj, args); }
@Override Object invokeConstructor(BeansWrapper bw, Object[] args) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, TemplateModelException { convertArgsToReflectionCompatible(bw, args); return callableMemberDesc.invokeConstructor(bw, args); }
private static boolean isBuggySeqButGoodCollection( TemplateModel model) { return model instanceof CollectionModel ? !((CollectionModel) model).getSupportsIndexedAccess() : false; }
Object invokeConstructor(BeansWrapper bw) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, TemplateModelException { return callableMemberDesc.invokeConstructor(bw, args); }
/** * Returns a {@link ClassIntrospectorBuilder}-s that could be used to create an identical {@link #ClassIntrospector} * . The returned {@link ClassIntrospectorBuilder} can be modified without interfering with anything. */ ClassIntrospectorBuilder createBuilder() { return new ClassIntrospectorBuilder(this); }
/** * As of this writing, this is only used for testing if method order really doesn't mater. */ private void sortMethodDescriptors(List<MethodDescriptor> methodDescriptors) { if (methodSorter != null) { methodSorter.sortMethodDescriptors(methodDescriptors); } }
static EmptyMemberAndArguments noCompatibleOverload(Object[] unwrappedArgs) { return new EmptyMemberAndArguments( "No compatible overloaded variation was found; declared parameter types and argument value types mismatch.", false, unwrappedArgs); }
/** * @since 2.3.22 */ public Object tryUnwrapTo(TemplateModel model, Class<?> targetClass) throws TemplateModelException { return tryUnwrapTo(model, targetClass, 0); }
/** * See {@link BeansWrapper#setMethodAppearanceFineTuner(MethodAppearanceFineTuner)}; additionally, * note that currently setting this to non-{@code null} will disable class introspection cache sharing, unless * the value implements {@link SingletonCustomizer}. */ public void setMethodAppearanceFineTuner(MethodAppearanceFineTuner methodAppearanceFineTuner) { classIntrospectorBuilder.setMethodAppearanceFineTuner(methodAppearanceFineTuner); }
@Override protected String doConversion(Object callableMemberDescriptor) { return ((CallableMemberDescriptor) callableMemberDescriptor).getDeclaration(); } },