freemarker.template.TemplateCollectionModel Java Examples

@Override
public TemplateCollectionModel values() throws TemplateModelException {
	return new IteratorModel(new Iterator<Object>() {
		private int currentIdx = 0;

		@Override
		public boolean hasNext() {
			return currentIdx < applicationContext.getBeanDefinitionCount();
		}

		@Override
		public Object next() {
			if (!hasNext()) {
				throw new NoSuchElementException();
			}
			String name = applicationContext.getBeanDefinitionNames()[currentIdx++];
			return new LazySpringBeanAccessModel(applicationContext, beansWrapper, name);
		}

	}, beansWrapper);
}
 

@Override
public TemplateCollectionModel keys() throws TemplateModelException {
	return new IteratorModel(new Iterator<String>() {
		private int currentIdx = 0;

		@Override
		public boolean hasNext() {
			return currentIdx < applicationContext.getBeanDefinitionCount();
		}

		@Override
		public String next() {
			if (!hasNext()) {
				throw new NoSuchElementException();
			}
			return "@" + applicationContext.getBeanDefinitionNames()[currentIdx++];
		}

	}, beansWrapper);
}
 

/**
 * Shallow-copies map or list. Note: won't preserve order for maps.
 *
 * @param object
 * @param targetType if true, converts to simple FTL type instead of beans, where possible
 * @return
 * @throws TemplateModelException
 */
public static Object copyObject(TemplateModel object, TemplateValueTargetType targetType, ObjectWrapper objectWrapper) throws TemplateModelException {
    if (targetType == null) {
        targetType = TemplateValueTargetType.PRESERVE;
    }
    if (OfbizFtlObjectType.COMPLEXMAP.isObjectType(object) || (object instanceof TemplateHashModelEx && OfbizFtlObjectType.MAP.isObjectType(object))) {
        return LangFtlUtil.copyMap(object, null, null, targetType, objectWrapper);
    } else if (object instanceof TemplateCollectionModel || object instanceof TemplateSequenceModel) {
        return LangFtlUtil.copyList(object, targetType, objectWrapper);
    } else {
        throw new TemplateModelException("object is not cloneable");
    }
}
 

@Override
public TemplateCollectionModel keys()
    throws TemplateModelException
{
    List<String> names = descriptor.state().properties()
        .map( descriptor -> descriptor.qualifiedName().name() )
        .collect( Collectors.toList() );
    return (TemplateCollectionModel) wrapper.wrap( names.iterator() );
}
 

public static void addToSimpleList(SimpleSequence dest, TemplateModel source) throws TemplateModelException {
    if (source instanceof TemplateCollectionModel) {
        addToSimpleList(dest, (TemplateCollectionModel) source);
    }
    else if (source instanceof TemplateSequenceModel) {
        addToSimpleList(dest, (TemplateSequenceModel) source);
    }
    else {
        throw new TemplateModelException("Can't add to simple list from source type (non-list type): " + source.getClass());
    }
}
 

/**
 * Gets collection as a keys.
 * <p>
 * WARN: This bypasses auto-escaping in all cases. Caller must decide how to handle.
 * (e.g. the object wrapper used to rewrap the result).
 */
public static Set<String> getAsStringSet(TemplateModel model) throws TemplateModelException {
    Set<String> exKeys = null;
    if (model != null) {
        if (model instanceof BeanModel && ((BeanModel) model).getWrappedObject() instanceof Set) {
            // WARN: bypasses auto-escaping
            exKeys = UtilGenerics.cast(((BeanModel) model).getWrappedObject());
        }
        else if (model instanceof TemplateCollectionModel) {
            exKeys = new HashSet<String>();
            TemplateModelIterator keysIt = ((TemplateCollectionModel) model).iterator();
            while(keysIt.hasNext()) {
                exKeys.add(getAsStringNonEscaping((TemplateScalarModel) keysIt.next()));
            }
        }
        else if (model instanceof TemplateSequenceModel) {
            TemplateSequenceModel seqModel = (TemplateSequenceModel) model;
            exKeys = new HashSet<String>(seqModel.size());
            for(int i=0; i < seqModel.size(); i++) {
                exKeys.add(getAsStringNonEscaping((TemplateScalarModel) seqModel.get(i)));
            }
        }
        else {
            throw new TemplateModelException("Include/exclude keys argument not a collection or set of strings");
        }
    }
    return exKeys;
}
 

/**
 * Add to string set.
 * <p>
 * WARN: bypasses auto-escaping, caller handles.
 * (e.g. the object wrapper used to rewrap the result).
 */
