archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-26 22:34:27 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8336847: Use pattern match switch in NumberFormat classes

Browse source 
Reviewed-by: liach, naoto
This commit is contained in:
Justin Lu 2024-07-24 20:14:00 +00:00
parent 9e8e359513
commit 5a8861a3a1
3 changed files with 118 additions and 143 deletions
Download patch file Download diff file Expand all files Collapse all files

104
src/java.base/share/classes/java/text/CompactNumberFormat.java
View file

@ -539,58 +539,42 @@ public final class CompactNumberFormat extends NumberFormat {
public final StringBuffer format(Object number,
StringBuffer toAppendTo,
FieldPosition fieldPosition) {
if (number == null) {
throw new IllegalArgumentException("Cannot format null as a number");
}
if (number instanceof Long || number instanceof Integer
|| number instanceof Short || number instanceof Byte
|| number instanceof AtomicInteger
|| number instanceof AtomicLong
|| (number instanceof BigInteger
&& ((BigInteger) number).bitLength() < 64)) {
return format(((Number) number).longValue(), toAppendTo,
fieldPosition);
} else if (number instanceof BigDecimal) {
return format((BigDecimal) number, StringBufFactory.of(toAppendTo), fieldPosition).asStringBuffer();
} else if (number instanceof BigInteger) {
return format((BigInteger) number, StringBufFactory.of(toAppendTo), fieldPosition).asStringBuffer();
} else if (number instanceof Number) {
return format(((Number) number).doubleValue(), toAppendTo, fieldPosition);
} else {
throw new IllegalArgumentException("Cannot format "
+ number.getClass().getName() + " as a number");
}
return switch (number) {
case Long l -> format(l.longValue(), toAppendTo, fieldPosition);
case Integer i -> format(i.longValue(), toAppendTo, fieldPosition);
case Short s -> format(s.longValue(), toAppendTo, fieldPosition);
case Byte b -> format(b.longValue(), toAppendTo, fieldPosition);
case AtomicInteger ai -> format(ai.longValue(), toAppendTo, fieldPosition);
case AtomicLong al -> format(al.longValue(), toAppendTo, fieldPosition);
case BigInteger bi when bi.bitLength() < 64 -> format(bi.longValue(), toAppendTo, fieldPosition);
case BigDecimal bd -> format(bd, StringBufFactory.of(toAppendTo), fieldPosition).asStringBuffer();
case BigInteger bi -> format(bi, StringBufFactory.of(toAppendTo), fieldPosition).asStringBuffer();
case Number n -> format(n.doubleValue(), toAppendTo, fieldPosition);
case null -> throw new IllegalArgumentException("Cannot format null as a number");
default -> throw new IllegalArgumentException(
String.format("Cannot format %s as a number", number.getClass().getName()));
};
}
@Override
StringBuf format(Object number,
StringBuf toAppendTo,
FieldPosition fieldPosition) {
if (number == null) {
throw new IllegalArgumentException("Cannot format null as a number");
}
if (number instanceof Long || number instanceof Integer
|| number instanceof Short || number instanceof Byte
|| number instanceof AtomicInteger
|| number instanceof AtomicLong
|| (number instanceof BigInteger
&& ((BigInteger) number).bitLength() < 64)) {
return format(((Number) number).longValue(), toAppendTo,
fieldPosition);
} else if (number instanceof BigDecimal) {
return format((BigDecimal) number, toAppendTo, fieldPosition);
} else if (number instanceof BigInteger) {
return format((BigInteger) number, toAppendTo, fieldPosition);
} else if (number instanceof Number) {
return format(((Number) number).doubleValue(), toAppendTo, fieldPosition);
} else {
throw new IllegalArgumentException("Cannot format "
+ number.getClass().getName() + " as a number");
}
return switch (number) {
case Long l -> format(l.longValue(), toAppendTo, fieldPosition);
case Integer i -> format(i.longValue(), toAppendTo, fieldPosition);
case Short s -> format(s.longValue(), toAppendTo, fieldPosition);
case Byte b -> format(b.longValue(), toAppendTo, fieldPosition);
case AtomicInteger ai -> format(ai.longValue(), toAppendTo, fieldPosition);
case AtomicLong al -> format(al.longValue(), toAppendTo, fieldPosition);
case BigInteger bi when bi.bitLength() < 64 -> format(bi.longValue(), toAppendTo, fieldPosition);
case BigDecimal bd -> format(bd, toAppendTo, fieldPosition);
case BigInteger bi -> format(bi, toAppendTo, fieldPosition);
case Number n -> format(n.doubleValue(), toAppendTo, fieldPosition);
case null -> throw new IllegalArgumentException("Cannot format null as a number");
default -> throw new IllegalArgumentException(
String.format("Cannot format %s as a number", number.getClass().getName()));
};
}
/**
@ -1182,22 +1166,20 @@ public final class CompactNumberFormat extends NumberFormat {
CharacterIteratorFieldDelegate delegate
= new CharacterIteratorFieldDelegate();
StringBuf sb = StringBufFactory.of();
if (obj instanceof Double || obj instanceof Float) {
format(((Number) obj).doubleValue(), sb, delegate);
} else if (obj instanceof Long || obj instanceof Integer
|| obj instanceof Short || obj instanceof Byte
|| obj instanceof AtomicInteger || obj instanceof AtomicLong) {
format(((Number) obj).longValue(), sb, delegate);
} else if (obj instanceof BigDecimal) {
format((BigDecimal) obj, sb, delegate);
} else if (obj instanceof BigInteger) {
format((BigInteger) obj, sb, delegate, false);
} else if (obj == null) {
throw new NullPointerException(
switch (obj) {
case Double d -> format(d.doubleValue(), sb, delegate);
case Float f -> format(f.doubleValue(), sb, delegate);
case Long l -> format(l.longValue(), sb, delegate);
case Integer i -> format(i.longValue(), sb, delegate);
case Short s -> format(s.longValue(), sb, delegate);
case Byte b -> format(b.longValue(), sb, delegate);
case AtomicInteger ai -> format(ai.longValue(), sb, delegate);
case AtomicLong al -> format(al.longValue(), sb, delegate);
case BigDecimal bd -> format(bd, sb, delegate);
case BigInteger bi -> format(bi, sb, delegate, false);
case null -> throw new NullPointerException(
"formatToCharacterIterator must be passed non-null object");
} else {
throw new IllegalArgumentException(
default -> throw new IllegalArgumentException(
"Cannot format given Object as a Number");
}
return delegate.getIterator(sb.toString());

113
src/java.base/share/classes/java/text/DecimalFormat.java
View file

@ -548,44 +548,38 @@ public class DecimalFormat extends NumberFormat {
public final StringBuffer format(Object number,
StringBuffer toAppendTo,
FieldPosition pos) {
if (number instanceof Long || number instanceof Integer ||
number instanceof Short || number instanceof Byte ||
number instanceof AtomicInteger ||
number instanceof AtomicLong ||
(number instanceof BigInteger &&
((BigInteger)number).bitLength () < 64)) {
return format(((Number)number).longValue(), toAppendTo, pos);
} else if (number instanceof BigDecimal) {
return format((BigDecimal)number, StringBufFactory.of(toAppendTo), pos).asStringBuffer();
} else if (number instanceof BigInteger) {
return format((BigInteger)number, StringBufFactory.of(toAppendTo), pos).asStringBuffer();
} else if (number instanceof Number) {
return format(((Number)number).doubleValue(), toAppendTo, pos);
} else {
throw new IllegalArgumentException("Cannot format given Object as a Number");
}
return switch (number) {
case Long l -> format(l.longValue(), toAppendTo, pos);
case Integer i -> format(i.longValue(), toAppendTo, pos);
case Short s -> format(s.longValue(), toAppendTo, pos);
case Byte b -> format(b.longValue(), toAppendTo, pos);
case AtomicInteger ai -> format(ai.longValue(), toAppendTo, pos);
case AtomicLong al -> format(al.longValue(), toAppendTo, pos);
case BigInteger bi when bi.bitLength() < 64 -> format(bi.longValue(), toAppendTo, pos);
case BigDecimal bd -> format(bd, StringBufFactory.of(toAppendTo), pos).asStringBuffer();
case BigInteger bi -> format(bi, StringBufFactory.of(toAppendTo), pos).asStringBuffer();
case Number n -> format(n.doubleValue(), toAppendTo, pos);
case null, default -> throw new IllegalArgumentException("Cannot format given Object as a Number");
};
}
@Override
final StringBuf format(Object number,
StringBuf toAppendTo,
FieldPosition pos) {
if (number instanceof Long || number instanceof Integer ||
number instanceof Short || number instanceof Byte ||
number instanceof AtomicInteger ||
number instanceof AtomicLong ||
(number instanceof BigInteger &&
((BigInteger) number).bitLength() < 64)) {
return format(((Number) number).longValue(), toAppendTo, pos);
} else if (number instanceof BigDecimal) {
return format((BigDecimal) number, toAppendTo, pos);
} else if (number instanceof BigInteger) {
return format((BigInteger) number, toAppendTo, pos);
} else if (number instanceof Number) {
return format(((Number) number).doubleValue(), toAppendTo, pos);
} else {
throw new IllegalArgumentException("Cannot format given Object as a Number");
}
return switch (number) {
case Long l -> format(l.longValue(), toAppendTo, pos);
case Integer i -> format(i.longValue(), toAppendTo, pos);
case Short s -> format(s.longValue(), toAppendTo, pos);
case Byte b -> format(b.longValue(), toAppendTo, pos);
case AtomicInteger ai -> format(ai.longValue(), toAppendTo, pos);
case AtomicLong al -> format(al.longValue(), toAppendTo, pos);
case BigInteger bi when bi.bitLength() < 64 -> format(bi.longValue(), toAppendTo, pos);
case BigDecimal bd -> format(bd, toAppendTo, pos);
case BigInteger bi -> format(bi, toAppendTo, pos);
case Number n -> format(n.doubleValue(), toAppendTo, pos);
case null, default -> throw new IllegalArgumentException("Cannot format given Object as a Number");
};
}
/**
@ -1021,25 +1015,23 @@ public class DecimalFormat extends NumberFormat {
@Override
public AttributedCharacterIterator formatToCharacterIterator(Object obj) {
CharacterIteratorFieldDelegate delegate =
new CharacterIteratorFieldDelegate();
new CharacterIteratorFieldDelegate();
StringBuf sb = StringBufFactory.of();
if (obj instanceof Double || obj instanceof Float) {
format(((Number)obj).doubleValue(), sb, delegate);
} else if (obj instanceof Long || obj instanceof Integer ||
obj instanceof Short || obj instanceof Byte ||
obj instanceof AtomicInteger || obj instanceof AtomicLong) {
format(((Number)obj).longValue(), sb, delegate);
} else if (obj instanceof BigDecimal) {
format((BigDecimal)obj, sb, delegate);
} else if (obj instanceof BigInteger) {
format((BigInteger)obj, sb, delegate, false);
} else if (obj == null) {
throw new NullPointerException(
"formatToCharacterIterator must be passed non-null object");
} else {
throw new IllegalArgumentException(
"Cannot format given Object as a Number");
switch (obj) {
case Double d -> format(d.doubleValue(), sb, delegate);
case Float f -> format(f.doubleValue(), sb, delegate);
case Long l -> format(l.longValue(), sb, delegate);
case Integer i -> format(i.longValue(), sb, delegate);
case Short s -> format(s.longValue(), sb, delegate);
case Byte b -> format(b.longValue(), sb, delegate);
case AtomicInteger ai -> format(ai.longValue(), sb, delegate);
case AtomicLong al -> format(al.longValue(), sb, delegate);
case BigDecimal bd -> format(bd, sb, delegate);
case BigInteger bi -> format(bi, sb, delegate, false);
case null -> throw new NullPointerException(
"formatToCharacterIterator must be passed non-null object");
default -> throw new IllegalArgumentException(
"Cannot format given Object as a Number");
}
return delegate.getIterator(sb.toString());
}
@ -1790,22 +1782,23 @@ public class DecimalFormat extends NumberFormat {
}
/**
* Sets the {@code DigitList} used by this {@code DecimalFormat}
* Utility method that sets the {@code DigitList} used by this {@code DecimalFormat}
* instance.
*
* @param number the number to format
* @param isNegative true, if the number is negative; false otherwise
* @param maxDigits the max digits
* @throws AssertionError if provided a Number subclass that is not supported
* by {@code DigitList}
*/
void setDigitList(Number number, boolean isNegative, int maxDigits) {
if (number instanceof Double) {
digitList.set(isNegative, (Double) number, maxDigits, true);
} else if (number instanceof BigDecimal) {
digitList.set(isNegative, (BigDecimal) number, maxDigits, true);
} else if (number instanceof Long) {
digitList.set(isNegative, (Long) number, maxDigits);
} else if (number instanceof BigInteger) {
digitList.set(isNegative, (BigInteger) number, maxDigits);
switch (number) {
case Double d -> digitList.set(isNegative, d, maxDigits, true);
case BigDecimal bd -> digitList.set(isNegative, bd, maxDigits, true);
case Long l -> digitList.set(isNegative, l, maxDigits);
case BigInteger bi -> digitList.set(isNegative, bi, maxDigits);
default -> throw new AssertionError(
String.format("DigitList does not support %s", number.getClass().getName()));
}
}

44
src/java.base/share/classes/java/text/NumberFormat.java
View file

@ -302,34 +302,34 @@ public abstract class NumberFormat extends Format {
public StringBuffer format(Object number,
StringBuffer toAppendTo,
FieldPosition pos) {
if (number instanceof Long || number instanceof Integer ||
number instanceof Short || number instanceof Byte ||
number instanceof AtomicInteger || number instanceof AtomicLong ||
(number instanceof BigInteger &&
((BigInteger)number).bitLength() < 64)) {
return format(((Number)number).longValue(), toAppendTo, pos);
} else if (number instanceof Number) {
return format(((Number)number).doubleValue(), toAppendTo, pos);
} else {
throw new IllegalArgumentException("Cannot format given Object as a Number");
}
return switch (number) {
case Long l -> format(l.longValue(), toAppendTo, pos);
case Integer i -> format(i.longValue(), toAppendTo, pos);
case Short s -> format(s.longValue(), toAppendTo, pos);
case Byte b -> format(b.longValue(), toAppendTo, pos);
case AtomicInteger ai -> format(ai.longValue(), toAppendTo, pos);
case AtomicLong al -> format(al.longValue(), toAppendTo, pos);
case BigInteger bi when bi.bitLength() < 64 -> format(bi.longValue(), toAppendTo, pos);
case Number n -> format(n.doubleValue(), toAppendTo, pos);
case null, default -> throw new IllegalArgumentException("Cannot format given Object as a Number");
};
}
@Override
StringBuf format(Object number,
StringBuf toAppendTo,
FieldPosition pos) {
if (number instanceof Long || number instanceof Integer ||
number instanceof Short || number instanceof Byte ||
number instanceof AtomicInteger || number instanceof AtomicLong ||
(number instanceof BigInteger &&
((BigInteger) number).bitLength() < 64)) {
return format(((Number) number).longValue(), toAppendTo, pos);
} else if (number instanceof Number) {
return format(((Number) number).doubleValue(), toAppendTo, pos);
} else {
throw new IllegalArgumentException("Cannot format given Object as a Number");
}
return switch (number) {
case Long l -> format(l.longValue(), toAppendTo, pos);
case Integer i -> format(i.longValue(), toAppendTo, pos);
case Short s -> format(s.longValue(), toAppendTo, pos);
case Byte b -> format(b.longValue(), toAppendTo, pos);
case AtomicInteger ai -> format(ai.longValue(), toAppendTo, pos);
case AtomicLong al -> format(al.longValue(), toAppendTo, pos);
case BigInteger bi when bi.bitLength() < 64 -> format(bi.longValue(), toAppendTo, pos);
case Number n -> format(n.doubleValue(), toAppendTo, pos);
case null, default -> throw new IllegalArgumentException("Cannot format given Object as a Number");
};
}
/**