NativeDecimalFormat (moe.ios.core API)

java.lang.Object
- libcore.icu.NativeDecimalFormat

All Implemented Interfaces:: Cloneable

public final class NativeDecimalFormat
extends Object
implements Cloneable

Constructor Summary

Constructors
Constructor and Description
`NativeDecimalFormat(String pattern, DecimalFormatSymbols dfs)`
`NativeDecimalFormat(String pattern, LocaleData data)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`applyLocalizedPattern(String pattern)`
`void`	`applyPattern(String pattern)`
`Object`	`clone()` Creates and returns a copy of this `Object`.
`void`	`close()`
`boolean`	`equals(Object object)` Note: this doesn't check that the underlying native DecimalFormat objects' configured native DecimalFormatSymbols objects are equal.
`protected void`	`finalize()` Invoked when the garbage collector has detected that this instance is no longer reachable.
`char[]`	`formatBigDecimal(BigDecimal value, FieldPosition field)`
`char[]`	`formatBigInteger(BigInteger value, FieldPosition field)`
`char[]`	`formatDouble(double value, FieldPosition field)`
`char[]`	`formatLong(long value, FieldPosition field)`
`AttributedCharacterIterator`	`formatToCharacterIterator(Object object)`
`int`	`getGroupingSize()`
`int`	`getMaximumFractionDigits()`
`int`	`getMaximumIntegerDigits()`
`int`	`getMinimumFractionDigits()`
`int`	`getMinimumIntegerDigits()`
`int`	`getMultiplier()`
`String`	`getNegativePrefix()`
`String`	`getNegativeSuffix()`
`String`	`getPositivePrefix()`
`String`	`getPositiveSuffix()`
`boolean`	`isDecimalSeparatorAlwaysShown()`
`boolean`	`isGroupingUsed()`
`boolean`	`isParseBigDecimal()`
`boolean`	`isParseIntegerOnly()`
`Number`	`parse(String string, ParsePosition position)`
`void`	`setCurrency(String currencySymbol, String currencyCode)`
`void`	`setDecimalFormatSymbols(DecimalFormatSymbols dfs)` Copies the DecimalFormatSymbols settings into our native peer in bulk.
`void`	`setDecimalFormatSymbols(LocaleData localeData)`
`void`	`setDecimalSeparatorAlwaysShown(boolean value)`
`void`	`setGroupingSize(int value)`
`void`	`setGroupingUsed(boolean value)`
`void`	`setMaximumFractionDigits(int value)`
`void`	`setMaximumIntegerDigits(int value)`
`void`	`setMinimumFractionDigits(int value)`
`void`	`setMinimumIntegerDigits(int value)`
`void`	`setMultiplier(int value)`
`void`	`setNegativePrefix(String value)`
`void`	`setNegativeSuffix(String value)`
`void`	`setParseBigDecimal(boolean value)`
`void`	`setParseIntegerOnly(boolean value)`
`void`	`setPositivePrefix(String value)`
`void`	`setPositiveSuffix(String value)`
`void`	`setRoundingMode(RoundingMode roundingMode, double roundingIncrement)`
`String`	`toLocalizedPattern()`
`String`	`toPattern()`
`String`	`toString()` Returns a string containing a concise, human-readable description of this object.

Methods inherited from class java.lang.Object
getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - NativeDecimalFormat
```
public NativeDecimalFormat(String pattern,
                           DecimalFormatSymbols dfs)
```
  - NativeDecimalFormat
```
public NativeDecimalFormat(String pattern,
                           LocaleData data)
```
- Method Detail
  - close
```
public void close()
```
  - finalize
```
protected void finalize()
                 throws Throwable
```
    Description copied from class: Object
    
    Invoked when the garbage collector has detected that this instance is no longer reachable. The default implementation does nothing, but this method can be overridden to free resources.
    Note that objects that override finalize are significantly more expensive than objects that don't. Finalizers may be run a long time after the object is no longer reachable, depending on memory pressure, so it's a bad idea to rely on them for cleanup. Note also that finalizers are run on a single VM-wide finalizer thread, so doing blocking work in a finalizer is a bad idea. A finalizer is usually only necessary for a class that has a native peer and needs to call a native method to destroy that peer. Even then, it's better to provide an explicit close method (and implement Closeable), and insist that callers manually dispose of instances. This works well for something like files, but less well for something like a BigInteger where typical calling code would have to deal with lots of temporaries. Unfortunately, code that creates lots of temporaries is the worst kind of code from the point of view of the single finalizer thread.
    If you must use finalizers, consider at least providing your own ReferenceQueue and having your own thread process that queue.
    Unlike constructors, finalizers are not automatically chained. You are responsible for calling super.finalize() yourself.
    Uncaught exceptions thrown by finalizers are ignored and do not terminate the finalizer thread. See Effective Java Item 7, "Avoid finalizers" for more.
    
    Overrides:
    
    finalize in class Object
    
    Throws:
    
    Throwable
  - clone
```
public Object clone()
```
    Description copied from class: Object
    
    Creates and returns a copy of this Object. The default implementation returns a so-called "shallow" copy: It creates a new instance of the same class and then copies the field values (including object references) from this instance to the new instance. A "deep" copy, in contrast, would also recursively clone nested objects. A subclass that needs to implement this kind of cloning should call super.clone() to create the new instance and then create deep copies of the nested, mutable objects.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    a copy of this object.
  - equals
```
public boolean equals(Object object)
```
    Note: this doesn't check that the underlying native DecimalFormat objects' configured native DecimalFormatSymbols objects are equal. It is assumed that the caller (DecimalFormat) will check the DecimalFormatSymbols objects instead, for performance. This is also unreasonably expensive, calling down to JNI multiple times. TODO: remove this and just have DecimalFormat.equals do the right thing itself.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    object - the object to compare this instance with.
    
    Returns:
    
    true if the specified object is equal to this Object; false otherwise.
    
    See Also:
    
    Object.hashCode()
  - toString
```
public String toString()
```
    Description copied from class: Object
    Returns a string containing a concise, human-readable description of this object. Subclasses are encouraged to override this method and provide an implementation that takes into account the object's type and data. The default implementation is equivalent to the following expression:
```
   getClass().getName() + '@' + Integer.toHexString(hashCode())
