// © 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;
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