MessageFormat.java [plain text]
package java.text;
import gnu.java.text.FormatCharacterIterator;
import java.io.InvalidObjectException;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Vector;
public class MessageFormat extends Format
{
private static final class MessageFormatElement
{
int argNumber;
Format setFormat;
Format format;
Class formatClass;
String type;
String style;
String trailer;
void setLocale (Locale loc)
{
if (type == null)
;
else if (type.equals("number"))
{
formatClass = java.lang.Number.class;
if (style == null)
format = NumberFormat.getInstance(loc);
else if (style.equals("currency"))
format = NumberFormat.getCurrencyInstance(loc);
else if (style.equals("percent"))
format = NumberFormat.getPercentInstance(loc);
else if (style.equals("integer"))
{
NumberFormat nf = NumberFormat.getNumberInstance(loc);
nf.setMaximumFractionDigits(0);
nf.setGroupingUsed(false);
format = nf;
}
else
{
format = NumberFormat.getNumberInstance(loc);
DecimalFormat df = (DecimalFormat) format;
df.applyPattern(style);
}
}
else if (type.equals("time") || type.equals("date"))
{
formatClass = java.util.Date.class;
int val = DateFormat.DEFAULT;
boolean styleIsPattern = false;
if (style == null)
;
else if (style.equals("short"))
val = DateFormat.SHORT;
else if (style.equals("medium"))
val = DateFormat.MEDIUM;
else if (style.equals("long"))
val = DateFormat.LONG;
else if (style.equals("full"))
val = DateFormat.FULL;
else
styleIsPattern = true;
if (type.equals("time"))
format = DateFormat.getTimeInstance(val, loc);
else
format = DateFormat.getDateInstance(val, loc);
if (styleIsPattern)
{
SimpleDateFormat sdf = (SimpleDateFormat) format;
sdf.applyPattern(style);
}
}
else if (type.equals("choice"))
{
formatClass = java.lang.Number.class;
if (style == null)
throw new
IllegalArgumentException ("style required for choice format");
format = new ChoiceFormat (style);
}
}
}
private static final long serialVersionUID = 6479157306784022952L;
public static class Field extends Format.Field
{
static final long serialVersionUID = 7899943957617360810L;
public static final MessageFormat.Field ARGUMENT = new MessageFormat.Field("argument");
private Field()
{
super("");
}
protected Field(String s)
{
super(s);
}
protected Object readResolve() throws InvalidObjectException
{
if (getName().equals(ARGUMENT.getName()))
return ARGUMENT;
throw new InvalidObjectException("no such MessageFormat field called " + getName());
}
}
private static int scanString(String pat, int index, StringBuffer buffer)
{
int max = pat.length();
buffer.setLength(0);
boolean quoted = false;
for (; index < max; ++index)
{
char c = pat.charAt(index);
if (quoted)
{
if (c == '\'')
quoted = false;
else
buffer.append(c);
}
else if (c == '\'' && index + 1 < max && pat.charAt(index + 1) == '\'')
{
buffer.append(c);
++index;
}
else if (c == '\'')
{
quoted = true;
}
else if (c == '{')
break;
else
buffer.append(c);
}
return index;
}
private static int scanFormatElement(String pat, int index,
StringBuffer buffer, char term)
{
int max = pat.length();
buffer.setLength(0);
int brace_depth = 1;
boolean quoted = false;
for (; index < max; ++index)
{
char c = pat.charAt(index);
if (quoted)
{
if (c == '\'')
quoted = false;
}
else if (c == '\'' && index + 1 < max
&& pat.charAt(index + 1) == '\'')
{
buffer.append(c);
++index;
}
else if (c == '\'')
quoted = true;
else if (c == '{')
++brace_depth;
else if (c == '}')
{
if (--brace_depth == 0)
break;
}
else if (c == term)
break;
buffer.append(c);
}
return index;
}
private static int scanFormat(String pat, int index, StringBuffer buffer,
Vector elts, Locale locale)
{
MessageFormatElement mfe = new MessageFormatElement ();
elts.addElement(mfe);
int max = pat.length();
++index;
index = scanFormatElement (pat, index, buffer, ',');
try
{
mfe.argNumber = Integer.parseInt(buffer.toString());
}
catch (NumberFormatException nfx)
{
IllegalArgumentException iae = new IllegalArgumentException(pat);
iae.initCause(nfx);
throw iae;
}
if (index < max && pat.charAt(index) == ',')
{
index = scanFormatElement (pat, index + 1, buffer, ',');
mfe.type = buffer.toString();
if (index < max && pat.charAt(index) == ',')
{
index = scanFormatElement (pat, index + 1, buffer, '}');
mfe.style = buffer.toString ();
}
}
if (index >= max || pat.charAt(index) != '}')
throw new IllegalArgumentException("Missing '}' at end of message format");
++index;
index = scanString (pat, index, buffer);
mfe.trailer = buffer.toString ();
mfe.setLocale(locale);
return index;
}
public void applyPattern (String newPattern)
{
pattern = newPattern;
StringBuffer tempBuffer = new StringBuffer ();
int index = scanString (newPattern, 0, tempBuffer);
leader = tempBuffer.toString();
Vector elts = new Vector ();
while (index < newPattern.length())
index = scanFormat (newPattern, index, tempBuffer, elts, locale);
elements = new MessageFormatElement[elts.size()];
elts.copyInto(elements);
}
public Object clone ()
{
MessageFormat c = (MessageFormat) super.clone ();
c.elements = (MessageFormatElement[]) elements.clone ();
return c;
}
public boolean equals (Object obj)
{
if (! (obj instanceof MessageFormat))
return false;
MessageFormat mf = (MessageFormat) obj;
return (pattern.equals(mf.pattern)
&& locale.equals(mf.locale));
}
public AttributedCharacterIterator formatToCharacterIterator (Object arguments)
{
Object[] arguments_array = (Object[])arguments;
FormatCharacterIterator iterator = new FormatCharacterIterator();
formatInternal(arguments_array, new StringBuffer(), null, iterator);
return iterator;
}
public static String format (String pattern, Object arguments[])
{
MessageFormat mf = new MessageFormat (pattern);
StringBuffer sb = new StringBuffer ();
FieldPosition fp = new FieldPosition (NumberFormat.INTEGER_FIELD);
return mf.formatInternal(arguments, sb, fp, null).toString();
}
public final StringBuffer format (Object arguments[], StringBuffer appendBuf,
FieldPosition fp)
{
return formatInternal(arguments, appendBuf, fp, null);
}
private StringBuffer formatInternal (Object arguments[],
StringBuffer appendBuf,
FieldPosition fp,
FormatCharacterIterator output_iterator)
{
appendBuf.append(leader);
if (output_iterator != null)
output_iterator.append(leader);
for (int i = 0; i < elements.length; ++i)
{
Object thisArg = null;
boolean unavailable = false;
if (arguments == null || elements[i].argNumber >= arguments.length)
unavailable = true;
else
thisArg = arguments[elements[i].argNumber];
AttributedCharacterIterator iterator = null;
Format formatter = null;
if (fp != null && i == fp.getField() && fp.getFieldAttribute() == Field.ARGUMENT)
fp.setBeginIndex(appendBuf.length());
if (unavailable)
appendBuf.append("{" + elements[i].argNumber + "}");
else
{
if (elements[i].setFormat != null)
formatter = elements[i].setFormat;
else if (elements[i].format != null)
{
if (elements[i].formatClass != null
&& ! elements[i].formatClass.isInstance(thisArg))
throw new IllegalArgumentException("Wrong format class");
formatter = elements[i].format;
}
else if (thisArg instanceof Number)
formatter = NumberFormat.getInstance(locale);
else if (thisArg instanceof Date)
formatter = DateFormat.getTimeInstance(DateFormat.DEFAULT, locale);
else
appendBuf.append(thisArg);
}
if (fp != null && fp.getField() == i && fp.getFieldAttribute() == Field.ARGUMENT)
fp.setEndIndex(appendBuf.length());
if (formatter != null)
{
if (formatter instanceof ChoiceFormat)
{
StringBuffer buf = new StringBuffer ();
formatter.format(thisArg, buf, fp);
MessageFormat mf = new MessageFormat ();
mf.setLocale(locale);
mf.applyPattern(buf.toString());
mf.format(arguments, appendBuf, fp);
}
else
{
if (output_iterator != null)
iterator = formatter.formatToCharacterIterator(thisArg);
else
formatter.format(thisArg, appendBuf, fp);
}
elements[i].format = formatter;
}
if (output_iterator != null)
{
HashMap hash_argument = new HashMap();
int position = output_iterator.getEndIndex();
hash_argument.put (MessageFormat.Field.ARGUMENT,
new Integer(elements[i].argNumber));
if (iterator != null)
{
output_iterator.append(iterator);
output_iterator.addAttributes(hash_argument, position,
output_iterator.getEndIndex());
}
else
output_iterator.append(thisArg.toString(), hash_argument);
output_iterator.append(elements[i].trailer);
}
appendBuf.append(elements[i].trailer);
}
return appendBuf;
}
public final StringBuffer format (Object objectArray, StringBuffer appendBuf,
FieldPosition fpos)
{
return format ((Object[])objectArray, appendBuf, fpos);
}
public Format[] getFormats ()
{
Format[] f = new Format[elements.length];
for (int i = elements.length - 1; i >= 0; --i)
f[i] = elements[i].setFormat;
return f;
}
public Locale getLocale ()
{
return locale;
}
public int hashCode ()
{
return pattern.hashCode() + locale.hashCode();
}
private MessageFormat ()
{
}
public MessageFormat(String pattern)
{
this(pattern, Locale.getDefault());
}
public MessageFormat(String pattern, Locale locale)
{
this.locale = locale;
applyPattern (pattern);
}
public Object[] parse (String sourceStr, ParsePosition pos)
{
int index = pos.getIndex();
if (! sourceStr.startsWith(leader, index))
{
pos.setErrorIndex(index);
return null;
}
index += leader.length();
Vector results = new Vector (elements.length, 1);
for (int i = 0; i < elements.length; ++i)
{
Format formatter = null;
if (elements[i].setFormat != null)
formatter = elements[i].setFormat;
else if (elements[i].format != null)
formatter = elements[i].format;
Object value = null;
if (formatter instanceof ChoiceFormat)
{
ChoiceFormat cf = (ChoiceFormat) formatter;
String[] formats = (String[]) cf.getFormats();
double[] limits = (double[]) cf.getLimits();
MessageFormat subfmt = new MessageFormat ();
subfmt.setLocale(locale);
ParsePosition subpos = new ParsePosition (index);
int j;
for (j = 0; value == null && j < limits.length; ++j)
{
subfmt.applyPattern(formats[j]);
subpos.setIndex(index);
value = subfmt.parse(sourceStr, subpos);
}
if (value != null)
{
index = subpos.getIndex();
value = new Double (limits[j]);
}
}
else if (formatter != null)
{
pos.setIndex(index);
value = formatter.parseObject(sourceStr, pos);
if (value != null)
index = pos.getIndex();
}
else
{
int next_index = sourceStr.indexOf(elements[i].trailer, index);
if (next_index == -1)
{
pos.setErrorIndex(index);
return null;
}
value = sourceStr.substring(index, next_index);
index = next_index;
}
if (value == null
|| ! sourceStr.startsWith(elements[i].trailer, index))
{
pos.setErrorIndex(index);
return null;
}
if (elements[i].argNumber >= results.size())
results.setSize(elements[i].argNumber + 1);
results.setElementAt(value, elements[i].argNumber);
index += elements[i].trailer.length();
}
Object[] r = new Object[results.size()];
results.copyInto(r);
return r;
}
public Object[] parse (String sourceStr) throws ParseException
{
ParsePosition pp = new ParsePosition (0);
Object[] r = parse (sourceStr, pp);
if (r == null)
throw new ParseException ("couldn't parse string", pp.getErrorIndex());
return r;
}
public Object parseObject (String sourceStr, ParsePosition pos)
{
return parse (sourceStr, pos);
}
public void setFormat (int variableNum, Format newFormat)
{
elements[variableNum].setFormat = newFormat;
}
public void setFormats (Format[] newFormats)
{
if (newFormats.length < elements.length)
throw new IllegalArgumentException("Not enough format objects");
int len = Math.min(newFormats.length, elements.length);
for (int i = 0; i < len; ++i)
elements[i].setFormat = newFormats[i];
}
public void setLocale (Locale loc)
{
locale = loc;
if (elements != null)
{
for (int i = 0; i < elements.length; ++i)
elements[i].setLocale(loc);
}
}
public String toPattern ()
{
return pattern;
}
public Format[] getFormatsByArgumentIndex()
{
int argNumMax = 0;
for (int i=0;i<elements.length;i++)
if (elements[i].argNumber > argNumMax)
argNumMax = elements[i].argNumber;
Format[] formats = new Format[argNumMax];
for (int i=0;i<elements.length;i++)
{
if (elements[i].setFormat != null)
formats[elements[i].argNumber] = elements[i].setFormat;
else if (elements[i].format != null)
formats[elements[i].argNumber] = elements[i].format;
}
return formats;
}
public void setFormatByArgumentIndex(int argumentIndex,
Format newFormat)
{
for (int i=0;i<elements.length;i++)
{
if (elements[i].argNumber == argumentIndex)
elements[i].setFormat = newFormat;
}
}
public void setFormatsByArgumentIndex(Format[] newFormats)
{
for (int i=0;i<newFormats.length;i++)
{
setFormatByArgumentIndex(i, newFormats[i]);
}
}
private String pattern;
private Locale locale;
private MessageFormatElement[] elements;
private String leader;
}