/**
  * 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);
  }
Exemple #3
0
 /**
  * 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());
 }
Exemple #6
0
 /**
  * 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);
 }