// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ****************************************************************************** * Copyright (C) 1997-2015, International Business Machines * Corporation and others. All Rights Reserved. ****************************************************************************** * file name: nfsubs.h * encoding: UTF-8 * 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; DecimalFormat* numberFormat; protected: NFSubstitution(int32_t pos, const NFRuleSet* ruleSet, 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, int16_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; void setDecimalFormatSymbols(const DecimalFormatSymbols &newSymbols, UErrorCode& status); //----------------------------------------------------------------------- // 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, int32_t recursionCount, UErrorCode& status) 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, int32_t recursionCount, UErrorCode& status) 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, uint32_t nonNumericalExecutedRuleMask, 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 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; /** * Apple addition * @return true if this is a decimal format-only substitution */ virtual UBool isDecimalFormatSubstitutionOnly() const; /** * Apple addition, not currently used * @return true if this substitution only points to another ruleSet (no numberFormat) */ //virtual UBool isRuleSetSubstitutionOnly() 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