001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.lang3.text;
018
019import java.text.Format;
020import java.text.MessageFormat;
021import java.text.ParsePosition;
022import java.util.ArrayList;
023import java.util.Collection;
024import java.util.Iterator;
025import java.util.Locale;
026import java.util.Map;
027import java.util.Objects;
028
029import org.apache.commons.lang3.ObjectUtils;
030import org.apache.commons.lang3.Validate;
031
032/**
033 * Extends <code>java.text.MessageFormat</code> to allow pluggable/additional formatting
034 * options for embedded format elements.  Client code should specify a registry
035 * of <code>FormatFactory</code> instances associated with <code>String</code>
036 * format names.  This registry will be consulted when the format elements are
037 * parsed from the message pattern.  In this way custom patterns can be specified,
038 * and the formats supported by <code>java.text.MessageFormat</code> can be overridden
039 * at the format and/or format style level (see MessageFormat).  A "format element"
040 * embedded in the message pattern is specified (<b>()?</b> signifies optionality):<br>
041 * <code>{</code><i>argument-number</i><b>(</b><code>,</code><i>format-name</i><b>
042 * (</b><code>,</code><i>format-style</i><b>)?)?</b><code>}</code>
043 *
044 * <p>
045 * <i>format-name</i> and <i>format-style</i> values are trimmed of surrounding whitespace
046 * in the manner of <code>java.text.MessageFormat</code>.  If <i>format-name</i> denotes
047 * <code>FormatFactory formatFactoryInstance</code> in <code>registry</code>, a <code>Format</code>
048 * matching <i>format-name</i> and <i>format-style</i> is requested from
049 * <code>formatFactoryInstance</code>.  If this is successful, the <code>Format</code>
050 * found is used for this format element.
051 * </p>
052 *
053 * <p><b>NOTICE:</b> The various subformat mutator methods are considered unnecessary; they exist on the parent
054 * class to allow the type of customization which it is the job of this class to provide in
055 * a configurable fashion.  These methods have thus been disabled and will throw
056 * <code>UnsupportedOperationException</code> if called.
057 * </p>
058 *
059 * <p>Limitations inherited from <code>java.text.MessageFormat</code>:</p>
060 * <ul>
061 * <li>When using "choice" subformats, support for nested formatting instructions is limited
062 *     to that provided by the base class.</li>
063 * <li>Thread-safety of <code>Format</code>s, including <code>MessageFormat</code> and thus
064 *     <code>ExtendedMessageFormat</code>, is not guaranteed.</li>
065 * </ul>
066 *
067 * @since 2.4
068 * @deprecated as of 3.6, use commons-text
069 * <a href="https://commons.apache.org/proper/commons-text/javadocs/api-release/org/apache/commons/text/ExtendedMessageFormat.html">
070 * ExtendedMessageFormat</a> instead
071 */
072@Deprecated
073public class ExtendedMessageFormat extends MessageFormat {
074    private static final long serialVersionUID = -2362048321261811743L;
075    private static final int HASH_SEED = 31;
076
077    private static final String DUMMY_PATTERN = "";
078    private static final char START_FMT = ',';
079    private static final char END_FE = '}';
080    private static final char START_FE = '{';
081    private static final char QUOTE = '\'';
082
083    private String toPattern;
084    private final Map<String, ? extends FormatFactory> registry;
085
086    /**
087     * Create a new ExtendedMessageFormat for the default locale.
088     *
089     * @param pattern  the pattern to use, not null
090     * @throws IllegalArgumentException in case of a bad pattern.
091     */
092    public ExtendedMessageFormat(final String pattern) {
093        this(pattern, Locale.getDefault());
094    }
095
096    /**
097     * Create a new ExtendedMessageFormat.
098     *
099     * @param pattern  the pattern to use, not null
100     * @param locale  the locale to use, not null
101     * @throws IllegalArgumentException in case of a bad pattern.
102     */
103    public ExtendedMessageFormat(final String pattern, final Locale locale) {
104        this(pattern, locale, null);
105    }
106
107    /**
108     * Create a new ExtendedMessageFormat for the default locale.
109     *
110     * @param pattern  the pattern to use, not null
111     * @param registry  the registry of format factories, may be null
112     * @throws IllegalArgumentException in case of a bad pattern.
113     */
114    public ExtendedMessageFormat(final String pattern, final Map<String, ? extends FormatFactory> registry) {
115        this(pattern, Locale.getDefault(), registry);
116    }
117
118    /**
119     * Create a new ExtendedMessageFormat.
120     *
121     * @param pattern  the pattern to use, not null
122     * @param locale  the locale to use, not null
123     * @param registry  the registry of format factories, may be null
124     * @throws IllegalArgumentException in case of a bad pattern.
125     */
126    public ExtendedMessageFormat(final String pattern, final Locale locale, final Map<String, ? extends FormatFactory> registry) {
127        super(DUMMY_PATTERN);
128        setLocale(locale);
129        this.registry = registry;
130        applyPattern(pattern);
131    }
132
133    /**
134     * {@inheritDoc}
135     */
136    @Override
137    public String toPattern() {
138        return toPattern;
139    }
140
141    /**
142     * Apply the specified pattern.
143     *
144     * @param pattern String
145     */
146    @Override
147    public final void applyPattern(final String pattern) {
148        if (registry == null) {
149            super.applyPattern(pattern);
150            toPattern = super.toPattern();
151            return;
152        }
153        final ArrayList<Format> foundFormats = new ArrayList<>();
154        final ArrayList<String> foundDescriptions = new ArrayList<>();
155        final StringBuilder stripCustom = new StringBuilder(pattern.length());
156
157        final ParsePosition pos = new ParsePosition(0);
158        final char[] c = pattern.toCharArray();
159        int fmtCount = 0;
160        while (pos.getIndex() < pattern.length()) {
161            switch (c[pos.getIndex()]) {
162            case QUOTE:
163                appendQuotedString(pattern, pos, stripCustom);
164                break;
165            case START_FE:
166                fmtCount++;
167                seekNonWs(pattern, pos);
168                final int start = pos.getIndex();
169                final int index = readArgumentIndex(pattern, next(pos));
170                stripCustom.append(START_FE).append(index);
171                seekNonWs(pattern, pos);
172                Format format = null;
173                String formatDescription = null;
174                if (c[pos.getIndex()] == START_FMT) {
175                    formatDescription = parseFormatDescription(pattern,
176                            next(pos));
177                    format = getFormat(formatDescription);
178                    if (format == null) {
179                        stripCustom.append(START_FMT).append(formatDescription);
180                    }
181                }
182                foundFormats.add(format);
183                foundDescriptions.add(format == null ? null : formatDescription);
184                Validate.isTrue(foundFormats.size() == fmtCount);
185                Validate.isTrue(foundDescriptions.size() == fmtCount);
186                if (c[pos.getIndex()] != END_FE) {
187                    throw new IllegalArgumentException(
188                            "Unreadable format element at position " + start);
189                }
190                //$FALL-THROUGH$
191            default:
192                stripCustom.append(c[pos.getIndex()]);
193                next(pos);
194            }
195        }
196        super.applyPattern(stripCustom.toString());
197        toPattern = insertFormats(super.toPattern(), foundDescriptions);
198        if (containsElements(foundFormats)) {
199            final Format[] origFormats = getFormats();
200            // only loop over what we know we have, as MessageFormat on Java 1.3
201            // seems to provide an extra format element:
202            int i = 0;
203            for (final Iterator<Format> it = foundFormats.iterator(); it.hasNext(); i++) {
204                final Format f = it.next();
205                if (f != null) {
206                    origFormats[i] = f;
207                }
208            }
209            super.setFormats(origFormats);
210        }
211    }
212
213    /**
214     * Throws UnsupportedOperationException - see class Javadoc for details.
215     *
216     * @param formatElementIndex format element index
217     * @param newFormat the new format
218     * @throws UnsupportedOperationException always thrown since this isn't supported by ExtendMessageFormat
219     */
220    @Override
221    public void setFormat(final int formatElementIndex, final Format newFormat) {
222        throw new UnsupportedOperationException();
223    }
224
225    /**
226     * Throws UnsupportedOperationException - see class Javadoc for details.
227     *
228     * @param argumentIndex argument index
229     * @param newFormat the new format
230     * @throws UnsupportedOperationException always thrown since this isn't supported by ExtendMessageFormat
231     */
232    @Override
233    public void setFormatByArgumentIndex(final int argumentIndex, final Format newFormat) {
234        throw new UnsupportedOperationException();
235    }
236
237    /**
238     * Throws UnsupportedOperationException - see class Javadoc for details.
239     *
240     * @param newFormats new formats
241     * @throws UnsupportedOperationException always thrown since this isn't supported by ExtendMessageFormat
242     */
243    @Override
244    public void setFormats(final Format[] newFormats) {
245        throw new UnsupportedOperationException();
246    }
247
248    /**
249     * Throws UnsupportedOperationException - see class Javadoc for details.
250     *
251     * @param newFormats new formats
252     * @throws UnsupportedOperationException always thrown since this isn't supported by ExtendMessageFormat
253     */
254    @Override
255    public void setFormatsByArgumentIndex(final Format[] newFormats) {
256        throw new UnsupportedOperationException();
257    }
258
259    /**
260     * Check if this extended message format is equal to another object.
261     *
262     * @param obj the object to compare to
263     * @return true if this object equals the other, otherwise false
264     */
265    @Override
266    public boolean equals(final Object obj) {
267        if (obj == this) {
268            return true;
269        }
270        if (obj == null) {
271            return false;
272        }
273        if (!super.equals(obj)) {
274            return false;
275        }
276        if (ObjectUtils.notEqual(getClass(), obj.getClass())) {
277          return false;
278        }
279        final ExtendedMessageFormat rhs = (ExtendedMessageFormat) obj;
280        if (ObjectUtils.notEqual(toPattern, rhs.toPattern)) {
281            return false;
282        }
283        return !ObjectUtils.notEqual(registry, rhs.registry);
284    }
285
286    /**
287     * {@inheritDoc}
288     */
289    @Override
290    public int hashCode() {
291        int result = super.hashCode();
292        result = HASH_SEED * result + Objects.hashCode(registry);
293        result = HASH_SEED * result + Objects.hashCode(toPattern);
294        return result;
295    }
296
297    /**
298     * Get a custom format from a format description.
299     *
300     * @param desc String
301     * @return Format
302     */
303    private Format getFormat(final String desc) {
304        if (registry != null) {
305            String name = desc;
306            String args = null;
307            final int i = desc.indexOf(START_FMT);
308            if (i > 0) {
309                name = desc.substring(0, i).trim();
310                args = desc.substring(i + 1).trim();
311            }
312            final FormatFactory factory = registry.get(name);
313            if (factory != null) {
314                return factory.getFormat(name, args, getLocale());
315            }
316        }
317        return null;
318    }
319
320    /**
321     * Read the argument index from the current format element
322     *
323     * @param pattern pattern to parse
324     * @param pos current parse position
325     * @return argument index
326     */
327    private int readArgumentIndex(final String pattern, final ParsePosition pos) {
328        final int start = pos.getIndex();
329        seekNonWs(pattern, pos);
330        final StringBuilder result = new StringBuilder();
331        boolean error = false;
332        for (; !error && pos.getIndex() < pattern.length(); next(pos)) {
333            char c = pattern.charAt(pos.getIndex());
334            if (Character.isWhitespace(c)) {
335                seekNonWs(pattern, pos);
336                c = pattern.charAt(pos.getIndex());
337                if (c != START_FMT && c != END_FE) {
338                    error = true;
339                    continue;
340                }
341            }
342            if ((c == START_FMT || c == END_FE) && result.length() > 0) {
343                try {
344                    return Integer.parseInt(result.toString());
345                } catch (final NumberFormatException e) { // NOPMD
346                    // we've already ensured only digits, so unless something
347                    // outlandishly large was specified we should be okay.
348                }
349            }
350            error = !Character.isDigit(c);
351            result.append(c);
352        }
353        if (error) {
354            throw new IllegalArgumentException(
355                    "Invalid format argument index at position " + start + ": "
356                            + pattern.substring(start, pos.getIndex()));
357        }
358        throw new IllegalArgumentException(
359                "Unterminated format element at position " + start);
360    }
361
362    /**
363     * Parse the format component of a format element.
364     *
365     * @param pattern string to parse
366     * @param pos current parse position
367     * @return Format description String
368     */
369    private String parseFormatDescription(final String pattern, final ParsePosition pos) {
370        final int start = pos.getIndex();
371        seekNonWs(pattern, pos);
372        final int text = pos.getIndex();
373        int depth = 1;
374        for (; pos.getIndex() < pattern.length(); next(pos)) {
375            switch (pattern.charAt(pos.getIndex())) {
376            case START_FE:
377                depth++;
378                break;
379            case END_FE:
380                depth--;
381                if (depth == 0) {
382                    return pattern.substring(text, pos.getIndex());
383                }
384                break;
385            case QUOTE:
386                getQuotedString(pattern, pos);
387                break;
388            default:
389                break;
390            }
391        }
392        throw new IllegalArgumentException(
393                "Unterminated format element at position " + start);
394    }
395
396    /**
397     * Insert formats back into the pattern for toPattern() support.
398     *
399     * @param pattern source
400     * @param customPatterns The custom patterns to re-insert, if any
401     * @return full pattern
402     */
403    private String insertFormats(final String pattern, final ArrayList<String> customPatterns) {
404        if (!containsElements(customPatterns)) {
405            return pattern;
406        }
407        final StringBuilder sb = new StringBuilder(pattern.length() * 2);
408        final ParsePosition pos = new ParsePosition(0);
409        int fe = -1;
410        int depth = 0;
411        while (pos.getIndex() < pattern.length()) {
412            final char c = pattern.charAt(pos.getIndex());
413            switch (c) {
414            case QUOTE:
415                appendQuotedString(pattern, pos, sb);
416                break;
417            case START_FE:
418                depth++;
419                sb.append(START_FE).append(readArgumentIndex(pattern, next(pos)));
420                // do not look for custom patterns when they are embedded, e.g. in a choice
421                if (depth == 1) {
422                    fe++;
423                    final String customPattern = customPatterns.get(fe);
424                    if (customPattern != null) {
425                        sb.append(START_FMT).append(customPattern);
426                    }
427                }
428                break;
429            case END_FE:
430                depth--;
431                //$FALL-THROUGH$
432            default:
433                sb.append(c);
434                next(pos);
435            }
436        }
437        return sb.toString();
438    }
439
440    /**
441     * Consume whitespace from the current parse position.
442     *
443     * @param pattern String to read
444     * @param pos current position
445     */
446    private void seekNonWs(final String pattern, final ParsePosition pos) {
447        int len = 0;
448        final char[] buffer = pattern.toCharArray();
449        do {
450            len = StrMatcher.splitMatcher().isMatch(buffer, pos.getIndex());
451            pos.setIndex(pos.getIndex() + len);
452        } while (len > 0 && pos.getIndex() < pattern.length());
453    }
454
455    /**
456     * Convenience method to advance parse position by 1
457     *
458     * @param pos ParsePosition
459     * @return <code>pos</code>
460     */
461    private ParsePosition next(final ParsePosition pos) {
462        pos.setIndex(pos.getIndex() + 1);
463        return pos;
464    }
465
466    /**
467     * Consume a quoted string, adding it to <code>appendTo</code> if
468     * specified.
469     *
470     * @param pattern pattern to parse
471     * @param pos current parse position
472     * @param appendTo optional StringBuilder to append
473     * @return <code>appendTo</code>
474     */
475    private StringBuilder appendQuotedString(final String pattern, final ParsePosition pos,
476            final StringBuilder appendTo) {
477        assert pattern.toCharArray()[pos.getIndex()] == QUOTE :
478            "Quoted string must start with quote character";
479
480        // handle quote character at the beginning of the string
481        if (appendTo != null) {
482            appendTo.append(QUOTE);
483        }
484        next(pos);
485
486        final int start = pos.getIndex();
487        final char[] c = pattern.toCharArray();
488        final int lastHold = start;
489        for (int i = pos.getIndex(); i < pattern.length(); i++) {
490            switch (c[pos.getIndex()]) {
491            case QUOTE:
492                next(pos);
493                return appendTo == null ? null : appendTo.append(c, lastHold,
494                        pos.getIndex() - lastHold);
495            default:
496                next(pos);
497            }
498        }
499        throw new IllegalArgumentException(
500                "Unterminated quoted string at position " + start);
501    }
502
503    /**
504     * Consume quoted string only
505     *
506     * @param pattern pattern to parse
507     * @param pos current parse position
508     */
509    private void getQuotedString(final String pattern, final ParsePosition pos) {
510        appendQuotedString(pattern, pos, null);
511    }
512
513    /**
514     * Learn whether the specified Collection contains non-null elements.
515     * @param coll to check
516     * @return <code>true</code> if some Object was found, <code>false</code> otherwise.
517     */
518    private boolean containsElements(final Collection<?> coll) {
519        if (coll == null || coll.isEmpty()) {
520            return false;
521        }
522        for (final Object name : coll) {
523            if (name != null) {
524                return true;
525            }
526        }
527        return false;
528    }
529}