| /* |
| * 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.core; |
| |
| import freemarker.template.TemplateException; |
| import freemarker.template.TemplateModel; |
| import freemarker.template.TemplateScalarModel; |
| |
| /** |
| * Used for implementing the "truncate" family of built-ins. There are several variations of the "truncate" built-ins, |
| * each has a corresponding method here. See |
| * {@link #truncateM(String, int, TemplateModel, Integer, Environment)} |
| * as the starting point. |
| * |
| * <p>New methods may be added in later versions, whoever they won't be abstract for backward compatibility. |
| * |
| * @see Configurable#setTruncateBuiltinAlgorithm(TruncateBuiltinAlgorithm) |
| * |
| * @since 2.3.29 |
| */ |
| public abstract class TruncateBuiltinAlgorithm { |
| |
| /** |
| * Corresponds to {@code ?truncate_m(...)} in templates. This method decides automatically if it will truncate at |
| * word boundary (see {@link #truncateWM}) or at character boundary (see {@link #truncateCM}). While it depends |
| * on the implementation, the idea is that it should truncate at word boundary, unless that gives a too short |
| * string, in which case it falls back to truncation at character duration. |
| * |
| * <p>The terminator and the return value can be {@link TemplateMarkupOutputModel} (FTL markup output type), not |
| * just {@link String} (FTL string type), hence the "m" in the name. |
| * |
| * @param s |
| * The input string whose length need to be limited. The caller (the FreeMarker core normally) is |
| * expected to guarantee that this won't be {@code null}. |
| * |
| * @param maxLength |
| * The maximum length of the returned string, although the algorithm need not guarantee this strictly. |
| * For example, if this is less than the length of the {@code terminator} string, then most algorithms |
| * should still return the {@code terminator} string. Or, some sophisticated algorithm may counts in |
| * letters differently depending on their visual width. The goal is usually to prevent unusually long |
| * string values to ruin visual layout, while showing clearly to the user that the end of the string |
| * was cut off. If the input string is not longer than the maximum length, then it should be returned |
| * as is. The caller (the FreeMarker core normally) is expected to guarantee that this will be at |
| * least 0. |
| * |
| * @param terminator |
| * The string or markup to show at the end of the returned string if the string was actually truncated. |
| * This can be {@code null}, in which case the default terminator of the algorithm will be used. It |
| * can be an FTL string (a {@link TemplateScalarModel}) of any length (including 0), or a |
| * {@link TemplateMarkupOutputModel} (typically HTML markup). If it's {@link TemplateMarkupOutputModel}, |
| * then the result is {@link TemplateMarkupOutputModel} of the same output format as well, otherwise |
| * it can remain {@link TemplateScalarModel}. Note that the length of the terminator counts into the |
| * result length that shouldn't be exceed ({@code maxLength}) (or at least the algorithm should make |
| * an effort to avoid that). |
| * |
| * @param terminatorLength |
| * The assumed length of the terminator. If this is {@code null} (and typically it is), then the method |
| * decides the length of the terminator. If this is not {@code null}, then the method must pretend |
| * that the terminator length is this. This can be used to specify the visual length of a terminator |
| * explicitly, which can't always be decided well programmatically. |
| * |
| * @param env |
| * The runtime environment from which this algorithm was called. The caller (the FreeMarker core |
| * normally) is expected to guarantee that this won't be {@code null}. |
| * |
| * @return The truncated text, which is either a {@link TemplateScalarModel} (FTL string), or a |
| * {@link TemplateMarkupOutputModel}. |
| * |
| * @throws TemplateException |
| * If anything goes wrong during truncating. It's unlikely that an implementation will need this though. |
| */ |
| public abstract TemplateModel truncateM( |
| String s, int maxLength, TemplateModel terminator, Integer terminatorLength, |
| Environment env) throws TemplateException; |
| |
| /** |
| * Corresponds to {@code ?truncate(...)} in templates. |
| * Similar to {@link #truncateM(String, int, TemplateModel, Integer, Environment)}, but only allows |
| * an FTL string as terminator, and thence the return value is always an FTL string as well (not |
| * {@link TemplateMarkupOutputModel}). |
| */ |
| public abstract TemplateScalarModel truncate( |
| String s, int maxLength, TemplateScalarModel terminator, Integer terminatorLength, |
| Environment env) throws TemplateException; |
| |
| /** |
| * Corresponds to {@code ?truncate_w(...)} in templates. |
| * Same as {@link #truncateWM(String, int, TemplateModel, Integer, Environment)}, but only allows |
| * an FTL string as terminator, and thence the return value is always an FTL string as well (not |
| * {@link TemplateMarkupOutputModel}). |
| */ |
| public abstract TemplateScalarModel truncateW( |
| String s, int maxLength, TemplateScalarModel terminator, Integer terminatorLength, |
| Environment env) throws TemplateException; |
| |
| /** |
| * Corresponds to {@code ?truncate_w_m(...)} in templates. |
| * Similar to {@link #truncateM(String, int, TemplateModel, Integer, Environment)}, but the |
| * truncation should happen at word boundary (hence the "w"). That is, the truncation isn't allowed to truncate a |
| * word. What counts as a word, is up to the implementation, but at least in {@link DefaultTruncateBuiltinAlgorithm} |
| * words are the sections that are separated by whitespace (so punctuation doesn't separate words). |
| */ |
| public abstract TemplateModel truncateWM( |
| String s, int maxLength, TemplateModel terminator, Integer terminatorLength, |
| Environment env) throws TemplateException; |
| |
| /** |
| * Corresponds to {@code ?truncate_c_m(...)} in templates. |
| * Same as {@link #truncateCM(String, int, TemplateModel, Integer, Environment)}, but only allows |
| * an FTL string as terminator, and thence the return value is always an FTL string as well (not markup). |
| */ |
| public abstract TemplateScalarModel truncateC( |
| String s, int maxLength, TemplateScalarModel terminator, Integer terminatorLength, |
| Environment env) throws TemplateException; |
| |
| /** |
| * Corresponds to {@code ?truncate_c_m(...)} in templates. |
| * Similar to {@link #truncateM(String, int, TemplateModel, Integer, Environment)}, but the |
| * truncation should not prefer truncating at word boundaries over the closer approximation of the desired {@code |
| * maxLength}. Hence, we say that it truncates at character boundary (hence the "c"). |
| */ |
| public abstract TemplateModel truncateCM( |
| String s, int maxLength, TemplateModel terminator, Integer terminatorLength, |
| Environment env) throws TemplateException; |
| |
| } |