/** * Replace MessageFormat(String, Locale) constructor (not available until JDK 1.4). * * @param pattern string * @param locale Locale * @return MessageFormat */ private MessageFormat createMessageFormat(final String pattern, final Locale locale) { final MessageFormat result = new MessageFormat(pattern); if (locale != null) { result.setLocale(locale); result.applyPattern(pattern); } return result; }
@Override protected String format(Locale locale, String message) { MessageFormat formatter = new MessageFormat(message); formatter.setLocale(locale); Object[] args = new Object[] {identity}; return formatter.format(args); }
/** * adds arbitrary number of data items to a log file * * @param level defines the log that will data * @param resourceID is used to load a string from a resource bundle * @param obj Array of data items to be logged */ public static void add(int level, String resourceID, Object[] obj) { if (logLevel >= level) { MessageFormat mf = new MessageFormat(I18N.loadString(resourceID)); mf.setLocale(I18N.locale); for (int i = 0; i < obj.length; i++) { obj[i] = obj[i].toString(); } addInfo(mf.format(obj)); } }
/** * Get a string from the underlying resource bundle and format it with the given set of arguments. * * @param key * @param args */ public String getString(final String key, final Object... args) { String value = getString(key); if (value == null) { value = key; } MessageFormat mf = new MessageFormat(value); mf.setLocale(locale); return mf.format(args, new StringBuffer(), null).toString(); }
@TestTargetNew( level = TestLevel.COMPLETE, method = "applyPattern", args = {java.lang.String.class}) public void test_applyPatternLjava_lang_String_AndroidFailure() { MessageFormat format = new MessageFormat("test"); format.setLocale(Locale.FRENCH); // use French since English has the // same LONG and FULL time patterns format.applyPattern("{0,time, Full}"); assertEquals("Wrong full time pattern", "{0,time,full}", format.toPattern()); }
/** * Get the message bundle and get the value according to the key and then format it all of this * using the dynamic Locale. * * @param key the identifying key for the message * @param classLoader, the classloader used to look for the basename resource. * @param baseName, used to create the underlying resource bundle, see {@link * ResourceBundle#getBundle(String)} * @param arguments, used for the formatting the return message using the {@link * java.text.MessageFormat} * @return the formatted message, never null * @exception MissingResourceException if not message was found with the key. */ protected String getFormattedMessage( String key, ClassLoader classLoader, String baseName, Object... arguments) throws MissingResourceException { Locale locale = getLocale(); ResourceBundle bundle = ResourceBundle.getBundle(baseName, locale, classLoader); String bundleValue = bundle.getString(key); // format it now formatter.setLocale(locale); formatter.applyPattern(bundleValue); return formatter.format(arguments); }
/** * ** Gets the Localized value for the specified key. The default String text is return if ** the * specified key does not exist ** @param key The LocalStrings key ** @param dft The default * String text to return if the LocalStrings key does not exist ** @param args An array of * replacement fields ** @return The Localized String text */ public String getString(String key, String dft, Object args[]) { String val = this.getString(key, dft); if ((args != null) && (args.length > 0) && (val != null)) { try { MessageFormat mf = new MessageFormat(val); mf.setLocale(this.locale); StringBuffer sb = mf.format(args, new StringBuffer(), null); return I18N.decodeNewLine(sb).toString(); } catch (Throwable th) { Print.logInfo("Exception: " + key + " ==> " + val); } } return I18N.decodeNewLine(val); }
private String getFormattedString(String msgtext, Object[] params) { String localizedStr = null; if (params == null || msgtext == null) { return msgtext; } StringBuffer b = new StringBuffer(100); MessageFormat mf = new MessageFormat(msgtext); if (locale != null) { mf.setLocale(locale); b.append(mf.format(params)); localizedStr = b.toString(); } return localizedStr; }
/** @tests java.text.MessageFormat#setLocale(java.util.Locale) */ @TestTargetNew( level = TestLevel.COMPLETE, notes = "", method = "setLocale", args = {java.util.Locale.class}) public void test_setLocaleLjava_util_Locale() { // Test for method void // java.text.MessageFormat.setLocale(java.util.Locale) MessageFormat format = new MessageFormat("date {0,date}"); format.setLocale(Locale.CHINA); assertEquals("Wrong locale1", Locale.CHINA, format.getLocale()); format.applyPattern("{1,date}"); assertEquals( "Wrong locale3", DateFormat.getDateInstance(DateFormat.DEFAULT, Locale.CHINA), format.getFormats()[0]); }
static SQLException createSQLException( Locale msgLocale, String messageId, Object[] messageArguments) { Locale currentLocale; int sqlcode; if (msgLocale == null) currentLocale = Locale.getDefault(); else currentLocale = msgLocale; try { PropertyResourceBundle messageBundle = (PropertyResourceBundle) ResourceBundle.getBundle( "SQLMXT2Messages", currentLocale); // R321 changed property file name to // SQLMXT2Messages_en.properties MessageFormat formatter = new MessageFormat(""); formatter.setLocale(currentLocale); formatter.applyPattern(messageBundle.getString(messageId + "_msg")); String message = formatter.format(messageArguments); String sqlState = messageBundle.getString(messageId + "_sqlstate"); String sqlcodeStr = messageBundle.getString(messageId + "_sqlcode"); if (sqlcodeStr != null) { try { sqlcode = Integer.parseInt(sqlcodeStr); sqlcode = -sqlcode; } catch (NumberFormatException e1) { sqlcode = -1; } } else sqlcode = -1; return new SQLException(message, sqlState, sqlcode); } catch (MissingResourceException e) { // If the resource bundle is not found, concatenate the messageId and the parameters String message; int i = 0; message = "The message id: " + messageId; if (messageArguments != null) { message = message.concat(" With parameters: "); while (true) { message = message.concat(messageArguments[i++].toString()); if (i >= messageArguments.length) break; else message = message.concat(","); } } return new SQLException(message, "HY000", -1); } }
public JasperPrintLP getReport(String sDrucktype) throws Throwable { WochenabschlussReportDto wochenabschlussReportDto = null; wochenabschlussReportDto = DelegateFactory.getInstance() .getZeiterfassungDelegate() .printWochenabschluss( internalFrameZeiterfassung.getPersonalDto().getIId(), wdfKW.getTimestamp()); wbuZeitenAbschliessen.setToolTipText(""); if (wochenabschlussReportDto.isBFehlerVorhanden() == false) { java.sql.Timestamp tLetzterAbschluss = DelegateFactory.getInstance() .getZeiterfassungDelegate() .gibtEsBereitseinenZeitabschlussBisZurKW( internalFrameZeiterfassung.getPersonalDto().getIId(), wdfKW.getTimestamp()); if (tLetzterAbschluss != null) { wbuZeitenAbschliessen.setEnabled(false); MessageFormat mf = new MessageFormat( LPMain.getTextRespectUISPr("pers.wochenabschluss.fehler.zeitabschlussvorhanden")); mf.setLocale(LPMain.getTheClient().getLocUi()); Object pattern[] = { Helper.formatDatum(tLetzterAbschluss, LPMain.getTheClient().getLocUi()) }; String sMsg = mf.format(pattern); wbuZeitenAbschliessen.setToolTipText(sMsg); } else { wbuZeitenAbschliessen.setEnabled(true); } } else { wbuZeitenAbschliessen.setEnabled(false); wbuZeitenAbschliessen.setToolTipText( LPMain.getTextRespectUISPr("pers.wochenabschluss.fehler.vorhanden")); } return wochenabschlussReportDto.getJasperPrintLP(); }
/** * @tests java.text.MessageFormat#getLocale() Test of method java.text.MessageFormat#getLocale(). */ @TestTargetNew( level = TestLevel.COMPLETE, notes = "", method = "getLocale", args = {}) public void test_getLocale() { try { Locale[] l = { Locale.FRANCE, Locale.KOREA, new Locale(Locale.FRANCE.getCountry(), Locale.FRANCE.getLanguage()), new Locale("mk"), new Locale("mk", "MK"), Locale.US, new Locale("#ru", "@31230") }; String pattern = "getLocale test {0,number,#,####}"; MessageFormat mf; for (int i = 0; i < 0; i++) { mf = new MessageFormat(pattern, l[i]); Locale result = mf.getLocale(); assertEquals("Returned local: " + result + " instead of " + l[i], l[i], result); assertEquals( "Returned language: " + result.getLanguage() + " instead of " + l[i].getLanguage(), l[i].getLanguage(), result.getLanguage()); assertEquals( "Returned country: " + result.getCountry() + " instead of " + l[i].getCountry(), l[i].getCountry(), result.getCountry()); } mf = new MessageFormat(pattern); mf.setLocale(null); Locale result = mf.getLocale(); assertEquals("Returned local: " + result + " instead of null", null, result); } catch (Exception e) { fail("unexpected exception " + e.toString()); } }
private MessageFormat getMessageFormat(String pattern) { MessageFormat messageFormat = new MessageFormat(""); messageFormat.setLocale((Locale) locale.getValue()); messageFormat.applyPattern(pattern); return messageFormat; }
/** * Parse a string <code>sourceStr</code> against the pattern specified to the MessageFormat * constructor. * * @param sourceStr the string to be parsed. * @param pos the current parse position (and eventually the error position). * @return the array of parsed objects sorted according to their argument number in the pattern. */ public Object[] parse(String sourceStr, ParsePosition pos) { // Check initial text. int index = pos.getIndex(); if (!sourceStr.startsWith(leader, index)) { pos.setErrorIndex(index); return null; } index += leader.length(); Vector results = new Vector(elements.length, 1); // Now check each format. 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) { // We must special-case a ChoiceFormat because it might // have recursive formatting. 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 { // We have a String format. This can lose in a number // of ways, but we give it a shot. 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; }
/** @tests java.text.MessageFormat#applyPattern(java.lang.String) */ @TestTargetNew( level = TestLevel.COMPLETE, method = "applyPattern", args = {java.lang.String.class}) public void test_applyPatternLjava_lang_String() { // Test for method void // java.text.MessageFormat.applyPattern(java.lang.String) MessageFormat format = new MessageFormat("test"); format.applyPattern("xx {0}"); assertEquals("Invalid number", "xx 46", format.format(new Object[] {new Integer(46)})); Date date = new Date(); String result = format.format(new Object[] {date}); String expected = "xx " + DateFormat.getInstance().format(date); assertTrue("Invalid date:\n" + result + "\n" + expected, result.equals(expected)); format = new MessageFormat("{0,date}{1,time}{2,number,integer}"); format.applyPattern("nothing"); assertEquals("Found formats", "nothing", format.toPattern()); format.applyPattern("{0}"); assertNull("Wrong format", format.getFormats()[0]); assertEquals("Wrong pattern", "{0}", format.toPattern()); format.applyPattern("{0, \t\u001ftime }"); assertTrue("Wrong time format", format.getFormats()[0].equals(DateFormat.getTimeInstance())); assertEquals("Wrong time pattern", "{0,time}", format.toPattern()); format.applyPattern("{0,Time, Short\n}"); assertTrue( "Wrong short time format", format.getFormats()[0].equals(DateFormat.getTimeInstance(DateFormat.SHORT))); assertEquals("Wrong short time pattern", "{0,time,short}", format.toPattern()); format.applyPattern("{0,TIME,\nmedium }"); assertTrue( "Wrong medium time format", format.getFormats()[0].equals(DateFormat.getTimeInstance(DateFormat.MEDIUM))); assertEquals("Wrong medium time pattern", "{0,time}", format.toPattern()); format.applyPattern("{0,time,LONG}"); assertTrue( "Wrong long time format", format.getFormats()[0].equals(DateFormat.getTimeInstance(DateFormat.LONG))); assertEquals("Wrong long time pattern", "{0,time,long}", format.toPattern()); format.setLocale(Locale.FRENCH); // use French since English has the // same LONG and FULL time patterns format.applyPattern("{0,time, Full}"); assertTrue( "Wrong full time format", format.getFormats()[0].equals(DateFormat.getTimeInstance(DateFormat.FULL, Locale.FRENCH))); // Outsourced to _AndroidFailure: // // assertEquals("Wrong full time pattern", "{0,time,full}", format // .toPattern()); format.setLocale(Locale.getDefault()); format.applyPattern("{0, date}"); assertTrue("Wrong date format", format.getFormats()[0].equals(DateFormat.getDateInstance())); assertEquals("Wrong date pattern", "{0,date}", format.toPattern()); format.applyPattern("{0, date, short}"); assertTrue( "Wrong short date format", format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.SHORT))); assertEquals("Wrong short date pattern", "{0,date,short}", format.toPattern()); format.applyPattern("{0, date, medium}"); assertTrue( "Wrong medium date format", format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.MEDIUM))); assertEquals("Wrong medium date pattern", "{0,date}", format.toPattern()); format.applyPattern("{0, date, long}"); assertTrue( "Wrong long date format", format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.LONG))); assertEquals("Wrong long date pattern", "{0,date,long}", format.toPattern()); format.applyPattern("{0, date, full}"); assertTrue( "Wrong full date format", format.getFormats()[0].equals(DateFormat.getDateInstance(DateFormat.FULL))); assertEquals("Wrong full date pattern", "{0,date,full}", format.toPattern()); format.applyPattern("{0, date, MMM d {hh:mm:ss}}"); assertEquals( "Wrong time/date format", " MMM d {hh:mm:ss}", ((SimpleDateFormat) (format.getFormats()[0])).toPattern()); assertEquals("Wrong time/date pattern", "{0,date, MMM d {hh:mm:ss}}", format.toPattern()); format.applyPattern("{0, number}"); assertTrue( "Wrong number format", format.getFormats()[0].equals(NumberFormat.getNumberInstance())); assertEquals("Wrong number pattern", "{0,number}", format.toPattern()); format.applyPattern("{0, number, currency}"); assertTrue( "Wrong currency number format", format.getFormats()[0].equals(NumberFormat.getCurrencyInstance())); assertEquals("Wrong currency number pattern", "{0,number,currency}", format.toPattern()); format.applyPattern("{0, number, percent}"); assertTrue( "Wrong percent number format", format.getFormats()[0].equals(NumberFormat.getPercentInstance())); assertEquals("Wrong percent number pattern", "{0,number,percent}", format.toPattern()); format.applyPattern("{0, number, integer}"); NumberFormat nf = NumberFormat.getInstance(); nf.setMaximumFractionDigits(0); nf.setParseIntegerOnly(true); assertTrue("Wrong integer number format", format.getFormats()[0].equals(nf)); assertEquals("Wrong integer number pattern", "{0,number,integer}", format.toPattern()); format.applyPattern("{0, number, {'#'}##0.0E0}"); /* * TODO validate these assertions String actual = * ((DecimalFormat)(format.getFormats()[0])).toPattern(); * assertEquals("Wrong pattern number format", "' {#}'##0.0E0", actual); * assertEquals("Wrong pattern number pattern", "{0,number,' * {#}'##0.0E0}", format.toPattern()); * */ format.applyPattern("{0, choice,0#no|1#one|2#{1,number}}"); assertEquals( "Wrong choice format", "0.0#no|1.0#one|2.0#{1,number}", ((ChoiceFormat) format.getFormats()[0]).toPattern()); assertEquals( "Wrong choice pattern", "{0,choice,0.0#no|1.0#one|2.0#{1,number}}", format.toPattern()); assertEquals( "Wrong formatted choice", "3.6", format.format(new Object[] {new Integer(2), new Float(3.6)})); try { format.applyPattern("WRONG MESSAGE FORMAT {0,number,{}"); fail("Expected IllegalArgumentException for invalid pattern"); } catch (IllegalArgumentException e) { } // Regression for HARMONY-65 MessageFormat mf = new MessageFormat("{0,number,integer}"); String badpattern = "{0,number,#"; try { mf.applyPattern(badpattern); fail("Assert 0: Failed to detect unmatched brackets."); } catch (IllegalArgumentException e) { // expected } }
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) { // Special-case ChoiceFormat. 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; }
/** * Sets the locale to be used when creating or comparing subformats. This affects subsequent calls * * <ul> * <li>to the {@link #applyPattern applyPattern} and methods if format elements specify a format * type and therefore have the subformats created in the <code>applyPattern</code> method, * as well as * <li>to the <code>format</code> and {@link #formatToCharacterIterator * formatToCharacterIterator} methods if format elements do not specify a format type and * therefore have the subformats created in the formatting methods. * </ul> * * Subformats that have already been created are not affected. * * @param locale the locale to be used when creating or comparing subformats */ public void setLocale(Locale locale) { inner.setLocale(locale); }
/** * 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 <a * href="#patterns">class description</a>. * * @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 BeanMessageFormat(String pattern, Locale locale) { this(pattern); inner.setLocale(locale); }