public static void addToStringSet(Set<String> dest, TemplateCollectionModel collModel) throws TemplateModelException {
    TemplateModelIterator modelIt = collModel.iterator();
    while(modelIt.hasNext()) {
        dest.add(getAsStringNonEscaping((TemplateScalarModel) modelIt.next()));
    }
}
 

/**
 * To string set.
 * <p>
 * WARN: Bypasses auto-escaping, caller handles.
 * (e.g. the object wrapper used to rewrap the result).
 */
public static Set<String> toStringSet(TemplateCollectionModel collModel) throws TemplateModelException {
    Set<String> set = new HashSet<String>();
    TemplateModelIterator modelIt = collModel.iterator();
    while(modelIt.hasNext()) {
        set.add(getAsStringNonEscaping((TemplateScalarModel) modelIt.next()));
    }
    return set;
}
 

/**
 * Adds the still-wrapped TemplateModels in hash to a java Map.
 * <p>
 * <em>WARN</em>: This is not BeanModel-aware (complex map).
 */
public static void addModelsToMap(Map<String, ? super TemplateModel> dest, TemplateHashModelEx source) throws TemplateModelException {
    TemplateCollectionModel keysModel = source.keys();
    TemplateModelIterator modelIt = keysModel.iterator();
    while(modelIt.hasNext()) {
        String key = getAsStringNonEscaping((TemplateScalarModel) modelIt.next());
        dest.put(key, source.get(key));
    }
}
 

/**
 * Adds to simple hash from source map.
 * <p>
 * <em>WARN</em>: This is not BeanModel-aware (complex map).
 */
public static void addToSimpleMap(SimpleHash dest, TemplateHashModelEx source) throws TemplateModelException {
    TemplateCollectionModel keysModel = source.keys();
    TemplateModelIterator modelIt = keysModel.iterator();
    while(modelIt.hasNext()) {
        String key = getAsStringNonEscaping((TemplateScalarModel) modelIt.next());
        dest.put(key, source.get(key));
    }
}
 

/**
 * Adds all the elements in the given collection to a new list, as TemplateModels.
 * <p>
 * NOTE: This method does NOT handle string escaping explicitly; you may want {@link #toStringSet} instead.
 */
public static <T extends TemplateModel> List<T> toListNoUnwrap(TemplateCollectionModel collModel) throws TemplateModelException {
    // would be safer to let the wrapper do it, but we know it's just a BeanModel in Ofbiz so we can optimize.
    List<Object> res = new ArrayList<>();
    TemplateModelIterator it = collModel.iterator();
    while(it.hasNext()) {
        res.add(it.next());
    }
    return UtilGenerics.cast(res);
}
 

/**
 * Adds all the elements in the given collection to a new list.
 * <p>
 * NOTE: This method does NOT handle string escaping explicitly; you may want {@link #toStringSet} instead.
 */
public static <T> List<T> toList(TemplateCollectionModel collModel) throws TemplateModelException {
    // would be safer to let the wrapper do it, but we know it's just a BeanModel in Ofbiz so we can optimize.
    List<Object> res = new ArrayList<>();
    TemplateModelIterator it = collModel.iterator();
    while(it.hasNext()) {
        res.add(LangFtlUtil.unwrapAlways(it.next()));
    }
    return UtilGenerics.cast(res);
}
 

/**
 * Adds all the elements in the given collection to a new set, as TemplateModels.
 * <p>
 * NOTE: This method does NOT handle string escaping explicitly; you may want {@link #toStringSet} instead.
 */
public static <T extends TemplateModel> Set<T> toSetNoUnwrap(TemplateCollectionModel object) throws TemplateModelException {
    // would be safer to let the wrapper do it, but we know it's just a BeanModel in Ofbiz so we can optimize.
    TemplateCollectionModel collModel = (TemplateCollectionModel) object;
    Set<Object> res = new HashSet<>();
    TemplateModelIterator it = collModel.iterator();
    while(it.hasNext()) {
        res.add(it.next());
    }
    return UtilGenerics.cast(res);
}
 

/**
 * Adds all the elements in the given collection to a new set.
 * <p>
 * NOTE: This method does NOT handle string escaping explicitly; you may want {@link #toStringSet} instead.
 */
public static <T> Set<T> toSet(TemplateCollectionModel object) throws TemplateModelException {
    // would be safer to let the wrapper do it, but we know it's just a BeanModel in Ofbiz so we can optimize.
    TemplateCollectionModel collModel = (TemplateCollectionModel) object;
    Set<Object> res = new HashSet<>();
    TemplateModelIterator it = collModel.iterator();
    while(it.hasNext()) {
        res.add(LangFtlUtil.unwrapAlways(it.next()));
    }
    return UtilGenerics.cast(res);
}
 

