2281

Committed 09 Feb 2025 03:47PM UTC coverage: 71.134% (+0.2%) from 70.912%

Build # 2281

Build Type

push

circleci

Committed by

keilw

Commit Message

LocalUnitFormat incorrecly formating mass units #434

https://github.com/unitsofmeasurement/indriya/issues/434

Coverage Stats

5 of 6 new or added lines in 1 file covered. (83.33%)

3721 of 5231 relevant lines covered (71.13%)

0.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.11

/src/main/java/tech/units/indriya/format/LocalUnitFormat.java

/*
 * Units of Measurement Reference Implementation
 * Copyright (c) 2005-2025, Jean-Marie Dautelle, Werner Keil, Otavio Santana.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
 *    and the following disclaimer in the documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of JSR-385, Indriya nor the names of their contributors may be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package tech.units.indriya.format;

import static tech.units.indriya.format.ConverterFormatter.formatConverterLocal;
import static tech.units.indriya.format.FormatConstants.*;

import javax.measure.Quantity;
import javax.measure.Unit;
import javax.measure.UnitConverter;
import javax.measure.format.MeasurementParseException;
import tech.units.indriya.AbstractUnit;
import tech.units.indriya.internal.format.UnitFormatParser;
import tech.units.indriya.unit.AlternateUnit;
import tech.units.indriya.unit.AnnotatedUnit;
import tech.units.indriya.unit.BaseUnit;
import tech.units.indriya.unit.ProductUnit;
import tech.units.indriya.unit.TransformedUnit;

import static tech.units.indriya.unit.Units.CUBIC_METRE;
import static tech.units.indriya.unit.Units.GRAM;
import static tech.units.indriya.unit.Units.KILOGRAM;
import static tech.units.indriya.unit.Units.LITRE;

import java.io.IOException;
import java.io.StringReader;
import java.text.ParsePosition;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;

/**
 * <p>
 * This class represents the locale sensitive format.
 * </p>
 *
 * <h3>Here is the grammar for CommonUnits in Extended Backus-Naur Form (EBNF)</h3>
 * <p>
 * Note that the grammar has been left-factored to be suitable for use by a top-down parser generator such as <a
 * href="https://javacc.dev.java.net/">JavaCC</a>
 * </p>
 * <table * align="center">
 * <tr>
 * <th colspan="3" align="left">Lexical Entities:</th>
 * </tr>
 * <tr valign="top">
 * <td>&lt;sign&gt;</td>
 * <td>:=</td>
 * <td>"+" | "-"</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;digit&gt;</td>
 * <td>:=</td>
 * <td>"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;superscript_digit&gt;</td>
 * <td>:=</td>
 * <td>"⁰" | "¹" | "²" | "³" | "⁴" | "⁵" | "⁶" | "⁷" | "⁸" | "⁹"</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;integer&gt;</td>
 * <td>:=</td>
 * <td>(&lt;digit&gt;)+</td>
 * </tr>
 * <tr * valign="top">
 * <td>&lt;number&gt;</td>
 * <td>:=</td>
 * <td>(&lt;sign&gt;)? (&lt;digit&gt;)* (".")? (&lt;digit&gt;)+ (("e" | "E") (&lt;sign&gt;)? (&lt;digit&gt;)+)?</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;exponent&gt;</td>
 * <td>:=</td>
 * <td>( "^" ( &lt;sign&gt; )? &lt;integer&gt; ) <br>
 * | ( "^(" (&lt;sign&gt;)? &lt;integer&gt; ( "/" (&lt;sign&gt;)? &lt;integer&gt; )? ")" ) <br>
 * | ( &lt;superscript_digit&gt; )+</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;initial_char&gt;</td>
 * <td>:=</td>
 * <td>? Any Unicode character excluding the following: ASCII control & whitespace (&#92;u0000 - &#92;u0020), decimal digits '0'-'9', '('
 * (&#92;u0028), ')' (&#92;u0029), '*' (&#92;u002A), '+' (&#92;u002B), '-' (&#92;u002D), '.' (&#92;u002E), '/' (&#92;u005C), ':' (&#92;u003A), '^'
 * (&#92;u005E), '²' (&#92;u00B2), '³' (&#92;u00B3), '·' (&#92;u00B7), '¹' (&#92;u00B9), '⁰' (&#92;u2070), '⁴' (&#92;u2074), '⁵' (&#92;u2075), '⁶'
 * (&#92;u2076), '⁷' (&#92;u2077), '⁸' (&#92;u2078), '⁹' (&#92;u2079) ?</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;unit_identifier&gt;</td>
 * <td>:=</td>
 * <td>&lt;initial_char&gt; ( &lt;initial_char&gt; | &lt;digit&gt; )*</td>
 * </tr>
 * <tr>
 * <th colspan="3" align="left">Non-Terminals:</th>
 * </tr>
 * <tr * valign="top">
 * <td>&lt;unit_expr&gt;</td>
 * <td>:=</td>
 * <td>&lt;mix_expr&gt;</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;mix_expr&gt;</td>
 * <td>:=</td>
 * <td>&lt;add_expr&gt; ( ":" &lt;add_expr&gt; )*</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;add_expr&gt;</td>
 * <td>:=</td>
 * <td>( &lt;number&gt; &lt;sign&gt; )? &lt;mul_expr&gt; ( &lt;sign&gt; &lt;number&gt; )?</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;mul_expr&gt;</td>
 * <td>:=</td>
 * <td>&lt;exponent_expr&gt; ( ( ( "*" | "·" ) &lt;exponent_expr&gt; ) | ( "/" &lt;exponent_expr&gt; ) )*</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;exponent_expr&gt;</td>
 * <td>:=</td>
 * <td>( &lt;atomic_expr&gt; ( &lt;exponent&gt; )? ) <br>
 * | (&lt;integer&gt; "^" &lt;atomic_expr&gt;) <br>
 * | ( ( "log" ( &lt;integer&gt; )? ) | "ln" ) "(" &lt;add_expr&gt; ")" )</td>
 * </tr>
 * <tr valign="top">
 * <td>&lt;atomic_expr&gt;</td>
 * <td>:=</td>
 * <td>&lt;number&gt; <br>
 * | &lt;unit_identifier&gt; <br>
 * | ( "(" &lt;add_expr&gt; ")" )</td>
 * </tr>
 * </table>
 *
 * @author <a href="mailto:eric-r@northwestern.edu">Eric Russell</a>
 * @author <a href="mailto:werner@units.tech">Werner Keil</a>
 * @version 1.7, February 9, 2025
 * @since 1.0
 */
