declare namespace java {
namespace text {
/**
* Format
is an abstract base class for formatting locale-sensitive
* information such as dates, messages, and numbers.
*
* Format
defines the programming interface for formatting
* locale-sensitive objects into String
s (the
* format
method) and for parsing String
s back
* into objects (the parseObject
method).
*
* Generally, a format's parseObject
method must be able to parse
* any string formatted by its format
method. However, there may
* be exceptional cases where this is not possible. For example, a
* format
method might create two adjacent integer numbers with
* no separator in between, and in this case the parseObject
could
* not tell which digits belong to which number.
*
* The Java Platform provides three specialized subclasses of Format
--
* DateFormat
, MessageFormat
, and
* NumberFormat
--for formatting dates, messages, and numbers,
* respectively.
*
* Concrete subclasses must implement three methods: *
format(Object obj, StringBuffer toAppendTo, FieldPosition pos)
* formatToCharacterIterator(Object obj)
* parseObject(String source, ParsePosition pos)
* MessageFormat
.
* Subclasses often also provide additional format
methods for
* specific input types as well as parse
methods for specific
* result types. Any parse
method that does not take a
* ParsePosition
argument should throw ParseException
* when no text in the required format is at the beginning of the input text.
* * Most subclasses will also implement the following factory methods: *
getInstance
for getting a useful format object appropriate
* for the current locale
* getInstance(Locale)
for getting a useful format
* object appropriate for the specified locale
* getXxxxInstance
methods for more specialized control. For
* example, the NumberFormat
class provides
* getPercentInstance
and getCurrencyInstance
* methods for getting specialized number formatters.
*
* Subclasses of Format
that allow programmers to create objects
* for locales (with getInstance(Locale)
for example)
* must also implement the following class method:
*
*** public static Locale[] getAvailableLocales() **
* And finally subclasses may define a set of constants to identify the various
* fields in the formatted output. These constants are used to create a FieldPosition
* object which identifies what information is contained in the field and its
* position in the formatted result. These constants should be named
* item_FIELD
where item
identifies
* the field. For examples of these constants, see ERA_FIELD
and its
* friends in {@link DateFormat}.
*
* Formats are generally not synchronized. * It is recommended to create separate format instances for each thread. * If multiple threads access a format concurrently, it must be synchronized * externally. * @see java.text.ParsePosition * @see java.text.FieldPosition * @see java.text.NumberFormat * @see java.text.DateFormat * @see java.text.MessageFormat * @author Mark Davis */ // @ts-ignore abstract class Format extends java.lang.Object implements java.io.Serializable, java.lang.Cloneable { /** * Sole constructor. (For invocation by subclass constructors, typically * implicit.) */ // @ts-ignore constructor() /** * Formats an object to produce a string. This is equivalent to *
* {@link #format(Object, StringBuffer, FieldPosition) format}(obj,
* new StringBuffer(), new FieldPosition(0)).toString();
*
* @param obj The object to format
* @return Formatted string.
* @exception IllegalArgumentException if the Format cannot format the given
* object
*/
// @ts-ignore
public format(obj: java.lang.Object | any): string
/**
* Formats an object and appends the resulting text to a given string
* buffer.
* If the pos
argument identifies a field used by the format,
* then its indices are set to the beginning and end of the first such
* field encountered.
* @param obj The object to format
* @param toAppendTo where the text is to be appended
* @param pos A FieldPosition
identifying a field
* in the formatted text
* @return the string buffer passed in as toAppendTo
,
* with formatted text appended
* @exception NullPointerException if toAppendTo
or
* pos
is null
* @exception IllegalArgumentException if the Format cannot format the given
* object
*/
// @ts-ignore
public abstract format(obj: java.lang.Object | any, toAppendTo: java.lang.StringBuffer, pos: java.text.FieldPosition): java.lang.StringBuffer
/**
* Formats an Object producing an AttributedCharacterIterator
.
* You can use the returned AttributedCharacterIterator
* to build the resulting String, as well as to determine information
* about the resulting String.
*
* Each attribute key of the AttributedCharacterIterator will be of type
* Field
. It is up to each Format
implementation
* to define what the legal values are for each attribute in the
* AttributedCharacterIterator
, but typically the attribute
* key is also used as the attribute value.
*
The default implementation creates an
* AttributedCharacterIterator
with no attributes. Subclasses
* that support fields should override this and create an
* AttributedCharacterIterator
with meaningful attributes.
* @exception NullPointerException if obj is null.
* @exception IllegalArgumentException when the Format cannot format the
* given object.
* @param obj The object to format
* @return AttributedCharacterIterator describing the formatted value.
* @since 1.4
*/
// @ts-ignore
public formatToCharacterIterator(obj: java.lang.Object | any): java.text.AttributedCharacterIterator
/**
* Parses text from a string to produce an object.
*
* The method attempts to parse text starting at the index given by
* pos
.
* If parsing succeeds, then the index of pos
is updated
* to the index after the last character used (parsing does not necessarily
* use all characters up to the end of the string), and the parsed
* object is returned. The updated pos
can be used to
* indicate the starting point for the next call to this method.
* If an error occurs, then the index of pos
is not
* changed, the error index of pos
is set to the index of
* the character where the error occurred, and null is returned.
* @param source A String
, part of which should be parsed.
* @param pos A ParsePosition
object with index and error
* index information as described above.
* @return An Object
parsed from the string. In case of
* error, returns null.
* @exception NullPointerException if pos
is null.
*/
// @ts-ignore
public abstract parseObject(source: java.lang.String | string, pos: java.text.ParsePosition): any
/**
* Parses text from the beginning of the given string to produce an object.
* The method may not use the entire text of the given string.
* @param source A String
whose beginning should be parsed.
* @return An Object
parsed from the string.
* @exception ParseException if the beginning of the specified string
* cannot be parsed.
*/
// @ts-ignore
public parseObject(source: java.lang.String | string): any
/**
* Creates and returns a copy of this object.
* @return a clone of this instance.
*/
// @ts-ignore
public clone(): any
}
}
}