code
stringlengths 11
173k
| docstring
stringlengths 2
593k
| func_name
stringlengths 2
189
| language
stringclasses 1
value | repo
stringclasses 844
values | path
stringlengths 11
294
| url
stringlengths 60
339
| license
stringclasses 4
values |
|---|---|---|---|---|---|---|---|
public float floatValue() {
if (signum == 0) {
return 0.0f;
}
int exponent = ((mag.length - 1) << 5) + bitLengthForInt(mag[0]) - 1;
// exponent == floor(log2(abs(this)))
if (exponent < Long.SIZE - 1) {
return longValue();
} else if (exponent > Float.MAX_EXPONENT) {
return signum > 0 ? Float.POSITIVE_INFINITY : Float.NEGATIVE_INFINITY;
}
/*
* We need the top SIGNIFICAND_WIDTH bits, including the "implicit"
* one bit. To make rounding easier, we pick out the top
* SIGNIFICAND_WIDTH + 1 bits, so we have one to help us round up or
* down. twiceSignifFloor will contain the top SIGNIFICAND_WIDTH + 1
* bits, and signifFloor the top SIGNIFICAND_WIDTH.
*
* It helps to consider the real number signif = abs(this) *
* 2^(SIGNIFICAND_WIDTH - 1 - exponent).
*/
int shift = exponent - FloatConsts.SIGNIFICAND_WIDTH;
int twiceSignifFloor;
// twiceSignifFloor will be == abs().shiftRight(shift).intValue()
// We do the shift into an int directly to improve performance.
int nBits = shift & 0x1f;
int nBits2 = 32 - nBits;
if (nBits == 0) {
twiceSignifFloor = mag[0];
} else {
twiceSignifFloor = mag[0] >>> nBits;
if (twiceSignifFloor == 0) {
twiceSignifFloor = (mag[0] << nBits2) | (mag[1] >>> nBits);
}
}
int signifFloor = twiceSignifFloor >> 1;
signifFloor &= FloatConsts.SIGNIF_BIT_MASK; // remove the implied bit
/*
* We round up if either the fractional part of signif is strictly
* greater than 0.5 (which is true if the 0.5 bit is set and any lower
* bit is set), or if the fractional part of signif is >= 0.5 and
* signifFloor is odd (which is true if both the 0.5 bit and the 1 bit
* are set). This is equivalent to the desired HALF_EVEN rounding.
*/
boolean increment = (twiceSignifFloor & 1) != 0
&& ((signifFloor & 1) != 0 || abs().getLowestSetBit() < shift);
int signifRounded = increment ? signifFloor + 1 : signifFloor;
int bits = ((exponent + FloatConsts.EXP_BIAS))
<< (FloatConsts.SIGNIFICAND_WIDTH - 1);
bits += signifRounded;
/*
* If signifRounded == 2^24, we'd need to set all of the significand
* bits to zero and add 1 to the exponent. This is exactly the behavior
* we get from just adding signifRounded to bits directly. If the
* exponent is Float.MAX_EXPONENT, we round up (correctly) to
* Float.POSITIVE_INFINITY.
*/
bits |= signum & FloatConsts.SIGN_BIT_MASK;
return Float.intBitsToFloat(bits);
} |
Converts this BigInteger to a {@code float}. This
conversion is similar to the
<i>narrowing primitive conversion</i> from {@code double} to
{@code float} as defined in section 5.1.3 of
<cite>The Java™ Language Specification</cite>:
if this BigInteger has too great a magnitude
to represent as a {@code float}, it will be converted to
{@link Float#NEGATIVE_INFINITY} or {@link
Float#POSITIVE_INFINITY} as appropriate. Note that even when
the return value is finite, this conversion can lose
information about the precision of the BigInteger value.
@return this BigInteger converted to a {@code float}.
| BigInteger::floatValue | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
public double doubleValue() {
if (signum == 0) {
return 0.0;
}
int exponent = ((mag.length - 1) << 5) + bitLengthForInt(mag[0]) - 1;
// exponent == floor(log2(abs(this))Double)
if (exponent < Long.SIZE - 1) {
return longValue();
} else if (exponent > Double.MAX_EXPONENT) {
return signum > 0 ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
}
/*
* We need the top SIGNIFICAND_WIDTH bits, including the "implicit"
* one bit. To make rounding easier, we pick out the top
* SIGNIFICAND_WIDTH + 1 bits, so we have one to help us round up or
* down. twiceSignifFloor will contain the top SIGNIFICAND_WIDTH + 1
* bits, and signifFloor the top SIGNIFICAND_WIDTH.
*
* It helps to consider the real number signif = abs(this) *
* 2^(SIGNIFICAND_WIDTH - 1 - exponent).
*/
int shift = exponent - DoubleConsts.SIGNIFICAND_WIDTH;
long twiceSignifFloor;
// twiceSignifFloor will be == abs().shiftRight(shift).longValue()
// We do the shift into a long directly to improve performance.
int nBits = shift & 0x1f;
int nBits2 = 32 - nBits;
int highBits;
int lowBits;
if (nBits == 0) {
highBits = mag[0];
lowBits = mag[1];
} else {
highBits = mag[0] >>> nBits;
lowBits = (mag[0] << nBits2) | (mag[1] >>> nBits);
if (highBits == 0) {
highBits = lowBits;
lowBits = (mag[1] << nBits2) | (mag[2] >>> nBits);
}
}
twiceSignifFloor = ((highBits & LONG_MASK) << 32)
| (lowBits & LONG_MASK);
long signifFloor = twiceSignifFloor >> 1;
signifFloor &= DoubleConsts.SIGNIF_BIT_MASK; // remove the implied bit
/*
* We round up if either the fractional part of signif is strictly
* greater than 0.5 (which is true if the 0.5 bit is set and any lower
* bit is set), or if the fractional part of signif is >= 0.5 and
* signifFloor is odd (which is true if both the 0.5 bit and the 1 bit
* are set). This is equivalent to the desired HALF_EVEN rounding.
*/
boolean increment = (twiceSignifFloor & 1) != 0
&& ((signifFloor & 1) != 0 || abs().getLowestSetBit() < shift);
long signifRounded = increment ? signifFloor + 1 : signifFloor;
long bits = (long) ((exponent + DoubleConsts.EXP_BIAS))
<< (DoubleConsts.SIGNIFICAND_WIDTH - 1);
bits += signifRounded;
/*
* If signifRounded == 2^53, we'd need to set all of the significand
* bits to zero and add 1 to the exponent. This is exactly the behavior
* we get from just adding signifRounded to bits directly. If the
* exponent is Double.MAX_EXPONENT, we round up (correctly) to
* Double.POSITIVE_INFINITY.
*/
bits |= signum & DoubleConsts.SIGN_BIT_MASK;
return Double.longBitsToDouble(bits);
} |
Converts this BigInteger to a {@code double}. This
conversion is similar to the
<i>narrowing primitive conversion</i> from {@code double} to
{@code float} as defined in section 5.1.3 of
<cite>The Java™ Language Specification</cite>:
if this BigInteger has too great a magnitude
to represent as a {@code double}, it will be converted to
{@link Double#NEGATIVE_INFINITY} or {@link
Double#POSITIVE_INFINITY} as appropriate. Note that even when
the return value is finite, this conversion can lose
information about the precision of the BigInteger value.
@return this BigInteger converted to a {@code double}.
| BigInteger::doubleValue | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private static int[] stripLeadingZeroInts(int val[]) {
int vlen = val.length;
int keep;
// Find first nonzero byte
for (keep = 0; keep < vlen && val[keep] == 0; keep++)
;
return java.util.Arrays.copyOfRange(val, keep, vlen);
} |
Returns a copy of the input array stripped of any leading zero bytes.
| BigInteger::stripLeadingZeroInts | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private static int[] trustedStripLeadingZeroInts(int val[]) {
int vlen = val.length;
int keep;
// Find first nonzero byte
for (keep = 0; keep < vlen && val[keep] == 0; keep++)
;
return keep == 0 ? val : java.util.Arrays.copyOfRange(val, keep, vlen);
} |
Returns the input array stripped of any leading zero bytes.
Since the source is trusted the copying may be skipped.
| BigInteger::trustedStripLeadingZeroInts | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private static int[] stripLeadingZeroBytes(byte a[]) {
int byteLength = a.length;
int keep;
// Find first nonzero byte
for (keep = 0; keep < byteLength && a[keep] == 0; keep++)
;
// Allocate new array and copy relevant part of input array
int intLength = ((byteLength - keep) + 3) >>> 2;
int[] result = new int[intLength];
int b = byteLength - 1;
for (int i = intLength-1; i >= 0; i--) {
result[i] = a[b--] & 0xff;
int bytesRemaining = b - keep + 1;
int bytesToTransfer = Math.min(3, bytesRemaining);
for (int j=8; j <= (bytesToTransfer << 3); j += 8)
result[i] |= ((a[b--] & 0xff) << j);
}
return result;
} |
Returns a copy of the input array stripped of any leading zero bytes.
| BigInteger::stripLeadingZeroBytes | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private static int[] makePositive(byte a[]) {
int keep, k;
int byteLength = a.length;
// Find first non-sign (0xff) byte of input
for (keep=0; keep < byteLength && a[keep] == -1; keep++)
;
/* Allocate output array. If all non-sign bytes are 0x00, we must
* allocate space for one extra output byte. */
for (k=keep; k < byteLength && a[k] == 0; k++)
;
int extraByte = (k == byteLength) ? 1 : 0;
int intLength = ((byteLength - keep + extraByte) + 3) >>> 2;
int result[] = new int[intLength];
/* Copy one's complement of input into output, leaving extra
* byte (if it exists) == 0x00 */
int b = byteLength - 1;
for (int i = intLength-1; i >= 0; i--) {
result[i] = a[b--] & 0xff;
int numBytesToTransfer = Math.min(3, b-keep+1);
if (numBytesToTransfer < 0)
numBytesToTransfer = 0;
for (int j=8; j <= 8*numBytesToTransfer; j += 8)
result[i] |= ((a[b--] & 0xff) << j);
// Mask indicates which bits must be complemented
int mask = -1 >>> (8*(3-numBytesToTransfer));
result[i] = ~result[i] & mask;
}
// Add one to one's complement to generate two's complement
for (int i=result.length-1; i >= 0; i--) {
result[i] = (int)((result[i] & LONG_MASK) + 1);
if (result[i] != 0)
break;
}
return result;
} |
Takes an array a representing a negative 2's-complement number and
returns the minimal (no leading zero bytes) unsigned whose value is -a.
| BigInteger::makePositive | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private static int[] makePositive(int a[]) {
int keep, j;
// Find first non-sign (0xffffffff) int of input
for (keep=0; keep < a.length && a[keep] == -1; keep++)
;
/* Allocate output array. If all non-sign ints are 0x00, we must
* allocate space for one extra output int. */
for (j=keep; j < a.length && a[j] == 0; j++)
;
int extraInt = (j == a.length ? 1 : 0);
int result[] = new int[a.length - keep + extraInt];
/* Copy one's complement of input into output, leaving extra
* int (if it exists) == 0x00 */
for (int i = keep; i < a.length; i++)
result[i - keep + extraInt] = ~a[i];
// Add one to one's complement to generate two's complement
for (int i=result.length-1; ++result[i] == 0; i--)
;
return result;
} |
Takes an array a representing a negative 2's-complement number and
returns the minimal (no leading zero ints) unsigned whose value is -a.
| BigInteger::makePositive | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private int intLength() {
return (bitLength() >>> 5) + 1;
} |
Returns the length of the two's complement representation in ints,
including space for at least one sign bit.
| BigInteger::intLength | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private int signBit() {
return signum < 0 ? 1 : 0;
} |
Returns the length of the two's complement representation in ints,
including space for at least one sign bit.
private int intLength() {
return (bitLength() >>> 5) + 1;
}
/* Returns sign bit | BigInteger::signBit | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private int signInt() {
return signum < 0 ? -1 : 0;
} |
Returns the length of the two's complement representation in ints,
including space for at least one sign bit.
private int intLength() {
return (bitLength() >>> 5) + 1;
}
/* Returns sign bit
private int signBit() {
return signum < 0 ? 1 : 0;
}
/* Returns an int of sign bits | BigInteger::signInt | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private int getInt(int n) {
if (n < 0)
return 0;
if (n >= mag.length)
return signInt();
int magInt = mag[mag.length-n-1];
return (signum >= 0 ? magInt :
(n <= firstNonzeroIntNum() ? -magInt : ~magInt));
} |
Returns the specified int of the little-endian two's complement
representation (int 0 is the least significant). The int number can
be arbitrarily high (values are logically preceded by infinitely many
sign ints).
| BigInteger::getInt | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private int firstNonzeroIntNum() {
int fn = firstNonzeroIntNum - 2;
if (fn == -2) { // firstNonzeroIntNum not initialized yet
fn = 0;
// Search for the first nonzero int
int i;
int mlen = mag.length;
for (i = mlen - 1; i >= 0 && mag[i] == 0; i--)
;
fn = mlen - i - 1;
firstNonzeroIntNum = fn + 2; // offset by two to initialize
}
return fn;
} |
Returns the index of the int that contains the first nonzero int in the
little-endian binary representation of the magnitude (int 0 is the
least significant). If the magnitude is zero, return value is undefined.
| BigInteger::firstNonzeroIntNum | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
/*
* In order to maintain compatibility with previous serialized forms,
* the magnitude of a BigInteger is serialized as an array of bytes.
* The magnitude field is used as a temporary store for the byte array
* that is deserialized. The cached computation fields should be
* transient but are serialized for compatibility reasons.
*/
// prepare to read the alternate persistent fields
ObjectInputStream.GetField fields = s.readFields();
// Read the alternate persistent fields that we care about
int sign = fields.get("signum", -2);
byte[] magnitude = (byte[])fields.get("magnitude", null);
// Validate signum
if (sign < -1 || sign > 1) {
String message = "BigInteger: Invalid signum value";
if (fields.defaulted("signum"))
message = "BigInteger: Signum not present in stream";
throw new java.io.StreamCorruptedException(message);
}
int[] mag = stripLeadingZeroBytes(magnitude);
if ((mag.length == 0) != (sign == 0)) {
String message = "BigInteger: signum-magnitude mismatch";
if (fields.defaulted("magnitude"))
message = "BigInteger: Magnitude not present in stream";
throw new java.io.StreamCorruptedException(message);
}
// Commit final fields via Unsafe
UnsafeHolder.putSign(this, sign);
// Calculate mag field from magnitude and discard magnitude
UnsafeHolder.putMag(this, mag);
if (mag.length >= MAX_MAG_LENGTH) {
try {
checkRange();
} catch (ArithmeticException e) {
throw new java.io.StreamCorruptedException("BigInteger: Out of the supported range");
}
}
} |
Reconstitute the {@code BigInteger} instance from a stream (that is,
deserialize it). The magnitude is read in as an array of bytes
for historical reasons, but it is converted to an array of ints
and the byte array is discarded.
Note:
The current convention is to initialize the cache fields, bitCount,
bitLength and lowestSetBit, to 0 rather than some other marker value.
Therefore, no explicit action to set these fields needs to be taken in
readObject because those fields already have a 0 value be default since
defaultReadObject is not being used.
| BigInteger::readObject | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private void writeObject(ObjectOutputStream s) throws IOException {
// set the values of the Serializable fields
ObjectOutputStream.PutField fields = s.putFields();
fields.put("signum", signum);
fields.put("magnitude", magSerializedForm());
// The values written for cached fields are compatible with older
// versions, but are ignored in readObject so don't otherwise matter.
fields.put("bitCount", -1);
fields.put("bitLength", -1);
fields.put("lowestSetBit", -2);
fields.put("firstNonzeroByteNum", -2);
// save them
s.writeFields();
} |
Save the {@code BigInteger} instance to a stream.
The magnitude of a BigInteger is serialized as a byte array for
historical reasons.
@serialData two necessary fields are written as well as obsolete
fields for compatibility with older versions.
| UnsafeHolder::writeObject | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
private byte[] magSerializedForm() {
int len = mag.length;
int bitLen = (len == 0 ? 0 : ((len - 1) << 5) + bitLengthForInt(mag[0]));
int byteLen = (bitLen + 7) >>> 3;
byte[] result = new byte[byteLen];
for (int i = byteLen - 1, bytesCopied = 4, intIndex = len - 1, nextInt = 0;
i >= 0; i--) {
if (bytesCopied == 4) {
nextInt = mag[intIndex--];
bytesCopied = 1;
} else {
nextInt >>>= 8;
bytesCopied++;
}
result[i] = (byte)nextInt;
}
return result;
} |
Returns the mag array as an array of bytes.
| UnsafeHolder::magSerializedForm | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
public long longValueExact() {
if (mag.length <= 2 && bitLength() <= 63)
return longValue();
else
throw new ArithmeticException("BigInteger out of long range");
} |
Converts this {@code BigInteger} to a {@code long}, checking
for lost information. If the value of this {@code BigInteger}
is out of the range of the {@code long} type, then an
{@code ArithmeticException} is thrown.
@return this {@code BigInteger} converted to a {@code long}.
@throws ArithmeticException if the value of {@code this} will
not exactly fit in a {@code long}.
@see BigInteger#longValue
@since 1.8
| UnsafeHolder::longValueExact | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
public int intValueExact() {
if (mag.length <= 1 && bitLength() <= 31)
return intValue();
else
throw new ArithmeticException("BigInteger out of int range");
} |
Converts this {@code BigInteger} to an {@code int}, checking
for lost information. If the value of this {@code BigInteger}
is out of the range of the {@code int} type, then an
{@code ArithmeticException} is thrown.
@return this {@code BigInteger} converted to an {@code int}.
@throws ArithmeticException if the value of {@code this} will
not exactly fit in a {@code int}.
@see BigInteger#intValue
@since 1.8
| UnsafeHolder::intValueExact | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
public short shortValueExact() {
if (mag.length <= 1 && bitLength() <= 31) {
int value = intValue();
if (value >= Short.MIN_VALUE && value <= Short.MAX_VALUE)
return shortValue();
}
throw new ArithmeticException("BigInteger out of short range");
} |
Converts this {@code BigInteger} to a {@code short}, checking
for lost information. If the value of this {@code BigInteger}
is out of the range of the {@code short} type, then an
{@code ArithmeticException} is thrown.
@return this {@code BigInteger} converted to a {@code short}.
@throws ArithmeticException if the value of {@code this} will
not exactly fit in a {@code short}.
@see BigInteger#shortValue
@since 1.8
| UnsafeHolder::shortValueExact | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
public byte byteValueExact() {
if (mag.length <= 1 && bitLength() <= 31) {
int value = intValue();
if (value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE)
return byteValue();
}
throw new ArithmeticException("BigInteger out of byte range");
} |
Converts this {@code BigInteger} to a {@code byte}, checking
for lost information. If the value of this {@code BigInteger}
is out of the range of the {@code byte} type, then an
{@code ArithmeticException} is thrown.
@return this {@code BigInteger} converted to a {@code byte}.
@throws ArithmeticException if the value of {@code this} will
not exactly fit in a {@code byte}.
@see BigInteger#byteValue
@since 1.8
| UnsafeHolder::byteValueExact | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/BigInteger.java | Apache-2.0 |
SignedMutableBigInteger() {
super();
} |
The default constructor. An empty MutableBigInteger is created with
a one word capacity.
| SignedMutableBigInteger::SignedMutableBigInteger | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | Apache-2.0 |
SignedMutableBigInteger(int val) {
super(val);
} |
Construct a new MutableBigInteger with a magnitude specified by
the int val.
| SignedMutableBigInteger::SignedMutableBigInteger | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | Apache-2.0 |
SignedMutableBigInteger(MutableBigInteger val) {
super(val);
} |
Construct a new MutableBigInteger with a magnitude equal to the
specified MutableBigInteger.
| SignedMutableBigInteger::SignedMutableBigInteger | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | Apache-2.0 |
void signedAdd(SignedMutableBigInteger addend) {
if (sign == addend.sign)
add(addend);
else
sign = sign * subtract(addend);
} |
Signed addition built upon unsigned add and subtract.
| SignedMutableBigInteger::signedAdd | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | Apache-2.0 |
void signedAdd(MutableBigInteger addend) {
if (sign == 1)
add(addend);
else
sign = sign * subtract(addend);
} |
Signed addition built upon unsigned add and subtract.
| SignedMutableBigInteger::signedAdd | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | Apache-2.0 |
void signedSubtract(SignedMutableBigInteger addend) {
if (sign == addend.sign)
sign = sign * subtract(addend);
else
add(addend);
} |
Signed subtraction built upon unsigned add and subtract.
| SignedMutableBigInteger::signedSubtract | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | Apache-2.0 |
void signedSubtract(MutableBigInteger addend) {
if (sign == 1)
sign = sign * subtract(addend);
else
add(addend);
if (intLen == 0)
sign = 1;
} |
Signed subtraction built upon unsigned add and subtract.
| SignedMutableBigInteger::signedSubtract | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | Apache-2.0 |
public String toString() {
return this.toBigInteger(sign).toString();
} |
Print out the first intLen ints of this MutableBigInteger's value
array starting at offset.
| SignedMutableBigInteger::toString | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/math/SignedMutableBigInteger.java | Apache-2.0 |
public DecimalFormat() {
// Get the pattern for the default locale.
Locale def = Locale.getDefault(Locale.Category.FORMAT);
/* J2ObjC: java.text.spi is not provided.
LocaleProviderAdapter adapter = LocaleProviderAdapter.getAdapter(NumberFormatProvider.class, def);
if (!(adapter instanceof ResourceBundleBasedAdapter)) {
adapter = LocaleProviderAdapter.getResourceBundleBased();
}
String[] all = adapter.getLocaleResources(def).getNumberPatterns();*/
// Always applyPattern after the symbols are set
this.symbols = DecimalFormatSymbols.getInstance(def);
applyPattern(LocaleData.get(def).numberPattern, false);
} |
Creates a DecimalFormat using the default pattern and symbols
for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.
This is a convenient way to obtain a
DecimalFormat when internationalization is not the main concern.
<p>
To obtain standard formats for a given locale, use the factory methods
on NumberFormat such as getNumberInstance. These factories will
return the most appropriate sub-class of NumberFormat for a given
locale.
@see java.text.NumberFormat#getInstance
@see java.text.NumberFormat#getNumberInstance
@see java.text.NumberFormat#getCurrencyInstance
@see java.text.NumberFormat#getPercentInstance
| DecimalFormat::DecimalFormat | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public DecimalFormat(String pattern) {
// Always applyPattern after the symbols are set
this.symbols = DecimalFormatSymbols.getInstance(Locale.getDefault(Locale.Category.FORMAT));
applyPattern(pattern, false);
} |
Creates a DecimalFormat using the given pattern and the symbols
for the default {@link java.util.Locale.Category#FORMAT FORMAT} locale.
This is a convenient way to obtain a
DecimalFormat when internationalization is not the main concern.
<p>
To obtain standard formats for a given locale, use the factory methods
on NumberFormat such as getNumberInstance. These factories will
return the most appropriate sub-class of NumberFormat for a given
locale.
@param pattern a non-localized pattern string.
@exception NullPointerException if <code>pattern</code> is null
@exception IllegalArgumentException if the given pattern is invalid.
@see java.text.NumberFormat#getInstance
@see java.text.NumberFormat#getNumberInstance
@see java.text.NumberFormat#getCurrencyInstance
@see java.text.NumberFormat#getPercentInstance
| DecimalFormat::DecimalFormat | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public DecimalFormat (String pattern, DecimalFormatSymbols symbols) {
// Always applyPattern after the symbols are set
this.symbols = (DecimalFormatSymbols)symbols.clone();
applyPattern(pattern, false);
} |
Creates a DecimalFormat using the given pattern and symbols.
Use this constructor when you need to completely customize the
behavior of the format.
<p>
To obtain standard formats for a given
locale, use the factory methods on NumberFormat such as
getInstance or getCurrencyInstance. If you need only minor adjustments
to a standard format, you can modify the format returned by
a NumberFormat factory method.
@param pattern a non-localized pattern string
@param symbols the set of symbols to be used
@exception NullPointerException if any of the given arguments is null
@exception IllegalArgumentException if the given pattern is invalid
@see java.text.NumberFormat#getInstance
@see java.text.NumberFormat#getNumberInstance
@see java.text.NumberFormat#getCurrencyInstance
@see java.text.NumberFormat#getPercentInstance
@see java.text.DecimalFormatSymbols
| DecimalFormat::DecimalFormat | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private StringBuffer format(double number, StringBuffer result,
FieldDelegate delegate) {
if (Double.isNaN(number) ||
(Double.isInfinite(number) && multiplier == 0)) {
int iFieldStart = result.length();
result.append(symbols.getNaN());
delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,
iFieldStart, result.length(), result);
return result;
}
/* Detecting whether a double is negative is easy with the exception of
* the value -0.0. This is a double which has a zero mantissa (and
* exponent), but a negative sign bit. It is semantically distinct from
* a zero with a positive sign bit, and this distinction is important
* to certain kinds of computations. However, it's a little tricky to
* detect, since (-0.0 == 0.0) and !(-0.0 < 0.0). How then, you may
* ask, does it behave distinctly from +0.0? Well, 1/(-0.0) ==
* -Infinity. Proper detection of -0.0 is needed to deal with the
* issues raised by bugs 4106658, 4106667, and 4147706. Liu 7/6/98.
*/
boolean isNegative = ((number < 0.0) || (number == 0.0 && 1/number < 0.0)) ^ (multiplier < 0);
if (multiplier != 1) {
number *= multiplier;
}
if (Double.isInfinite(number)) {
if (isNegative) {
append(result, negativePrefix, delegate,
getNegativePrefixFieldPositions(), Field.SIGN);
} else {
append(result, positivePrefix, delegate,
getPositivePrefixFieldPositions(), Field.SIGN);
}
int iFieldStart = result.length();
result.append(symbols.getInfinity());
delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,
iFieldStart, result.length(), result);
if (isNegative) {
append(result, negativeSuffix, delegate,
getNegativeSuffixFieldPositions(), Field.SIGN);
} else {
append(result, positiveSuffix, delegate,
getPositiveSuffixFieldPositions(), Field.SIGN);
}
return result;
}
if (isNegative) {
number = -number;
}
// at this point we are guaranteed a nonnegative finite number.
assert(number >= 0 && !Double.isInfinite(number));
synchronized(digitList) {
int maxIntDigits = super.getMaximumIntegerDigits();
int minIntDigits = super.getMinimumIntegerDigits();
int maxFraDigits = super.getMaximumFractionDigits();
int minFraDigits = super.getMinimumFractionDigits();
digitList.set(isNegative, number, useExponentialNotation ?
maxIntDigits + maxFraDigits : maxFraDigits,
!useExponentialNotation);
return subformat(result, delegate, isNegative, false,
maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
}
} |
Formats a double to produce a string.
@param number The double to format
@param result where the text is to be appended
@param delegate notified of locations of sub fields
@exception ArithmeticException if rounding is needed with rounding
mode being set to RoundingMode.UNNECESSARY
@return The formatted number string
| DecimalFormat::format | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private StringBuffer format(long number, StringBuffer result,
FieldDelegate delegate) {
boolean isNegative = (number < 0);
if (isNegative) {
number = -number;
}
// In general, long values always represent real finite numbers, so
// we don't have to check for +/- Infinity or NaN. However, there
// is one case we have to be careful of: The multiplier can push
// a number near MIN_VALUE or MAX_VALUE outside the legal range. We
// check for this before multiplying, and if it happens we use
// BigInteger instead.
boolean useBigInteger = false;
if (number < 0) { // This can only happen if number == Long.MIN_VALUE.
if (multiplier != 0) {
useBigInteger = true;
}
} else if (multiplier != 1 && multiplier != 0) {
long cutoff = Long.MAX_VALUE / multiplier;
if (cutoff < 0) {
cutoff = -cutoff;
}
useBigInteger = (number > cutoff);
}
if (useBigInteger) {
if (isNegative) {
number = -number;
}
BigInteger bigIntegerValue = BigInteger.valueOf(number);
return format(bigIntegerValue, result, delegate, true);
}
number *= multiplier;
if (number == 0) {
isNegative = false;
} else {
if (multiplier < 0) {
number = -number;
isNegative = !isNegative;
}
}
synchronized(digitList) {
int maxIntDigits = super.getMaximumIntegerDigits();
int minIntDigits = super.getMinimumIntegerDigits();
int maxFraDigits = super.getMaximumFractionDigits();
int minFraDigits = super.getMinimumFractionDigits();
digitList.set(isNegative, number,
useExponentialNotation ? maxIntDigits + maxFraDigits : 0);
return subformat(result, delegate, isNegative, true,
maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
}
} |
Format a long to produce a string.
@param number The long to format
@param result where the text is to be appended
@param delegate notified of locations of sub fields
@return The formatted number string
@exception ArithmeticException if rounding is needed with rounding
mode being set to RoundingMode.UNNECESSARY
@see java.text.FieldPosition
| DecimalFormat::format | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private StringBuffer format(BigDecimal number, StringBuffer result,
FieldPosition fieldPosition) {
fieldPosition.setBeginIndex(0);
fieldPosition.setEndIndex(0);
return format(number, result, fieldPosition.getFieldDelegate());
} |
Formats a BigDecimal to produce a string.
@param number The BigDecimal to format
@param result where the text is to be appended
@param fieldPosition On input: an alignment field, if desired.
On output: the offsets of the alignment field.
@return The formatted number string
@exception ArithmeticException if rounding is needed with rounding
mode being set to RoundingMode.UNNECESSARY
@see java.text.FieldPosition
| DecimalFormat::format | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private StringBuffer format(BigDecimal number, StringBuffer result,
FieldDelegate delegate) {
if (multiplier != 1) {
number = number.multiply(getBigDecimalMultiplier());
}
boolean isNegative = number.signum() == -1;
if (isNegative) {
number = number.negate();
}
synchronized(digitList) {
int maxIntDigits = getMaximumIntegerDigits();
int minIntDigits = getMinimumIntegerDigits();
int maxFraDigits = getMaximumFractionDigits();
int minFraDigits = getMinimumFractionDigits();
int maximumDigits = maxIntDigits + maxFraDigits;
digitList.set(isNegative, number, useExponentialNotation ?
((maximumDigits < 0) ? Integer.MAX_VALUE : maximumDigits) :
maxFraDigits, !useExponentialNotation);
return subformat(result, delegate, isNegative, false,
maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
}
} |
Formats a BigDecimal to produce a string.
@param number The BigDecimal to format
@param result where the text is to be appended
@param delegate notified of locations of sub fields
@exception ArithmeticException if rounding is needed with rounding
mode being set to RoundingMode.UNNECESSARY
@return The formatted number string
| DecimalFormat::format | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private StringBuffer format(BigInteger number, StringBuffer result,
FieldPosition fieldPosition) {
fieldPosition.setBeginIndex(0);
fieldPosition.setEndIndex(0);
return format(number, result, fieldPosition.getFieldDelegate(), false);
} |
Format a BigInteger to produce a string.
@param number The BigInteger to format
@param result where the text is to be appended
@param fieldPosition On input: an alignment field, if desired.
On output: the offsets of the alignment field.
@return The formatted number string
@exception ArithmeticException if rounding is needed with rounding
mode being set to RoundingMode.UNNECESSARY
@see java.text.FieldPosition
| DecimalFormat::format | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private StringBuffer format(BigInteger number, StringBuffer result,
FieldDelegate delegate, boolean formatLong) {
if (multiplier != 1) {
number = number.multiply(getBigIntegerMultiplier());
}
boolean isNegative = number.signum() == -1;
if (isNegative) {
number = number.negate();
}
synchronized(digitList) {
int maxIntDigits, minIntDigits, maxFraDigits, minFraDigits, maximumDigits;
if (formatLong) {
maxIntDigits = super.getMaximumIntegerDigits();
minIntDigits = super.getMinimumIntegerDigits();
maxFraDigits = super.getMaximumFractionDigits();
minFraDigits = super.getMinimumFractionDigits();
maximumDigits = maxIntDigits + maxFraDigits;
} else {
maxIntDigits = getMaximumIntegerDigits();
minIntDigits = getMinimumIntegerDigits();
maxFraDigits = getMaximumFractionDigits();
minFraDigits = getMinimumFractionDigits();
maximumDigits = maxIntDigits + maxFraDigits;
if (maximumDigits < 0) {
maximumDigits = Integer.MAX_VALUE;
}
}
digitList.set(isNegative, number,
useExponentialNotation ? maximumDigits : 0);
return subformat(result, delegate, isNegative, true,
maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
}
} |
Format a BigInteger to produce a string.
@param number The BigInteger to format
@param result where the text is to be appended
@param delegate notified of locations of sub fields
@return The formatted number string
@exception ArithmeticException if rounding is needed with rounding
mode being set to RoundingMode.UNNECESSARY
@see java.text.FieldPosition
| DecimalFormat::format | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void checkAndSetFastPathStatus() {
boolean fastPathWasOn = isFastPath;
if ((roundingMode == RoundingMode.HALF_EVEN) &&
(isGroupingUsed()) &&
(groupingSize == 3) &&
(secondaryGroupingSize == 0) &&
(multiplier == 1) &&
(!decimalSeparatorAlwaysShown) &&
(!useExponentialNotation)) {
// The fast-path algorithm is semi-hardcoded against
// minimumIntegerDigits and maximumIntegerDigits.
isFastPath = ((minimumIntegerDigits == 1) &&
(maximumIntegerDigits >= 10));
// The fast-path algorithm is hardcoded against
// minimumFractionDigits and maximumFractionDigits.
if (isFastPath) {
if (isCurrencyFormat) {
if ((minimumFractionDigits != 2) ||
(maximumFractionDigits != 2))
isFastPath = false;
} else if ((minimumFractionDigits != 0) ||
(maximumFractionDigits != 3))
isFastPath = false;
}
} else
isFastPath = false;
// Since some instance properties may have changed while still falling
// in the fast-path case, we need to reinitialize fastPathData anyway.
if (isFastPath) {
// We need to instantiate fastPathData if not already done.
if (fastPathData == null)
fastPathData = new FastPathData();
// Sets up the locale specific constants used when formatting.
// '0' is our default representation of zero.
fastPathData.zeroDelta = symbols.getZeroDigit() - '0';
fastPathData.groupingChar = symbols.getGroupingSeparator();
// Sets up fractional constants related to currency/decimal pattern.
fastPathData.fractionalMaxIntBound = (isCurrencyFormat) ? 99 : 999;
fastPathData.fractionalScaleFactor = (isCurrencyFormat) ? 100.0d : 1000.0d;
// Records the need for adding prefix or suffix
fastPathData.positiveAffixesRequired =
(positivePrefix.length() != 0) || (positiveSuffix.length() != 0);
fastPathData.negativeAffixesRequired =
(negativePrefix.length() != 0) || (negativeSuffix.length() != 0);
// Creates a cached char container for result, with max possible size.
int maxNbIntegralDigits = 10;
int maxNbGroups = 3;
int containerSize =
Math.max(positivePrefix.length(), negativePrefix.length()) +
maxNbIntegralDigits + maxNbGroups + 1 + maximumFractionDigits +
Math.max(positiveSuffix.length(), negativeSuffix.length());
fastPathData.fastPathContainer = new char[containerSize];
// Sets up prefix and suffix char arrays constants.
fastPathData.charsPositiveSuffix = positiveSuffix.toCharArray();
fastPathData.charsNegativeSuffix = negativeSuffix.toCharArray();
fastPathData.charsPositivePrefix = positivePrefix.toCharArray();
fastPathData.charsNegativePrefix = negativePrefix.toCharArray();
// Sets up fixed index positions for integral and fractional digits.
// Sets up decimal point in cached result container.
int longestPrefixLength =
Math.max(positivePrefix.length(), negativePrefix.length());
int decimalPointIndex =
maxNbIntegralDigits + maxNbGroups + longestPrefixLength;
fastPathData.integralLastIndex = decimalPointIndex - 1;
fastPathData.fractionalFirstIndex = decimalPointIndex + 1;
fastPathData.fastPathContainer[decimalPointIndex] =
isCurrencyFormat ?
symbols.getMonetaryDecimalSeparator() :
symbols.getDecimalSeparator();
} else if (fastPathWasOn) {
// Previous state was fast-path and is no more.
// Resets cached array constants.
fastPathData.fastPathContainer = null;
fastPathData.charsPositiveSuffix = null;
fastPathData.charsNegativeSuffix = null;
fastPathData.charsPositivePrefix = null;
fastPathData.charsNegativePrefix = null;
}
fastPathCheckNeeded = false;
} |
Check validity of using fast-path for this instance. If fast-path is valid
for this instance, sets fast-path state as true and initializes fast-path
utility fields as needed.
This method is supposed to be called rarely, otherwise that will break the
fast-path performance. That means avoiding frequent changes of the
properties of the instance, since for most properties, each time a change
happens, a call to this method is needed at the next format call.
FAST-PATH RULES:
Similar to the default DecimalFormat instantiation case.
More precisely:
- HALF_EVEN rounding mode,
- isGroupingUsed() is true,
- groupingSize of 3,
- multiplier is 1,
- Decimal separator not mandatory,
- No use of exponential notation,
- minimumIntegerDigits is exactly 1 and maximumIntegerDigits at least 10
- For number of fractional digits, the exact values found in the default case:
Currency : min = max = 2.
Decimal : min = 0. max = 3.
| DecimalFormat::checkAndSetFastPathStatus | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private boolean exactRoundUp(double fractionalPart,
int scaledFractionalPartAsInt) {
/* exactRoundUp() method is called by fastDoubleFormat() only.
* The precondition expected to be verified by the passed parameters is :
* scaledFractionalPartAsInt ==
* (int) (fractionalPart * fastPathData.fractionalScaleFactor).
* This is ensured by fastDoubleFormat() code.
*/
/* We first calculate roundoff error made by fastDoubleFormat() on
* the scaled fractional part. We do this with exact calculation on the
* passed fractionalPart. Rounding decision will then be taken from roundoff.
*/
/* ---- TwoProduct(fractionalPart, scale factor (i.e. 1000.0d or 100.0d)).
*
* The below is an optimized exact "TwoProduct" calculation of passed
* fractional part with scale factor, using Ogita's Sum2S cascaded
* summation adapted as Kahan-Babuska equivalent by using FastTwoSum
* (much faster) rather than Knuth's TwoSum.
*
* We can do this because we order the summation from smallest to
* greatest, so that FastTwoSum can be used without any additional error.
*
* The "TwoProduct" exact calculation needs 17 flops. We replace this by
* a cascaded summation of FastTwoSum calculations, each involving an
* exact multiply by a power of 2.
*
* Doing so saves overall 4 multiplications and 1 addition compared to
* using traditional "TwoProduct".
*
* The scale factor is either 100 (currency case) or 1000 (decimal case).
* - when 1000, we replace it by (1024 - 16 - 8) = 1000.
* - when 100, we replace it by (128 - 32 + 4) = 100.
* Every multiplication by a power of 2 (1024, 128, 32, 16, 8, 4) is exact.
*
*/
double approxMax; // Will always be positive.
double approxMedium; // Will always be negative.
double approxMin;
double fastTwoSumApproximation = 0.0d;
double fastTwoSumRoundOff = 0.0d;
double bVirtual = 0.0d;
if (isCurrencyFormat) {
// Scale is 100 = 128 - 32 + 4.
// Multiply by 2**n is a shift. No roundoff. No error.
approxMax = fractionalPart * 128.00d;
approxMedium = - (fractionalPart * 32.00d);
approxMin = fractionalPart * 4.00d;
} else {
// Scale is 1000 = 1024 - 16 - 8.
// Multiply by 2**n is a shift. No roundoff. No error.
approxMax = fractionalPart * 1024.00d;
approxMedium = - (fractionalPart * 16.00d);
approxMin = - (fractionalPart * 8.00d);
}
// Shewchuk/Dekker's FastTwoSum(approxMedium, approxMin).
assert(-approxMedium >= Math.abs(approxMin));
fastTwoSumApproximation = approxMedium + approxMin;
bVirtual = fastTwoSumApproximation - approxMedium;
fastTwoSumRoundOff = approxMin - bVirtual;
double approxS1 = fastTwoSumApproximation;
double roundoffS1 = fastTwoSumRoundOff;
// Shewchuk/Dekker's FastTwoSum(approxMax, approxS1);
assert(approxMax >= Math.abs(approxS1));
fastTwoSumApproximation = approxMax + approxS1;
bVirtual = fastTwoSumApproximation - approxMax;
fastTwoSumRoundOff = approxS1 - bVirtual;
double roundoff1000 = fastTwoSumRoundOff;
double approx1000 = fastTwoSumApproximation;
double roundoffTotal = roundoffS1 + roundoff1000;
// Shewchuk/Dekker's FastTwoSum(approx1000, roundoffTotal);
assert(approx1000 >= Math.abs(roundoffTotal));
fastTwoSumApproximation = approx1000 + roundoffTotal;
bVirtual = fastTwoSumApproximation - approx1000;
// Now we have got the roundoff for the scaled fractional
double scaledFractionalRoundoff = roundoffTotal - bVirtual;
// ---- TwoProduct(fractionalPart, scale (i.e. 1000.0d or 100.0d)) end.
/* ---- Taking the rounding decision
*
* We take rounding decision based on roundoff and half-even rounding
* rule.
*
* The above TwoProduct gives us the exact roundoff on the approximated
* scaled fractional, and we know that this approximation is exactly
* 0.5d, since that has already been tested by the caller
* (fastDoubleFormat).
*
* Decision comes first from the sign of the calculated exact roundoff.
* - Since being exact roundoff, it cannot be positive with a scaled
* fractional less than 0.5d, as well as negative with a scaled
* fractional greater than 0.5d. That leaves us with following 3 cases.
* - positive, thus scaled fractional == 0.500....0fff ==> round-up.
* - negative, thus scaled fractional == 0.499....9fff ==> don't round-up.
* - is zero, thus scaled fractioanl == 0.5 ==> half-even rounding applies :
* we round-up only if the integral part of the scaled fractional is odd.
*
*/
if (scaledFractionalRoundoff > 0.0) {
return true;
} else if (scaledFractionalRoundoff < 0.0) {
return false;
} else if ((scaledFractionalPartAsInt & 1) != 0) {
return true;
}
return false;
// ---- Taking the rounding decision end
} |
Returns true if rounding-up must be done on {@code scaledFractionalPartAsInt},
false otherwise.
This is a utility method that takes correct half-even rounding decision on
passed fractional value at the scaled decimal point (2 digits for currency
case and 3 for decimal case), when the approximated fractional part after
scaled decimal point is exactly 0.5d. This is done by means of exact
calculations on the {@code fractionalPart} floating-point value.
This method is supposed to be called by private {@code fastDoubleFormat}
method only.
The algorithms used for the exact calculations are :
The <b><i>FastTwoSum</i></b> algorithm, from T.J.Dekker, described in the
papers "<i>A Floating-Point Technique for Extending the Available
Precision</i>" by Dekker, and in "<i>Adaptive Precision Floating-Point
Arithmetic and Fast Robust Geometric Predicates</i>" from J.Shewchuk.
A modified version of <b><i>Sum2S</i></b> cascaded summation described in
"<i>Accurate Sum and Dot Product</i>" from Takeshi Ogita and All. As
Ogita says in this paper this is an equivalent of the Kahan-Babuska's
summation algorithm because we order the terms by magnitude before summing
them. For this reason we can use the <i>FastTwoSum</i> algorithm rather
than the more expensive Knuth's <i>TwoSum</i>.
We do this to avoid a more expensive exact "<i>TwoProduct</i>" algorithm,
like those described in Shewchuk's paper above. See comments in the code
below.
@param fractionalPart The fractional value on which we take rounding
decision.
@param scaledFractionalPartAsInt The integral part of the scaled
fractional value.
@return the decision that must be taken regarding half-even rounding.
| DecimalFormat::exactRoundUp | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void collectIntegralDigits(int number,
char[] digitsBuffer,
int backwardIndex) {
int index = backwardIndex;
int q;
int r;
while (number > 999) {
// Generates 3 digits per iteration.
q = number / 1000;
r = number - (q << 10) + (q << 4) + (q << 3); // -1024 +16 +8 = 1000.
number = q;
digitsBuffer[index--] = DigitArrays.DigitOnes1000[r];
digitsBuffer[index--] = DigitArrays.DigitTens1000[r];
digitsBuffer[index--] = DigitArrays.DigitHundreds1000[r];
digitsBuffer[index--] = fastPathData.groupingChar;
}
// Collects last 3 or less digits.
digitsBuffer[index] = DigitArrays.DigitOnes1000[number];
if (number > 9) {
digitsBuffer[--index] = DigitArrays.DigitTens1000[number];
if (number > 99)
digitsBuffer[--index] = DigitArrays.DigitHundreds1000[number];
}
fastPathData.firstUsedIndex = index;
} |
Collects integral digits from passed {@code number}, while setting
grouping chars as needed. Updates {@code firstUsedIndex} accordingly.
Loops downward starting from {@code backwardIndex} position (inclusive).
@param number The int value from which we collect digits.
@param digitsBuffer The char array container where digits and grouping chars
are stored.
@param backwardIndex the position from which we start storing digits in
digitsBuffer.
| DecimalFormat::collectIntegralDigits | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void collectFractionalDigits(int number,
char[] digitsBuffer,
int startIndex) {
int index = startIndex;
char digitOnes = DigitArrays.DigitOnes1000[number];
char digitTens = DigitArrays.DigitTens1000[number];
if (isCurrencyFormat) {
// Currency case. Always collects fractional digits.
digitsBuffer[index++] = digitTens;
digitsBuffer[index++] = digitOnes;
} else if (number != 0) {
// Decimal case. Hundreds will always be collected
digitsBuffer[index++] = DigitArrays.DigitHundreds1000[number];
// Ending zeros won't be collected.
if (digitOnes != '0') {
digitsBuffer[index++] = digitTens;
digitsBuffer[index++] = digitOnes;
} else if (digitTens != '0')
digitsBuffer[index++] = digitTens;
} else
// This is decimal pattern and fractional part is zero.
// We must remove decimal point from result.
index--;
fastPathData.lastFreeIndex = index;
} |
Collects the 2 (currency) or 3 (decimal) fractional digits from passed
{@code number}, starting at {@code startIndex} position
inclusive. There is no punctuation to set here (no grouping chars).
Updates {@code fastPathData.lastFreeIndex} accordingly.
@param number The int value from which we collect digits.
@param digitsBuffer The char array container where digits are stored.
@param startIndex the position from which we start storing digits in
digitsBuffer.
| DecimalFormat::collectFractionalDigits | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void prependPrefix(char[] prefix,
int len,
char[] container) {
fastPathData.firstUsedIndex -= len;
int startIndex = fastPathData.firstUsedIndex;
// If prefix to prepend is only 1 char long, just assigns this char.
// If prefix is less or equal 4, we use a dedicated algorithm that
// has shown to run faster than System.arraycopy.
// If more than 4, we use System.arraycopy.
if (len == 1)
container[startIndex] = prefix[0];
else if (len <= 4) {
int dstLower = startIndex;
int dstUpper = dstLower + len - 1;
int srcUpper = len - 1;
container[dstLower] = prefix[0];
container[dstUpper] = prefix[srcUpper];
if (len > 2)
container[++dstLower] = prefix[1];
if (len == 4)
container[--dstUpper] = prefix[2];
} else
System.arraycopy(prefix, 0, container, startIndex, len);
} |
Prepends the passed {@code prefix} chars to given result
{@code container}. Updates {@code fastPathData.firstUsedIndex}
accordingly.
@param prefix The prefix characters to prepend to result.
@param len The number of chars to prepend.
@param container Char array container which to prepend the prefix
| DecimalFormat::prependPrefix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void appendSuffix(char[] suffix,
int len,
char[] container) {
int startIndex = fastPathData.lastFreeIndex;
// If suffix to append is only 1 char long, just assigns this char.
// If suffix is less or equal 4, we use a dedicated algorithm that
// has shown to run faster than System.arraycopy.
// If more than 4, we use System.arraycopy.
if (len == 1)
container[startIndex] = suffix[0];
else if (len <= 4) {
int dstLower = startIndex;
int dstUpper = dstLower + len - 1;
int srcUpper = len - 1;
container[dstLower] = suffix[0];
container[dstUpper] = suffix[srcUpper];
if (len > 2)
container[++dstLower] = suffix[1];
if (len == 4)
container[--dstUpper] = suffix[2];
} else
System.arraycopy(suffix, 0, container, startIndex, len);
fastPathData.lastFreeIndex += len;
} |
Appends the passed {@code suffix} chars to given result
{@code container}. Updates {@code fastPathData.lastFreeIndex}
accordingly.
@param suffix The suffix characters to append to result.
@param len The number of chars to append.
@param container Char array container which to append the suffix
| DecimalFormat::appendSuffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void localizeDigits(char[] digitsBuffer) {
// We will localize only the digits, using the groupingSize,
// and taking into account fractional part.
// First take into account fractional part.
int digitsCounter =
fastPathData.lastFreeIndex - fastPathData.fractionalFirstIndex;
// The case when there is no fractional digits.
if (digitsCounter < 0)
digitsCounter = groupingSize;
// Only the digits remains to localize.
for (int cursor = fastPathData.lastFreeIndex - 1;
cursor >= fastPathData.firstUsedIndex;
cursor--) {
if (digitsCounter != 0) {
// This is a digit char, we must localize it.
digitsBuffer[cursor] += fastPathData.zeroDelta;
digitsCounter--;
} else {
// Decimal separator or grouping char. Reinit counter only.
digitsCounter = groupingSize;
}
}
} |
Converts digit chars from {@code digitsBuffer} to current locale.
Must be called before adding affixes since we refer to
{@code fastPathData.firstUsedIndex} and {@code fastPathData.lastFreeIndex},
and do not support affixes (for speed reason).
We loop backward starting from last used index in {@code fastPathData}.
@param digitsBuffer The char array container where the digits are stored.
| DecimalFormat::localizeDigits | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void fastDoubleFormat(double d,
boolean negative) {
char[] container = fastPathData.fastPathContainer;
/*
* The principle of the algorithm is to :
* - Break the passed double into its integral and fractional parts
* converted into integers.
* - Then decide if rounding up must be applied or not by following
* the half-even rounding rule, first using approximated scaled
* fractional part.
* - For the difficult cases (approximated scaled fractional part
* being exactly 0.5d), we refine the rounding decision by calling
* exactRoundUp utility method that both calculates the exact roundoff
* on the approximation and takes correct rounding decision.
* - We round-up the fractional part if needed, possibly propagating the
* rounding to integral part if we meet a "all-nine" case for the
* scaled fractional part.
* - We then collect digits from the resulting integral and fractional
* parts, also setting the required grouping chars on the fly.
* - Then we localize the collected digits if needed, and
* - Finally prepend/append prefix/suffix if any is needed.
*/
// Exact integral part of d.
int integralPartAsInt = (int) d;
// Exact fractional part of d (since we subtract it's integral part).
double exactFractionalPart = d - (double) integralPartAsInt;
// Approximated scaled fractional part of d (due to multiplication).
double scaledFractional =
exactFractionalPart * fastPathData.fractionalScaleFactor;
// Exact integral part of scaled fractional above.
int fractionalPartAsInt = (int) scaledFractional;
// Exact fractional part of scaled fractional above.
scaledFractional = scaledFractional - (double) fractionalPartAsInt;
// Only when scaledFractional is exactly 0.5d do we have to do exact
// calculations and take fine-grained rounding decision, since
// approximated results above may lead to incorrect decision.
// Otherwise comparing against 0.5d (strictly greater or less) is ok.
boolean roundItUp = false;
if (scaledFractional >= 0.5d) {
if (scaledFractional == 0.5d)
// Rounding need fine-grained decision.
roundItUp = exactRoundUp(exactFractionalPart, fractionalPartAsInt);
else
roundItUp = true;
if (roundItUp) {
// Rounds up both fractional part (and also integral if needed).
if (fractionalPartAsInt < fastPathData.fractionalMaxIntBound) {
fractionalPartAsInt++;
} else {
// Propagates rounding to integral part since "all nines" case.
fractionalPartAsInt = 0;
integralPartAsInt++;
}
}
}
// Collecting digits.
collectFractionalDigits(fractionalPartAsInt, container,
fastPathData.fractionalFirstIndex);
collectIntegralDigits(integralPartAsInt, container,
fastPathData.integralLastIndex);
// Localizing digits.
if (fastPathData.zeroDelta != 0)
localizeDigits(container);
// Adding prefix and suffix.
if (negative) {
if (fastPathData.negativeAffixesRequired)
addAffixes(container,
fastPathData.charsNegativePrefix,
fastPathData.charsNegativeSuffix);
} else if (fastPathData.positiveAffixesRequired)
addAffixes(container,
fastPathData.charsPositivePrefix,
fastPathData.charsPositiveSuffix);
} |
This is the main entry point for the fast-path format algorithm.
At this point we are sure to be in the expected conditions to run it.
This algorithm builds the formatted result and puts it in the dedicated
{@code fastPathData.fastPathContainer}.
@param d the double value to be formatted.
@param negative Flag precising if {@code d} is negative.
| DecimalFormat::fastDoubleFormat | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
String fastFormat(double d) {
// (Re-)Evaluates fast-path status if needed.
if (fastPathCheckNeeded)
checkAndSetFastPathStatus();
if (!isFastPath )
// DecimalFormat instance is not in a fast-path state.
return null;
if (!Double.isFinite(d))
// Should not use fast-path for Infinity and NaN.
return null;
// Extracts and records sign of double value, possibly changing it
// to a positive one, before calling fastDoubleFormat().
boolean negative = false;
if (d < 0.0d) {
negative = true;
d = -d;
} else if (d == 0.0d) {
negative = (Math.copySign(1.0d, d) == -1.0d);
d = +0.0d;
}
if (d > MAX_INT_AS_DOUBLE)
// Filters out values that are outside expected fast-path range
return null;
else
fastDoubleFormat(d, negative);
// Returns a new string from updated fastPathContainer.
return new String(fastPathData.fastPathContainer,
fastPathData.firstUsedIndex,
fastPathData.lastFreeIndex - fastPathData.firstUsedIndex);
} |
A fast-path shortcut of format(double) to be called by NumberFormat, or by
format(double, ...) public methods.
If instance can be applied fast-path and passed double is not NaN or
Infinity, is in the integer range, we call {@code fastDoubleFormat}
after changing {@code d} to its positive value if necessary.
Otherwise returns null by convention since fast-path can't be exercized.
@param d The double value to be formatted
@return the formatted result for {@code d} as a string.
| DecimalFormat::fastFormat | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private StringBuffer subformat(StringBuffer result, FieldDelegate delegate,
boolean isNegative, boolean isInteger,
int maxIntDigits, int minIntDigits,
int maxFraDigits, int minFraDigits) {
// NOTE: This isn't required anymore because DigitList takes care of this.
//
// // The negative of the exponent represents the number of leading
// // zeros between the decimal and the first non-zero digit, for
// // a value < 0.1 (e.g., for 0.00123, -fExponent == 2). If this
// // is more than the maximum fraction digits, then we have an underflow
// // for the printed representation. We recognize this here and set
// // the DigitList representation to zero in this situation.
//
// if (-digitList.decimalAt >= getMaximumFractionDigits())
// {
// digitList.count = 0;
// }
char zero = symbols.getZeroDigit();
int zeroDelta = zero - '0'; // '0' is the DigitList representation of zero
char grouping = symbols.getGroupingSeparator();
char decimal = isCurrencyFormat ?
symbols.getMonetaryDecimalSeparator() :
symbols.getDecimalSeparator();
/* Per bug 4147706, DecimalFormat must respect the sign of numbers which
* format as zero. This allows sensible computations and preserves
* relations such as signum(1/x) = signum(x), where x is +Infinity or
* -Infinity. Prior to this fix, we always formatted zero values as if
* they were positive. Liu 7/6/98.
*/
if (digitList.isZero()) {
digitList.decimalAt = 0; // Normalize
}
if (isNegative) {
append(result, negativePrefix, delegate,
getNegativePrefixFieldPositions(), Field.SIGN);
} else {
append(result, positivePrefix, delegate,
getPositivePrefixFieldPositions(), Field.SIGN);
}
if (useExponentialNotation) {
int iFieldStart = result.length();
int iFieldEnd = -1;
int fFieldStart = -1;
// Minimum integer digits are handled in exponential format by
// adjusting the exponent. For example, 0.01234 with 3 minimum
// integer digits is "123.4E-4".
// Maximum integer digits are interpreted as indicating the
// repeating range. This is useful for engineering notation, in
// which the exponent is restricted to a multiple of 3. For
// example, 0.01234 with 3 maximum integer digits is "12.34e-3".
// If maximum integer digits are > 1 and are larger than
// minimum integer digits, then minimum integer digits are
// ignored.
int exponent = digitList.decimalAt;
int repeat = maxIntDigits;
int minimumIntegerDigits = minIntDigits;
if (repeat > 1 && repeat > minIntDigits) {
// A repeating range is defined; adjust to it as follows.
// If repeat == 3, we have 6,5,4=>3; 3,2,1=>0; 0,-1,-2=>-3;
// -3,-4,-5=>-6, etc. This takes into account that the
// exponent we have here is off by one from what we expect;
// it is for the format 0.MMMMMx10^n.
if (exponent >= 1) {
exponent = ((exponent - 1) / repeat) * repeat;
} else {
// integer division rounds towards 0
exponent = ((exponent - repeat) / repeat) * repeat;
}
minimumIntegerDigits = 1;
} else {
// No repeating range is defined; use minimum integer digits.
exponent -= minimumIntegerDigits;
}
// We now output a minimum number of digits, and more if there
// are more digits, up to the maximum number of digits. We
// place the decimal point after the "integer" digits, which
// are the first (decimalAt - exponent) digits.
int minimumDigits = minIntDigits + minFraDigits;
if (minimumDigits < 0) { // overflow?
minimumDigits = Integer.MAX_VALUE;
}
// The number of integer digits is handled specially if the number
// is zero, since then there may be no digits.
int integerDigits = digitList.isZero() ? minimumIntegerDigits :
digitList.decimalAt - exponent;
if (minimumDigits < integerDigits) {
minimumDigits = integerDigits;
}
int totalDigits = digitList.count;
if (minimumDigits > totalDigits) {
totalDigits = minimumDigits;
}
boolean addedDecimalSeparator = false;
for (int i=0; i<totalDigits; ++i) {
if (i == integerDigits) {
// Record field information for caller.
iFieldEnd = result.length();
result.append(decimal);
addedDecimalSeparator = true;
// Record field information for caller.
fFieldStart = result.length();
}
result.append((i < digitList.count) ?
(char)(digitList.digits[i] + zeroDelta) :
zero);
}
if (decimalSeparatorAlwaysShown && totalDigits == integerDigits) {
// Record field information for caller.
iFieldEnd = result.length();
result.append(decimal);
addedDecimalSeparator = true;
// Record field information for caller.
fFieldStart = result.length();
}
// Record field information
if (iFieldEnd == -1) {
iFieldEnd = result.length();
}
delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,
iFieldStart, iFieldEnd, result);
if (addedDecimalSeparator) {
delegate.formatted(Field.DECIMAL_SEPARATOR,
Field.DECIMAL_SEPARATOR,
iFieldEnd, fFieldStart, result);
}
if (fFieldStart == -1) {
fFieldStart = result.length();
}
delegate.formatted(FRACTION_FIELD, Field.FRACTION, Field.FRACTION,
fFieldStart, result.length(), result);
// The exponent is output using the pattern-specified minimum
// exponent digits. There is no maximum limit to the exponent
// digits, since truncating the exponent would result in an
// unacceptable inaccuracy.
int fieldStart = result.length();
result.append(symbols.getExponentSeparator());
delegate.formatted(Field.EXPONENT_SYMBOL, Field.EXPONENT_SYMBOL,
fieldStart, result.length(), result);
// For zero values, we force the exponent to zero. We
// must do this here, and not earlier, because the value
// is used to determine integer digit count above.
if (digitList.isZero()) {
exponent = 0;
}
boolean negativeExponent = exponent < 0;
if (negativeExponent) {
exponent = -exponent;
fieldStart = result.length();
result.append(symbols.getMinusSign());
delegate.formatted(Field.EXPONENT_SIGN, Field.EXPONENT_SIGN,
fieldStart, result.length(), result);
}
digitList.set(negativeExponent, exponent);
int eFieldStart = result.length();
for (int i=digitList.decimalAt; i<minExponentDigits; ++i) {
result.append(zero);
}
for (int i=0; i<digitList.decimalAt; ++i) {
result.append((i < digitList.count) ?
(char)(digitList.digits[i] + zeroDelta) : zero);
}
delegate.formatted(Field.EXPONENT, Field.EXPONENT, eFieldStart,
result.length(), result);
} else {
int iFieldStart = result.length();
// Output the integer portion. Here 'count' is the total
// number of integer digits we will display, including both
// leading zeros required to satisfy getMinimumIntegerDigits,
// and actual digits present in the number.
int count = minIntDigits;
int digitIndex = 0; // Index into digitList.fDigits[]
if (digitList.decimalAt > 0 && count < digitList.decimalAt) {
count = digitList.decimalAt;
}
// Handle the case where getMaximumIntegerDigits() is smaller
// than the real number of integer digits. If this is so, we
// output the least significant max integer digits. For example,
// the value 1997 printed with 2 max integer digits is just "97".
if (count > maxIntDigits) {
count = maxIntDigits;
digitIndex = digitList.decimalAt - count;
}
int sizeBeforeIntegerPart = result.length();
for (int i=count-1; i>=0; --i) {
if (i < digitList.decimalAt && digitIndex < digitList.count) {
// Output a real digit
result.append((char)(digitList.digits[digitIndex++] + zeroDelta));
} else {
// Output a leading zero
result.append(zero);
}
// Output grouping separator if necessary. Don't output a
// grouping separator if i==0 though; that's at the end of
// the integer part.
if (isGroupingUsed() && i>0 && (groupingSize != 0)
&& (secondaryGroupingSize > 0 && i > groupingSize
? (i - groupingSize) % secondaryGroupingSize == 0
: i % groupingSize == 0)) {
int gStart = result.length();
result.append(grouping);
delegate.formatted(Field.GROUPING_SEPARATOR,
Field.GROUPING_SEPARATOR, gStart,
result.length(), result);
}
}
// Determine whether or not there are any printable fractional
// digits. If we've used up the digits we know there aren't.
boolean fractionPresent = (minFraDigits > 0) ||
(!isInteger && digitIndex < digitList.count);
// If there is no fraction present, and we haven't printed any
// integer digits, then print a zero. Otherwise we won't print
// _any_ digits, and we won't be able to parse this string.
if (!fractionPresent && result.length() == sizeBeforeIntegerPart) {
result.append(zero);
}
delegate.formatted(INTEGER_FIELD, Field.INTEGER, Field.INTEGER,
iFieldStart, result.length(), result);
// Output the decimal separator if we always do so.
int sStart = result.length();
if (decimalSeparatorAlwaysShown || fractionPresent) {
result.append(decimal);
}
if (sStart != result.length()) {
delegate.formatted(Field.DECIMAL_SEPARATOR,
Field.DECIMAL_SEPARATOR,
sStart, result.length(), result);
}
int fFieldStart = result.length();
for (int i=0; i < maxFraDigits; ++i) {
// Here is where we escape from the loop. We escape if we've
// output the maximum fraction digits (specified in the for
// expression above).
// We also stop when we've output the minimum digits and either:
// we have an integer, so there is no fractional stuff to
// display, or we're out of significant digits.
if (i >= minFraDigits &&
(isInteger || digitIndex >= digitList.count)) {
break;
}
// Output leading fractional zeros. These are zeros that come
// after the decimal but before any significant digits. These
// are only output if abs(number being formatted) < 1.0.
if (-1-i > (digitList.decimalAt-1)) {
result.append(zero);
continue;
}
// Output a digit, if we have any precision left, or a
// zero if we don't. We don't want to output noise digits.
if (!isInteger && digitIndex < digitList.count) {
result.append((char)(digitList.digits[digitIndex++] + zeroDelta));
} else {
result.append(zero);
}
}
// Record field information for caller.
delegate.formatted(FRACTION_FIELD, Field.FRACTION, Field.FRACTION,
fFieldStart, result.length(), result);
}
if (isNegative) {
append(result, negativeSuffix, delegate,
getNegativeSuffixFieldPositions(), Field.SIGN);
} else {
append(result, positiveSuffix, delegate,
getPositiveSuffixFieldPositions(), Field.SIGN);
}
return result;
} |
Complete the formatting of a finite number. On entry, the digitList must
be filled in with the correct digits.
| DecimalFormat::subformat | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void append(StringBuffer result, String string,
FieldDelegate delegate,
FieldPosition[] positions,
Format.Field signAttribute) {
int start = result.length();
if (string.length() > 0) {
result.append(string);
for (int counter = 0, max = positions.length; counter < max;
counter++) {
FieldPosition fp = positions[counter];
Format.Field attribute = fp.getFieldAttribute();
if (attribute == Field.SIGN) {
attribute = signAttribute;
}
delegate.formatted(attribute, attribute,
start + fp.getBeginIndex(),
start + fp.getEndIndex(), result);
}
}
} |
Appends the String <code>string</code> to <code>result</code>.
<code>delegate</code> is notified of all the
<code>FieldPosition</code>s in <code>positions</code>.
<p>
If one of the <code>FieldPosition</code>s in <code>positions</code>
identifies a <code>SIGN</code> attribute, it is mapped to
<code>signAttribute</code>. This is used
to map the <code>SIGN</code> attribute to the <code>EXPONENT</code>
attribute as necessary.
<p>
This is used by <code>subformat</code> to add the prefix/suffix.
| DecimalFormat::append | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private BigInteger getBigIntegerMultiplier() {
if (bigIntegerMultiplier == null) {
bigIntegerMultiplier = BigInteger.valueOf(multiplier);
}
return bigIntegerMultiplier;
} |
Return a BigInteger multiplier.
| DecimalFormat::getBigIntegerMultiplier | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private BigDecimal getBigDecimalMultiplier() {
if (bigDecimalMultiplier == null) {
bigDecimalMultiplier = new BigDecimal(multiplier);
}
return bigDecimalMultiplier;
} |
Return a BigDecimal multiplier.
| DecimalFormat::getBigDecimalMultiplier | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private boolean signMatches(String text, int position, char[] signs) {
if (position < 0 || position >= text.length()) {
return false;
}
char ch = text.charAt(position);
for (char signCh : signs) {
if (signCh == ch) {
return true;
}
}
return false;
} |
Returns true if specified string position char matches one of an array
of Unicode characters.
| DecimalFormat::signMatches | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private final boolean subparse(String text, ParsePosition parsePosition,
String positivePrefix, String negativePrefix,
DigitList digits, boolean isExponent,
boolean status[]) {
int position = parsePosition.index;
int oldStart = parsePosition.index;
int backup;
boolean gotPositive, gotNegative;
// check for positivePrefix; take longest
gotPositive = text.regionMatches(position, positivePrefix, 0,
positivePrefix.length())
|| signMatches(text, position, PLUS_SIGNS);
gotNegative = text.regionMatches(position, negativePrefix, 0,
negativePrefix.length())
|| signMatches(text, position, MINUS_SIGNS);
if (gotPositive && gotNegative) {
if (positivePrefix.length() > negativePrefix.length()) {
gotNegative = false;
} else if (positivePrefix.length() < negativePrefix.length()) {
gotPositive = false;
}
}
if (gotPositive) {
position += positivePrefix.length();
} else if (gotNegative) {
position += negativePrefix.length();
} else {
parsePosition.errorIndex = position;
return false;
}
// process digits or Inf, find decimal position
status[STATUS_INFINITE] = false;
if (!isExponent && text.regionMatches(position,symbols.getInfinity(),0,
symbols.getInfinity().length())) {
position += symbols.getInfinity().length();
status[STATUS_INFINITE] = true;
} else {
// We now have a string of digits, possibly with grouping symbols,
// and decimal points. We want to process these into a DigitList.
// We don't want to put a bunch of leading zeros into the DigitList
// though, so we keep track of the location of the decimal point,
// put only significant digits into the DigitList, and adjust the
// exponent as needed.
digits.decimalAt = digits.count = 0;
char zero = symbols.getZeroDigit();
char decimal = isCurrencyFormat ?
symbols.getMonetaryDecimalSeparator() :
symbols.getDecimalSeparator();
char grouping = symbols.getGroupingSeparator();
String exponentString = symbols.getExponentSeparator();
boolean sawDecimal = false;
boolean sawExponent = false;
boolean sawDigit = false;
int exponent = 0; // Set to the exponent value, if any
// We have to track digitCount ourselves, because digits.count will
// pin when the maximum allowable digits is reached.
int digitCount = 0;
backup = -1;
for (; position < text.length(); ++position) {
char ch = text.charAt(position);
/* We recognize all digit ranges, not only the Latin digit range
* '0'..'9'. We do so by using the Character.digit() method,
* which converts a valid Unicode digit to the range 0..9.
*
* The character 'ch' may be a digit. If so, place its value
* from 0 to 9 in 'digit'. First try using the locale digit,
* which may or MAY NOT be a standard Unicode digit range. If
* this fails, try using the standard Unicode digit ranges by
* calling Character.digit(). If this also fails, digit will
* have a value outside the range 0..9.
*/
int digit = ch - zero;
if (digit < 0 || digit > 9) {
digit = Character.digit(ch, 10);
}
if (digit == 0) {
// Cancel out backup setting (see grouping handler below)
backup = -1; // Do this BEFORE continue statement below!!!
sawDigit = true;
// Handle leading zeros
if (digits.count == 0) {
// Ignore leading zeros in integer part of number.
if (!sawDecimal) {
continue;
}
// If we have seen the decimal, but no significant
// digits yet, then we account for leading zeros by
// decrementing the digits.decimalAt into negative
// values.
--digits.decimalAt;
} else {
++digitCount;
digits.append((char)(digit + '0'));
}
} else if (digit > 0 && digit <= 9) { // [sic] digit==0 handled above
sawDigit = true;
++digitCount;
digits.append((char)(digit + '0'));
// Cancel out backup setting (see grouping handler below)
backup = -1;
} else if (!isExponent && ch == decimal) {
// If we're only parsing integers, or if we ALREADY saw the
// decimal, then don't parse this one.
if (isParseIntegerOnly() || sawDecimal) {
break;
}
digits.decimalAt = digitCount; // Not digits.count!
sawDecimal = true;
} else if (!isExponent && ch == grouping && isGroupingUsed()) {
if (sawDecimal) {
break;
}
// Ignore grouping characters, if we are using them, but
// require that they be followed by a digit. Otherwise
// we backup and reprocess them.
backup = position;
} else if (!isExponent && text.regionMatches(position, exponentString, 0, exponentString.length())
&& !sawExponent) {
// Process the exponent by recursively calling this method.
ParsePosition pos = new ParsePosition(position + exponentString.length());
boolean[] stat = new boolean[STATUS_LENGTH];
DigitList exponentDigits = new DigitList();
if (subparse(text, pos, "", Character.toString(symbols.getMinusSign()), exponentDigits, true, stat) &&
exponentDigits.fitsIntoLong(stat[STATUS_POSITIVE], true)) {
position = pos.index; // Advance past the exponent
exponent = (int)exponentDigits.getLong();
if (!stat[STATUS_POSITIVE]) {
exponent = -exponent;
}
sawExponent = true;
}
break; // Whether we fail or succeed, we exit this loop
} else {
break;
}
}
if (backup != -1) {
position = backup;
}
// If there was no decimal point we have an integer
if (!sawDecimal) {
digits.decimalAt = digitCount; // Not digits.count!
}
// Adjust for exponent, if any
digits.decimalAt += exponent;
// If none of the text string was recognized. For example, parse
// "x" with pattern "#0.00" (return index and error index both 0)
// parse "$" with pattern "$#0.00". (return index 0 and error
// index 1).
if (!sawDigit && digitCount == 0) {
parsePosition.index = oldStart;
parsePosition.errorIndex = oldStart;
return false;
}
}
// check for suffix
if (!isExponent) {
if (gotPositive) {
gotPositive = text.regionMatches(position,positiveSuffix,0,
positiveSuffix.length());
}
if (gotNegative) {
gotNegative = text.regionMatches(position,negativeSuffix,0,
negativeSuffix.length());
}
// if both match, take longest
if (gotPositive && gotNegative) {
if (positiveSuffix.length() > negativeSuffix.length()) {
gotNegative = false;
} else if (positiveSuffix.length() < negativeSuffix.length()) {
gotPositive = false;
}
}
// fail if neither or both
if (gotPositive == gotNegative) {
parsePosition.errorIndex = position;
return false;
}
parsePosition.index = position +
(gotPositive ? positiveSuffix.length() : negativeSuffix.length()); // mark success!
} else {
parsePosition.index = position;
}
status[STATUS_POSITIVE] = gotPositive;
if (parsePosition.index == oldStart) {
parsePosition.errorIndex = position;
return false;
}
return true;
} |
Parse the given text into a number. The text is parsed beginning at
parsePosition, until an unparseable character is seen.
@param text The string to parse.
@param parsePosition The position at which to being parsing. Upon
return, the first unparseable character.
@param digits The DigitList to set to the parsed value.
@param isExponent If true, parse an exponent. This means no
infinite values and integer only.
@param status Upon return contains boolean status flags indicating
whether the value was infinite and whether it was positive.
| DecimalFormat::subparse | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public DecimalFormatSymbols getDecimalFormatSymbols() {
try {
// don't allow multiple references
return (DecimalFormatSymbols) symbols.clone();
} catch (Exception foo) {
return null; // should never happen
}
} |
Returns a copy of the decimal format symbols, which is generally not
changed by the programmer or user.
@return a copy of the desired DecimalFormatSymbols
@see java.text.DecimalFormatSymbols
| DecimalFormat::getDecimalFormatSymbols | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols) {
try {
// don't allow multiple references
symbols = (DecimalFormatSymbols) newSymbols.clone();
expandAffixes();
fastPathCheckNeeded = true;
} catch (Exception foo) {
// should never happen
}
} |
Sets the decimal format symbols, which is generally not changed
by the programmer or user.
@param newSymbols desired DecimalFormatSymbols
@see java.text.DecimalFormatSymbols
| DecimalFormat::setDecimalFormatSymbols | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public String getPositivePrefix () {
return positivePrefix;
} |
Get the positive prefix.
<P>Examples: +123, $123, sFr123
@return the positive prefix
| DecimalFormat::getPositivePrefix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setPositivePrefix (String newValue) {
positivePrefix = newValue;
posPrefixPattern = null;
positivePrefixFieldPositions = null;
fastPathCheckNeeded = true;
} |
Set the positive prefix.
<P>Examples: +123, $123, sFr123
@param newValue the new positive prefix
| DecimalFormat::setPositivePrefix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private FieldPosition[] getPositivePrefixFieldPositions() {
if (positivePrefixFieldPositions == null) {
if (posPrefixPattern != null) {
positivePrefixFieldPositions = expandAffix(posPrefixPattern);
} else {
positivePrefixFieldPositions = EmptyFieldPositionArray;
}
}
return positivePrefixFieldPositions;
} |
Returns the FieldPositions of the fields in the prefix used for
positive numbers. This is not used if the user has explicitly set
a positive prefix via <code>setPositivePrefix</code>. This is
lazily created.
@return FieldPositions in positive prefix
| DecimalFormat::getPositivePrefixFieldPositions | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public String getNegativePrefix () {
return negativePrefix;
} |
Get the negative prefix.
<P>Examples: -123, ($123) (with negative suffix), sFr-123
@return the negative prefix
| DecimalFormat::getNegativePrefix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setNegativePrefix (String newValue) {
negativePrefix = newValue;
negPrefixPattern = null;
fastPathCheckNeeded = true;
} |
Set the negative prefix.
<P>Examples: -123, ($123) (with negative suffix), sFr-123
@param newValue the new negative prefix
| DecimalFormat::setNegativePrefix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private FieldPosition[] getNegativePrefixFieldPositions() {
if (negativePrefixFieldPositions == null) {
if (negPrefixPattern != null) {
negativePrefixFieldPositions = expandAffix(negPrefixPattern);
} else {
negativePrefixFieldPositions = EmptyFieldPositionArray;
}
}
return negativePrefixFieldPositions;
} |
Returns the FieldPositions of the fields in the prefix used for
negative numbers. This is not used if the user has explicitly set
a negative prefix via <code>setNegativePrefix</code>. This is
lazily created.
@return FieldPositions in positive prefix
| DecimalFormat::getNegativePrefixFieldPositions | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public String getPositiveSuffix () {
return positiveSuffix;
} |
Get the positive suffix.
<P>Example: 123%
@return the positive suffix
| DecimalFormat::getPositiveSuffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setPositiveSuffix (String newValue) {
positiveSuffix = newValue;
posSuffixPattern = null;
fastPathCheckNeeded = true;
} |
Set the positive suffix.
<P>Example: 123%
@param newValue the new positive suffix
| DecimalFormat::setPositiveSuffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private FieldPosition[] getPositiveSuffixFieldPositions() {
if (positiveSuffixFieldPositions == null) {
if (posSuffixPattern != null) {
positiveSuffixFieldPositions = expandAffix(posSuffixPattern);
} else {
positiveSuffixFieldPositions = EmptyFieldPositionArray;
}
}
return positiveSuffixFieldPositions;
} |
Returns the FieldPositions of the fields in the suffix used for
positive numbers. This is not used if the user has explicitly set
a positive suffix via <code>setPositiveSuffix</code>. This is
lazily created.
@return FieldPositions in positive prefix
| DecimalFormat::getPositiveSuffixFieldPositions | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public String getNegativeSuffix () {
return negativeSuffix;
} |
Get the negative suffix.
<P>Examples: -123%, ($123) (with positive suffixes)
@return the negative suffix
| DecimalFormat::getNegativeSuffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setNegativeSuffix (String newValue) {
negativeSuffix = newValue;
negSuffixPattern = null;
fastPathCheckNeeded = true;
} |
Set the negative suffix.
<P>Examples: 123%
@param newValue the new negative suffix
| DecimalFormat::setNegativeSuffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private FieldPosition[] getNegativeSuffixFieldPositions() {
if (negativeSuffixFieldPositions == null) {
if (negSuffixPattern != null) {
negativeSuffixFieldPositions = expandAffix(negSuffixPattern);
} else {
negativeSuffixFieldPositions = EmptyFieldPositionArray;
}
}
return negativeSuffixFieldPositions;
} |
Returns the FieldPositions of the fields in the suffix used for
negative numbers. This is not used if the user has explicitly set
a negative suffix via <code>setNegativeSuffix</code>. This is
lazily created.
@return FieldPositions in positive prefix
| DecimalFormat::getNegativeSuffixFieldPositions | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public int getMultiplier () {
return multiplier;
} |
Gets the multiplier for use in percent, per mille, and similar
formats.
@return the multiplier
@see #setMultiplier(int)
| DecimalFormat::getMultiplier | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setMultiplier (int newValue) {
multiplier = newValue;
bigDecimalMultiplier = null;
bigIntegerMultiplier = null;
fastPathCheckNeeded = true;
} |
Sets the multiplier for use in percent, per mille, and similar
formats.
For a percent format, set the multiplier to 100 and the suffixes to
have '%' (for Arabic, use the Arabic percent sign).
For a per mille format, set the multiplier to 1000 and the suffixes to
have '\u2030'.
<P>Example: with multiplier 100, 1.23 is formatted as "123", and
"123" is parsed into 1.23.
@param newValue the new multiplier
@see #getMultiplier
| DecimalFormat::setMultiplier | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public int getGroupingSize () {
return groupingSize;
} |
Return the grouping size. Grouping size is the number of digits between
grouping separators in the integer portion of a number. For example,
in the number "123,456.78", the grouping size is 3.
@return the grouping size
@see #setGroupingSize
@see java.text.NumberFormat#isGroupingUsed
@see java.text.DecimalFormatSymbols#getGroupingSeparator
| DecimalFormat::getGroupingSize | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setGroupingSize (int newValue) {
groupingSize = (byte)newValue;
secondaryGroupingSize = 0;
fastPathCheckNeeded = true;
} |
Set the grouping size. Grouping size is the number of digits between
grouping separators in the integer portion of a number. For example,
in the number "123,456.78", the grouping size is 3.
<br>
The value passed in is converted to a byte, which may lose information.
@param newValue the new grouping size
@see #getGroupingSize
@see java.text.NumberFormat#setGroupingUsed
@see java.text.DecimalFormatSymbols#setGroupingSeparator
| DecimalFormat::setGroupingSize | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public boolean isDecimalSeparatorAlwaysShown() {
return decimalSeparatorAlwaysShown;
} |
Allows you to get the behavior of the decimal separator with integers.
(The decimal separator will always appear with decimals.)
<P>Example: Decimal ON: 12345 → 12345.; OFF: 12345 → 12345
@return {@code true} if the decimal separator is always shown;
{@code false} otherwise
| DecimalFormat::isDecimalSeparatorAlwaysShown | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setDecimalSeparatorAlwaysShown(boolean newValue) {
decimalSeparatorAlwaysShown = newValue;
fastPathCheckNeeded = true;
} |
Allows you to set the behavior of the decimal separator with integers.
(The decimal separator will always appear with decimals.)
<P>Example: Decimal ON: 12345 → 12345.; OFF: 12345 → 12345
@param newValue {@code true} if the decimal separator is always shown;
{@code false} otherwise
| DecimalFormat::setDecimalSeparatorAlwaysShown | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public boolean isParseBigDecimal() {
return parseBigDecimal;
} |
Returns whether the {@link #parse(java.lang.String, java.text.ParsePosition)}
method returns <code>BigDecimal</code>. The default value is false.
@return {@code true} if the parse method returns BigDecimal;
{@code false} otherwise
@see #setParseBigDecimal
@since 1.5
| DecimalFormat::isParseBigDecimal | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void setParseBigDecimal(boolean newValue) {
parseBigDecimal = newValue;
} |
Sets whether the {@link #parse(java.lang.String, java.text.ParsePosition)}
method returns <code>BigDecimal</code>.
@param newValue {@code true} if the parse method returns BigDecimal;
{@code false} otherwise
@see #isParseBigDecimal
@since 1.5
| DecimalFormat::setParseBigDecimal | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public String toPattern() {
return toPattern( false );
} |
Synthesizes a pattern string that represents the current state
of this Format object.
@return a pattern string
@see #applyPattern
| DecimalFormat::toPattern | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public String toLocalizedPattern() {
return toPattern( true );
} |
Synthesizes a localized pattern string that represents the current
state of this Format object.
@return a localized pattern string
@see #applyPattern
| DecimalFormat::toLocalizedPattern | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void expandAffixes() {
// Reuse one StringBuffer for better performance
StringBuffer buffer = new StringBuffer();
if (posPrefixPattern != null) {
positivePrefix = expandAffix(posPrefixPattern, buffer);
positivePrefixFieldPositions = null;
}
if (posSuffixPattern != null) {
positiveSuffix = expandAffix(posSuffixPattern, buffer);
positiveSuffixFieldPositions = null;
}
if (negPrefixPattern != null) {
negativePrefix = expandAffix(negPrefixPattern, buffer);
negativePrefixFieldPositions = null;
}
if (negSuffixPattern != null) {
negativeSuffix = expandAffix(negSuffixPattern, buffer);
negativeSuffixFieldPositions = null;
}
} |
Expand the affix pattern strings into the expanded affix strings. If any
affix pattern string is null, do not expand it. This method should be
called any time the symbols or the affix patterns change in order to keep
the expanded affix strings up to date.
| DecimalFormat::expandAffixes | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private String expandAffix(String pattern, StringBuffer buffer) {
buffer.setLength(0);
for (int i=0; i<pattern.length(); ) {
char c = pattern.charAt(i++);
if (c == QUOTE) {
c = pattern.charAt(i++);
switch (c) {
case CURRENCY_SIGN:
if (i<pattern.length() &&
pattern.charAt(i) == CURRENCY_SIGN) {
++i;
buffer.append(symbols.getInternationalCurrencySymbol());
} else {
buffer.append(symbols.getCurrencySymbol());
}
continue;
case PATTERN_PERCENT:
c = symbols.getPercent();
break;
case PATTERN_PER_MILLE:
c = symbols.getPerMill();
break;
case PATTERN_MINUS:
c = symbols.getMinusSign();
break;
}
}
buffer.append(c);
}
return buffer.toString();
} |
Expand an affix pattern into an affix string. All characters in the
pattern are literal unless prefixed by QUOTE. The following characters
after QUOTE are recognized: PATTERN_PERCENT, PATTERN_PER_MILLE,
PATTERN_MINUS, and CURRENCY_SIGN. If CURRENCY_SIGN is doubled (QUOTE +
CURRENCY_SIGN + CURRENCY_SIGN), it is interpreted as an ISO 4217
currency code. Any other character after a QUOTE represents itself.
QUOTE must be followed by another character; QUOTE may not occur by
itself at the end of the pattern.
@param pattern the non-null, possibly empty pattern
@param buffer a scratch StringBuffer; its contents will be lost
@return the expanded equivalent of pattern
| DecimalFormat::expandAffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private FieldPosition[] expandAffix(String pattern) {
ArrayList<FieldPosition> positions = null;
int stringIndex = 0;
for (int i=0; i<pattern.length(); ) {
char c = pattern.charAt(i++);
if (c == QUOTE) {
int field = -1;
Format.Field fieldID = null;
c = pattern.charAt(i++);
switch (c) {
case CURRENCY_SIGN:
String string;
if (i<pattern.length() &&
pattern.charAt(i) == CURRENCY_SIGN) {
++i;
string = symbols.getInternationalCurrencySymbol();
} else {
string = symbols.getCurrencySymbol();
}
if (string.length() > 0) {
if (positions == null) {
positions = new ArrayList<>(2);
}
FieldPosition fp = new FieldPosition(Field.CURRENCY);
fp.setBeginIndex(stringIndex);
fp.setEndIndex(stringIndex + string.length());
positions.add(fp);
stringIndex += string.length();
}
continue;
case PATTERN_PERCENT:
c = symbols.getPercent();
field = -1;
fieldID = Field.PERCENT;
break;
case PATTERN_PER_MILLE:
c = symbols.getPerMill();
field = -1;
fieldID = Field.PERMILLE;
break;
case PATTERN_MINUS:
c = symbols.getMinusSign();
field = -1;
fieldID = Field.SIGN;
break;
}
if (fieldID != null) {
if (positions == null) {
positions = new ArrayList<>(2);
}
FieldPosition fp = new FieldPosition(fieldID, field);
fp.setBeginIndex(stringIndex);
fp.setEndIndex(stringIndex + 1);
positions.add(fp);
}
}
stringIndex++;
}
if (positions != null) {
return positions.toArray(EmptyFieldPositionArray);
}
return EmptyFieldPositionArray;
} |
Expand an affix pattern into an array of FieldPositions describing
how the pattern would be expanded.
All characters in the
pattern are literal unless prefixed by QUOTE. The following characters
after QUOTE are recognized: PATTERN_PERCENT, PATTERN_PER_MILLE,
PATTERN_MINUS, and CURRENCY_SIGN. If CURRENCY_SIGN is doubled (QUOTE +
CURRENCY_SIGN + CURRENCY_SIGN), it is interpreted as an ISO 4217
currency code. Any other character after a QUOTE represents itself.
QUOTE must be followed by another character; QUOTE may not occur by
itself at the end of the pattern.
@param pattern the non-null, possibly empty pattern
@return FieldPosition array of the resulting fields.
| DecimalFormat::expandAffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void appendAffix(StringBuffer buffer, String affixPattern,
String expAffix, boolean localized) {
if (affixPattern == null) {
appendAffix(buffer, expAffix, localized);
} else {
int i;
for (int pos=0; pos<affixPattern.length(); pos=i) {
i = affixPattern.indexOf(QUOTE, pos);
if (i < 0) {
appendAffix(buffer, affixPattern.substring(pos), localized);
break;
}
if (i > pos) {
appendAffix(buffer, affixPattern.substring(pos, i), localized);
}
char c = affixPattern.charAt(++i);
++i;
if (c == QUOTE) {
buffer.append(c);
// Fall through and append another QUOTE below
} else if (c == CURRENCY_SIGN &&
i<affixPattern.length() &&
affixPattern.charAt(i) == CURRENCY_SIGN) {
++i;
buffer.append(c);
// Fall through and append another CURRENCY_SIGN below
} else if (localized) {
switch (c) {
case PATTERN_PERCENT:
c = symbols.getPercent();
break;
case PATTERN_PER_MILLE:
c = symbols.getPerMill();
break;
case PATTERN_MINUS:
c = symbols.getMinusSign();
break;
}
}
buffer.append(c);
}
}
} |
Appends an affix pattern to the given StringBuffer, quoting special
characters as needed. Uses the internal affix pattern, if that exists,
or the literal affix, if the internal affix pattern is null. The
appended string will generate the same affix pattern (or literal affix)
when passed to toPattern().
@param buffer the affix string is appended to this
@param affixPattern a pattern such as posPrefixPattern; may be null
@param expAffix a corresponding expanded affix, such as positivePrefix.
Ignored unless affixPattern is null. If affixPattern is null, then
expAffix is appended as a literal affix.
@param localized true if the appended pattern should contain localized
pattern characters; otherwise, non-localized pattern chars are appended
| DecimalFormat::appendAffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void appendAffix(StringBuffer buffer, String affix, boolean localized) {
boolean needQuote;
if (localized) {
needQuote = affix.indexOf(symbols.getZeroDigit()) >= 0
|| affix.indexOf(symbols.getGroupingSeparator()) >= 0
|| affix.indexOf(symbols.getDecimalSeparator()) >= 0
|| affix.indexOf(symbols.getPercent()) >= 0
|| affix.indexOf(symbols.getPerMill()) >= 0
|| affix.indexOf(symbols.getDigit()) >= 0
|| affix.indexOf(symbols.getPatternSeparator()) >= 0
|| affix.indexOf(symbols.getMinusSign()) >= 0
|| affix.indexOf(CURRENCY_SIGN) >= 0;
} else {
needQuote = affix.indexOf(PATTERN_ZERO_DIGIT) >= 0
|| affix.indexOf(PATTERN_GROUPING_SEPARATOR) >= 0
|| affix.indexOf(PATTERN_DECIMAL_SEPARATOR) >= 0
|| affix.indexOf(PATTERN_PERCENT) >= 0
|| affix.indexOf(PATTERN_PER_MILLE) >= 0
|| affix.indexOf(PATTERN_DIGIT) >= 0
|| affix.indexOf(PATTERN_SEPARATOR) >= 0
|| affix.indexOf(PATTERN_MINUS) >= 0
|| affix.indexOf(CURRENCY_SIGN) >= 0;
}
if (needQuote) buffer.append('\'');
if (affix.indexOf('\'') < 0) buffer.append(affix);
else {
for (int j=0; j<affix.length(); ++j) {
char c = affix.charAt(j);
buffer.append(c);
if (c == '\'') buffer.append(c);
}
}
if (needQuote) buffer.append('\'');
} |
Append an affix to the given StringBuffer, using quotes if
there are special characters. Single quotes themselves must be
escaped in either case.
| DecimalFormat::appendAffix | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private String toPattern(boolean localized) {
StringBuffer result = new StringBuffer();
for (int j = 1; j >= 0; --j) {
if (j == 1)
appendAffix(result, posPrefixPattern, positivePrefix, localized);
else appendAffix(result, negPrefixPattern, negativePrefix, localized);
int i;
int digitCount = useExponentialNotation
? getMaximumIntegerDigits()
: Math.max(groupingSize + secondaryGroupingSize, getMinimumIntegerDigits())+1;
for (i = digitCount; i > 0; --i) {
if (i != digitCount && isGroupingUsed() && groupingSize != 0 &&
(secondaryGroupingSize > 0 && i > groupingSize
? (i - groupingSize) % secondaryGroupingSize == 0
: i % groupingSize == 0)) {
result.append(localized ? symbols.getGroupingSeparator() :
PATTERN_GROUPING_SEPARATOR);
}
result.append(i <= getMinimumIntegerDigits()
? (localized ? symbols.getZeroDigit() : PATTERN_ZERO_DIGIT)
: (localized ? symbols.getDigit() : PATTERN_DIGIT));
}
if (getMaximumFractionDigits() > 0 || decimalSeparatorAlwaysShown)
result.append(localized ? symbols.getDecimalSeparator() :
PATTERN_DECIMAL_SEPARATOR);
for (i = 0; i < getMaximumFractionDigits(); ++i) {
if (i < getMinimumFractionDigits()) {
result.append(localized ? symbols.getZeroDigit() :
PATTERN_ZERO_DIGIT);
} else {
result.append(localized ? symbols.getDigit() :
PATTERN_DIGIT);
}
}
if (useExponentialNotation)
{
result.append(localized ? symbols.getExponentSeparator() :
PATTERN_EXPONENT);
for (i=0; i<minExponentDigits; ++i)
result.append(localized ? symbols.getZeroDigit() :
PATTERN_ZERO_DIGIT);
}
if (j == 1) {
appendAffix(result, posSuffixPattern, positiveSuffix, localized);
if ((negSuffixPattern == posSuffixPattern && // n == p == null
negativeSuffix.equals(positiveSuffix))
|| (negSuffixPattern != null &&
negSuffixPattern.equals(posSuffixPattern))) {
if ((negPrefixPattern != null && posPrefixPattern != null &&
negPrefixPattern.equals("'-" + posPrefixPattern)) ||
(negPrefixPattern == posPrefixPattern && // n == p == null
negativePrefix.equals(symbols.getMinusSign() + positivePrefix)))
break;
}
result.append(localized ? symbols.getPatternSeparator() :
PATTERN_SEPARATOR);
} else appendAffix(result, negSuffixPattern, negativeSuffix, localized);
}
return result.toString();
} |
* Does the real work of generating a pattern. | DecimalFormat::toPattern | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void applyPattern(String pattern) {
applyPattern(pattern, false);
} |
Apply the given pattern to this Format object. A pattern is a
short-hand specification for the various formatting properties.
These properties can also be changed individually through the
various setter methods.
<p>
There is no limit to integer digits set
by this routine, since that is the typical end-user desire;
use setMaximumInteger if you want to set a real value.
For negative numbers, use a second pattern, separated by a semicolon
<P>Example <code>"#,#00.0#"</code> → 1,234.56
<P>This means a minimum of 2 integer digits, 1 fraction digit, and
a maximum of 2 fraction digits.
<p>Example: <code>"#,#00.0#;(#,#00.0#)"</code> for negatives in
parentheses.
<p>In negative patterns, the minimum and maximum counts are ignored;
these are presumed to be set in the positive pattern.
@param pattern a new pattern
@exception NullPointerException if <code>pattern</code> is null
@exception IllegalArgumentException if the given pattern is invalid.
| DecimalFormat::applyPattern | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
public void applyLocalizedPattern(String pattern) {
applyPattern(pattern, true);
} |
Apply the given pattern to this Format object. The pattern
is assumed to be in a localized notation. A pattern is a
short-hand specification for the various formatting properties.
These properties can also be changed individually through the
various setter methods.
<p>
There is no limit to integer digits set
by this routine, since that is the typical end-user desire;
use setMaximumInteger if you want to set a real value.
For negative numbers, use a second pattern, separated by a semicolon
<P>Example <code>"#,#00.0#"</code> → 1,234.56
<P>This means a minimum of 2 integer digits, 1 fraction digit, and
a maximum of 2 fraction digits.
<p>Example: <code>"#,#00.0#;(#,#00.0#)"</code> for negatives in
parentheses.
<p>In negative patterns, the minimum and maximum counts are ignored;
these are presumed to be set in the positive pattern.
@param pattern a new pattern
@exception NullPointerException if <code>pattern</code> is null
@exception IllegalArgumentException if the given pattern is invalid.
| DecimalFormat::applyLocalizedPattern | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void applyPattern(String pattern, boolean localized) {
char zeroDigit = PATTERN_ZERO_DIGIT;
char groupingSeparator = PATTERN_GROUPING_SEPARATOR;
char decimalSeparator = PATTERN_DECIMAL_SEPARATOR;
char percent = PATTERN_PERCENT;
char perMill = PATTERN_PER_MILLE;
char digit = PATTERN_DIGIT;
char separator = PATTERN_SEPARATOR;
String exponent = PATTERN_EXPONENT;
char minus = PATTERN_MINUS;
if (localized) {
zeroDigit = symbols.getZeroDigit();
groupingSeparator = symbols.getGroupingSeparator();
decimalSeparator = symbols.getDecimalSeparator();
percent = symbols.getPercent();
perMill = symbols.getPerMill();
digit = symbols.getDigit();
separator = symbols.getPatternSeparator();
exponent = symbols.getExponentSeparator();
minus = symbols.getMinusSign();
}
boolean gotNegative = false;
decimalSeparatorAlwaysShown = false;
isCurrencyFormat = false;
useExponentialNotation = false;
// Two variables are used to record the subrange of the pattern
// occupied by phase 1. This is used during the processing of the
// second pattern (the one representing negative numbers) to ensure
// that no deviation exists in phase 1 between the two patterns.
int phaseOneStart = 0;
int phaseOneLength = 0;
int start = 0;
for (int j = 1; j >= 0 && start < pattern.length(); --j) {
boolean inQuote = false;
StringBuffer prefix = new StringBuffer();
StringBuffer suffix = new StringBuffer();
int decimalPos = -1;
int multiplier = 1;
int digitLeftCount = 0, zeroDigitCount = 0, digitRightCount = 0;
byte groupingCount = -1;
byte secondaryGroupingCount = -1;
// The phase ranges from 0 to 2. Phase 0 is the prefix. Phase 1 is
// the section of the pattern with digits, decimal separator,
// grouping characters. Phase 2 is the suffix. In phases 0 and 2,
// percent, per mille, and currency symbols are recognized and
// translated. The separation of the characters into phases is
// strictly enforced; if phase 1 characters are to appear in the
// suffix, for example, they must be quoted.
int phase = 0;
// The affix is either the prefix or the suffix.
StringBuffer affix = prefix;
for (int pos = start; pos < pattern.length(); ++pos) {
char ch = pattern.charAt(pos);
switch (phase) {
case 0:
case 2:
// Process the prefix / suffix characters
if (inQuote) {
// A quote within quotes indicates either the closing
// quote or two quotes, which is a quote literal. That
// is, we have the second quote in 'do' or 'don''t'.
if (ch == QUOTE) {
if ((pos+1) < pattern.length() &&
pattern.charAt(pos+1) == QUOTE) {
++pos;
affix.append("''"); // 'don''t'
} else {
inQuote = false; // 'do'
}
continue;
}
} else {
// Process unquoted characters seen in prefix or suffix
// phase.
if (ch == digit ||
ch == zeroDigit ||
ch == groupingSeparator ||
ch == decimalSeparator) {
phase = 1;
if (j == 1) {
phaseOneStart = pos;
}
--pos; // Reprocess this character
continue;
} else if (ch == CURRENCY_SIGN) {
// Use lookahead to determine if the currency sign
// is doubled or not.
boolean doubled = (pos + 1) < pattern.length() &&
pattern.charAt(pos + 1) == CURRENCY_SIGN;
if (doubled) { // Skip over the doubled character
++pos;
}
isCurrencyFormat = true;
affix.append(doubled ? "'\u00A4\u00A4" : "'\u00A4");
continue;
} else if (ch == QUOTE) {
// A quote outside quotes indicates either the
// opening quote or two quotes, which is a quote
// literal. That is, we have the first quote in 'do'
// or o''clock.
if (ch == QUOTE) {
if ((pos+1) < pattern.length() &&
pattern.charAt(pos+1) == QUOTE) {
++pos;
affix.append("''"); // o''clock
} else {
inQuote = true; // 'do'
}
continue;
}
} else if (ch == separator) {
// Don't allow separators before we see digit
// characters of phase 1, and don't allow separators
// in the second pattern (j == 0).
if (phase == 0 || j == 0) {
throw new IllegalArgumentException("Unquoted special character '" +
ch + "' in pattern \"" + pattern + '"');
}
start = pos + 1;
pos = pattern.length();
continue;
}
// Next handle characters which are appended directly.
else if (ch == percent) {
if (multiplier != 1) {
throw new IllegalArgumentException("Too many percent/per mille characters in pattern \"" +
pattern + '"');
}
multiplier = 100;
affix.append("'%");
continue;
} else if (ch == perMill) {
if (multiplier != 1) {
throw new IllegalArgumentException("Too many percent/per mille characters in pattern \"" +
pattern + '"');
}
multiplier = 1000;
affix.append("'\u2030");
continue;
} else if (ch == minus) {
affix.append("'-");
continue;
}
}
// Note that if we are within quotes, or if this is an
// unquoted, non-special character, then we usually fall
// through to here.
affix.append(ch);
break;
case 1:
// Phase one must be identical in the two sub-patterns. We
// enforce this by doing a direct comparison. While
// processing the first sub-pattern, we just record its
// length. While processing the second, we compare
// characters.
if (j == 1) {
++phaseOneLength;
} else {
if (--phaseOneLength == 0) {
phase = 2;
affix = suffix;
}
continue;
}
// Process the digits, decimal, and grouping characters. We
// record five pieces of information. We expect the digits
// to occur in the pattern ####0000.####, and we record the
// number of left digits, zero (central) digits, and right
// digits. The position of the last grouping character is
// recorded (should be somewhere within the first two blocks
// of characters), as is the position of the decimal point,
// if any (should be in the zero digits). If there is no
// decimal point, then there should be no right digits.
if (ch == digit) {
if (zeroDigitCount > 0) {
++digitRightCount;
} else {
++digitLeftCount;
}
if (groupingCount >= 0 && decimalPos < 0) {
++groupingCount;
}
} else if (ch == zeroDigit) {
if (digitRightCount > 0) {
throw new IllegalArgumentException("Unexpected '0' in pattern \"" +
pattern + '"');
}
++zeroDigitCount;
if (groupingCount >= 0 && decimalPos < 0) {
++groupingCount;
}
} else if (ch == groupingSeparator) {
if (groupingCount > 0) {
secondaryGroupingCount = groupingCount;
}
groupingCount = 0;
} else if (ch == decimalSeparator) {
if (decimalPos >= 0) {
throw new IllegalArgumentException("Multiple decimal separators in pattern \"" +
pattern + '"');
}
decimalPos = digitLeftCount + zeroDigitCount + digitRightCount;
} else if (pattern.regionMatches(pos, exponent, 0, exponent.length())){
if (useExponentialNotation) {
throw new IllegalArgumentException("Multiple exponential " +
"symbols in pattern \"" + pattern + '"');
}
useExponentialNotation = true;
minExponentDigits = 0;
// Use lookahead to parse out the exponential part
// of the pattern, then jump into phase 2.
pos = pos+exponent.length();
while (pos < pattern.length() &&
pattern.charAt(pos) == zeroDigit) {
++minExponentDigits;
++phaseOneLength;
++pos;
}
if ((digitLeftCount + zeroDigitCount) < 1 ||
minExponentDigits < 1) {
throw new IllegalArgumentException("Malformed exponential " +
"pattern \"" + pattern + '"');
}
// Transition to phase 2
phase = 2;
affix = suffix;
--pos;
continue;
} else {
phase = 2;
affix = suffix;
--pos;
--phaseOneLength;
continue;
}
break;
}
}
// Handle patterns with no '0' pattern character. These patterns
// are legal, but must be interpreted. "##.###" -> "#0.###".
// ".###" -> ".0##".
/* We allow patterns of the form "####" to produce a zeroDigitCount
* of zero (got that?); although this seems like it might make it
* possible for format() to produce empty strings, format() checks
* for this condition and outputs a zero digit in this situation.
* Having a zeroDigitCount of zero yields a minimum integer digits
* of zero, which allows proper round-trip patterns. That is, we
* don't want "#" to become "#0" when toPattern() is called (even
* though that's what it really is, semantically).
*/
if (zeroDigitCount == 0 && digitLeftCount > 0 && decimalPos >= 0) {
// Handle "###.###" and "###." and ".###"
int n = decimalPos;
if (n == 0) { // Handle ".###"
++n;
}
digitRightCount = digitLeftCount - n;
digitLeftCount = n - 1;
zeroDigitCount = 1;
}
// Do syntax checking on the digits.
if ((decimalPos < 0 && digitRightCount > 0) ||
(decimalPos >= 0 && (decimalPos < digitLeftCount ||
decimalPos > (digitLeftCount + zeroDigitCount))) ||
groupingCount == 0 || secondaryGroupingCount == 0 || inQuote) {
throw new IllegalArgumentException("Malformed pattern \"" +
pattern + '"');
}
if (j == 1) {
posPrefixPattern = prefix.toString();
posSuffixPattern = suffix.toString();
negPrefixPattern = posPrefixPattern; // assume these for now
negSuffixPattern = posSuffixPattern;
int digitTotalCount = digitLeftCount + zeroDigitCount + digitRightCount;
/* The effectiveDecimalPos is the position the decimal is at or
* would be at if there is no decimal. Note that if decimalPos<0,
* then digitTotalCount == digitLeftCount + zeroDigitCount.
*/
int effectiveDecimalPos = decimalPos >= 0 ?
decimalPos : digitTotalCount;
setMinimumIntegerDigits(effectiveDecimalPos - digitLeftCount);
setMaximumIntegerDigits(useExponentialNotation ?
digitLeftCount + getMinimumIntegerDigits() :
MAXIMUM_INTEGER_DIGITS);
setMaximumFractionDigits(decimalPos >= 0 ?
(digitTotalCount - decimalPos) : 0);
setMinimumFractionDigits(decimalPos >= 0 ?
(digitLeftCount + zeroDigitCount - decimalPos) : 0);
setGroupingUsed(groupingCount > 0);
this.groupingSize = (groupingCount > 0) ? groupingCount : 0;
this.secondaryGroupingSize =
(secondaryGroupingCount > 0 && secondaryGroupingCount != groupingCount)
? secondaryGroupingCount : 0;
this.multiplier = multiplier;
setDecimalSeparatorAlwaysShown(decimalPos == 0 ||
decimalPos == digitTotalCount);
} else {
negPrefixPattern = prefix.toString();
negSuffixPattern = suffix.toString();
gotNegative = true;
}
}
if (pattern.length() == 0) {
posPrefixPattern = posSuffixPattern = "";
setMinimumIntegerDigits(0);
setMaximumIntegerDigits(MAXIMUM_INTEGER_DIGITS);
setMinimumFractionDigits(0);
setMaximumFractionDigits(MAXIMUM_FRACTION_DIGITS);
}
// If there was no negative pattern, or if the negative pattern is
// identical to the positive pattern, then prepend the minus sign to
// the positive pattern to form the negative pattern.
if (!gotNegative ||
(negPrefixPattern.equals(posPrefixPattern)
&& negSuffixPattern.equals(posSuffixPattern))) {
negSuffixPattern = posSuffixPattern;
negPrefixPattern = "'-" + posPrefixPattern;
}
expandAffixes();
} |
Does the real work of applying a pattern.
| DecimalFormat::applyPattern | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException
{
stream.defaultReadObject();
digitList = new DigitList();
// We force complete fast-path reinitialization when the instance is
// deserialized. See clone() comment on fastPathCheckNeeded.
fastPathCheckNeeded = true;
isFastPath = false;
fastPathData = null;
if (serialVersionOnStream < 4) {
setRoundingMode(RoundingMode.HALF_EVEN);
} else {
setRoundingMode(getRoundingMode());
}
// We only need to check the maximum counts because NumberFormat
// .readObject has already ensured that the maximum is greater than the
// minimum count.
if (super.getMaximumIntegerDigits() > DOUBLE_INTEGER_DIGITS ||
super.getMaximumFractionDigits() > DOUBLE_FRACTION_DIGITS) {
throw new InvalidObjectException("Digit count out of range");
}
if (serialVersionOnStream < 3) {
setMaximumIntegerDigits(super.getMaximumIntegerDigits());
setMinimumIntegerDigits(super.getMinimumIntegerDigits());
setMaximumFractionDigits(super.getMaximumFractionDigits());
setMinimumFractionDigits(super.getMinimumFractionDigits());
}
if (serialVersionOnStream < 1) {
// Didn't have exponential fields
useExponentialNotation = false;
}
serialVersionOnStream = currentSerialVersion;
} |
Reads the default serializable fields from the stream and performs
validations and adjustments for older serialized versions. The
validations and adjustments are:
<ol>
<li>
Verify that the superclass's digit count fields correctly reflect
the limits imposed on formatting numbers other than
<code>BigInteger</code> and <code>BigDecimal</code> objects. These
limits are stored in the superclass for serialization compatibility
with older versions, while the limits for <code>BigInteger</code> and
<code>BigDecimal</code> objects are kept in this class.
If, in the superclass, the minimum or maximum integer digit count is
larger than <code>DOUBLE_INTEGER_DIGITS</code> or if the minimum or
maximum fraction digit count is larger than
<code>DOUBLE_FRACTION_DIGITS</code>, then the stream data is invalid
and this method throws an <code>InvalidObjectException</code>.
<li>
If <code>serialVersionOnStream</code> is less than 4, initialize
<code>roundingMode</code> to {@link java.math.RoundingMode#HALF_EVEN
RoundingMode.HALF_EVEN}. This field is new with version 4.
<li>
If <code>serialVersionOnStream</code> is less than 3, then call
the setters for the minimum and maximum integer and fraction digits with
the values of the corresponding superclass getters to initialize the
fields in this class. The fields in this class are new with version 3.
<li>
If <code>serialVersionOnStream</code> is less than 1, indicating that
the stream was written by JDK 1.1, initialize
<code>useExponentialNotation</code>
to false, since it was not present in JDK 1.1.
<li>
Set <code>serialVersionOnStream</code> to the maximum allowed value so
that default serialization will work properly if this object is streamed
out again.
</ol>
<p>Stream versions older than 2 will not have the affix pattern variables
<code>posPrefixPattern</code> etc. As a result, they will be initialized
to <code>null</code>, which means the affix strings will be taken as
literal values. This is exactly what we want, since that corresponds to
the pre-version-2 behavior.
| DecimalFormat::readObject | java | google/j2objc | jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/java/text/DecimalFormat.java | Apache-2.0 |
static String[] moduleNames() {
return new String[0];
} |
Returns the array of initial module names identified at link time.
| SystemModulesMap::moduleNames | java | google/j2objc | jre_emul/openjdk/src/share/classes/jdk/internal/module/SystemModulesMap.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/jdk/internal/module/SystemModulesMap.java | Apache-2.0 |
static String[] classNames() {
return new String[0];
} |
Returns the array of SystemModules class names. The elements
correspond to the elements in the array returned by moduleNames().
| SystemModulesMap::classNames | java | google/j2objc | jre_emul/openjdk/src/share/classes/jdk/internal/module/SystemModulesMap.java | https://github.com/google/j2objc/blob/master/jre_emul/openjdk/src/share/classes/jdk/internal/module/SystemModulesMap.java | Apache-2.0 |
public static ByteString toBytes(String str) {
return ByteString.copyFromUtf8(str);
} |
Contains methods for setting fields of {@code TestAllTypesLite}, {@code TestAllExtensionsLite},
and {@code TestPackedExtensionsLite}. This is analogous to the functionality in TestUtil.java but
does not depend on the presence of any non-lite protos.
<p>This code is not to be used outside of {@code com.google.protobuf} and subpackages.
public final class TestUtilLite {
private TestUtilLite() {}
/** Helper to convert a String to ByteString. | TestUtilLite::toBytes | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtilLite.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtilLite.java | Apache-2.0 |
public static TestAllTypesLite.Builder getAllLiteSetBuilder() {
TestAllTypesLite.Builder builder = TestAllTypesLite.newBuilder();
setAllFields(builder);
return builder;
} |
Get a {@code TestAllTypesLite.Builder} with all fields set as they would be by {@link
#setAllFields(TestAllTypesLite.Builder)}.
| TestUtilLite::getAllLiteSetBuilder | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtilLite.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtilLite.java | Apache-2.0 |
public static TestAllExtensionsLite getAllLiteExtensionsSet() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
setAllExtensions(builder);
return builder.build();
} |
Get a {@code TestAllExtensionsLite} with all fields set as they would be by {@link
#setAllExtensions(TestAllExtensionsLite.Builder)}.
| TestUtilLite::getAllLiteExtensionsSet | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtilLite.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtilLite.java | Apache-2.0 |
public static void setAllFields(TestAllTypesLite.Builder builder) {
builder.setOptionalInt32(101);
builder.setOptionalInt64(102);
builder.setOptionalUint32(103);
builder.setOptionalUint64(104);
builder.setOptionalSint32(105);
builder.setOptionalSint64(106);
builder.setOptionalFixed32(107);
builder.setOptionalFixed64(108);
builder.setOptionalSfixed32(109);
builder.setOptionalSfixed64(110);
builder.setOptionalFloat(111);
builder.setOptionalDouble(112);
builder.setOptionalBool(true);
builder.setOptionalString("115");
builder.setOptionalBytes(toBytes("116"));
builder.setOptionalGroup(TestAllTypesLite.OptionalGroup.newBuilder().setA(117).build());
builder.setOptionalNestedMessage(
TestAllTypesLite.NestedMessage.newBuilder().setBb(118).build());
builder.setOptionalForeignMessage(ForeignMessageLite.newBuilder().setC(119).build());
builder.setOptionalImportMessage(ImportMessageLite.newBuilder().setD(120).build());
builder.setOptionalPublicImportMessage(PublicImportMessageLite.newBuilder().setE(126).build());
builder.setOptionalLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(127).build());
builder.setOptionalNestedEnum(TestAllTypesLite.NestedEnum.BAZ);
builder.setOptionalForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAZ);
builder.setOptionalImportEnum(ImportEnumLite.IMPORT_LITE_BAZ);
builder.setOptionalStringPiece("124");
builder.setOptionalCord("125");
// -----------------------------------------------------------------
builder.addRepeatedInt32(201);
builder.addRepeatedInt64(202);
builder.addRepeatedUint32(203);
builder.addRepeatedUint64(204);
builder.addRepeatedSint32(205);
builder.addRepeatedSint64(206);
builder.addRepeatedFixed32(207);
builder.addRepeatedFixed64(208);
builder.addRepeatedSfixed32(209);
builder.addRepeatedSfixed64(210);
builder.addRepeatedFloat(211);
builder.addRepeatedDouble(212);
builder.addRepeatedBool(true);
builder.addRepeatedString("215");
builder.addRepeatedBytes(toBytes("216"));
builder.addRepeatedGroup(TestAllTypesLite.RepeatedGroup.newBuilder().setA(217).build());
builder.addRepeatedNestedMessage(
TestAllTypesLite.NestedMessage.newBuilder().setBb(218).build());
builder.addRepeatedForeignMessage(ForeignMessageLite.newBuilder().setC(219).build());
builder.addRepeatedImportMessage(ImportMessageLite.newBuilder().setD(220).build());
builder.addRepeatedLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(227).build());
builder.addRepeatedNestedEnum(TestAllTypesLite.NestedEnum.BAR);
builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAR);
builder.addRepeatedImportEnum(ImportEnumLite.IMPORT_LITE_BAR);
builder.addRepeatedStringPiece("224");
builder.addRepeatedCord("225");
// Add a second one of each field.
builder.addRepeatedInt32(301);
builder.addRepeatedInt64(302);
builder.addRepeatedUint32(303);
builder.addRepeatedUint64(304);
builder.addRepeatedSint32(305);
builder.addRepeatedSint64(306);
builder.addRepeatedFixed32(307);
builder.addRepeatedFixed64(308);
builder.addRepeatedSfixed32(309);
builder.addRepeatedSfixed64(310);
builder.addRepeatedFloat(311);
builder.addRepeatedDouble(312);
builder.addRepeatedBool(false);
builder.addRepeatedString("315");
builder.addRepeatedBytes(toBytes("316"));
builder.addRepeatedGroup(TestAllTypesLite.RepeatedGroup.newBuilder().setA(317).build());
builder.addRepeatedNestedMessage(
TestAllTypesLite.NestedMessage.newBuilder().setBb(318).build());
builder.addRepeatedForeignMessage(ForeignMessageLite.newBuilder().setC(319).build());
builder.addRepeatedImportMessage(ImportMessageLite.newBuilder().setD(320).build());
builder.addRepeatedLazyMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(327).build());
builder.addRepeatedNestedEnum(TestAllTypesLite.NestedEnum.BAZ);
builder.addRepeatedForeignEnum(ForeignEnumLite.FOREIGN_LITE_BAZ);
builder.addRepeatedImportEnum(ImportEnumLite.IMPORT_LITE_BAZ);
builder.addRepeatedStringPiece("324");
builder.addRepeatedCord("325");
// -----------------------------------------------------------------
builder.setDefaultInt32(401);
builder.setDefaultInt64(402);
builder.setDefaultUint32(403);
builder.setDefaultUint64(404);
builder.setDefaultSint32(405);
builder.setDefaultSint64(406);
builder.setDefaultFixed32(407);
builder.setDefaultFixed64(408);
builder.setDefaultSfixed32(409);
builder.setDefaultSfixed64(410);
builder.setDefaultFloat(411);
builder.setDefaultDouble(412);
builder.setDefaultBool(false);
builder.setDefaultString("415");
builder.setDefaultBytes(toBytes("416"));
builder.setDefaultNestedEnum(TestAllTypesLite.NestedEnum.FOO);
builder.setDefaultForeignEnum(ForeignEnumLite.FOREIGN_LITE_FOO);
builder.setDefaultImportEnum(ImportEnumLite.IMPORT_LITE_FOO);
builder.setDefaultStringPiece("424");
builder.setDefaultCord("425");
builder.setOneofUint32(601);
builder.setOneofNestedMessage(TestAllTypesLite.NestedMessage.newBuilder().setBb(602).build());
builder.setOneofString("603");
builder.setOneofBytes(toBytes("604"));
} |
Get a {@code TestAllExtensionsLite} with all fields set as they would be by {@link
#setAllExtensions(TestAllExtensionsLite.Builder)}.
public static TestAllExtensionsLite getAllLiteExtensionsSet() {
TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
setAllExtensions(builder);
return builder.build();
}
public static TestPackedExtensionsLite getLitePackedExtensionsSet() {
TestPackedExtensionsLite.Builder builder = TestPackedExtensionsLite.newBuilder();
setPackedExtensions(builder);
return builder.build();
}
/** Set every field of {@code builder} to the values expected by {@code assertAllFieldsSet()}. | TestUtilLite::setAllFields | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtilLite.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtilLite.java | Apache-2.0 |
public static ExtensionRegistryLite getExtensionRegistryLite() {
ExtensionRegistryLite registry = ExtensionRegistryLite.newInstance();
registerAllExtensionsLite(registry);
return registry.getUnmodifiable();
} |
Get an unmodifiable {@link ExtensionRegistryLite} containing all the extensions of {@code
TestAllExtensionsLite}.
| TestUtilLite::getExtensionRegistryLite | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtilLite.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtilLite.java | Apache-2.0 |
public static void registerAllExtensionsLite(ExtensionRegistryLite registry) {
UnittestLite.registerAllExtensions(registry);
} |
Register all of {@code TestAllExtensionsLite}'s extensions with the given {@link
ExtensionRegistryLite}.
| TestUtilLite::registerAllExtensionsLite | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtilLite.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtilLite.java | Apache-2.0 |
public static void setAllExtensions(TestAllExtensionsLite.Builder message) {
message.setExtension(optionalInt32ExtensionLite, 101);
message.setExtension(optionalInt64ExtensionLite, 102L);
message.setExtension(optionalUint32ExtensionLite, 103);
message.setExtension(optionalUint64ExtensionLite, 104L);
message.setExtension(optionalSint32ExtensionLite, 105);
message.setExtension(optionalSint64ExtensionLite, 106L);
message.setExtension(optionalFixed32ExtensionLite, 107);
message.setExtension(optionalFixed64ExtensionLite, 108L);
message.setExtension(optionalSfixed32ExtensionLite, 109);
message.setExtension(optionalSfixed64ExtensionLite, 110L);
message.setExtension(optionalFloatExtensionLite, 111F);
message.setExtension(optionalDoubleExtensionLite, 112D);
message.setExtension(optionalBoolExtensionLite, true);
message.setExtension(optionalStringExtensionLite, "115");
message.setExtension(optionalBytesExtensionLite, toBytes("116"));
message.setExtension(
optionalGroupExtensionLite, OptionalGroup_extension_lite.newBuilder().setA(117).build());
message.setExtension(
optionalNestedMessageExtensionLite,
TestAllTypesLite.NestedMessage.newBuilder().setBb(118).build());
message.setExtension(
optionalForeignMessageExtensionLite, ForeignMessageLite.newBuilder().setC(119).build());
message.setExtension(
optionalImportMessageExtensionLite, ImportMessageLite.newBuilder().setD(120).build());
message.setExtension(
optionalPublicImportMessageExtensionLite,
PublicImportMessageLite.newBuilder().setE(126).build());
message.setExtension(
optionalLazyMessageExtensionLite,
TestAllTypesLite.NestedMessage.newBuilder().setBb(127).build());
message.setExtension(optionalNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ);
message.setExtension(optionalForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);
message.setExtension(optionalImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ);
message.setExtension(optionalStringPieceExtensionLite, "124");
message.setExtension(optionalCordExtensionLite, "125");
// -----------------------------------------------------------------
message.addExtension(repeatedInt32ExtensionLite, 201);
message.addExtension(repeatedInt64ExtensionLite, 202L);
message.addExtension(repeatedUint32ExtensionLite, 203);
message.addExtension(repeatedUint64ExtensionLite, 204L);
message.addExtension(repeatedSint32ExtensionLite, 205);
message.addExtension(repeatedSint64ExtensionLite, 206L);
message.addExtension(repeatedFixed32ExtensionLite, 207);
message.addExtension(repeatedFixed64ExtensionLite, 208L);
message.addExtension(repeatedSfixed32ExtensionLite, 209);
message.addExtension(repeatedSfixed64ExtensionLite, 210L);
message.addExtension(repeatedFloatExtensionLite, 211F);
message.addExtension(repeatedDoubleExtensionLite, 212D);
message.addExtension(repeatedBoolExtensionLite, true);
message.addExtension(repeatedStringExtensionLite, "215");
message.addExtension(repeatedBytesExtensionLite, toBytes("216"));
message.addExtension(
repeatedGroupExtensionLite, RepeatedGroup_extension_lite.newBuilder().setA(217).build());
message.addExtension(
repeatedNestedMessageExtensionLite,
TestAllTypesLite.NestedMessage.newBuilder().setBb(218).build());
message.addExtension(
repeatedForeignMessageExtensionLite, ForeignMessageLite.newBuilder().setC(219).build());
message.addExtension(
repeatedImportMessageExtensionLite, ImportMessageLite.newBuilder().setD(220).build());
message.addExtension(
repeatedLazyMessageExtensionLite,
TestAllTypesLite.NestedMessage.newBuilder().setBb(227).build());
message.addExtension(repeatedNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAR);
message.addExtension(repeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAR);
message.addExtension(repeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAR);
message.addExtension(repeatedStringPieceExtensionLite, "224");
message.addExtension(repeatedCordExtensionLite, "225");
// Add a second one of each field.
message.addExtension(repeatedInt32ExtensionLite, 301);
message.addExtension(repeatedInt64ExtensionLite, 302L);
message.addExtension(repeatedUint32ExtensionLite, 303);
message.addExtension(repeatedUint64ExtensionLite, 304L);
message.addExtension(repeatedSint32ExtensionLite, 305);
message.addExtension(repeatedSint64ExtensionLite, 306L);
message.addExtension(repeatedFixed32ExtensionLite, 307);
message.addExtension(repeatedFixed64ExtensionLite, 308L);
message.addExtension(repeatedSfixed32ExtensionLite, 309);
message.addExtension(repeatedSfixed64ExtensionLite, 310L);
message.addExtension(repeatedFloatExtensionLite, 311F);
message.addExtension(repeatedDoubleExtensionLite, 312D);
message.addExtension(repeatedBoolExtensionLite, false);
message.addExtension(repeatedStringExtensionLite, "315");
message.addExtension(repeatedBytesExtensionLite, toBytes("316"));
message.addExtension(
repeatedGroupExtensionLite, RepeatedGroup_extension_lite.newBuilder().setA(317).build());
message.addExtension(
repeatedNestedMessageExtensionLite,
TestAllTypesLite.NestedMessage.newBuilder().setBb(318).build());
message.addExtension(
repeatedForeignMessageExtensionLite, ForeignMessageLite.newBuilder().setC(319).build());
message.addExtension(
repeatedImportMessageExtensionLite, ImportMessageLite.newBuilder().setD(320).build());
message.addExtension(
repeatedLazyMessageExtensionLite,
TestAllTypesLite.NestedMessage.newBuilder().setBb(327).build());
message.addExtension(repeatedNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.BAZ);
message.addExtension(repeatedForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_BAZ);
message.addExtension(repeatedImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_BAZ);
message.addExtension(repeatedStringPieceExtensionLite, "324");
message.addExtension(repeatedCordExtensionLite, "325");
// -----------------------------------------------------------------
message.setExtension(defaultInt32ExtensionLite, 401);
message.setExtension(defaultInt64ExtensionLite, 402L);
message.setExtension(defaultUint32ExtensionLite, 403);
message.setExtension(defaultUint64ExtensionLite, 404L);
message.setExtension(defaultSint32ExtensionLite, 405);
message.setExtension(defaultSint64ExtensionLite, 406L);
message.setExtension(defaultFixed32ExtensionLite, 407);
message.setExtension(defaultFixed64ExtensionLite, 408L);
message.setExtension(defaultSfixed32ExtensionLite, 409);
message.setExtension(defaultSfixed64ExtensionLite, 410L);
message.setExtension(defaultFloatExtensionLite, 411F);
message.setExtension(defaultDoubleExtensionLite, 412D);
message.setExtension(defaultBoolExtensionLite, false);
message.setExtension(defaultStringExtensionLite, "415");
message.setExtension(defaultBytesExtensionLite, toBytes("416"));
message.setExtension(defaultNestedEnumExtensionLite, TestAllTypesLite.NestedEnum.FOO);
message.setExtension(defaultForeignEnumExtensionLite, ForeignEnumLite.FOREIGN_LITE_FOO);
message.setExtension(defaultImportEnumExtensionLite, ImportEnumLite.IMPORT_LITE_FOO);
message.setExtension(defaultStringPieceExtensionLite, "424");
message.setExtension(defaultCordExtensionLite, "425");
message.setExtension(oneofUint32ExtensionLite, 601);
message.setExtension(
oneofNestedMessageExtensionLite,
TestAllTypesLite.NestedMessage.newBuilder().setBb(602).build());
message.setExtension(oneofStringExtensionLite, "603");
message.setExtension(oneofBytesExtensionLite, toBytes("604"));
} |
Set every field of {@code message} to the values expected by {@code assertAllExtensionsSet()}.
| TestUtilLite::setAllExtensions | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtilLite.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtilLite.java | Apache-2.0 |
public static void modifyRepeatedExtensions(TestAllExtensionsLite.Builder message) {
message.setExtension(repeatedInt32ExtensionLite, 1, 501);
message.setExtension(repeatedInt64ExtensionLite, 1, 502L);
message.setExtension(repeatedUint32ExtensionLite, 1, 503);
message.setExtension(repeatedUint64ExtensionLite, 1, 504L);
message.setExtension(repeatedSint32ExtensionLite, 1, 505);
message.setExtension(repeatedSint64ExtensionLite, 1, 506L);
message.setExtension(repeatedFixed32ExtensionLite, 1, 507);
message.setExtension(repeatedFixed64ExtensionLite, 1, 508L);
message.setExtension(repeatedSfixed32ExtensionLite, 1, 509);
message.setExtension(repeatedSfixed64ExtensionLite, 1, 510L);
message.setExtension(repeatedFloatExtensionLite, 1, 511F);
message.setExtension(repeatedDoubleExtensionLite, 1, 512D);
message.setExtension(repeatedBoolExtensionLite, 1, true);
message.setExtension(repeatedStringExtensionLite, 1, "515");
message.setExtension(repeatedBytesExtensionLite, 1, toBytes("516"));
message.setExtension(
repeatedGroupExtensionLite, 1, RepeatedGroup_extension_lite.newBuilder().setA(517).build());
message.setExtension(
repeatedNestedMessageExtensionLite,
1,
TestAllTypesLite.NestedMessage.newBuilder().setBb(518).build());
message.setExtension(
repeatedForeignMessageExtensionLite, 1, ForeignMessageLite.newBuilder().setC(519).build());
message.setExtension(
repeatedImportMessageExtensionLite, 1, ImportMessageLite.newBuilder().setD(520).build());
message.setExtension(
repeatedLazyMessageExtensionLite,
1,
TestAllTypesLite.NestedMessage.newBuilder().setBb(527).build());
message.setExtension(repeatedNestedEnumExtensionLite, 1, TestAllTypesLite.NestedEnum.FOO);
message.setExtension(repeatedForeignEnumExtensionLite, 1, ForeignEnumLite.FOREIGN_LITE_FOO);
message.setExtension(repeatedImportEnumExtensionLite, 1, ImportEnumLite.IMPORT_LITE_FOO);
message.setExtension(repeatedStringPieceExtensionLite, 1, "524");
message.setExtension(repeatedCordExtensionLite, 1, "525");
} |
Modify the repeated extensions of {@code message} to contain the values expected by {@code
assertRepeatedExtensionsModified()}.
| TestUtilLite::modifyRepeatedExtensions | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtilLite.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtilLite.java | Apache-2.0 |
public static ByteString toBytes(String str) {
return ByteString.copyFromUtf8(str);
} |
Contains methods for setting all fields of {@code TestAllTypes} to some values as well as
checking that all the fields are set to those values. These are useful for testing various
protocol message features, e.g. set all fields of a message, serialize it, it, and check
that all fields are set.
<p>This code is not to be used outside of {@code com.google.protobuf} and subpackages.
@author [email protected] Kenton Varda
public final class TestUtil {
private TestUtil() {}
public static final TestRequired TEST_REQUIRED_UNINITIALIZED =
TestRequired.newBuilder().setA(1).buildPartial();
public static final TestRequired TEST_REQUIRED_INITIALIZED =
TestRequired.newBuilder().setA(1).setB(2).setC(3).build();
/** Helper to convert a String to ByteString. | TestUtil::toBytes | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static TestAllTypes getAllSet() {
TestAllTypes.Builder builder = TestAllTypes.newBuilder();
setAllFields(builder);
return builder.build();
} |
Get a {@code TestAllTypes} with all fields set as they would be by {@link
#setAllFields(TestAllTypes.Builder)}.
| TestUtil::getAllSet | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static TestAllTypes.Builder getAllSetBuilder() {
TestAllTypes.Builder builder = TestAllTypes.newBuilder();
setAllFields(builder);
return builder;
} |
Get a {@code TestAllTypes.Builder} with all fields set as they would be by {@link
#setAllFields(TestAllTypes.Builder)}.
| TestUtil::getAllSetBuilder | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static TestAllExtensions getAllExtensionsSet() {
TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
setAllExtensions(builder);
return builder.build();
} |
Get a {@code TestAllExtensions} with all fields set as they would be by {@link
#setAllExtensions(TestAllExtensions.Builder)}.
| TestUtil::getAllExtensionsSet | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
public static void setAllFields(TestAllTypes.Builder message) {
message.setOptionalInt32(101);
message.setOptionalInt64(102);
message.setOptionalUint32(103);
message.setOptionalUint64(104);
message.setOptionalSint32(105);
message.setOptionalSint64(106);
message.setOptionalFixed32(107);
message.setOptionalFixed64(108);
message.setOptionalSfixed32(109);
message.setOptionalSfixed64(110);
message.setOptionalFloat(111);
message.setOptionalDouble(112);
message.setOptionalBool(true);
message.setOptionalString("115");
message.setOptionalBytes(toBytes("116"));
message.setOptionalGroup(TestAllTypes.OptionalGroup.newBuilder().setA(117).build());
message.setOptionalNestedMessage(TestAllTypes.NestedMessage.newBuilder().setBb(118).build());
message.setOptionalForeignMessage(ForeignMessage.newBuilder().setC(119).build());
message.setOptionalImportMessage(ImportMessage.newBuilder().setD(120).build());
message.setOptionalPublicImportMessage(PublicImportMessage.newBuilder().setE(126).build());
message.setOptionalLazyMessage(TestAllTypes.NestedMessage.newBuilder().setBb(127).build());
message.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAZ);
message.setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ);
message.setOptionalImportEnum(ImportEnum.IMPORT_BAZ);
message.setOptionalStringPiece("124");
message.setOptionalCord("125");
// -----------------------------------------------------------------
message.addRepeatedInt32(201);
message.addRepeatedInt64(202);
message.addRepeatedUint32(203);
message.addRepeatedUint64(204);
message.addRepeatedSint32(205);
message.addRepeatedSint64(206);
message.addRepeatedFixed32(207);
message.addRepeatedFixed64(208);
message.addRepeatedSfixed32(209);
message.addRepeatedSfixed64(210);
message.addRepeatedFloat(211);
message.addRepeatedDouble(212);
message.addRepeatedBool(true);
message.addRepeatedString("215");
message.addRepeatedBytes(toBytes("216"));
message.addRepeatedGroup(TestAllTypes.RepeatedGroup.newBuilder().setA(217).build());
message.addRepeatedNestedMessage(TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
message.addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(219).build());
message.addRepeatedImportMessage(ImportMessage.newBuilder().setD(220).build());
message.addRepeatedLazyMessage(TestAllTypes.NestedMessage.newBuilder().setBb(227).build());
message.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR);
message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR);
message.addRepeatedImportEnum(ImportEnum.IMPORT_BAR);
message.addRepeatedStringPiece("224");
message.addRepeatedCord("225");
// Add a second one of each field.
message.addRepeatedInt32(301);
message.addRepeatedInt64(302);
message.addRepeatedUint32(303);
message.addRepeatedUint64(304);
message.addRepeatedSint32(305);
message.addRepeatedSint64(306);
message.addRepeatedFixed32(307);
message.addRepeatedFixed64(308);
message.addRepeatedSfixed32(309);
message.addRepeatedSfixed64(310);
message.addRepeatedFloat(311);
message.addRepeatedDouble(312);
message.addRepeatedBool(false);
message.addRepeatedString("315");
message.addRepeatedBytes(toBytes("316"));
message.addRepeatedGroup(TestAllTypes.RepeatedGroup.newBuilder().setA(317).build());
message.addRepeatedNestedMessage(TestAllTypes.NestedMessage.newBuilder().setBb(318).build());
message.addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(319).build());
message.addRepeatedImportMessage(ImportMessage.newBuilder().setD(320).build());
message.addRepeatedLazyMessage(TestAllTypes.NestedMessage.newBuilder().setBb(327).build());
message.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ);
message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ);
message.addRepeatedImportEnum(ImportEnum.IMPORT_BAZ);
message.addRepeatedStringPiece("324");
message.addRepeatedCord("325");
// -----------------------------------------------------------------
message.setDefaultInt32(401);
message.setDefaultInt64(402);
message.setDefaultUint32(403);
message.setDefaultUint64(404);
message.setDefaultSint32(405);
message.setDefaultSint64(406);
message.setDefaultFixed32(407);
message.setDefaultFixed64(408);
message.setDefaultSfixed32(409);
message.setDefaultSfixed64(410);
message.setDefaultFloat(411);
message.setDefaultDouble(412);
message.setDefaultBool(false);
message.setDefaultString("415");
message.setDefaultBytes(toBytes("416"));
message.setDefaultNestedEnum(TestAllTypes.NestedEnum.FOO);
message.setDefaultForeignEnum(ForeignEnum.FOREIGN_FOO);
message.setDefaultImportEnum(ImportEnum.IMPORT_FOO);
message.setDefaultStringPiece("424");
message.setDefaultCord("425");
message.setOneofUint32(601);
message.setOneofNestedMessage(TestAllTypes.NestedMessage.newBuilder().setBb(602).build());
message.setOneofString("603");
message.setOneofBytes(toBytes("604"));
} |
Get a {@code TestAllExtensions} with all fields set as they would be by {@link
#setAllExtensions(TestAllExtensions.Builder)}.
public static TestAllExtensions getAllExtensionsSet() {
TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
setAllExtensions(builder);
return builder.build();
}
public static TestPackedTypes getPackedSet() {
TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
setPackedFields(builder);
return builder.build();
}
public static TestUnpackedTypes getUnpackedSet() {
TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
setUnpackedFields(builder);
return builder.build();
}
public static TestPackedExtensions getPackedExtensionsSet() {
TestPackedExtensions.Builder builder = TestPackedExtensions.newBuilder();
setPackedExtensions(builder);
return builder.build();
}
/** Set every field of {@code message} to the values expected by {@code assertAllFieldsSet()}. | TestUtil::setAllFields | java | google/j2objc | protobuf/tests/com/google/protobuf/TestUtil.java | https://github.com/google/j2objc/blob/master/protobuf/tests/com/google/protobuf/TestUtil.java | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.