Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 262 insertions, 0 deletions

diff --git a/intl/icu/source/i18n/nfsubs.h b/intl/icu/source/i18n/nfsubs.h
new file mode 100644
index 0000000000..d252f86499
--- /dev/null
+++ b/intl/icu/source/i18n/nfsubs.h
@@ -0,0 +1,262 @@
+// © 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 bool 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.
+     */
+    bool 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 char16_t 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;
+    
+private:
+    NFSubstitution(const NFSubstitution &other) = delete; // forbid copying of this class
+    NFSubstitution &operator=(const NFSubstitution &other) = delete; // forbid copying of this class
+
+public:
+    static UClassID getStaticClassID();
+    virtual UClassID getDynamicClassID() const override;
+};
+
+U_NAMESPACE_END
+
+/* U_HAVE_RBNF */
+#endif
+
+// NFSUBS_H
+#endif