The Tor Browser: comparison intl/icu/source/i18n/nfsubs.h

--1:000000000000
+:b4014544a718
+/*
+******************************************************************************
+*   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

The Tor Browser / file comparison

comparison: intl/icu/source/i18n/nfsubs.h

intl/icu/source/i18n/nfsubs.h