The Tor Browser / file revision

 /*

 ******************************************************************************

 *   Copyright (C) 1997-2007, International Business Machines

 *   Corporation and others.  All Rights Reserved.

 ******************************************************************************

 *   file name:  nfsubs.h

 *   encoding:   US-ASCII

 *   tab size:   8 (not used)

 *   indentation:4

 *

 * Modification history

 * Date        Name      Comments

 * 10/11/2001  Doug      Ported from ICU4J

 */

 #ifndef NFSUBS_H

 #define NFSUBS_H

 #include "unicode/utypes.h"

 #include "unicode/uobject.h"

 #include "nfrule.h"

 #if U_HAVE_RBNF

 #include "unicode/utypes.h"

 #include "unicode/decimfmt.h"

 #include "nfrs.h"

 #include <float.h>

 U_NAMESPACE_BEGIN

 class NFSubstitution : public UObject {

     int32_t pos;

     const NFRuleSet* ruleSet;

     const DecimalFormat* numberFormat;

 protected:

     NFSubstitution(int32_t pos,

         const NFRuleSet* ruleSet,

         const RuleBasedNumberFormat* rbnf,

         const UnicodeString& description,

         UErrorCode& status);

     /**

      * Get the Ruleset of the object.

      * @return the Ruleset of the object.

      */

     const NFRuleSet* getRuleSet() const { return ruleSet; }

     /**

      * get the NumberFormat of this object.

      * @return the numberformat of this object.

      */

     const DecimalFormat* getNumberFormat() const { return numberFormat; }

 public:

     static NFSubstitution* makeSubstitution(int32_t pos, 

         const NFRule* rule, 

         const NFRule* predecessor,

         const NFRuleSet* ruleSet, 

         const RuleBasedNumberFormat* rbnf, 

         const UnicodeString& description,

         UErrorCode& status);

     /**

      * Destructor.

      */

     virtual ~NFSubstitution();

     /**

      * Return true if the given Format objects are semantically equal.

      * Objects of different subclasses are considered unequal.

      * @param rhs    the object to be compared with.

      * @return       true if the given Format objects are semantically equal.

      */

     virtual UBool operator==(const NFSubstitution& rhs) const;

     /**

      * Return true if the given Format objects are semantically unequal.

      * Objects of different subclasses are considered unequal.

      * @param rhs    the object to be compared with.

      * @return       true if the given Format objects are semantically unequal.

      */

     UBool operator!=(const NFSubstitution& rhs) const { return !operator==(rhs); }

     /**

      * Sets the substitution's divisor.  Used by NFRule.setBaseValue().

      * A no-op for all substitutions except multiplier and modulus

      * substitutions.

      * @param radix The radix of the divisor

      * @param exponent The exponent of the divisor

      */

     virtual void setDivisor(int32_t radix, int32_t exponent, UErrorCode& status);

     /**

      * Replaces result with the string describing the substitution.

      * @param result    Output param which will receive the string.

      */

     virtual void toString(UnicodeString& result) const;

     //-----------------------------------------------------------------------

     // formatting

     //-----------------------------------------------------------------------

     /**

      * Performs a mathematical operation on the number, formats it using

      * either ruleSet or decimalFormat, and inserts the result into

      * toInsertInto.

      * @param number The number being formatted.

      * @param toInsertInto The string we insert the result into

      * @param pos The position in toInsertInto where the owning rule's

      * rule text begins (this value is added to this substitution's

      * position to determine exactly where to insert the new text)

      */

     virtual void doSubstitution(int64_t number, UnicodeString& toInsertInto, int32_t pos) const;

     /**

      * Performs a mathematical operation on the number, formats it using

      * either ruleSet or decimalFormat, and inserts the result into

      * toInsertInto.

      * @param number The number being formatted.

      * @param toInsertInto The string we insert the result into

      * @param pos The position in toInsertInto where the owning rule's

      * rule text begins (this value is added to this substitution's

      * position to determine exactly where to insert the new text)

      */

     virtual void doSubstitution(double number, UnicodeString& toInsertInto, int32_t pos) const;

 protected:

     /**

      * Subclasses override this function to perform some kind of

      * mathematical operation on the number.  The result of this operation

      * is formatted using the rule set or DecimalFormat that this

      * substitution refers to, and the result is inserted into the result

      * string.

      * @param The number being formatted

      * @return The result of performing the opreration on the number

      */

     virtual int64_t transformNumber(int64_t number) const = 0;

     /**

      * Subclasses override this function to perform some kind of

      * mathematical operation on the number.  The result of this operation

      * is formatted using the rule set or DecimalFormat that this

      * substitution refers to, and the result is inserted into the result

      * string.

      * @param The number being formatted

      * @return The result of performing the opreration on the number

      */

     virtual double transformNumber(double number) const = 0;

 public:

     //-----------------------------------------------------------------------

     // parsing

     //-----------------------------------------------------------------------

     /**

      * Parses a string using the rule set or DecimalFormat belonging

      * to this substitution.  If there's a match, a mathematical

      * operation (the inverse of the one used in formatting) is

      * performed on the result of the parse and the value passed in

      * and returned as the result.  The parse position is updated to

      * point to the first unmatched character in the string.

      * @param text The string to parse

      * @param parsePosition On entry, ignored, but assumed to be 0.

      * On exit, this is updated to point to the first unmatched

      * character (or 0 if the substitution didn't match)

      * @param baseValue A partial parse result that should be

      * combined with the result of this parse

      * @param upperBound When searching the rule set for a rule

      * matching the string passed in, only rules with base values

      * lower than this are considered

      * @param lenientParse If true and matching against rules fails,

      * the substitution will also try matching the text against

      * numerals using a default-costructed NumberFormat.  If false,

      * no extra work is done.  (This value is false whenever the

      * formatter isn't in lenient-parse mode, but is also false

      * under some conditions even when the formatter _is_ in

      * lenient-parse mode.)

      * @return If there's a match, this is the result of composing

      * baseValue with whatever was returned from matching the

      * characters.  This will be either a Long or a Double.  If there's

      * no match this is new Long(0) (not null), and parsePosition

      * is left unchanged.

      */

     virtual UBool doParse(const UnicodeString& text, 

         ParsePosition& parsePosition, 

         double baseValue,

         double upperBound, 

         UBool lenientParse,

         Formattable& result) const;

     /**

      * Derives a new value from the two values passed in.  The two values

      * are typically either the base values of two rules (the one containing

      * the substitution and the one matching the substitution) or partial

      * parse results derived in some other way.  The operation is generally

      * the inverse of the operation performed by transformNumber().

      * @param newRuleValue The value produced by matching this substitution

      * @param oldRuleValue The value that was passed to the substitution

      * by the rule that owns it

      * @return A third value derived from the other two, representing a

      * partial parse result

      */

     virtual double composeRuleValue(double newRuleValue, double oldRuleValue) const = 0;

     /**

      * Calculates an upper bound when searching for a rule that matches

      * this substitution.  Rules with base values greater than or equal

      * to upperBound are not considered.

      * @param oldUpperBound    The current upper-bound setting.  The new

      *                         upper bound can't be any higher.

      * @return                 the upper bound when searching for a rule that matches

      *                         this substitution.

      */

     virtual double calcUpperBound(double oldUpperBound) const = 0;

     //-----------------------------------------------------------------------

     // simple accessors

     //-----------------------------------------------------------------------

     /**

      * Returns the substitution's position in the rule that owns it.

      * @return The substitution's position in the rule that owns it.

      */

     int32_t getPos() const { return pos; }

     /**

      * Returns the character used in the textual representation of

      * substitutions of this type.  Used by toString().

      * @return This substitution's token character.

      */

     virtual UChar tokenChar() const = 0;

     /**

      * Returns true if this is a null substitution.  (We didn't do this

      * with instanceof partially because it causes source files to

      * proliferate and partially because we have to port this to C++.)

      * @return true if this object is an instance of NullSubstitution

      */

     virtual UBool isNullSubstitution() const;

     /**

      * Returns true if this is a modulus substitution.  (We didn't do this

      * with instanceof partially because it causes source files to

      * proliferate and partially because we have to port this to C++.)

      * @return true if this object is an instance of ModulusSubstitution

      */

     virtual UBool isModulusSubstitution() const;

 private:

     NFSubstitution(const NFSubstitution &other); // forbid copying of this class

     NFSubstitution &operator=(const NFSubstitution &other); // forbid copying of this class

 public:

     static UClassID getStaticClassID(void);

     virtual UClassID getDynamicClassID(void) const;

 };

 U_NAMESPACE_END

 /* U_HAVE_RBNF */

 #endif

 // NFSUBS_H

 #endif