public class LocalUnitFormat extends AbstractUnitFormat {

  //////////////////////////////////////////////////////
  // Class variables                                  //
  //////////////////////////////////////////////////////
  /**
   * DefaultQuantityFactory locale instance. If the default locale is changed after the class is initialized, this instance will no longer be used.
   */
  private static final LocalUnitFormat DEFAULT_INSTANCE = new LocalUnitFormat(SymbolMap.of(ResourceBundle.getBundle(LocalUnitFormat.class
      .getPackage().getName() + ".messages")));

  // /////////////////
  // Class methods //
  // /////////////////
  /**
   * Returns the instance for the current default locale (non-ascii characters are allowed)
   */
  public static LocalUnitFormat getInstance() {
    return DEFAULT_INSTANCE;
  }

  /**
   * Returns an instance for the given locale.
   * 
   * @param locale the locale to use
   */
  public static LocalUnitFormat getInstance(Locale locale) {
    return new LocalUnitFormat(SymbolMap.of(ResourceBundle.getBundle(LocalUnitFormat.class.getPackage().getName() + ".messages", locale)));
  }

  /** Returns an instance for the given symbol map. */
  public static LocalUnitFormat getInstance(SymbolMap symbols) {
    return new LocalUnitFormat(symbols);
  }

  // //////////////////////
  // Instance variables //
  // //////////////////////
  /**
   * The symbol map used by this instance to map between {@link Unit Unit}s and <code>String</code>s, etc...
   */
  private final transient SymbolMap symbolMap;

  // ////////////////
  // Constructors //
  // ////////////////
  /**
   * Base constructor.
   *
   * @param symbols
   *          the symbol mapping.
   */
  private LocalUnitFormat(SymbolMap symbols) {
    symbolMap = symbols;
  }

  ////////////////////////
  // Instance methods //
  ////////////////////////
  /**
   * Get the symbol map used by this instance to map between {@link AbstractUnit Unit}s and <code>String</code>s, etc...
   * 
   * @return SymbolMap the current symbol map
   */
  protected SymbolMap getSymbols() {
    return symbolMap;
  }
  
  @Override
  public String toString() {
    return getClass().getSimpleName();
  }

  ////////////////
  // Formatting //
  ////////////////
  @Override
  public Appendable format(Unit<?> unit, Appendable appendable) throws IOException {
    if (!(unit instanceof AbstractUnit)) {
      return appendable.append(unit.toString()); // Unknown unit (use
      // intrinsic toString()
      // method)
    }
    formatInternal(unit, appendable);
    return appendable;
  }

