java.text.MessageFormat Maven / Gradle / Ivy
/*
This is not an official specification document, and usage is restricted.
NOTICE
(c) 2005-2007 Sun Microsystems, Inc. All Rights Reserved.
Neither this file nor any files generated from it describe a complete
specification, and they may only be used as described below. For
example, no permission is given for you to incorporate this file, in
whole or in part, in an implementation of a Java specification.
Sun Microsystems Inc. owns the copyright in this file and it is provided
to you for informative, as opposed to normative, use. The file and any
files generated from it may be used to generate other informative
documentation, such as a unified set of documents of API signatures for
a platform that includes technologies expressed as Java APIs. The file
may also be used to produce "compilation stubs," which allow
applications to be compiled and validated for such platforms.
Any work generated from this file, such as unified javadocs or compiled
stub files, must be accompanied by this notice in its entirety.
This work corresponds to the API signatures of JSR 219: Foundation
Profile 1.1. In the event of a discrepency between this work and the
JSR 219 specification, which is available at
http://www.jcp.org/en/jsr/detail?id=219, the latter takes precedence.
*/
package java.text;
import java.io.InvalidObjectException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;
/**
* MessageFormat provides a means to produce concatenated
* messages in language-neutral way. Use this to construct messages
* displayed for end users.
*
*
* MessageFormat takes a set of objects, formats them, then
* inserts the formatted strings into the pattern at the appropriate places.
*
*
* Note:
* MessageFormat differs from the other Format
* classes in that you create a MessageFormat object with one
* of its constructors (not with a getInstance style factory
* method). The factory methods aren't necessary because MessageFormat
* itself doesn't implement locale specific behavior. Any locale specific
* behavior is defined by the pattern that you provide as well as the
* subformats used for inserted arguments.
*
*
Patterns and Their Interpretation
*
* MessageFormat uses patterns of the following form:
*
* MessageFormatPattern:
* String
* MessageFormatPattern FormatElement String
*
* FormatElement:
* { ArgumentIndex }
* { ArgumentIndex , FormatType }
* { ArgumentIndex , FormatType , FormatStyle }
*
* FormatType: one of
* number date time choice
*
* FormatStyle:
* short
* medium
* long
* full
* integer
* currency
* percent
* SubformatPattern
*
* String:
* StringPartopt
* String StringPart
*
* StringPart:
* ''
* ' QuotedString '
* UnquotedString
*
* SubformatPattern:
* SubformatPatternPartopt
* SubformatPattern SubformatPatternPart
*
* SubFormatPatternPart:
* ' QuotedPattern '
* UnquotedPattern
*
*
*
* Within a String, "''" represents a single
* quote. A QuotedString can contain arbitrary characters
* except single quotes; the surrounding single quotes are removed.
* An UnquotedString can contain arbitrary characters
* except single quotes and left curly brackets. Thus, a string that
* should result in the formatted message "'{0}'" can be written as
* "'''{'0}''" or "'''{0}'''".
*
* Within a SubformatPattern, different rules apply.
* A QuotedPattern can contain arbitrary characters
* except single quotes; but the surrounding single quotes are
* not removed, so they may be interpreted by the
* subformat. For example, "{1,number,$'#',##}" will
* produce a number format with the pound-sign quoted, with a result
* such as: "$#31,45".
* An UnquotedPattern can contain arbitrary characters
* except single quotes, but curly braces within it must be balanced.
* For example, "ab {0} de" and "ab '}' de"
* are valid subformat patterns, but "ab {0'}' de" and
* "ab } de" are not.
*
*
- Warning:
- The rules for using quotes within message
* format patterns unfortunately have shown to be somewhat confusing.
* In particular, it isn't always obvious to localizers whether single
* quotes need to be doubled or not. Make sure to inform localizers about
* the rules, and tell them (for example, by using comments in resource
* bundle source files) which strings will be processed by MessageFormat.
* Note that localizers may need to use single quotes in translated
* strings where the original version doesn't have them.
*
*
* The ArgumentIndex value is a non-negative integer written
* using the digits '0' through '9', and represents an index into the
* arguments array passed to the format methods
* or the result array returned by the parse methods.
*
* The FormatType and FormatStyle values are used to create
* a Format instance for the format element. The following
* table shows how the values map to Format instances. Combinations not
* shown in the table are illegal. A SubformatPattern must
* be a valid pattern string for the Format subclass used.
*
*
*
* Format Type
* Format Style
* Subformat Created
*
* (none)
* (none)
* null
*
* number
* (none)
* NumberFormat.getInstance(getLocale())
*
* integer
* NumberFormat.getIntegerInstance(getLocale())
*
* currency
* NumberFormat.getCurrencyInstance(getLocale())
*
* percent
* NumberFormat.getPercentInstance(getLocale())
*
* SubformatPattern
* new DecimalFormat(subformatPattern, new DecimalFormatSymbols(getLocale()))
*
* date
* (none)
* DateFormat.getDateInstance(DateFormat.DEFAULT, getLocale())
*
* short
* DateFormat.getDateInstance(DateFormat.SHORT, getLocale())
*
* medium
* DateFormat.getDateInstance(DateFormat.DEFAULT, getLocale())
*
* long
* DateFormat.getDateInstance(DateFormat.LONG, getLocale())
*
* full
* DateFormat.getDateInstance(DateFormat.FULL, getLocale())
*
* SubformatPattern
* new SimpleDateFormat(subformatPattern, getLocale())
*
* time
* (none)
* DateFormat.getTimeInstance(DateFormat.DEFAULT, getLocale())
*
* short
* DateFormat.getTimeInstance(DateFormat.SHORT, getLocale())
*
* medium
* DateFormat.getTimeInstance(DateFormat.DEFAULT, getLocale())
*
* long
* DateFormat.getTimeInstance(DateFormat.LONG, getLocale())
*
* full
* DateFormat.getTimeInstance(DateFormat.FULL, getLocale())
*
* SubformatPattern
* new SimpleDateFormat(subformatPattern, getLocale())
*
* choice
* SubformatPattern
* new ChoiceFormat(subformatPattern)
*
*
*
*
Usage Information
*
*
* Here are some examples of usage:
*
*
* Object[] arguments = {
* new Integer(7),
* new Date(System.currentTimeMillis()),
* "a disturbance in the Force"
* };
*
* String result = MessageFormat.format(
* "At {1,time} on {1,date}, there was {2} on planet {0,number,integer}.",
* arguments);
*
* output: At 12:30 PM on Jul 3, 2053, there was a disturbance
* in the Force on planet 7.
*
*
*
* Typically, the message format will come from resources, and the
* arguments will be dynamically set at runtime.
*
*
* Example 2:
*
*
* Object[] testArgs = {new Long(3), "MyDisk"};
*
* MessageFormat form = new MessageFormat(
* "The disk \"{1}\" contains {0} file(s).");
*
* System.out.println(form.format(testArgs));
*
* // output, with different testArgs
* output: The disk "MyDisk" contains 0 file(s).
* output: The disk "MyDisk" contains 1 file(s).
* output: The disk "MyDisk" contains 1,273 file(s).
*
*
*
*
* For more sophisticated patterns, you can use a ChoiceFormat to get
* output such as:
*
*
* MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0}.");
* double[] filelimits = {0,1,2};
* String[] filepart = {"no files","one file","{0,number} files"};
* ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
* form.setFormatByArgumentIndex(0, fileform);
*
* Object[] testArgs = {new Long(12373), "MyDisk"};
*
* System.out.println(form.format(testArgs));
*
* // output, with different testArgs
* output: The disk "MyDisk" contains no files.
* output: The disk "MyDisk" contains one file.
* output: The disk "MyDisk" contains 1,273 files.
*
*
* You can either do this programmatically, as in the above example,
* or by using a pattern (see
* {@link ChoiceFormat}
* for more information) as in:
*
*
* form.applyPattern(
* "There {0,choice,0#are no files|1#is one file|1<are {0,number,integer} files}.");
*
*
*
* Note: As we see above, the string produced
* by a ChoiceFormat in MessageFormat is treated specially;
* occurances of '{' are used to indicated subformats, and cause recursion.
* If you create both a MessageFormat and ChoiceFormat
* programmatically (instead of using the string patterns), then be careful not to
* produce a format that recurses on itself, which will cause an infinite loop.
*
* When a single argument is parsed more than once in the string, the last match
* will be the final result of the parsing. For example,
*
* MessageFormat mf = new MessageFormat("{0,number,#.##}, {0,number,#.#}");
* Object[] objs = {new Double(3.1415)};
* String result = mf.format( objs );
* // result now equals "3.14, 3.1"
* objs = null;
* objs = mf.parse(result, new ParsePosition(0));
* // objs now equals {new Double(3.1)}
*
*
* Likewise, parsing with a MessageFormat object using patterns containing
* multiple occurances of the same argument would return the last match. For
* example,
*
* MessageFormat mf = new MessageFormat("{0}, {0}, {0}");
* String forParsing = "x, y, z";
* Object[] objs = mf.parse(forParsing, new ParsePosition(0));
* // result now equals {new String("z")}
*
*
* Synchronization
*
*
* Message formats are not synchronized.
* It is recommended to create separate format instances for each thread.
* If multiple threads access a format concurrently, it must be synchronized
* externally.
*
* @see java.util.Locale
* @see Format
* @see NumberFormat
* @see DecimalFormat
* @see ChoiceFormat
* @version 1.38, 01/19/00
* @author Mark Davis
*/
public class MessageFormat extends Format
{
private static final long serialVersionUID = 6479157306784022952L;
/**
* The locale to use for formatting numbers and dates.
* @serial
*/
private Locale locale;
/**
* The string that the formatted values are to be plugged into. In other words, this
* is the pattern supplied on construction with all of the {} expressions taken out.
* @serial
*/
private String pattern;
/**
* An array of formatters, which are used to format the arguments.
* @serial
*/
private Format[] formats;
/**
* The positions where the results of formatting each argument are to be inserted
* into the pattern.
* @serial
*/
private int[] offsets;
/**
* The argument numbers corresponding to each formatter. (The formatters are stored
* in the order they occur in the pattern, not in the order in which the arguments
* are specified.)
* @serial
*/
private int[] argumentNumbers;
/**
* One less than the number of entries in offsets. Can also be thought of
* as the index of the highest-numbered element in offsets that is being used.
* All of these arrays should have the same number of elements being used as offsets
* does, and so this variable suffices to tell us how many entries are in all of them.
* @serial
*/
private int maxOffset;
/**
* Constructs a MessageFormat for the default locale and the
* specified pattern.
* The constructor first sets the locale, then parses the pattern and
* creates a list of subformats for the format elements contained in it.
* Patterns and their interpretation are specified in the
* class description.
*
* @param pattern the pattern for this message format
* @exception IllegalArgumentException if the pattern is invalid
*/
public MessageFormat(String pattern) { }
/**
* Constructs a MessageFormat for the specified locale and
* pattern.
* The constructor first sets the locale, then parses the pattern and
* creates a list of subformats for the format elements contained in it.
* Patterns and their interpretation are specified in the
* class description.
*
* @param pattern the pattern for this message format
* @param locale the locale for this message format
* @exception IllegalArgumentException if the pattern is invalid
* @since 1.4
*/
public MessageFormat(String pattern, Locale locale) { }
/**
* Sets the locale to be used when creating or comparing subformats.
* This affects subsequent calls to the {@link #applyPattern applyPattern}
* and {@link #toPattern toPattern} methods as well as to the
* format and
* {@link #formatToCharacterIterator formatToCharacterIterator} methods.
*
* @param locale the locale to be used when creating or comparing subformats
*/
public void setLocale(Locale locale) { }
/**
* Gets the locale that's used when creating or comparing subformats.
*
* @return the locale used when creating or comparing subformats
*/
public Locale getLocale() {
return null;
}
/**
* Sets the pattern used by this message format.
* The method parses the pattern and creates a list of subformats
* for the format elements contained in it.
* Patterns and their interpretation are specified in the
* class description.
*
* @param pattern the pattern for this message format
* @exception IllegalArgumentException if the pattern is invalid
*/
public void applyPattern(String pattern) { }
/**
* Returns a pattern representing the current state of the message format.
* The string is constructed from internal information and therefore
* does not necessarily equal the previously applied pattern.
*
* @return a pattern representing the current state of the message format
*/
public String toPattern() {
return null;
}
/**
* Sets the formats to use for the values passed into
* format methods or returned from parse
* methods. The indices of elements in newFormats
* correspond to the argument indices used in the previously set
* pattern string.
* The order of formats in newFormats thus corresponds to
* the order of elements in the arguments array passed
* to the format methods or the result array returned
* by the parse methods.
*
* If an argument index is used for more than one format element
* in the pattern string, then the corresponding new format is used
* for all such format elements. If an argument index is not used
* for any format element in the pattern string, then the
* corresponding new format is ignored. If fewer formats are provided
* than needed, then only the formats for argument indices less
* than newFormats.length are replaced.
*
* @param newFormats the new formats to use
* @exception NullPointerException if newFormats is null
* @since 1.4
*/
public void setFormatsByArgumentIndex(Format[] newFormats) { }
/**
* Sets the formats to use for the format elements in the
* previously set pattern string.
* The order of formats in newFormats corresponds to
* the order of format elements in the pattern string.
*
* If more formats are provided than needed by the pattern string,
* the remaining ones are ignored. If fewer formats are provided
* than needed, then only the first newFormats.length
* formats are replaced.
*
* Since the order of format elements in a pattern string often
* changes during localization, it is generally better to use the
* {@link #setFormatsByArgumentIndex setFormatsByArgumentIndex}
* method, which assumes an order of formats corresponding to the
* order of elements in the arguments array passed to
* the format methods or the result array returned by
* the parse methods.
*
* @param newFormats the new formats to use
* @exception NullPointerException if newFormats is null
*/
public void setFormats(Format[] newFormats) { }
/**
* Sets the format to use for the format elements within the
* previously set pattern string that use the given argument
* index.
* The argument index is part of the format element definition and
* represents an index into the arguments array passed
* to the format methods or the result array returned
* by the parse methods.
*
* If the argument index is used for more than one format element
* in the pattern string, then the new format is used for all such
* format elements. If the argument index is not used for any format
* element in the pattern string, then the new format is ignored.
*
* @param argumentIndex the argument index for which to use the new format
* @param newFormat the new format to use
* @since 1.4
*/
public void setFormatByArgumentIndex(int argumentIndex, Format newFormat)
{ }
/**
* Sets the format to use for the format element with the given
* format element index within the previously set pattern string.
* The format element index is the zero-based number of the format
* element counting from the start of the pattern string.
*
* Since the order of format elements in a pattern string often
* changes during localization, it is generally better to use the
* {@link #setFormatByArgumentIndex setFormatByArgumentIndex}
* method, which accesses format elements based on the argument
* index they specify.
*
* @param formatElementIndex the index of a format element within the pattern
* @param newFormat the format to use for the specified format element
* @exception ArrayIndexOutOfBoundsException if formatElementIndex is equal to or
* larger than the number of format elements in the pattern string
*/
public void setFormat(int formatElementIndex, Format newFormat) { }
/**
* Gets the formats used for the values passed into
* format methods or returned from parse
* methods. The indices of elements in the returned array
* correspond to the argument indices used in the previously set
* pattern string.
* The order of formats in the returned array thus corresponds to
* the order of elements in the arguments array passed
* to the format methods or the result array returned
* by the parse methods.
*
* If an argument index is used for more than one format element
* in the pattern string, then the format used for the last such
* format element is returned in the array. If an argument index
* is not used for any format element in the pattern string, then
* null is returned in the array.
*
* @return the formats used for the arguments within the pattern
* @since 1.4
*/
public Format[] getFormatsByArgumentIndex() {
return null;
}
/**
* Gets the formats used for the format elements in the
* previously set pattern string.
* The order of formats in the returned array corresponds to
* the order of format elements in the pattern string.
*
* Since the order of format elements in a pattern string often
* changes during localization, it's generally better to use the
* {@link #getFormatsByArgumentIndex getFormatsByArgumentIndex}
* method, which assumes an order of formats corresponding to the
* order of elements in the arguments array passed to
* the format methods or the result array returned by
* the parse methods.
*
* @return the formats used for the format elements in the pattern
*/
public Format[] getFormats() {
return null;
}
/**
* Formats an array of objects and appends the MessageFormat's
* pattern, with format elements replaced by the formatted objects, to the
* provided StringBuffer.
*
* The text substituted for the individual format elements is derived from
* the current subformat of the format element and the
* arguments element at the format element's argument index
* as indicated by the first matching line of the following table. An
* argument is unavailable if arguments is
* null or has fewer than argumentIndex+1 elements.
*
*
*
* Subformat
* Argument
* Formatted Text
*
* any
* unavailable
* "{" + argumentIndex + "}"
*
* any
* null
* "null"
*
* instanceof ChoiceFormat
* any
* subformat.format(argument).indexOf('{') >= 0 ?
* (new MessageFormat(subformat.format(argument), getLocale())).format(argument) :
* subformat.format(argument)
*
* != null
* any
* subformat.format(argument)
*
* null
* instanceof Number
* NumberFormat.getInstance(getLocale()).format(argument)
*
* null
* instanceof Date
* DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, getLocale()).format(argument)
*
* null
* instanceof String
* argument
*
* null
* any
* argument.toString()
*
*
* If pos is non-null, and refers to
* Field.ARGUMENT, the location of the first formatted
* string will be returned.
*
* @param arguments an array of objects to be formatted and substituted.
* @param result where text is appended.
* @param pos On input: an alignment field, if desired.
* On output: the offsets of the alignment field.
* @exception IllegalArgumentException if an argument in the
* arguments array is not of the type
* expected by the format element(s) that use it.
*/
public final StringBuffer format(Object[] arguments, StringBuffer result,
FieldPosition pos)
{
return null;
}
/**
* Creates a MessageFormat with the given pattern and uses it
* to format the given arguments. This is equivalent to
*
* (new {@link #MessageFormat(String) MessageFormat}(pattern)).{@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments, new StringBuffer(), null).toString()
*
*
* @exception IllegalArgumentException if the pattern is invalid,
* or if an argument in the arguments array
* is not of the type expected by the format element(s)
* that use it.
*/
public static String format(String pattern, Object[] arguments) {
return null;
}
/**
* Formats an array of objects and appends the MessageFormat's
* pattern, with format elements replaced by the formatted objects, to the
* provided StringBuffer.
* This is equivalent to
*
* {@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}((Object[]) arguments, result, pos)
*
*
* @param arguments an array of objects to be formatted and substituted.
* @param result where text is appended.
* @param pos On input: an alignment field, if desired.
* On output: the offsets of the alignment field.
* @exception IllegalArgumentException if an argument in the
* arguments array is not of the type
* expected by the format element(s) that use it.
*/
public final StringBuffer format(Object arguments, StringBuffer result,
FieldPosition pos)
{
return null;
}
/**
* Formats an array of objects and inserts them into the
* MessageFormat's pattern, producing an
* AttributedCharacterIterator.
* You can use the returned AttributedCharacterIterator
* to build the resulting String, as well as to determine information
* about the resulting String.
*
* The text of the returned AttributedCharacterIterator is
* the same that would be returned by
*
* {@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments, new StringBuffer(), null).toString()
*
*
* In addition, the AttributedCharacterIterator contains at
* least attributes indicating where text was generated from an
* argument in the arguments array. The keys of these attributes are of
* type MessageFormat.Field, their values are
* Integer objects indicating the index in the arguments
* array of the argument from which the text was generated.
*
* The attributes/value from the underlying Format
* instances that MessageFormat uses will also be
* placed in the resulting AttributedCharacterIterator.
* This allows you to not only find where an argument is placed in the
* resulting String, but also which fields it contains in turn.
*
* @param arguments an array of objects to be formatted and substituted.
* @return AttributedCharacterIterator describing the formatted value.
* @exception NullPointerException if arguments is null.
* @exception IllegalArgumentException if an argument in the
* arguments array is not of the type
* expected by the format element(s) that use it.
* @since 1.4
*/
public AttributedCharacterIterator formatToCharacterIterator(Object
arguments)
{
return null;
}
/**
* Parses the string.
*
*
Caveats: The parse may fail in a number of circumstances.
* For example:
*
* - If one of the arguments does not occur in the pattern.
*
- If the format of an argument loses information, such as
* with a choice format where a large number formats to "many".
*
- Does not yet handle recursion (where
* the substituted strings contain {n} references.)
*
- Will not always find a match (or the correct match)
* if some part of the parse is ambiguous.
* For example, if the pattern "{1},{2}" is used with the
* string arguments {"a,b", "c"}, it will format as "a,b,c".
* When the result is parsed, it will return {"a", "b,c"}.
*
- If a single argument is parsed more than once in the string,
* then the later parse wins.
*
* When the parse fails, use ParsePosition.getErrorIndex() to find out
* where in the string did the parsing failed. The returned error
* index is the starting offset of the sub-patterns that the string
* is comparing with. For example, if the parsing string "AAA {0} BBB"
* is comparing against the pattern "AAD {0} BBB", the error index is
* 0. When an error occurs, the call to this method will return null.
* If the source is null, return an empty array.
*/
public Object[] parse(String source, ParsePosition pos) {
return null;
}
/**
* Parses text from the beginning of the given string to produce an object
* array.
* The method may not use the entire text of the given string.
*
* See the {@link #parse(String, ParsePosition)} method for more information
* on message parsing.
*
* @param source A String whose beginning should be parsed.
* @return An Object array parsed from the string.
* @exception ParseException if the beginning of the specified string
* cannot be parsed.
*/
public Object[] parse(String source) throws ParseException {
return null;
}
/**
* Parses text from a string to produce an object array.
*
* The method attempts to parse text starting at the index given by
* pos.
* If parsing succeeds, then the index of pos is updated
* to the index after the last character used (parsing does not necessarily
* use all characters up to the end of the string), and the parsed
* object array is returned. The updated pos can be used to
* indicate the starting point for the next call to this method.
* If an error occurs, then the index of pos is not
* changed, the error index of pos is set to the index of
* the character where the error occurred, and null is returned.
*
* See the {@link #parse(String, ParsePosition)} method for more information
* on message parsing.
*
* @param source A String, part of which should be parsed.
* @param pos A ParsePosition object with index and error
* index information as described above.
* @return An Object array parsed from the string. In case of
* error, returns null.
* @exception NullPointerException if pos is null.
*/
public Object parseObject(String source, ParsePosition pos) {
return null;
}
/**
* Creates and returns a copy of this object.
*
* @return a clone of this instance.
*/
public Object clone() {
return null;
}
/**
* Equality comparison between two message format objects
*/
public boolean equals(Object obj) {
return false;
}
/**
* Generates a hash code for the message format object.
*/
public int hashCode() {
return 0;
}
/**
* After reading an object from the input stream, do a simple verification
* to maintain class invariants.
* @throws InvalidObjectException if the objects read from the stream is invalid.
*/
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException
{ }
/**
* Defines constants that are used as attribute keys in the
* AttributedCharacterIterator returned
* from MessageFormat.formatToCharacterIterator.
*
* @since 1.4
*/
public static class Field extends Format.Field
{
/**
* Constant identifying a portion of a message that was generated
* from an argument passed into formatToCharacterIterator.
* The value associated with the key will be an Integer
* indicating the index in the arguments array of the
* argument from which the text was generated.
*/
public static final java.text.MessageFormat.Field ARGUMENT = null;
/**
* Creates a Field with the specified name.
*
* @param name Name of the attribute
*/
protected Field(String name) {
super(name);
}
/**
* Resolves instances being deserialized to the predefined constants.
*
* @throws InvalidObjectException if the constant could not be
* resolved.
* @return resolved MessageFormat.Field constant
*/
protected Object readResolve() throws InvalidObjectException {
return null;
}
}
}