538 lines
15 KiB
C++
538 lines
15 KiB
C++
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 2009, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
*******************************************************************************
|
|
*
|
|
* File PLURFMT.CPP
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
*******************************************************************************
|
|
*/
|
|
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/plurfmt.h"
|
|
#include "unicode/plurrule.h"
|
|
#include "plurrule_impl.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
U_CDECL_BEGIN
|
|
static void U_CALLCONV
|
|
deleteHashStrings(void *obj) {
|
|
delete (UnicodeString *)obj;
|
|
}
|
|
U_CDECL_END
|
|
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(PluralFormat)
|
|
|
|
#define MAX_KEYWORD_SIZE 30
|
|
|
|
PluralFormat::PluralFormat(UErrorCode& status) {
|
|
init(NULL, Locale::getDefault(), status);
|
|
}
|
|
|
|
PluralFormat::PluralFormat(const Locale& loc, UErrorCode& status) {
|
|
init(NULL, loc, status);
|
|
}
|
|
|
|
PluralFormat::PluralFormat(const PluralRules& rules, UErrorCode& status) {
|
|
init(&rules, Locale::getDefault(), status);
|
|
}
|
|
|
|
PluralFormat::PluralFormat(const Locale& loc, const PluralRules& rules, UErrorCode& status) {
|
|
init(&rules, loc, status);
|
|
}
|
|
|
|
PluralFormat::PluralFormat(const UnicodeString& pat, UErrorCode& status) {
|
|
init(NULL, Locale::getDefault(), status);
|
|
applyPattern(pat, status);
|
|
}
|
|
|
|
PluralFormat::PluralFormat(const Locale& loc, const UnicodeString& pat, UErrorCode& status) {
|
|
init(NULL, loc, status);
|
|
applyPattern(pat, status);
|
|
}
|
|
|
|
PluralFormat::PluralFormat(const PluralRules& rules, const UnicodeString& pat, UErrorCode& status) {
|
|
init(&rules, Locale::getDefault(), status);
|
|
applyPattern(pat, status);
|
|
}
|
|
|
|
PluralFormat::PluralFormat(const Locale& loc, const PluralRules& rules, const UnicodeString& pat, UErrorCode& status) {
|
|
init(&rules, loc, status);
|
|
applyPattern(pat, status);
|
|
}
|
|
|
|
PluralFormat::PluralFormat(const PluralFormat& other) : Format(other) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
locale = other.locale;
|
|
pluralRules = other.pluralRules->clone();
|
|
pattern = other.pattern;
|
|
copyHashtable(other.fParsedValuesHash, status);
|
|
if (U_FAILURE(status)) {
|
|
delete pluralRules;
|
|
pluralRules = NULL;
|
|
return;
|
|
}
|
|
numberFormat=NumberFormat::createInstance(locale, status);
|
|
if (U_FAILURE(status)) {
|
|
delete pluralRules;
|
|
pluralRules = NULL;
|
|
delete fParsedValuesHash;
|
|
fParsedValuesHash = NULL;
|
|
return;
|
|
}
|
|
replacedNumberFormat=other.replacedNumberFormat;
|
|
}
|
|
|
|
PluralFormat::~PluralFormat() {
|
|
delete pluralRules;
|
|
delete fParsedValuesHash;
|
|
delete numberFormat;
|
|
}
|
|
|
|
void
|
|
PluralFormat::init(const PluralRules* rules, const Locale& curLocale, UErrorCode& status) {
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
locale = curLocale;
|
|
if ( rules==NULL) {
|
|
pluralRules = PluralRules::forLocale(locale, status);
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
}
|
|
else {
|
|
pluralRules = rules->clone();
|
|
}
|
|
fParsedValuesHash=NULL;
|
|
pattern.remove();
|
|
numberFormat= NumberFormat::createInstance(curLocale, status);
|
|
if (U_FAILURE(status)) {
|
|
delete pluralRules;
|
|
pluralRules = NULL;
|
|
return;
|
|
}
|
|
replacedNumberFormat=NULL;
|
|
}
|
|
|
|
void
|
|
PluralFormat::applyPattern(const UnicodeString& newPattern, UErrorCode& status) {
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
this->pattern = newPattern;
|
|
UnicodeString token;
|
|
int32_t braceCount=0;
|
|
fmtToken type;
|
|
UBool spaceIncluded=FALSE;
|
|
|
|
if (fParsedValuesHash==NULL) {
|
|
fParsedValuesHash = new Hashtable(TRUE, status);
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
fParsedValuesHash->setValueDeleter(deleteHashStrings);
|
|
}
|
|
|
|
UBool getKeyword=TRUE;
|
|
UnicodeString hashKeyword;
|
|
UnicodeString *hashPattern;
|
|
|
|
for (int32_t i=0; i<pattern.length(); ++i) {
|
|
UChar ch=pattern.charAt(i);
|
|
|
|
if ( !inRange(ch, type) ) {
|
|
if (getKeyword) {
|
|
status = U_ILLEGAL_CHARACTER;
|
|
return;
|
|
}
|
|
else {
|
|
token += ch;
|
|
continue;
|
|
}
|
|
}
|
|
switch (type) {
|
|
case tSpace:
|
|
if (token.length()==0) {
|
|
continue;
|
|
}
|
|
if (getKeyword) {
|
|
// space after keyword
|
|
spaceIncluded = TRUE;
|
|
}
|
|
else {
|
|
token += ch;
|
|
}
|
|
break;
|
|
case tLeftBrace:
|
|
if ( getKeyword ) {
|
|
if (fParsedValuesHash->get(token)!= NULL) {
|
|
status = U_DUPLICATE_KEYWORD;
|
|
return;
|
|
}
|
|
if (token.length()==0) {
|
|
status = U_PATTERN_SYNTAX_ERROR;
|
|
return;
|
|
}
|
|
if (!pluralRules->isKeyword(token)) {
|
|
status = U_UNDEFINED_KEYWORD;
|
|
return;
|
|
}
|
|
hashKeyword = token;
|
|
getKeyword = FALSE;
|
|
token.remove();
|
|
}
|
|
else {
|
|
if (braceCount==0) {
|
|
status = U_UNEXPECTED_TOKEN;
|
|
return;
|
|
}
|
|
else {
|
|
token += ch;
|
|
}
|
|
}
|
|
braceCount++;
|
|
spaceIncluded = FALSE;
|
|
break;
|
|
case tRightBrace:
|
|
if ( getKeyword ) {
|
|
status = U_UNEXPECTED_TOKEN;
|
|
return;
|
|
}
|
|
else {
|
|
hashPattern = new UnicodeString(token);
|
|
fParsedValuesHash->put(hashKeyword, hashPattern, status);
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
braceCount--;
|
|
if ( braceCount==0 ) {
|
|
getKeyword=TRUE;
|
|
hashKeyword.remove();
|
|
hashPattern=NULL;
|
|
token.remove();
|
|
}
|
|
else {
|
|
token += ch;
|
|
}
|
|
}
|
|
spaceIncluded = FALSE;
|
|
break;
|
|
case tLetter:
|
|
case tNumberSign:
|
|
if (spaceIncluded) {
|
|
status = U_PATTERN_SYNTAX_ERROR;
|
|
return;
|
|
}
|
|
default:
|
|
token+=ch;
|
|
break;
|
|
}
|
|
}
|
|
if ( checkSufficientDefinition() ) {
|
|
return;
|
|
}
|
|
else {
|
|
status = U_DEFAULT_KEYWORD_MISSING;
|
|
return;
|
|
}
|
|
}
|
|
|
|
UnicodeString&
|
|
PluralFormat::format(const Formattable& obj,
|
|
UnicodeString& appendTo,
|
|
FieldPosition& pos,
|
|
UErrorCode& status) const
|
|
{
|
|
if (U_FAILURE(status)) return appendTo;
|
|
int32_t number;
|
|
|
|
switch (obj.getType())
|
|
{
|
|
case Formattable::kDouble:
|
|
return format((int32_t)obj.getDouble(), appendTo, pos, status);
|
|
break;
|
|
case Formattable::kLong:
|
|
number = (int32_t)obj.getLong();
|
|
return format(number, appendTo, pos, status);
|
|
break;
|
|
case Formattable::kInt64:
|
|
return format((int32_t)obj.getInt64(), appendTo, pos, status);
|
|
default:
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return appendTo;
|
|
}
|
|
}
|
|
|
|
UnicodeString
|
|
PluralFormat::format(int32_t number, UErrorCode& status) const {
|
|
if (U_FAILURE(status)) {
|
|
return UnicodeString();
|
|
}
|
|
FieldPosition fpos(0);
|
|
UnicodeString result;
|
|
|
|
return format(number, result, fpos, status);
|
|
}
|
|
|
|
UnicodeString
|
|
PluralFormat::format(double number, UErrorCode& status) const {
|
|
if (U_FAILURE(status)) {
|
|
return UnicodeString();
|
|
}
|
|
FieldPosition fpos(0);
|
|
UnicodeString result;
|
|
|
|
return format(number, result, fpos, status);
|
|
}
|
|
|
|
|
|
UnicodeString&
|
|
PluralFormat::format(int32_t number,
|
|
UnicodeString& appendTo,
|
|
FieldPosition& pos,
|
|
UErrorCode& status) const {
|
|
return format((double)number, appendTo, pos, status);
|
|
}
|
|
|
|
UnicodeString&
|
|
PluralFormat::format(double number,
|
|
UnicodeString& appendTo,
|
|
FieldPosition& pos,
|
|
UErrorCode& /*status*/) const {
|
|
|
|
if (fParsedValuesHash==NULL) {
|
|
if ( replacedNumberFormat== NULL ) {
|
|
return numberFormat->format(number, appendTo, pos);
|
|
}
|
|
else {
|
|
replacedNumberFormat->format(number, appendTo, pos);
|
|
}
|
|
}
|
|
UnicodeString selectedRule = pluralRules->select(number);
|
|
UnicodeString *selectedPattern = (UnicodeString *)fParsedValuesHash->get(selectedRule);
|
|
if (selectedPattern==NULL) {
|
|
selectedPattern = (UnicodeString *)fParsedValuesHash->get(pluralRules->getKeywordOther());
|
|
}
|
|
appendTo = insertFormattedNumber(number, *selectedPattern, appendTo, pos);
|
|
|
|
return appendTo;
|
|
}
|
|
|
|
UnicodeString&
|
|
PluralFormat::toPattern(UnicodeString& appendTo) {
|
|
appendTo+= pattern;
|
|
return appendTo;
|
|
}
|
|
|
|
UBool
|
|
PluralFormat::inRange(UChar ch, fmtToken& type) {
|
|
if ((ch>=CAP_A) && (ch<=CAP_Z)) {
|
|
// we assume all characters are in lower case already.
|
|
return FALSE;
|
|
}
|
|
if ((ch>=LOW_A) && (ch<=LOW_Z)) {
|
|
type = tLetter;
|
|
return TRUE;
|
|
}
|
|
switch (ch) {
|
|
case LEFTBRACE:
|
|
type = tLeftBrace;
|
|
return TRUE;
|
|
case SPACE:
|
|
type = tSpace;
|
|
return TRUE;
|
|
case RIGHTBRACE:
|
|
type = tRightBrace;
|
|
return TRUE;
|
|
case NUMBER_SIGN:
|
|
type = tNumberSign;
|
|
return TRUE;
|
|
default :
|
|
type = none;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
UBool
|
|
PluralFormat::checkSufficientDefinition() {
|
|
// Check that at least the default rule is defined.
|
|
if (fParsedValuesHash==NULL) return FALSE;
|
|
if (fParsedValuesHash->get(pluralRules->getKeywordOther()) == NULL) {
|
|
return FALSE;
|
|
}
|
|
else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
void
|
|
PluralFormat::setLocale(const Locale& loc, UErrorCode& status) {
|
|
if (U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
if (pluralRules!=NULL) {
|
|
delete pluralRules;
|
|
pluralRules=NULL;
|
|
}
|
|
if (fParsedValuesHash!= NULL) {
|
|
delete fParsedValuesHash;
|
|
fParsedValuesHash = NULL;
|
|
}
|
|
if (numberFormat!=NULL) {
|
|
delete numberFormat;
|
|
numberFormat = NULL;
|
|
replacedNumberFormat=NULL;
|
|
}
|
|
init(NULL, loc, status);
|
|
}
|
|
|
|
void
|
|
PluralFormat::setNumberFormat(const NumberFormat* format, UErrorCode& /*status*/) {
|
|
// TODO: The copy constructor and assignment op of NumberFormat class are protected.
|
|
// create a pointer as the workaround.
|
|
replacedNumberFormat = (NumberFormat *)format;
|
|
}
|
|
|
|
Format*
|
|
PluralFormat::clone() const
|
|
{
|
|
return new PluralFormat(*this);
|
|
}
|
|
|
|
PluralFormat&
|
|
PluralFormat::operator=(const PluralFormat& other) {
|
|
if (this != &other) {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
delete pluralRules;
|
|
delete fParsedValuesHash;
|
|
delete numberFormat;
|
|
locale = other.locale;
|
|
pluralRules = other.pluralRules->clone();
|
|
pattern = other.pattern;
|
|
copyHashtable(other.fParsedValuesHash, status);
|
|
if (U_FAILURE(status)) {
|
|
delete pluralRules;
|
|
pluralRules = NULL;
|
|
fParsedValuesHash = NULL;
|
|
numberFormat = NULL;
|
|
return *this;
|
|
}
|
|
numberFormat=NumberFormat::createInstance(locale, status);
|
|
if (U_FAILURE(status)) {
|
|
delete pluralRules;
|
|
delete fParsedValuesHash;
|
|
pluralRules = NULL;
|
|
fParsedValuesHash = NULL;
|
|
numberFormat = NULL;
|
|
return *this;
|
|
}
|
|
replacedNumberFormat=other.replacedNumberFormat;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
UBool
|
|
PluralFormat::operator==(const Format& other) const {
|
|
// This protected comparison operator should only be called by subclasses
|
|
// which have confirmed that the other object being compared against is
|
|
// an instance of a sublcass of PluralFormat. THIS IS IMPORTANT.
|
|
// Format::operator== guarantees that this cast is safe
|
|
PluralFormat* fmt = (PluralFormat*)&other;
|
|
return ((*pluralRules == *(fmt->pluralRules)) &&
|
|
(*numberFormat == *(fmt->numberFormat)));
|
|
}
|
|
|
|
UBool
|
|
PluralFormat::operator!=(const Format& other) const {
|
|
return !operator==(other);
|
|
}
|
|
|
|
void
|
|
PluralFormat::parseObject(const UnicodeString& /*source*/,
|
|
Formattable& /*result*/,
|
|
ParsePosition& /*pos*/) const
|
|
{
|
|
// TODO: not yet supported in icu4j and icu4c
|
|
}
|
|
|
|
UnicodeString
|
|
PluralFormat::insertFormattedNumber(double number,
|
|
UnicodeString& message,
|
|
UnicodeString& appendTo,
|
|
FieldPosition& pos) const {
|
|
UnicodeString result;
|
|
int32_t braceStack=0;
|
|
int32_t startIndex=0;
|
|
|
|
if (message.length()==0) {
|
|
return result;
|
|
}
|
|
appendTo = numberFormat->format(number, appendTo, pos);
|
|
for(int32_t i=0; i<message.length(); ++i) {
|
|
switch(message.charAt(i)) {
|
|
case LEFTBRACE:
|
|
++braceStack;
|
|
break;
|
|
case RIGHTBRACE:
|
|
--braceStack;
|
|
break;
|
|
case NUMBER_SIGN:
|
|
if (braceStack==0) {
|
|
result += UnicodeString(message, startIndex, i);
|
|
result += appendTo;
|
|
startIndex = i + 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if ( startIndex < message.length() ) {
|
|
result += UnicodeString(message, startIndex, message.length()-startIndex);
|
|
}
|
|
appendTo = result;
|
|
return result;
|
|
}
|
|
|
|
void
|
|
PluralFormat::copyHashtable(Hashtable *other, UErrorCode& status) {
|
|
if (other == NULL || U_FAILURE(status)) {
|
|
fParsedValuesHash = NULL;
|
|
return;
|
|
}
|
|
fParsedValuesHash = new Hashtable(TRUE, status);
|
|
if(U_FAILURE(status)){
|
|
return;
|
|
}
|
|
fParsedValuesHash->setValueDeleter(deleteHashStrings);
|
|
int32_t pos = -1;
|
|
const UHashElement* elem = NULL;
|
|
// walk through the hash table and create a deep clone
|
|
while((elem = other->nextElement(pos))!= NULL){
|
|
const UHashTok otherKeyTok = elem->key;
|
|
UnicodeString* otherKey = (UnicodeString*)otherKeyTok.pointer;
|
|
const UHashTok otherKeyToVal = elem->value;
|
|
UnicodeString* otherValue = (UnicodeString*)otherKeyToVal.pointer;
|
|
fParsedValuesHash->put(*otherKey, new UnicodeString(*otherValue), status);
|
|
if(U_FAILURE(status)){
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
U_NAMESPACE_END
|
|
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|
|
|
|
//eof
|