  public boolean isLocaleSensitive() {
    return true;
  }

  protected Unit<?> parse(CharSequence csq, int index) throws MeasurementParseException {
    return parse(csq, new ParsePosition(index));
  }

  public Unit<?> parse(CharSequence csq, ParsePosition cursor) throws MeasurementParseException {
    // Parsing reads the whole character sequence from the parse position.
    int start = cursor.getIndex();
    int end = csq.length();
    if (end <= start) {
      return AbstractUnit.ONE;
    }
    String source = csq.subSequence(start, end).toString().trim();
    if (source.length() == 0) {
      return AbstractUnit.ONE;
    }
    try {
      UnitFormatParser parser = new UnitFormatParser(symbolMap, new StringReader(source));
      Unit<?> result = parser.parseUnit();
      cursor.setIndex(end);
      return result;
    } catch (TokenException e) {
      if (e.currentToken != null) {
        cursor.setErrorIndex(start + e.currentToken.endColumn);
      } else {
        cursor.setErrorIndex(start);
      }
      throw new IllegalArgumentException(e); // TODO should we throw
      // ParserException here,
      // too?
    } catch (TokenMgrError e) {
      cursor.setErrorIndex(start);
      throw new MeasurementParseException(e);
    }
  }

  @Override
  public Unit<? extends Quantity<?>> parse(CharSequence csq) throws MeasurementParseException {
    return parse(csq, new ParsePosition(0));
  }

  /**
   * Format the given unit to the given StringBuilder, then return the operator precedence of the outermost operator in the unit expression that was
   * formatted. See {@link ConverterFormat} for the constants that define the various precedence values.
   * 
   * @param unit
   *          the unit to be formatted
   * @param buffer
   *          the <code>StringBuilder</code> to be written to
   * @return the operator precedence of the outermost operator in the unit expression that was output
   */
  @SuppressWarnings({ "rawtypes", "unchecked" })
  private int formatInternal(Unit<?> unit, Appendable buffer) throws IOException {
    if (unit instanceof AnnotatedUnit<?>) {
      unit = ((AnnotatedUnit<?>) unit).getActualUnit();
      // } else if (unit instanceof ProductUnit<?>) {
      // ProductUnit<?> p = (ProductUnit<?>)unit;
    }
    // TODO is the behavior similar to EBNFUnitFormat for AnnotatedUnit?
    String symbol = symbolMap.getSymbol((AbstractUnit<?>) unit);
    if (symbol != null) {
      buffer.append(symbol);
      return NOOP_PRECEDENCE;
    } else if (unit instanceof ProductUnit<?> && unit.getBaseUnits() != null) {
      Map<Unit<?>, Integer> productUnits = (Map<Unit<?>, Integer>) unit.getBaseUnits();
      int negativeExponentCount = 0;
      // Write positive exponents first...
      boolean start = true;
      for (Map.Entry<Unit<?>, Integer> e : productUnits.entrySet()) {
        int pow = e.getValue();
        if (pow >= 0) {
          formatExponent(e.getKey(), pow, 1, !start, buffer);
          start = false;
        } else {
          negativeExponentCount += 1;
        }
      }
      // ..then write negative exponents.
      if (negativeExponentCount > 0) {
        if (start) {
          buffer.append('1');
        }
        buffer.append('/');
        if (negativeExponentCount > 1) {
          buffer.append('(');
        }
        start = true;
        for (Map.Entry<Unit<?>, Integer> e : productUnits.entrySet()) {
          int pow = e.getValue();
          if (pow < 0) {
            formatExponent(e.getKey(), -pow, 1, !start, buffer);
            start = false;
          }
        }
        if (negativeExponentCount > 1) {
          buffer.append(')');
        }
      }
      return PRODUCT_PRECEDENCE;
    } else if (unit instanceof BaseUnit<?>) {
      buffer.append(((BaseUnit<?>) unit).getSymbol());
      return NOOP_PRECEDENCE;
    } else if (unit instanceof AlternateUnit<?>) { // unit.getSymbol() !=
      // null) { // Alternate
      // unit.
      buffer.append(unit.getSymbol());
      return NOOP_PRECEDENCE;
    } else { // A transformed unit or new unit type!
      UnitConverter converter = null;
      boolean printSeparator = false;
      StringBuilder temp = new StringBuilder();
      int unitPrecedence = NOOP_PRECEDENCE;
      Unit<?> parentUnit = unit.getSystemUnit();
      converter = ((AbstractUnit<?>) unit).getSystemConverter();
      if (KILOGRAM.equals(parentUnit)) {
        // More special-case hackery to work around gram/kilogram
        // incosistency
        if (unit.equals(GRAM)) {
          buffer.append(symbolMap.getSymbol(GRAM));
          return NOOP_PRECEDENCE;
        }
        parentUnit = GRAM;
        if (unit instanceof TransformedUnit<?>) {
          converter = ((TransformedUnit<?>) unit).getConverter();
        } else {
          converter = unit.getConverterTo((Unit) GRAM);
        }
      } else if (CUBIC_METRE.equals(parentUnit)) {
        if (converter != null) {
          parentUnit = LITRE;
        }
      }

      if (unit instanceof TransformedUnit) {
          TransformedUnit<?> transUnit = (TransformedUnit<?>) unit;
          if (parentUnit == null) {
                  parentUnit = transUnit.getParentUnit();
          } else {
                  if (transUnit.getParentUnit() != null) {
                          parentUnit =  transUnit.getParentUnit();
                  }
          }
          converter = transUnit.getConverter();
      }

      unitPrecedence = formatInternal(parentUnit, temp);
      printSeparator = !parentUnit.equals(AbstractUnit.ONE);
      int result = formatConverterLocal(converter, printSeparator, unitPrecedence, temp, symbolMap);
      buffer.append(temp);
      return result;
    }
  }