```
    See Writing a useful toString method if you intend implementing your own toString method.
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a printable representation of this object.
  - setDecimalFormatSymbols
```
public void setDecimalFormatSymbols(DecimalFormatSymbols dfs)
```
    Copies the DecimalFormatSymbols settings into our native peer in bulk.
  - setDecimalFormatSymbols
```
public void setDecimalFormatSymbols(LocaleData localeData)
```
  - formatBigDecimal
```
public char[] formatBigDecimal(BigDecimal value,
                               FieldPosition field)
```
  - formatBigInteger
```
public char[] formatBigInteger(BigInteger value,
                               FieldPosition field)
```
  - formatLong
```
public char[] formatLong(long value,
                         FieldPosition field)
```
  - formatDouble
```
public char[] formatDouble(double value,
                           FieldPosition field)
```
  - applyLocalizedPattern
```
public void applyLocalizedPattern(String pattern)
```
  - applyPattern
```
public void applyPattern(String pattern)
```
  - formatToCharacterIterator
```
public AttributedCharacterIterator formatToCharacterIterator(Object object)
```
  - toLocalizedPattern
```
public String toLocalizedPattern()
```
  - toPattern
```
public String toPattern()
```
  - parse
```
public Number parse(String string,
                    ParsePosition position)
```
  - getMaximumFractionDigits
```
public int getMaximumFractionDigits()
```
  - getMaximumIntegerDigits
```
public int getMaximumIntegerDigits()
```
  - getMinimumFractionDigits
```
public int getMinimumFractionDigits()
```
  - getMinimumIntegerDigits
```
public int getMinimumIntegerDigits()
```
  - getGroupingSize
```
public int getGroupingSize()
```
  - getMultiplier
```
public int getMultiplier()
```
  - getNegativePrefix
```
public String getNegativePrefix()
```
  - getNegativeSuffix
```
public String getNegativeSuffix()
```
  - getPositivePrefix
```
public String getPositivePrefix()
```
  - getPositiveSuffix
```
public String getPositiveSuffix()
```
  - isDecimalSeparatorAlwaysShown
```
public boolean isDecimalSeparatorAlwaysShown()
```
  - isParseBigDecimal
```
public boolean isParseBigDecimal()
```
  - isParseIntegerOnly
```
public boolean isParseIntegerOnly()
```
  - isGroupingUsed
```
public boolean isGroupingUsed()
```
  - setDecimalSeparatorAlwaysShown
```
public void setDecimalSeparatorAlwaysShown(boolean value)
```
  - setCurrency
```
public void setCurrency(String currencySymbol,
                        String currencyCode)
```
  - setGroupingSize
```
public void setGroupingSize(int value)
```
  - setGroupingUsed
```
public void setGroupingUsed(boolean value)
```
  - setMaximumFractionDigits
```
public void setMaximumFractionDigits(int value)
```
  - setMaximumIntegerDigits
```
public void setMaximumIntegerDigits(int value)
```
  - setMinimumFractionDigits
```
public void setMinimumFractionDigits(int value)
```
  - setMinimumIntegerDigits
```
public void setMinimumIntegerDigits(int value)
```
  - setMultiplier
```
public void setMultiplier(int value)
```
  - setNegativePrefix
```
public void setNegativePrefix(String value)
```
  - setNegativeSuffix
```
public void setNegativeSuffix(String value)
```
  - setPositivePrefix
```
public void setPositivePrefix(String value)
```
  - setPositiveSuffix
```
public void setPositiveSuffix(String value)
```
  - setParseBigDecimal
```
public void setParseBigDecimal(boolean value)
```
  - setParseIntegerOnly
```
public void setParseIntegerOnly(boolean value)
```
  - setRoundingMode
```
public void setRoundingMode(RoundingMode roundingMode,
                            double roundingIncrement)
```

Class NativeDecimalFormat

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

NativeDecimalFormat

NativeDecimalFormat

Method Detail

close

finalize

clone

equals

toString

setDecimalFormatSymbols

setDecimalFormatSymbols

formatBigDecimal

formatBigInteger

formatLong

formatDouble

applyLocalizedPattern

applyPattern

formatToCharacterIterator

toLocalizedPattern

toPattern

parse

getMaximumFractionDigits

getMaximumIntegerDigits

getMinimumFractionDigits

getMinimumIntegerDigits

getGroupingSize

getMultiplier

getNegativePrefix

getNegativeSuffix

getPositivePrefix

getPositiveSuffix

isDecimalSeparatorAlwaysShown

isParseBigDecimal

isParseIntegerOnly

isGroupingUsed

setDecimalSeparatorAlwaysShown

setCurrency

setGroupingSize

setGroupingUsed

setMaximumFractionDigits

setMaximumIntegerDigits

setMinimumFractionDigits

setMinimumIntegerDigits

setMultiplier

setNegativePrefix

setNegativeSuffix

setPositivePrefix

setPositiveSuffix

setParseBigDecimal

setParseIntegerOnly

setRoundingMode