????
Your IP : 3.145.105.85
// © 2018 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
#ifndef __FORMATTEDVALUE_H__
#define __FORMATTEDVALUE_H__
#include "unicode/utypes.h"
#if U_SHOW_CPLUSPLUS_API
#if !UCONFIG_NO_FORMATTING
#include "unicode/appendable.h"
#include "unicode/fpositer.h"
#include "unicode/unistr.h"
#include "unicode/uformattedvalue.h"
U_NAMESPACE_BEGIN
/**
* \file
* \brief C++ API: Abstract operations for localized strings.
*
* This file contains declarations for classes that deal with formatted strings. A number
* of APIs throughout ICU use these classes for expressing their localized output.
*/
// The following cannot have #ifndef U_HIDE_DRAFT_API because
// class FormattedValue depends on it, and FormattedValue cannot be
// hidden becauseclass FormattedNumber (stable ICU 60) depends on it.
#ifndef U_FORCE_HIDE_DRAFT_API
/**
* Represents a span of a string containing a given field.
*
* This class differs from FieldPosition in the following ways:
*
* 1. It has information on the field category.
* 2. It allows you to set constraints to use when iterating over field positions.
* 3. It is used for the newer FormattedValue APIs.
*
* This class is not intended for public subclassing.
*
* @draft ICU 64
*/
class U_I18N_API ConstrainedFieldPosition : public UMemory {
public:
/**
* Initializes a ConstrainedFieldPosition.
*
* By default, the ConstrainedFieldPosition has no iteration constraints.
*
* @draft ICU 64
*/
ConstrainedFieldPosition();
/** @draft ICU 64 */
~ConstrainedFieldPosition();
#ifndef U_HIDE_DRAFT_API
/**
* Resets this ConstrainedFieldPosition to its initial state, as if it were newly created:
*
* - Removes any constraints that may have been set on the instance.
* - Resets the iteration position.
*
* @draft ICU 64
*/
void reset();
/**
* Sets a constraint on the field category.
*
* When this instance of ConstrainedFieldPosition is passed to FormattedValue#nextPosition,
* positions are skipped unless they have the given category.
*
* Any previously set constraints are cleared.
*
* For example, to loop over only the number-related fields:
*
* ConstrainedFieldPosition cfpos;
* cfpos.constrainCategory(UFIELDCATEGORY_NUMBER_FORMAT);
* while (fmtval.nextPosition(cfpos, status)) {
* // handle the number-related field position
* }
*
* Changing the constraint while in the middle of iterating over a FormattedValue
* does not generally have well-defined behavior.
*
* @param category The field category to fix when iterating.
* @draft ICU 64
*/
void constrainCategory(int32_t category);
/**
* Sets a constraint on the category and field.
*
* When this instance of ConstrainedFieldPosition is passed to FormattedValue#nextPosition,
* positions are skipped unless they have the given category and field.
*
* Any previously set constraints are cleared.
*
* For example, to loop over all grouping separators:
*
* ConstrainedFieldPosition cfpos;
* cfpos.constrainField(UFIELDCATEGORY_NUMBER_FORMAT, UNUM_GROUPING_SEPARATOR_FIELD);
* while (fmtval.nextPosition(cfpos, status)) {
* // handle the grouping separator position
* }
*
* Changing the constraint while in the middle of iterating over a FormattedValue
* does not generally have well-defined behavior.
*
* @param category The field category to fix when iterating.
* @param field The field to fix when iterating.
* @draft ICU 64
*/
void constrainField(int32_t category, int32_t field);
/**
* Gets the field category for the current position.
*
* The return value is well-defined only after
* FormattedValue#nextPosition returns TRUE.
*
* @return The field category saved in the instance.
* @draft ICU 64
*/
inline int32_t getCategory() const {
return fCategory;
}
/**
* Gets the field for the current position.
*
* The return value is well-defined only after
* FormattedValue#nextPosition returns TRUE.
*
* @return The field saved in the instance.
* @draft ICU 64
*/
inline int32_t getField() const {
return fField;
}
/**
* Gets the INCLUSIVE start index for the current position.
*
* The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
*
* @return The start index saved in the instance.
* @draft ICU 64
*/
inline int32_t getStart() const {
return fStart;
}
/**
* Gets the EXCLUSIVE end index stored for the current position.
*
* The return value is well-defined only after FormattedValue#nextPosition returns TRUE.
*
* @return The end index saved in the instance.
* @draft ICU 64
*/
inline int32_t getLimit() const {
return fLimit;
}
////////////////////////////////////////////////////////////////////
//// The following methods are for FormattedValue implementers; ////
//// most users can ignore them. ////
////////////////////////////////////////////////////////////////////
/**
* Gets an int64 that FormattedValue implementations may use for storage.
*
* The initial value is zero.
*
* Users of FormattedValue should not need to call this method.
*
* @return The current iteration context from {@link #setInt64IterationContext}.
* @draft ICU 64
*/
inline int64_t getInt64IterationContext() const {
return fContext;
}
/**
* Sets an int64 that FormattedValue implementations may use for storage.
*
* Intended to be used by FormattedValue implementations.
*
* @param context The new iteration context.
* @draft ICU 64
*/
void setInt64IterationContext(int64_t context);
/**
* Determines whether a given field should be included given the
* constraints.
*
* Intended to be used by FormattedValue implementations.
*
* @param category The category to test.
* @param field The field to test.
* @draft ICU 64
*/
UBool matchesField(int32_t category, int32_t field) const;
/**
* Sets new values for the primary public getters.
*
* Intended to be used by FormattedValue implementations.
*
* It is up to the implementation to ensure that the user-requested
* constraints are satisfied. This method does not check!
*
* @param category The new field category.
* @param field The new field.
* @param start The new inclusive start index.
* @param limit The new exclusive end index.
* @draft ICU 64
*/
void setState(
int32_t category,
int32_t field,
int32_t start,
int32_t limit);
#endif /* U_HIDE_DRAFT_API */
private:
int64_t fContext = 0LL;
int32_t fField = 0;
int32_t fStart = 0;
int32_t fLimit = 0;
#ifndef U_HIDE_DRAFT_API
int32_t fCategory = UFIELD_CATEGORY_UNDEFINED;
#else /* U_HIDE_DRAFT_API */
int32_t fCategory = 0;
#endif /* U_HIDE_DRAFT_API */
int8_t fConstraint = 0;
};
// The following cannot have #ifndef U_HIDE_DRAFT_API because
// class FormattedNumber (stable ICU 60) depends on it.
/**
* An abstract formatted value: a string with associated field attributes.
* Many formatters format to classes implementing FormattedValue.
*
* @draft ICU 64
*/
class U_I18N_API FormattedValue /* not : public UObject because this is an interface/mixin class */ {
public:
/** @draft ICU 64 */
virtual ~FormattedValue();
/**
* Returns the formatted string as a self-contained UnicodeString.
*
* If you need the string within the current scope only, consider #toTempString.
*
* @param status Set if an error occurs.
* @return a UnicodeString containing the formatted string.
*
* @draft ICU 64
*/
virtual UnicodeString toString(UErrorCode& status) const = 0;
/**
* Returns the formatted string as a read-only alias to memory owned by the FormattedValue.
*
* The return value is valid only as long as this FormattedValue is present and unchanged in
* memory. If you need the string outside the current scope, consider #toString.
*
* The buffer returned by calling UnicodeString#getBuffer() on the return value is
* guaranteed to be NUL-terminated.
*
* @param status Set if an error occurs.
* @return a temporary UnicodeString containing the formatted string.
*
* @draft ICU 64
*/
virtual UnicodeString toTempString(UErrorCode& status) const = 0;
/**
* Appends the formatted string to an Appendable.
*
* @param appendable
* The Appendable to which to append the string output.
* @param status Set if an error occurs.
* @return The same Appendable, for chaining.
*
* @draft ICU 64
* @see Appendable
*/
virtual Appendable& appendTo(Appendable& appendable, UErrorCode& status) const = 0;
/**
* Iterates over field positions in the FormattedValue. This lets you determine the position
* of specific types of substrings, like a month or a decimal separator.
*
* To loop over all field positions:
*
* ConstrainedFieldPosition cfpos;
* while (fmtval.nextPosition(cfpos, status)) {
* // handle the field position; get information from cfpos
* }
*
* @param cfpos
* The object used for iteration state. This can provide constraints to iterate over
* only one specific category or field;
* see ConstrainedFieldPosition#constrainCategory
* and ConstrainedFieldPosition#constrainField.
* @param status Set if an error occurs.
* @return TRUE if a new occurrence of the field was found;
* FALSE otherwise or if an error was set.
*
* @draft ICU 64
*/
virtual UBool nextPosition(ConstrainedFieldPosition& cfpos, UErrorCode& status) const = 0;
};
#endif // U_FORCE_HIDE_DRAFT_API
U_NAMESPACE_END
#endif /* #if !UCONFIG_NO_FORMATTING */
#endif /* U_SHOW_CPLUSPLUS_API */
#endif // __FORMATTEDVALUE_H__