  /**
   * Format the given unit raised to the given fractional power to the given <code>StringBuffer</code>.
   * 
   * @param unit
   *          Unit the unit to be formatted
   * @param pow
   *          int the numerator of the fractional power
   * @param root
   *          int the denominator of the fractional power
   * @param continued
   *          boolean <code>true</code> if the converter expression should begin with an operator, otherwise <code>false</code>. This will always be
   *          true unless the unit being modified is equal to Unit.ONE.
   * @param buffer
   *          StringBuffer the buffer to append to. No assumptions should be made about its content.
   */
  private void formatExponent(Unit<?> unit, int pow, int root, boolean continued, Appendable buffer) throws IOException {
    if (continued) {
      buffer.append(MIDDLE_DOT);
    }
    StringBuffer temp = new StringBuffer();
    int unitPrecedence = formatInternal(unit, temp);
    if (unitPrecedence < PRODUCT_PRECEDENCE) {
      temp.insert(0, '(');
      temp.append(')');
    }
    buffer.append(temp);
    if ((root == 1) && (pow == 1)) {
      // do nothing
    } else if ((root == 1) && (pow > 1)) {
      String powStr = Integer.toString(pow);
      for (int i = 0; i < powStr.length(); i += 1) {
        char c = powStr.charAt(i);
        switch (c) {
          case '0':
            buffer.append('\u2070');
            break;
          case '1':
            buffer.append('\u00b9');
            break;
          case '2':
            buffer.append('\u00b2');
            break;
          case '3':
            buffer.append('\u00b3');
            break;
          case '4':
            buffer.append('\u2074');
            break;
          case '5':
            buffer.append('\u2075');
            break;
          case '6':
            buffer.append('\u2076');
            break;
          case '7':
            buffer.append('\u2077');
            break;
          case '8':
            buffer.append('\u2078');
            break;
          case '9':
            buffer.append('\u2079');
            break;
        }
      }
    } else if (root == 1) {
      buffer.append("^");
      buffer.append(String.valueOf(pow));
    } else {
      buffer.append("^(");
      buffer.append(String.valueOf(pow));
      buffer.append('/');
      buffer.append(String.valueOf(root));
      buffer.append(')');
    }
  }
}

