public Writer getWriter(final Writer out, final Map args) throws TemplateModelException { String errmsg = "Must specify the name of the variable in " + "which to capture the output with the 'var' or 'local' or 'global' parameter."; if (args == null) throw new TemplateModelException(errmsg); throw new TemplateModelException(errmsg); throw new TemplateModelException("Second parameter can only be namespace"); throw new TemplateModelException("Cannot specify namespace for a local assignment"); throw new TemplateModelException("Cannot specify namespace for a global assignment"); throw new TemplateModelException("namespace parameter does not specify a namespace. It is a " + nsModel.getClass().getName()); } else if (args.size() != 1) throw new TemplateModelException( "Bad parameters. Use only one of 'var' or 'local' or 'global' parameters."); throw new TemplateModelException("'var' or 'local' or 'global' parameter doesn't evaluate to a string"); final String varName = ((TemplateScalarModel) varNameModel).getAsString(); if (varName == null) { throw new TemplateModelException("'var' or 'local' or 'global' parameter evaluates to null string");
private void ensureInitializedRTE() { try { ensureInitializedTME(); } catch (TemplateModelException e) { throw new RuntimeException(e.getMessage(), e.getCause()); } }
@Override public Object exec(@SuppressWarnings("rawtypes") List arguments) throws TemplateModelException { if (arguments.size() != 1) { throw new TemplateModelException( "Error, method expects one argument (Object)"); } StringModel stringModel = (StringModel) arguments.get(0); Object object = stringModel.getWrappedObject(); return object instanceof RulePhase; }
private void checkIteratorOwned() throws TemplateModelException { if (iteratorOwned) { throw new TemplateModelException( "This collection value wraps a java.util.Iterator, thus it can be listed only once."); } }
int cnt = ((List) context).size(); if (cnt != 0) { throw new TemplateModelException( "Cannot perform an XPath query against a node set of " + cnt + " nodes. Expecting a single node."/* " + ERRMSG_RECOMMEND_JAXEN*/); } else { throw new TemplateModelException(ERRMSG_EMPTY_NODE_SET); throw new TemplateModelException( "Cannot perform an XPath query against a " + context.getClass().getName() + ". Expecting a single org.w3c.dom.Node."); throw new TemplateModelException(ERRMSG_EMPTY_NODE_SET); return new SimpleScalar(xresult.toString()); throw new TemplateModelException("Cannot deal with type: " + xresult.getClass().getName()); } catch (TransformerException te) { throw new TemplateModelException(te);
public Object exec(List list) throws TemplateModelException { if (list.size() < 1) { throw new TemplateModelException("The nameForTypeDefinition method must have a type definition as a parameter."); } TemplateModel from = (TemplateModel) list.get(0); BeansWrapper wrapper = new BeansWrapperBuilder(Configuration.DEFAULT_INCOMPATIBLE_IMPROVEMENTS).build(); Object unwrapped = wrapper.unwrap(from); if (!(unwrapped instanceof TypeDefinition)) { throw new TemplateModelException("The nameForTypeDefinition method must have a type definition as a parameter."); } return calculateName((TypeDefinition) unwrapped); }
result = (List) listClass.newInstance(); } catch (Exception e) { throw new TemplateModelException("Error instantiating an object of type " + listClass.getName(), e); BeansWrapper bw = BeansWrapper.getDefaultInstance(); for (int i = 0; i < list.size(); i++) { Object elem = list.get(i); if (elem instanceof TemplateModel) { elem = bw.unwrap((TemplateModel) elem);
@Override public Object exec(List arguments) throws TemplateModelException { if (arguments.size() != 1) { throw new TemplateModelException("Wrong number of arguments"); } String code = ((SimpleScalar) arguments.get(0)).getAsString(); if (code == null || code.isEmpty()) { throw new TemplateModelException("Invalid code value '" + code + "'"); } return messageSource.getMessage(code, null, locale); } }
&& ((StringModel) args.get(0)).getWrappedObject() instanceof ConstraintViolation) { ConstraintViolation violation = (ConstraintViolation) ((StringModel) args.get(0)).getWrappedObject(); .orElse(violation.getDefaultMessage()); return new SimpleScalar(messageValue); String messageKey = ((SimpleScalar) args.get(0)).getAsString(); return new SimpleScalar(messageValue); throw new TemplateModelException( "Using i18n without any key is not possible.");
throw new TemplateModelException( "Please specify at least classname and controller (2 parameters)."); strings.add((String) o); } if (o instanceof SimpleScalar) { strings.add(((SimpleScalar) o).getAsString()); } else if (o instanceof SimpleNumber) { strings.add(((SimpleNumber) o).toString()); parameterMap); return new SimpleScalar(reverseRoute); } catch (ClassNotFoundException ex) { throw new TemplateModelException("Error. Cannot find class for String: " + strings.get(0));
public Object exec(List args) throws TemplateModelException { if (args.isEmpty()) { throw new TemplateModelException("This method must have at least one argument, the name of the class to instantiate."); } String classname = args.get(0).toString(); Class cl = null; try { cl = ClassUtil.forName(classname); } catch (Exception e) { throw new TemplateModelException(e.getMessage()); } BeansWrapper bw = BeansWrapper.getDefaultInstance(); Object obj = bw.newInstance(cl, args.subList(1, args.size())); return bw.wrap(obj); } }
NodeModel nm = (NodeModel) get(i); TemplateScalarModel textModel = (TemplateScalarModel) nm.get(key); result.append(textModel.getAsString()); return new SimpleScalar(result.toString()); } else if (key.length() != 2 /* to allow "@@" to fall through */) { throw new TemplateModelException( "\"" + key + "\" is only applicable to a single XML node, but it was applied on " + (size != 0 : "an empty list of XML nodes (no matches).")); } else { throw new TemplateModelException("Unsupported @@ key: " + key); return xps.executeQuery(context, key); } else { throw new TemplateModelException( "Can't try to resolve the XML query key, because no XPath support is available. " + "This is either malformed or an XPath expression: " + key);
ObjectWrapperAndUnwrapper unwrapper = wrapper instanceof ObjectWrapperAndUnwrapper ? (ObjectWrapperAndUnwrapper) wrapper : BeansWrapper.getDefaultInstance(); // [2.4] Throw exception in this case final Object[] argArray = new Object[1]; for (Iterator iter = args.entrySet().iterator(); iter.hasNext(); ) { if (setterMethod == null) { if (dynaSetter == null) { throw new TemplateModelException("Unknown property " + StringUtil.jQuote(paramName.toString()) + " on instance of " + tagClass.getName()); argArray[0] = BeansWrapper.coerceBigDecimal( (BigDecimal) arg, setterMethod.getParameterTypes()[0]);
/** * Attempts to unwrap a model into an object of the desired class. * Generally, this method is the inverse of the {@link #wrap(Object)} * method. It recognizes a wide range of target classes - all Java built-in * primitives, primitive wrappers, numbers, dates, sets, lists, maps, and * native arrays. * @param model the model to unwrap * @param targetClass the class of the unwrapped result; {@code Object.class} of we don't know what the expected type is. * @return the unwrapped result of the desired class * @throws TemplateModelException if an attempted unwrapping fails. * * @see #tryUnwrapTo(TemplateModel, Class) */ public Object unwrap(TemplateModel model, Class<?> targetClass) throws TemplateModelException { final Object obj = tryUnwrapTo(model, targetClass); if (obj == ObjectWrapperAndUnwrapper.CANT_UNWRAP_TO_TARGET_CLASS) { throw new TemplateModelException("Can not unwrap model of type " + model.getClass().getName() + " to type " + targetClass.getName()); } return obj; }
/** * Returns the field or method named by the <tt>key</tt> * parameter. */ public TemplateModel get(String key) throws TemplateModelException { Object model = map.get(key); // Simple method, overloaded method or final field -- these have cached // template models if (model instanceof TemplateModel) return (TemplateModel) model; // Non-final field; this must be evaluated on each call. if (model instanceof Field) { try { return wrapper.getOuterIdentity().wrap(((Field) model).get(null)); } catch (IllegalAccessException e) { throw new TemplateModelException( "Illegal access for field " + key + " of class " + clazz.getName()); } } throw new TemplateModelException( "No such key: " + key + " in class " + clazz.getName()); }
private void populate() throws TemplateModelException { if (!Modifier.isPublic(clazz.getModifiers())) { throw new TemplateModelException( "Can't wrap the non-public class " + clazz.getName()); if (wrapper.getExposureLevel() == BeansWrapper.EXPOSE_NOTHING) { return; map.put(field.getName(), wrapper.getOuterIdentity().wrap(field.get(null))); } catch (IllegalAccessException e) { if (wrapper.getExposureLevel() < BeansWrapper.EXPOSE_PROPERTIES_ONLY) { Method[] methods = clazz.getMethods(); for (int i = 0; i < methods.length; ++i) {
Object listToArray(List<?> list, Class<?> arrayClass, Map<Object, Object> recursionStops) throws TemplateModelException { if (list instanceof SequenceAdapter) { return unwrapSequenceToArray( ((SequenceAdapter) list).getTemplateSequenceModel(), arrayClass, false, listItem = forceUnwrappedNumberToType((Number) listItem, componentType, true); } else if (componentType == String.class && listItem instanceof Character) { listItem = String.valueOf(((Character) listItem).charValue()); listItem = listToArray((List<?>) listItem, componentType, recursionStops); } else if (listItem instanceof TemplateSequenceModel) { listItem = unwrapSequenceToArray((TemplateSequenceModel) listItem, componentType, false, recursionStops); Array.set(array, i, listItem); } catch (IllegalArgumentException e) { throw new TemplateModelException( "Failed to convert " + ClassUtil.getShortClassNameOfObject(list) + " object to " + ClassUtil.getShortClassNameOfObject(array)
throw new TemplateModelException("No message key was specified"); return new StringModel(format(key, params), wrapper); } catch (MissingResourceException e) { throw new TemplateModelException("No such key: " + key); } catch (Exception e) { throw new TemplateModelException(e.getMessage());
protected String getObjectId(Environment environment){ try { TemplateHashModel model = environment.getDataModel(); return ((SimpleScalar) model.get("id")).getAsString(); } catch (TemplateModelException e) { e.printStackTrace(); return null; } }
public static TemplateModel autoWrap(Object obj, Environment env) { TemplateModel templateModelObj = null; try { templateModelObj = getDefaultOfbizWrapper().wrap(obj); } catch (TemplateModelException e) { throw new RuntimeException(e.getMessage()); } return templateModelObj; }