| /* GENERATED SOURCE. DO NOT MODIFY. */ |
| // ? 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * Copyright (C) 2010-2016, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ******************************************************************************* |
| * created on: 2010aug21 |
| * created by: Markus W. Scherer |
| */ |
| |
| |
| package android.icu.text; |
| |
| |
| /** |
| * Parses and represents ICU MessageFormat patterns. |
| * Also handles patterns for ChoiceFormat, PluralFormat and SelectFormat. |
| * Used in the implementations of those classes as well as in tools |
| * for message validation, translation and format conversion. |
| * <p> |
| * The parser handles all syntax relevant for identifying message arguments. |
| * This includes "complex" arguments whose style strings contain |
| * nested MessageFormat pattern substrings. |
| * For "simple" arguments (with no nested MessageFormat pattern substrings), |
| * the argument style is not parsed any further. |
| * <p> |
| * The parser handles named and numbered message arguments and allows both in one message. |
| * <p> |
| * Once a pattern has been parsed successfully, iterate through the parsed data |
| * with countParts(), getPart() and related methods. |
| * <p> |
| * The data logically represents a parse tree, but is stored and accessed |
| * as a list of "parts" for fast and simple parsing and to minimize object allocations. |
| * Arguments and nested messages are best handled via recursion. |
| * For every _START "part", {@link #getLimitPartIndex(int)} efficiently returns |
| * the index of the corresponding _LIMIT "part". |
| * <p> |
| * List of "parts": |
| * <pre> |
| * message = MSG_START (SKIP_SYNTAX | INSERT_CHAR | REPLACE_NUMBER | argument)* MSG_LIMIT |
| * argument = noneArg | simpleArg | complexArg |
| * complexArg = choiceArg | pluralArg | selectArg |
| * |
| * noneArg = ARG_START.NONE (ARG_NAME | ARG_NUMBER) ARG_LIMIT.NONE |
| * simpleArg = ARG_START.SIMPLE (ARG_NAME | ARG_NUMBER) ARG_TYPE [ARG_STYLE] ARG_LIMIT.SIMPLE |
| * choiceArg = ARG_START.CHOICE (ARG_NAME | ARG_NUMBER) choiceStyle ARG_LIMIT.CHOICE |
| * pluralArg = ARG_START.PLURAL (ARG_NAME | ARG_NUMBER) pluralStyle ARG_LIMIT.PLURAL |
| * selectArg = ARG_START.SELECT (ARG_NAME | ARG_NUMBER) selectStyle ARG_LIMIT.SELECT |
| * |
| * choiceStyle = ((ARG_INT | ARG_DOUBLE) ARG_SELECTOR message)+ |
| * pluralStyle = [ARG_INT | ARG_DOUBLE] (ARG_SELECTOR [ARG_INT | ARG_DOUBLE] message)+ |
| * selectStyle = (ARG_SELECTOR message)+ |
| * </pre> |
| * <ul> |
| * <li>Literal output text is not represented directly by "parts" but accessed |
| * between parts of a message, from one part's getLimit() to the next part's getIndex(). |
| * <li><code>ARG_START.CHOICE</code> stands for an ARG_START Part with ArgType CHOICE. |
| * <li>In the choiceStyle, the ARG_SELECTOR has the '<', the '#' or |
| * the less-than-or-equal-to sign (U+2264). |
| * <li>In the pluralStyle, the first, optional numeric Part has the "offset:" value. |
| * The optional numeric Part between each (ARG_SELECTOR, message) pair |
| * is the value of an explicit-number selector like "=2", |
| * otherwise the selector is a non-numeric identifier. |
| * <li>The REPLACE_NUMBER Part can occur only in an immediate sub-message of the pluralStyle. |
| * </ul> |
| * <p> |
| * This class is not intended for public subclassing. |
| * |
| * @author Markus Scherer |
| */ |
| |
| @SuppressWarnings({"unchecked", "deprecation", "all"}) |
| public final class MessagePattern implements java.lang.Cloneable, android.icu.util.Freezable<android.icu.text.MessagePattern> { |
| |
| /** |
| * Constructs an empty MessagePattern with default ApostropheMode. |
| */ |
| |
| public MessagePattern() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Constructs an empty MessagePattern. |
| * @param mode Explicit ApostropheMode. |
| */ |
| |
| public MessagePattern(android.icu.text.MessagePattern.ApostropheMode mode) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Constructs a MessagePattern with default ApostropheMode and |
| * parses the MessageFormat pattern string. |
| * @param pattern a MessageFormat pattern string |
| * @throws java.lang.IllegalArgumentException for syntax errors in the pattern string |
| * @throws java.lang.IndexOutOfBoundsException if certain limits are exceeded |
| * (e.g., argument number too high, argument name too long, etc.) |
| * @throws java.lang.NumberFormatException if a number could not be parsed |
| */ |
| |
| public MessagePattern(java.lang.String pattern) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Parses a MessageFormat pattern string. |
| * @param pattern a MessageFormat pattern string |
| * @return this |
| * @throws java.lang.IllegalArgumentException for syntax errors in the pattern string |
| * @throws java.lang.IndexOutOfBoundsException if certain limits are exceeded |
| * (e.g., argument number too high, argument name too long, etc.) |
| * @throws java.lang.NumberFormatException if a number could not be parsed |
| */ |
| |
| public android.icu.text.MessagePattern parse(java.lang.String pattern) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Parses a ChoiceFormat pattern string. |
| * @param pattern a ChoiceFormat pattern string |
| * @return this |
| * @throws java.lang.IllegalArgumentException for syntax errors in the pattern string |
| * @throws java.lang.IndexOutOfBoundsException if certain limits are exceeded |
| * (e.g., argument number too high, argument name too long, etc.) |
| * @throws java.lang.NumberFormatException if a number could not be parsed |
| */ |
| |
| public android.icu.text.MessagePattern parseChoiceStyle(java.lang.String pattern) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Parses a PluralFormat pattern string. |
| * @param pattern a PluralFormat pattern string |
| * @return this |
| * @throws java.lang.IllegalArgumentException for syntax errors in the pattern string |
| * @throws java.lang.IndexOutOfBoundsException if certain limits are exceeded |
| * (e.g., argument number too high, argument name too long, etc.) |
| * @throws java.lang.NumberFormatException if a number could not be parsed |
| */ |
| |
| public android.icu.text.MessagePattern parsePluralStyle(java.lang.String pattern) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Parses a SelectFormat pattern string. |
| * @param pattern a SelectFormat pattern string |
| * @return this |
| * @throws java.lang.IllegalArgumentException for syntax errors in the pattern string |
| * @throws java.lang.IndexOutOfBoundsException if certain limits are exceeded |
| * (e.g., argument number too high, argument name too long, etc.) |
| * @throws java.lang.NumberFormatException if a number could not be parsed |
| */ |
| |
| public android.icu.text.MessagePattern parseSelectStyle(java.lang.String pattern) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Clears this MessagePattern. |
| * countParts() will return 0. |
| */ |
| |
| public void clear() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Clears this MessagePattern and sets the ApostropheMode. |
| * countParts() will return 0. |
| * @param mode The new ApostropheMode. |
| */ |
| |
| public void clearPatternAndSetApostropheMode(android.icu.text.MessagePattern.ApostropheMode mode) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * @param other another object to compare with. |
| * @return true if this object is equivalent to the other one. |
| */ |
| |
| public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| |
| public int hashCode() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * @return this instance's ApostropheMode. |
| */ |
| |
| public android.icu.text.MessagePattern.ApostropheMode getApostropheMode() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * @return the parsed pattern string (null if none was parsed). |
| */ |
| |
| public java.lang.String getPatternString() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Does the parsed pattern have named arguments like {first_name}? |
| * @return true if the parsed pattern has at least one named argument. |
| */ |
| |
| public boolean hasNamedArguments() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Does the parsed pattern have numbered arguments like {2}? |
| * @return true if the parsed pattern has at least one numbered argument. |
| */ |
| |
| public boolean hasNumberedArguments() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| |
| public java.lang.String toString() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Validates and parses an argument name or argument number string. |
| * An argument name must be a "pattern identifier", that is, it must contain |
| * no Unicode Pattern_Syntax or Pattern_White_Space characters. |
| * If it only contains ASCII digits, then it must be a small integer with no leading zero. |
| * @param name Input string. |
| * @return >=0 if the name is a valid number, |
| * ARG_NAME_NOT_NUMBER (-1) if it is a "pattern identifier" but not all ASCII digits, |
| * ARG_NAME_NOT_VALID (-2) if it is neither. |
| */ |
| |
| public static int validateArgumentName(java.lang.String name) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns a version of the parsed pattern string where each ASCII apostrophe |
| * is doubled (escaped) if it is not already, and if it is not interpreted as quoting syntax. |
| * <p> |
| * For example, this turns "I don't '{know}' {gender,select,female{h''er}other{h'im}}." |
| * into "I don''t '{know}' {gender,select,female{h''er}other{h''im}}." |
| * @return the deep-auto-quoted version of the parsed pattern string. |
| * @see android.icu.text.MessageFormat#autoQuoteApostrophe(String) |
| */ |
| |
| public java.lang.String autoQuoteApostropheDeep() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the number of "parts" created by parsing the pattern string. |
| * Returns 0 if no pattern has been parsed or clear() was called. |
| * @return the number of pattern parts. |
| */ |
| |
| public int countParts() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Gets the i-th pattern "part". |
| * @param i The index of the Part data. (0..countParts()-1) |
| * @return the i-th pattern "part". |
| * @throws java.lang.IndexOutOfBoundsException if i is outside the (0..countParts()-1) range |
| */ |
| |
| public android.icu.text.MessagePattern.Part getPart(int i) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the Part.Type of the i-th pattern "part". |
| * Convenience method for getPart(i).getType(). |
| * @param i The index of the Part data. (0..countParts()-1) |
| * @return The Part.Type of the i-th Part. |
| * @throws java.lang.IndexOutOfBoundsException if i is outside the (0..countParts()-1) range |
| */ |
| |
| public android.icu.text.MessagePattern.Part.Type getPartType(int i) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the pattern index of the specified pattern "part". |
| * Convenience method for getPart(partIndex).getIndex(). |
| * @param partIndex The index of the Part data. (0..countParts()-1) |
| * @return The pattern index of this Part. |
| * @throws java.lang.IndexOutOfBoundsException if partIndex is outside the (0..countParts()-1) range |
| */ |
| |
| public int getPatternIndex(int partIndex) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the substring of the pattern string indicated by the Part. |
| * Convenience method for getPatternString().substring(part.getIndex(), part.getLimit()). |
| * @param part a part of this MessagePattern. |
| * @return the substring associated with part. |
| */ |
| |
| public java.lang.String getSubstring(android.icu.text.MessagePattern.Part part) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Compares the part's substring with the input string s. |
| * @param part a part of this MessagePattern. |
| * @param s a string. |
| * @return true if getSubstring(part).equals(s). |
| */ |
| |
| public boolean partSubstringMatches(android.icu.text.MessagePattern.Part part, java.lang.String s) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the numeric value associated with an ARG_INT or ARG_DOUBLE. |
| * @param part a part of this MessagePattern. |
| * @return the part's numeric value, or NO_NUMERIC_VALUE if this is not a numeric part. |
| */ |
| |
| public double getNumericValue(android.icu.text.MessagePattern.Part part) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the "offset:" value of a PluralFormat argument, or 0 if none is specified. |
| * @param pluralStart the index of the first PluralFormat argument style part. (0..countParts()-1) |
| * @return the "offset:" value. |
| * @throws java.lang.IndexOutOfBoundsException if pluralStart is outside the (0..countParts()-1) range |
| */ |
| |
| public double getPluralOffset(int pluralStart) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the index of the ARG|MSG_LIMIT part corresponding to the ARG|MSG_START at start. |
| * @param start The index of some Part data (0..countParts()-1); |
| * this Part should be of Type ARG_START or MSG_START. |
| * @return The first i>start where getPart(i).getType()==ARG|MSG_LIMIT at the same nesting level, |
| * or start itself if getPartType(msgStart)!=ARG|MSG_START. |
| * @throws java.lang.IndexOutOfBoundsException if start is outside the (0..countParts()-1) range |
| */ |
| |
| public int getLimitPartIndex(int start) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Creates and returns a copy of this object. |
| * @return a copy of this object (or itself if frozen). |
| */ |
| |
| public java.lang.Object clone() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Creates and returns an unfrozen copy of this object. |
| * @return a copy of this object. |
| */ |
| |
| public android.icu.text.MessagePattern cloneAsThawed() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Freezes this object, making it immutable and thread-safe. |
| * @return this |
| */ |
| |
| public android.icu.text.MessagePattern freeze() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Determines whether this object is frozen (immutable) or not. |
| * @return true if this object is frozen. |
| */ |
| |
| public boolean isFrozen() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Return value from {@link #validateArgumentName(java.lang.String)} for when |
| * the string is a valid "pattern identifier" but not a number. |
| */ |
| |
| public static final int ARG_NAME_NOT_NUMBER = -1; // 0xffffffff |
| |
| /** |
| * Return value from {@link #validateArgumentName(java.lang.String)} for when |
| * the string is invalid. |
| * It might not be a valid "pattern identifier", |
| * or it have only ASCII digits but there is a leading zero or the number is too large. |
| */ |
| |
| public static final int ARG_NAME_NOT_VALID = -2; // 0xfffffffe |
| |
| /** |
| * Special value that is returned by getNumericValue(Part) when no |
| * numeric value is defined for a part. |
| * @see #getNumericValue |
| */ |
| |
| public static final double NO_NUMERIC_VALUE = -1.23456789E8; |
| /** |
| * Mode for when an apostrophe starts quoted literal text for MessageFormat output. |
| * The default is DOUBLE_OPTIONAL unless overridden via ICUConfig |
| * (/com/ibm/icu/ICUConfig.properties). |
| * <p> |
| * A pair of adjacent apostrophes always results in a single apostrophe in the output, |
| * even when the pair is between two single, text-quoting apostrophes. |
| * <p> |
| * The following table shows examples of desired MessageFormat.format() output |
| * with the pattern strings that yield that output. |
| * |
| * <table> |
| * <tr> |
| * <th>Desired output</th> |
| * <th>DOUBLE_OPTIONAL</th> |
| * <th>DOUBLE_REQUIRED</th> |
| * </tr> |
| * <tr> |
| * <td>I see {many}</td> |
| * <td>I see '{many}'</td> |
| * <td>(same)</td> |
| * </tr> |
| * <tr> |
| * <td>I said {'Wow!'}</td> |
| * <td>I said '{''Wow!''}'</td> |
| * <td>(same)</td> |
| * </tr> |
| * <tr> |
| * <td>I don't know</td> |
| * <td>I don't know OR<br> I don''t know</td> |
| * <td>I don''t know</td> |
| * </tr> |
| * </table> |
| */ |
| |
| @SuppressWarnings({"unchecked", "deprecation", "all"}) |
| public enum ApostropheMode { |
| /** |
| * A literal apostrophe is represented by |
| * either a single or a double apostrophe pattern character. |
| * Within a MessageFormat pattern, a single apostrophe only starts quoted literal text |
| * if it immediately precedes a curly brace {}, |
| * or a pipe symbol | if inside a choice format, |
| * or a pound symbol # if inside a plural format. |
| * <p> |
| * This is the default behavior starting with ICU 4.8. |
| */ |
| |
| DOUBLE_OPTIONAL, |
| /** |
| * A literal apostrophe must be represented by |
| * a double apostrophe pattern character. |
| * A single apostrophe always starts quoted literal text. |
| * <p> |
| * This is the behavior of ICU 4.6 and earlier, and of {@link java.text.MessageFormat}. |
| */ |
| |
| DOUBLE_REQUIRED; |
| } |
| |
| /** |
| * Argument type constants. |
| * Returned by Part.getArgType() for ARG_START and ARG_LIMIT parts. |
| * |
| * Messages nested inside an argument are each delimited by MSG_START and MSG_LIMIT, |
| * with a nesting level one greater than the surrounding message. |
| */ |
| |
| @SuppressWarnings({"unchecked", "deprecation", "all"}) |
| public enum ArgType { |
| /** |
| * The argument has no specified type. |
| */ |
| |
| NONE, |
| /** |
| * The argument has a "simple" type which is provided by the ARG_TYPE part. |
| * An ARG_STYLE part might follow that. |
| */ |
| |
| SIMPLE, |
| /** |
| * The argument is a ChoiceFormat with one or more |
| * ((ARG_INT | ARG_DOUBLE), ARG_SELECTOR, message) tuples. |
| */ |
| |
| CHOICE, |
| /** |
| * The argument is a cardinal-number PluralFormat with an optional ARG_INT or ARG_DOUBLE offset |
| * (e.g., offset:1) |
| * and one or more (ARG_SELECTOR [explicit-value] message) tuples. |
| * If the selector has an explicit value (e.g., =2), then |
| * that value is provided by the ARG_INT or ARG_DOUBLE part preceding the message. |
| * Otherwise the message immediately follows the ARG_SELECTOR. |
| */ |
| |
| PLURAL, |
| /** |
| * The argument is a SelectFormat with one or more (ARG_SELECTOR, message) pairs. |
| */ |
| |
| SELECT, |
| /** |
| * The argument is an ordinal-number PluralFormat |
| * with the same style parts sequence and semantics as {@link android.icu.text.MessagePattern.ArgType#PLURAL ArgType#PLURAL}. |
| */ |
| |
| SELECTORDINAL; |
| |
| /** |
| * @return true if the argument type has a plural style part sequence and semantics, |
| * for example {@link android.icu.text.MessagePattern.ArgType#PLURAL ArgType#PLURAL} and {@link android.icu.text.MessagePattern.ArgType#SELECTORDINAL ArgType#SELECTORDINAL}. |
| */ |
| |
| public boolean hasPluralStyle() { throw new RuntimeException("Stub!"); } |
| } |
| |
| /** |
| * A message pattern "part", representing a pattern parsing event. |
| * There is a part for the start and end of a message or argument, |
| * for quoting and escaping of and with ASCII apostrophes, |
| * and for syntax elements of "complex" arguments. |
| */ |
| |
| @SuppressWarnings({"unchecked", "deprecation", "all"}) |
| public static final class Part { |
| |
| private Part() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the type of this part. |
| * @return the part type. |
| */ |
| |
| public android.icu.text.MessagePattern.Part.Type getType() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the pattern string index associated with this Part. |
| * @return this part's pattern string index. |
| */ |
| |
| public int getIndex() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the length of the pattern substring associated with this Part. |
| * This is 0 for some parts. |
| * @return this part's pattern substring length. |
| */ |
| |
| public int getLength() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the pattern string limit (exclusive-end) index associated with this Part. |
| * Convenience method for getIndex()+getLength(). |
| * @return this part's pattern string limit index, same as getIndex()+getLength(). |
| */ |
| |
| public int getLimit() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns a value associated with this part. |
| * See the documentation of each part type for details. |
| * @return the part value. |
| */ |
| |
| public int getValue() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * Returns the argument type if this part is of type ARG_START or ARG_LIMIT, |
| * otherwise ArgType.NONE. |
| * @return the argument type for this part. |
| */ |
| |
| public android.icu.text.MessagePattern.ArgType getArgType() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * @return a string representation of this part. |
| */ |
| |
| public java.lang.String toString() { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * @param other another object to compare with. |
| * @return true if this object is equivalent to the other one. |
| */ |
| |
| public boolean equals(java.lang.Object other) { throw new RuntimeException("Stub!"); } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| |
| public int hashCode() { throw new RuntimeException("Stub!"); } |
| /** |
| * Part type constants. |
| */ |
| |
| @SuppressWarnings({"unchecked", "deprecation", "all"}) |
| public enum Type { |
| /** |
| * Start of a message pattern (main or nested). |
| * The length is 0 for the top-level message |
| * and for a choice argument sub-message, otherwise 1 for the '{'. |
| * The value indicates the nesting level, starting with 0 for the main message. |
| * <p> |
| * There is always a later MSG_LIMIT part. |
| */ |
| |
| MSG_START, |
| /** |
| * End of a message pattern (main or nested). |
| * The length is 0 for the top-level message and |
| * the last sub-message of a choice argument, |
| * otherwise 1 for the '}' or (in a choice argument style) the '|'. |
| * The value indicates the nesting level, starting with 0 for the main message. |
| */ |
| |
| MSG_LIMIT, |
| /** |
| * Indicates a substring of the pattern string which is to be skipped when formatting. |
| * For example, an apostrophe that begins or ends quoted text |
| * would be indicated with such a part. |
| * The value is undefined and currently always 0. |
| */ |
| |
| SKIP_SYNTAX, |
| /** |
| * Indicates that a syntax character needs to be inserted for auto-quoting. |
| * The length is 0. |
| * The value is the character code of the insertion character. (U+0027=APOSTROPHE) |
| */ |
| |
| INSERT_CHAR, |
| /** |
| * Indicates a syntactic (non-escaped) # symbol in a plural variant. |
| * When formatting, replace this part's substring with the |
| * (value-offset) for the plural argument value. |
| * The value is undefined and currently always 0. |
| */ |
| |
| REPLACE_NUMBER, |
| /** |
| * Start of an argument. |
| * The length is 1 for the '{'. |
| * The value is the ordinal value of the ArgType. Use getArgType(). |
| * <p> |
| * This part is followed by either an ARG_NUMBER or ARG_NAME, |
| * followed by optional argument sub-parts (see ArgType constants) |
| * and finally an ARG_LIMIT part. |
| */ |
| |
| ARG_START, |
| /** |
| * End of an argument. |
| * The length is 1 for the '}'. |
| * The value is the ordinal value of the ArgType. Use getArgType(). |
| */ |
| |
| ARG_LIMIT, |
| /** |
| * The argument number, provided by the value. |
| */ |
| |
| ARG_NUMBER, |
| /** |
| * The argument name. |
| * The value is undefined and currently always 0. |
| */ |
| |
| ARG_NAME, |
| /** |
| * The argument type. |
| * The value is undefined and currently always 0. |
| */ |
| |
| ARG_TYPE, |
| /** |
| * The argument style text. |
| * The value is undefined and currently always 0. |
| */ |
| |
| ARG_STYLE, |
| /** |
| * A selector substring in a "complex" argument style. |
| * The value is undefined and currently always 0. |
| */ |
| |
| ARG_SELECTOR, |
| /** |
| * An integer value, for example the offset or an explicit selector value |
| * in a PluralFormat style. |
| * The part value is the integer value. |
| */ |
| |
| ARG_INT, |
| /** |
| * A numeric value, for example the offset or an explicit selector value |
| * in a PluralFormat style. |
| * The part value is an index into an internal array of numeric values; |
| * use getNumericValue(). |
| */ |
| |
| ARG_DOUBLE; |
| |
| /** |
| * Indicates whether this part has a numeric value. |
| * If so, then that numeric value can be retrieved via {@link android.icu.text.MessagePattern#getNumericValue(android.icu.text.MessagePattern.Part) MessagePattern#getNumericValue(Part)}. |
| * @return true if this part has a numeric value. |
| */ |
| |
| public boolean hasNumericValue() { throw new RuntimeException("Stub!"); } |
| } |
| |
| } |
| |
| } |
| |