1	/*
2	* Units of Measurement Reference Implementation
3	* Copyright (c) 2005-2025, Jean-Marie Dautelle, Werner Keil, Otavio Santana.
4	*
5	* All rights reserved.
6	*
7	* Redistribution and use in source and binary forms, with or without modification,
8	* are permitted provided that the following conditions are met:
9	*
10	* 1. Redistributions of source code must retain the above copyright notice,
11	* this list of conditions and the following disclaimer.
12	*
13	* 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions
14	* and the following disclaimer in the documentation and/or other materials provided with the distribution.
15	*
16	* 3. Neither the name of JSR-385, Indriya nor the names of their contributors may be used to endorse or promote products
17	* derived from this software without specific prior written permission.
18	*
19	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
23	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
26	* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
28	* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29	*/
30	package tech.units.indriya.format;
31
32	import static tech.units.indriya.format.ConverterFormatter.formatConverterLocal;
33	import static tech.units.indriya.format.FormatConstants.*;
34
35	import javax.measure.Quantity;
36	import javax.measure.Unit;
37	import javax.measure.UnitConverter;
38	import javax.measure.format.MeasurementParseException;
39	import tech.units.indriya.AbstractUnit;
40	import tech.units.indriya.internal.format.UnitFormatParser;
41	import tech.units.indriya.unit.AlternateUnit;
42	import tech.units.indriya.unit.AnnotatedUnit;
43	import tech.units.indriya.unit.BaseUnit;
44	import tech.units.indriya.unit.ProductUnit;
45	import tech.units.indriya.unit.TransformedUnit;
46
47	import static tech.units.indriya.unit.Units.CUBIC_METRE;
48	import static tech.units.indriya.unit.Units.GRAM;
49	import static tech.units.indriya.unit.Units.KILOGRAM;
50	import static tech.units.indriya.unit.Units.LITRE;
51
52	import java.io.IOException;
53	import java.io.StringReader;
54	import java.text.ParsePosition;
55	import java.util.Locale;
56	import java.util.Map;
57	import java.util.ResourceBundle;
58
59	/**
60	* <p>
61	* This class represents the locale sensitive format.
62	* </p>
63	*
64	* <h3>Here is the grammar for CommonUnits in Extended Backus-Naur Form (EBNF)</h3>
65	* <p>
66	* Note that the grammar has been left-factored to be suitable for use by a top-down parser generator such as <a
67	* href="https://javacc.dev.java.net/">JavaCC</a>
68	* </p>
69	* <table * align="center">
70	* <tr>
71	* <th colspan="3" align="left">Lexical Entities:</th>
72	* </tr>
73	* <tr valign="top">
74	* <td><sign></td>
75	* <td>:=</td>
76	* <td>"+" \| "-"</td>
77	* </tr>
78	* <tr valign="top">
79	* <td><digit></td>
80	* <td>:=</td>
81	* <td>"0" \| "1" \| "2" \| "3" \| "4" \| "5" \| "6" \| "7" \| "8" \| "9"</td>
82	* </tr>
83	* <tr valign="top">
84	* <td><superscript_digit></td>
85	* <td>:=</td>
86	* <td>"⁰" \| "¹" \| "²" \| "³" \| "⁴" \| "⁵" \| "⁶" \| "⁷" \| "⁸" \| "⁹"</td>
87	* </tr>
88	* <tr valign="top">
89	* <td><integer></td>
90	* <td>:=</td>
91	* <td>(<digit>)+</td>
92	* </tr>
93	* <tr * valign="top">
94	* <td><number></td>
95	* <td>:=</td>
96	* <td>(<sign>)? (<digit>)* (".")? (<digit>)+ (("e" \| "E") (<sign>)? (<digit>)+)?</td>
97	* </tr>
98	* <tr valign="top">
99	* <td><exponent></td>
100	* <td>:=</td>
101	* <td>( "^" ( <sign> )? <integer> ) <br>
102	* \| ( "^(" (<sign>)? <integer> ( "/" (<sign>)? <integer> )? ")" ) <br>
103	* \| ( <superscript_digit> )+</td>
104	* </tr>
105	* <tr valign="top">
106	* <td><initial_char></td>
107	* <td>:=</td>
108	* <td>? Any Unicode character excluding the following: ASCII control & whitespace (\u0000 - \u0020), decimal digits '0'-'9', '('
109	* (\u0028), ')' (\u0029), '*' (\u002A), '+' (\u002B), '-' (\u002D), '.' (\u002E), '/' (\u005C), ':' (\u003A), '^'
110	* (\u005E), '²' (\u00B2), '³' (\u00B3), '·' (\u00B7), '¹' (\u00B9), '⁰' (\u2070), '⁴' (\u2074), '⁵' (\u2075), '⁶'
111	* (\u2076), '⁷' (\u2077), '⁸' (\u2078), '⁹' (\u2079) ?</td>
112	* </tr>
113	* <tr valign="top">
114	* <td><unit_identifier></td>
115	* <td>:=</td>
116	* <td><initial_char> ( <initial_char> \| <digit> )*</td>
117	* </tr>
118	* <tr>
119	* <th colspan="3" align="left">Non-Terminals:</th>
120	* </tr>
121	* <tr * valign="top">
122	* <td><unit_expr></td>
123	* <td>:=</td>
124	* <td><mix_expr></td>
125	* </tr>
126	* <tr valign="top">
127	* <td><mix_expr></td>
128	* <td>:=</td>
129	* <td><add_expr> ( ":" <add_expr> )*</td>
130	* </tr>
131	* <tr valign="top">
132	* <td><add_expr></td>
133	* <td>:=</td>
134	* <td>( <number> <sign> )? <mul_expr> ( <sign> <number> )?</td>
135	* </tr>
136	* <tr valign="top">
137	* <td><mul_expr></td>
138	* <td>:=</td>
139	* <td><exponent_expr> ( ( ( "" \| "·" ) <exponent_expr> ) \| ( "/" <exponent_expr> ) )</td>
140	* </tr>
141	* <tr valign="top">
142	* <td><exponent_expr></td>
143	* <td>:=</td>
144	* <td>( <atomic_expr> ( <exponent> )? ) <br>
145	* \| (<integer> "^" <atomic_expr>) <br>
146	* \| ( ( "log" ( <integer> )? ) \| "ln" ) "(" <add_expr> ")" )</td>
147	* </tr>
148	* <tr valign="top">
149	* <td><atomic_expr></td>
150	* <td>:=</td>
151	* <td><number> <br>
152	* \| <unit_identifier> <br>
153	* \| ( "(" <add_expr> ")" )</td>
154	* </tr>
155	* </table>
156	*
157	* @author <a href="mailto:eric-r@northwestern.edu">Eric Russell</a>
158	* @author <a href="mailto:werner@units.tech">Werner Keil</a>
159	* @version 1.7, February 9, 2025
160	* @since 1.0
161	*/
162	public class LocalUnitFormat extends AbstractUnitFormat {
163
164	//////////////////////////////////////////////////////
165	// Class variables //
166	//////////////////////////////////////////////////////
167	/**
168	* DefaultQuantityFactory locale instance. If the default locale is changed after the class is initialized, this instance will no longer be used.
169	*/
170	private static final LocalUnitFormat DEFAULT_INSTANCE = new LocalUnitFormat(SymbolMap.of(ResourceBundle.getBundle(LocalUnitFormat.class	1✔
171	.getPackage().getName() + ".messages")));	1✔
172
173	// /////////////////
174	// Class methods //
175	// /////////////////
176	/**
177	* Returns the instance for the current default locale (non-ascii characters are allowed)
178	*/
179	public static LocalUnitFormat getInstance() {
180	return DEFAULT_INSTANCE;	1✔
181	}
182
183	/**
184	* Returns an instance for the given locale.
185	*
186	* @param locale the locale to use
187	*/
188	public static LocalUnitFormat getInstance(Locale locale) {
189	return new LocalUnitFormat(SymbolMap.of(ResourceBundle.getBundle(LocalUnitFormat.class.getPackage().getName() + ".messages", locale)));	1✔
190	}
191
192	/** Returns an instance for the given symbol map. */
193	public static LocalUnitFormat getInstance(SymbolMap symbols) {
194	return new LocalUnitFormat(symbols);	×
195	}
196
197	// //////////////////////
198	// Instance variables //
199	// //////////////////////
200	/**
201	* The symbol map used by this instance to map between {@link Unit Unit}s and <code>String</code>s, etc...
202	*/
203	private final transient SymbolMap symbolMap;
204
205	// ////////////////
206	// Constructors //
207	// ////////////////
208	/**
209	* Base constructor.
210	*
211	* @param symbols
212	* the symbol mapping.
213	*/
214	private LocalUnitFormat(SymbolMap symbols) {	1✔
215	symbolMap = symbols;	1✔
216	}	1✔
217
218	////////////////////////
219	// Instance methods //
220	////////////////////////
221	/**
222	* Get the symbol map used by this instance to map between {@link AbstractUnit Unit}s and <code>String</code>s, etc...
223	*
224	* @return SymbolMap the current symbol map
225	*/
226	protected SymbolMap getSymbols() {
227	return symbolMap;	×
228	}
229
230	@Override
231	public String toString() {
232	return getClass().getSimpleName();	1✔
233	}
234
235	////////////////
236	// Formatting //
237	////////////////
238	@Override
239	public Appendable format(Unit<?> unit, Appendable appendable) throws IOException {
240	if (!(unit instanceof AbstractUnit)) {	1✔
241	return appendable.append(unit.toString()); // Unknown unit (use	×
242	// intrinsic toString()
243	// method)
244	}
245	formatInternal(unit, appendable);	1✔
246	return appendable;	1✔
247	}
248
249	public boolean isLocaleSensitive() {
250	return true;	1✔
251	}
252
253	protected Unit<?> parse(CharSequence csq, int index) throws MeasurementParseException {
254	return parse(csq, new ParsePosition(index));	×
255	}
256
257	public Unit<?> parse(CharSequence csq, ParsePosition cursor) throws MeasurementParseException {
258	// Parsing reads the whole character sequence from the parse position.
259	int start = cursor.getIndex();	1✔
260	int end = csq.length();	1✔
261	if (end <= start) {	1✔
262	return AbstractUnit.ONE;	×
263	}
264	String source = csq.subSequence(start, end).toString().trim();	1✔
265	if (source.length() == 0) {	1✔
266	return AbstractUnit.ONE;	×
267	}
268	try {
269	UnitFormatParser parser = new UnitFormatParser(symbolMap, new StringReader(source));	1✔
270	Unit<?> result = parser.parseUnit();	1✔
271	cursor.setIndex(end);	1✔
272	return result;	1✔
273	} catch (TokenException e) {	×
274	if (e.currentToken != null) {	×
275	cursor.setErrorIndex(start + e.currentToken.endColumn);	×
276	} else {
277	cursor.setErrorIndex(start);	×
278	}
279	throw new IllegalArgumentException(e); // TODO should we throw	×
280	// ParserException here,
281	// too?
282	} catch (TokenMgrError e) {	×
283	cursor.setErrorIndex(start);	×
284	throw new MeasurementParseException(e);	×
285	}
286	}
287
288	@Override
289	public Unit<? extends Quantity<?>> parse(CharSequence csq) throws MeasurementParseException {
290	return parse(csq, new ParsePosition(0));	1✔
291	}
292
293	/**
294	* Format the given unit to the given StringBuilder, then return the operator precedence of the outermost operator in the unit expression that was
295	* formatted. See {@link ConverterFormat} for the constants that define the various precedence values.
296	*
297	* @param unit
298	* the unit to be formatted
299	* @param buffer
300	* the <code>StringBuilder</code> to be written to
301	* @return the operator precedence of the outermost operator in the unit expression that was output
302	*/
303	@SuppressWarnings({ "rawtypes", "unchecked" })
304	private int formatInternal(Unit<?> unit, Appendable buffer) throws IOException {
305	if (unit instanceof AnnotatedUnit<?>) {	1✔
306	unit = ((AnnotatedUnit<?>) unit).getActualUnit();	×
307	// } else if (unit instanceof ProductUnit<?>) {
308	// ProductUnit<?> p = (ProductUnit<?>)unit;
309	}
310	// TODO is the behavior similar to EBNFUnitFormat for AnnotatedUnit?
311	String symbol = symbolMap.getSymbol((AbstractUnit<?>) unit);	1✔
312	if (symbol != null) {	1✔
313	buffer.append(symbol);	1✔
314	return NOOP_PRECEDENCE;	1✔
315	} else if (unit instanceof ProductUnit<?> && unit.getBaseUnits() != null) {	1✔
316	Map<Unit<?>, Integer> productUnits = (Map<Unit<?>, Integer>) unit.getBaseUnits();	1✔
317	int negativeExponentCount = 0;	1✔
318	// Write positive exponents first...
319	boolean start = true;	1✔
320	for (Map.Entry<Unit<?>, Integer> e : productUnits.entrySet()) {	1✔
321	int pow = e.getValue();	1✔
322	if (pow >= 0) {	1✔
323	formatExponent(e.getKey(), pow, 1, !start, buffer);	1✔
324	start = false;	1✔
325	} else {
326	negativeExponentCount += 1;	1✔
327	}
328	}	1✔
329	// ..then write negative exponents.
330	if (negativeExponentCount > 0) {	1✔
331	if (start) {	1✔
332	buffer.append('1');	×
333	}
334	buffer.append('/');	1✔
335	if (negativeExponentCount > 1) {	1✔
336	buffer.append('(');	×
337	}
338	start = true;	1✔
339	for (Map.Entry<Unit<?>, Integer> e : productUnits.entrySet()) {	1✔
340	int pow = e.getValue();	1✔
341	if (pow < 0) {	1✔
342	formatExponent(e.getKey(), -pow, 1, !start, buffer);	1✔
343	start = false;	1✔
344	}
345	}	1✔
346	if (negativeExponentCount > 1) {	1✔
347	buffer.append(')');	×
348	}
349	}
350	return PRODUCT_PRECEDENCE;	1✔
351	} else if (unit instanceof BaseUnit<?>) {	1✔
352	buffer.append(((BaseUnit<?>) unit).getSymbol());	×
353	return NOOP_PRECEDENCE;	×
354	} else if (unit instanceof AlternateUnit<?>) { // unit.getSymbol() !=	1✔
355	// null) { // Alternate
356	// unit.
357	buffer.append(unit.getSymbol());	×
358	return NOOP_PRECEDENCE;	×
359	} else { // A transformed unit or new unit type!
360	UnitConverter converter = null;	1✔
361	boolean printSeparator = false;	1✔
362	StringBuilder temp = new StringBuilder();	1✔
363	int unitPrecedence = NOOP_PRECEDENCE;	1✔
364	Unit<?> parentUnit = unit.getSystemUnit();	1✔
365	converter = ((AbstractUnit<?>) unit).getSystemConverter();	1✔
366	if (KILOGRAM.equals(parentUnit)) {	1✔
367	// More special-case hackery to work around gram/kilogram
368	// incosistency
369	if (unit.equals(GRAM)) {	×
370	buffer.append(symbolMap.getSymbol(GRAM));	×
371	return NOOP_PRECEDENCE;	×
372	}
373	parentUnit = GRAM;	×
374	if (unit instanceof TransformedUnit<?>) {	×
375	converter = ((TransformedUnit<?>) unit).getConverter();	×
376	} else {
377	converter = unit.getConverterTo((Unit) GRAM);	×
378	}
379	} else if (CUBIC_METRE.equals(parentUnit)) {	1✔
380	if (converter != null) {	×
381	parentUnit = LITRE;	×
382	}
383	}
384
385	if (unit instanceof TransformedUnit) {	1✔
386	TransformedUnit<?> transUnit = (TransformedUnit<?>) unit;	1✔
387	if (parentUnit == null) {	1✔
NEW 388	parentUnit = transUnit.getParentUnit();	×
389	} else {
390	if (transUnit.getParentUnit() != null) {	1✔
391	parentUnit = transUnit.getParentUnit();	1✔
392	}
393	}
394	converter = transUnit.getConverter();	1✔
395	}
396
397	unitPrecedence = formatInternal(parentUnit, temp);	1✔
398	printSeparator = !parentUnit.equals(AbstractUnit.ONE);	1✔
399	int result = formatConverterLocal(converter, printSeparator, unitPrecedence, temp, symbolMap);	1✔
400	buffer.append(temp);	1✔
401	return result;	1✔
402	}
403	}
404
405	/**
406	* Format the given unit raised to the given fractional power to the given <code>StringBuffer</code>.
407	*
408	* @param unit
409	* Unit the unit to be formatted
410	* @param pow
411	* int the numerator of the fractional power
412	* @param root
413	* int the denominator of the fractional power
414	* @param continued
415	* boolean <code>true</code> if the converter expression should begin with an operator, otherwise <code>false</code>. This will always be
416	* true unless the unit being modified is equal to Unit.ONE.
417	* @param buffer
418	* StringBuffer the buffer to append to. No assumptions should be made about its content.
419	*/
420	private void formatExponent(Unit<?> unit, int pow, int root, boolean continued, Appendable buffer) throws IOException {
421	if (continued) {	1✔
422	buffer.append(MIDDLE_DOT);	×
423	}
424	StringBuffer temp = new StringBuffer();	1✔
425	int unitPrecedence = formatInternal(unit, temp);	1✔
426	if (unitPrecedence < PRODUCT_PRECEDENCE) {	1✔
427	temp.insert(0, '(');	×
428	temp.append(')');	×
429	}
430	buffer.append(temp);	1✔
431	if ((root == 1) && (pow == 1)) {	1✔
432	// do nothing
433	} else if ((root == 1) && (pow > 1)) {	×
434	String powStr = Integer.toString(pow);	×
435	for (int i = 0; i < powStr.length(); i += 1) {	×
436	char c = powStr.charAt(i);	×
437	switch (c) {	×
438	case '0':
439	buffer.append('\u2070');	×
440	break;	×
441	case '1':
442	buffer.append('\u00b9');	×
443	break;	×
444	case '2':
445	buffer.append('\u00b2');	×
446	break;	×
447	case '3':
448	buffer.append('\u00b3');	×
449	break;	×
450	case '4':
451	buffer.append('\u2074');	×
452	break;	×
453	case '5':
454	buffer.append('\u2075');	×
455	break;	×
456	case '6':
457	buffer.append('\u2076');	×
458	break;	×
459	case '7':
460	buffer.append('\u2077');	×
461	break;	×
462	case '8':
463	buffer.append('\u2078');	×
464	break;	×
465	case '9':
466	buffer.append('\u2079');	×
467	break;
468	}
469	}
470	} else if (root == 1) {	×
471	buffer.append("^");	×
472	buffer.append(String.valueOf(pow));	×
473	} else {
474	buffer.append("^(");	×
475	buffer.append(String.valueOf(pow));	×
476	buffer.append('/');	×
477	buffer.append(String.valueOf(root));	×
478	buffer.append(')');	×
479	}
480	}	1✔
481	}

unitsofmeasurement / indriya / 2281

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous