/*
 *******************************************************************************
 * Copyright (C) 1996-2000, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 *
 * $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/text/resources/Attic/NumberFormatRules.java,v $ 
 * $Date: 2000/03/10 04:07:27 $ 
 * $Revision: 1.2 $
 *
 *****************************************************************************************
 */
package com.ibm.text.resources;

import java.util.ListResourceBundle;

/**
 * Base resource for RuleBasedNumberFormat data.  Each resource contains
 * rule sets for three uses: spelled-out numerical values, ordinal
 * abbreviations, and durations in seconds.  This resource contains the
 * U.S. English data.
 *
 * @author Richard Gillam
 * @version $Version$ $Date: 2000/03/10 04:07:27 $
 */
public class NumberFormatRules extends ListResourceBundle {
    /**
     * Puts a copyright in the .class file
     */
    private static final String copyrightNotice
        = "Copyright \u00a91997-1998 IBM Corp.  All rights reserved.";

    public Object[][] getContents() {
        return contents;
    }

    Object[][] contents = {
        /*
         * Spellout rules for U.S. English.  This rule set has two variants:
         * %simplified is a set of rules showing the simple method of spelling
         * out numbers in English: 289 is formatted as "two hundred eighty-nine".
         * %default uses a more complicated algorithm to format
         * numbers in a more natural way: 289 is formatted as "two hundred AND
         * eighty-nine" and commas are inserted between the thousands groups for
         * values above 100,000.
         */
        { "SpelloutRules",
            // This rule set shows the normal simple formatting rules for English
            "%simplified:\n"
                   // negative number rule.  This rule is used to format negative
                   // numbers.  The result of formatting the number's absolute
                   // value is placed where the >> is.
            + "    -x: minus >>;\n"
                   // faction rule.  This rule is used for formatting numbers
                   // with fractional parts.  The result of formatting the
                   // number's integral part is substituted for the <<, and
                   // the result of formatting the number's fractional part
                   // (one digit at a time, e.g., 0.123 is "zero point one two
                   // three") replaces the >>.
            + "    x.x: << point >>;\n"
                   // the rules for the values from 0 to 19 are simply the
                   // words for those numbers
            + "    zero; one; two; three; four; five; six; seven; eight; nine;\n"
            + "    ten; eleven; twelve; thirteen; fourteen; fifteen; sixteen;\n"
            + "        seventeen; eighteen; nineteen;\n"
                   // beginning at 20, we use the >> to mark the position where
                   // the result of formatting the number's ones digit.  Thus,
                   // we only need a new rule at every multiple of 10.  Text in
                   // backets is omitted if the value being formatted is an
                   // even multiple of 10.
            + "    20: twenty[->>];\n"
            + "    30: thirty[->>];\n"
            + "    40: forty[->>];\n"
            + "    50: fifty[->>];\n"
            + "    60: sixty[->>];\n"
            + "    70: seventy[->>];\n"
            + "    80: eighty[->>];\n"
            + "    90: ninety[->>];\n"
                   // beginning at 100, we can use << to mark the position where
                   // the result of formatting the multiple of 100 is to be
                   // inserted.  Notice also that the meaning of >> has shifted:
                   // here, it refers to both the ones place and the tens place.
                   // The meanings of the << and >> tokens depend on the base value
                   // of the rule.  A rule's divisor is (usually) the highest
                   // power of 10 that is less than or equal to the rule's base
                   // value.  The value being formatted is divided by the rule's
                   // divisor, and the integral quotient is used to get the text
                   // for <<, while the remainder is used to produce the text
                   // for >>.  Again, text in brackets is omitted if the value
                   // being formatted is an even multiple of the rule's divisor
                   // (in this case, an even multiple of 100)
            + "    100: << hundred[ >>];\n"
                   // The rules for the higher numbers work the same way as the
                   // rule for 100: Again, the << and >> tokens depend on the
                   // rule's divisor, which for all these rules is also the rule's
                   // base value.  To group by thousand, we simply don't have any
                   // rules between 1,000 and 1,000,000.
            + "    1000: << thousand[ >>];\n"
            + "    1,000,000: << million[ >>];\n"
            + "    1,000,000,000: << billion[ >>];\n"
            + "    1,000,000,000,000: << trillion[ >>];\n"
                   // overflow rule.  This rule specifies that values of a
                   // quadrillion or more are shown in numerals rather than words.
                   // The == token means to format (with new rules) the value
                   // being formatted by this rule and place the result where
                   // the == is.  The #,##0 inside the == signs is a
                   // DecimalFormat pattern.  It specifies that the value should
                   // be formatted with a DecimalFormat object, and that it
                   // should be formatted with no decimal places, at least one
                   // digit, and a thousands separator.
            + "    1,000,000,000,000,000: =#,##0=;\n"

            // %default is a more elaborate form of %simplified;  It is basically
            // the same, except that it introduces "and" before the ones digit
            // when appropriate (basically, between the tens and ones digits) and
            // separates the thousands groups with commas in values over 100,000.
            + "%default:\n"
                   // negative-number and fraction rules.  These are the same
                   // as those for %simplified, but ave to be stated here too
                   // because this is an entry point
            + "    -x: minus >>;\n"
            + "    x.x: << point >>;\n"
                   // just use %simplified for values below 100
            + "    =%simplified=;\n"
                   // for values from 100 to 9,999 use %%and to decide whether or
                   // not to interpose the "and"
            + "    100: << hundred[ >%%and>];\n"
            + "    1000: << thousand[ >%%and>];\n"
                   // for values of 100,000 and up, use %%commas to interpose the
                   // commas in the right places (and also to interpose the "and")
            + "    100,000>>: << thousand[>%%commas>];\n"
            + "    1,000,000: << million[>%%commas>];\n"
            + "    1,000,000,000: << billion[>%%commas>];\n"
            + "    1,000,000,000,000: << trillion[>%%commas>];\n"
            + "    1,000,000,000,000,000: =#,##0=;\n"
            // if the value passed to this rule set is greater than 100, don't
            // add the "and"; if it's less than 100, add "and" before the last
            // digits
            + "%%and:\n"
            + "    and =%default=;\n"
            + "    100: =%default=;\n"
            // this rule set is used to place the commas
            + "%%commas:\n"
                   // for values below 100, add "and" (the apostrophe at the
                   // beginning is ignored, but causes the space that follows it
                   // to be significant: this is necessary because the rules
                   // calling %%commas don't put a space before it)
            + "    ' and =%default=;\n"
                   // put a comma after the thousands (or whatever preceded the
                   // hundreds)
            + "    100: , =%default=;\n"
                   // put a comma after the millions (or whatever precedes the
                   // thousands)
            + "    1000: , <%default< thousand, >%default>;\n"
                   // and so on...
            + "    1,000,000: , =%default=;"
            // %%lenient-parse isn't really a set of number formatting rules;
            // it's a set of collation rules.  Lenient-parse mode uses a Collator
            // object to compare fragments of the text being parsed to the text
            // in the rules, allowing more leeway in the matching text.  This set
            // of rules tells the formatter to ignore commas when parsing (it
            // already ignores spaces, which is why we refer to the space; it also
            // ignores hyphens, making "twenty one" and "twenty-one" parse
            // identically)
            + "%%lenient-parse:\n"
            + "    & ' ' , ',' ;\n" },

        /*
         * This rule set adds an English ordinal abbreviation to the end of a
         * number.  For example, 2 is formatted as "2nd".  Parsing doesn't work with
         * this rule set.  To parse, use DecimalFormat on the numeral.
         */
        { "OrdinalRules",
            // this rule set formats the numeral and calls %%abbrev to
            // supply the abbreviation
            "%main:\n"
            + "    =#,##0==%%abbrev=;\n"
            // this rule set supplies the abbreviation
            + "%%abbrev:\n"
                   // the abbreviations.  Everything from 4 to 19 ends in "th"
            + "    th; st; nd; rd; th;\n"
                   // at 20, we begin repeating the cycle every 10 (13 is "13th",
                   // but 23 and 33 are "23rd" and "33rd")  We do this by
                   // ignoring all bug the ones digit in selecting the abbreviation
            + "    20: >>;\n"
                   // at 100, we repeat the whole cycle by considering only the
                   // tens and ones digits in picking an abbreviation
            + "    100: >>;\n" },

        /*
         * This rule set formats a number of seconds in sexagesimal notation
         * (i.e., hours, minutes, and seconds).  %with-words formats it with
         * words (3,740 is "1 hour, 2 minutes, 20 seconds") and %in-numerals
         * formats it entirely in numerals (3,740 is "1:02:20").
         */
        { "DurationRules",
            // main rule set for formatting with words
            "%with-words:\n"
                   // take care of singular and plural forms of "second"
            + "    0 seconds; 1 second; =0= seconds;\n"
                   // use %%min to format values greater than 60 seconds
            + "    60/60: <%%min<[, >>];\n"
                   // use %%hr to format values greater than 3,600 seconds
                   // (the ">>>" below causes us to see the number of minutes
                   // when when there are zero minutes)
            + "    3600/60: <%%hr<[, >>>];\n"
            // this rule set takes care of the singular and plural forms
            // of "minute"
            + "%%min:\n"
            + "    0 minutes; 1 minute; =0= minutes;\n"
            // this rule set takes care of the singular and plural forms
            // of "hour"
            + "%%hr:\n"
            + "    0 hours; 1 hour; =0= hours;\n"

            // main rule set for formatting in numerals
            + "%in-numerals:\n"
                   // values below 60 seconds are shown with "sec."
            + "    =0= sec.;\n"
                   // higher values are shown with colons: %%min-sec is used for
                   // values below 3,600 seconds...
            + "    60: =%%min-sec=;\n"
                   // ...and %%hr-min-sec is used for values of 3,600 seconds
                   // and above
            + "    3600: =%%hr-min-sec=;\n"
            // this rule causes values of less than 10 minutes to show without
            // a leading zero
            + "%%min-sec:\n"
            + "    0: :=00=;\n"
            + "    60/60: <0<>>;\n"
            // this rule set is used for values of 3,600 or more.  Minutes are always
            // shown, and always shown with two digits
            + "%%hr-min-sec:\n"
            + "    0: :=00=;\n"
            + "    60/60: <00<>>;\n"
            + "    3600/60: <#,##0<:>>>;\n"
            // the lenient-parse rules allow several different characters to be used
            // as delimiters between hours, minutes, and seconds
            + "%%lenient-parse:\n"
            + "    & ':' = '.' = ' ' = '-';\n" }
    };
}