    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}