/**
 * Adds all the elements in the given collection to a new set.
 * <p>
 * NOTE: This method does NOT handle string escaping explicitly; you may want {@link #toStringSet} instead.
 */
@SuppressWarnings("unchecked")
public static <T> Set<T> toSet(TemplateModel object) throws TemplateModelException {
    if (object instanceof WrapperTemplateModel && ((WrapperTemplateModel) object).getWrappedObject() instanceof Set) {
        return (Set<T>) ((WrapperTemplateModel) object).getWrappedObject();
    } else if (object instanceof TemplateCollectionModel) {
        return toSet((TemplateCollectionModel) object);
    } else if (object instanceof TemplateSequenceModel) {
        return toSet((TemplateSequenceModel) object);
    } else {
        throw new TemplateModelException("Cannot convert object of type " + (object != null ? object.getClass() : "null") + " to set");
    }
}
 

@SuppressWarnings({ "unchecked", "unused" })
@Deprecated
private static TemplateSequenceModel toSimpleSequence(TemplateModel object, ObjectWrapper objectWrapper) throws TemplateModelException {
    if (object instanceof TemplateSequenceModel) {
        return (TemplateSequenceModel) object;
    }
    else if (object instanceof WrapperTemplateModel) {
        WrapperTemplateModel wrapperModel = (WrapperTemplateModel) object;
        // WARN: bypasses auto-escaping
        Object wrappedObject = wrapperModel.getWrappedObject();
        if (wrappedObject instanceof List) {
            return DefaultListAdapter.adapt((List<Object>) wrappedObject, (RichObjectWrapper) objectWrapper);
        }
        else if (wrappedObject instanceof Object[]) {
            return DefaultArrayAdapter.adapt((Object[]) wrappedObject, (ObjectWrapperAndUnwrapper) objectWrapper);
        }
        else if (wrappedObject instanceof Set) {
            throw new UnsupportedOperationException("Not yet implemented");
        }
        else if (wrappedObject instanceof Collection) {
            throw new UnsupportedOperationException("Not yet implemented");
        }
        else if (wrappedObject instanceof Iterable) {
            throw new UnsupportedOperationException("Not yet implemented");
        }
        else {
            throw new TemplateModelException("Cannot convert bean-wrapped object of type " + (object != null ? object.getClass() : "null") + " to simple sequence");
        }
    } else if (object instanceof TemplateCollectionModel) {
        TemplateCollectionModel collModel = (TemplateCollectionModel) object;
        SimpleSequence res = new SimpleSequence(objectWrapper);
        TemplateModelIterator it = collModel.iterator();
        while(it.hasNext()) {
            res.add(it.next());
        }
        return res;
    } else {
        throw new TemplateModelException("Cannot convert object of type " + (object != null ? object.getClass() : "null") + " to simple sequence");
    }
}
 

@SuppressWarnings("unchecked")
static Collection<String> getAsRawSequence(TemplateModel elems) throws TemplateModelException {
    if (elems == null || elems instanceof TemplateBooleanModel) {
        return Collections.emptyList();
    } else if (elems instanceof TemplateCollectionModel || elems instanceof TemplateSequenceModel) {
        return (Collection<String>) LangFtlUtil.unwrapAlways(elems);
    } else if (elems instanceof TemplateHashModelEx) {
        return (Collection<String>) LangFtlUtil.getMapKeys(elems);
    } else {
        throw new TemplateModelException("invalid parameter type, can't interpret as sequence: " + elems.getClass());
    }
}
 

public static SimpleHash makeSimpleMap(TemplateHashModel map, TemplateCollectionModel keys, ObjectWrapper objectWrapper) throws TemplateModelException {
    SimpleHash res = new SimpleHash(objectWrapper);
    addToSimpleMap(res, map, LangFtlUtil.toStringSet(keys));
    return res;
}
 

public static void addToSimpleList(SimpleSequence dest, TemplateCollectionModel source) throws TemplateModelException {
    TemplateModelIterator it = source.iterator();
    while(it.hasNext()) {
        dest.add(it.next());
    }
}
 

public TemplateCollectionModel keys() {
    return new SimpleCollection(map.keySet(), WRAPPER);
}
 

public TemplateCollectionModel values() {
    return new SimpleCollection(map.values(), WRAPPER);
}
 

@Override
public TemplateCollectionModel keys() {
  return new SimpleCollection(jsonObject.fieldNames(), getObjectWrapper());
}
 

@Override
public TemplateCollectionModel values() {
  return new SimpleCollection(jsonObject.getMap().values(), getObjectWrapper());
}