icuSources/test/intltest/fldset.cpp

   1 /*
   2 ************************************************************************
   3 * Copyright (c) 2007-2011, International Business Machines
   4 * Corporation and others.  All Rights Reserved.
   5 ************************************************************************
   6 */
   7
   8 #include "fldset.h"
   9 #include "intltest.h"
  10
  11 #if !UCONFIG_NO_FORMATTING
  12 #include "unicode/regex.h"
  13
  14
  15 FieldsSet::FieldsSet() {
  16     // NOTREACHED
  17 }
  18
  19 FieldsSet::FieldsSet(int32_t fieldCount) {
  20     construct((UDebugEnumType)-1, fieldCount);
  21 }
  22
  23 FieldsSet::FieldsSet(UDebugEnumType field) {
  24     construct(field, udbg_enumCount(field));
  25 }
  26
  27 FieldsSet::~FieldsSet() {
  28
  29 }
  30
  31 int32_t FieldsSet::fieldCount() const {
  32     return fFieldCount;
  33 }
  34
  35 void FieldsSet::construct(UDebugEnumType field, int32_t fieldCount) {
  36     fEnum = field;
  37     if(fieldCount > U_FIELDS_SET_MAX) {
  38         fieldCount = U_FIELDS_SET_MAX;
  39     }
  40     fFieldCount = fieldCount;
  41     clear();
  42 }
  43
  44 UnicodeString FieldsSet::diffFrom(const FieldsSet& other, UErrorCode& status) const {
  45     UnicodeString str;
  46     if(!isSameType(other)) {
  47         status = U_ILLEGAL_ARGUMENT_ERROR;
  48         return UnicodeString("U_ILLEGAL_ARGUMENT_ERROR: FieldsSet of a different type!");
  49     }
  50     for (int i=0; i<fieldCount(); i++) {
  51         if (isSet((UCalendarDateFields)i)) {
  52             int32_t myVal = get(i);
  53             int32_t theirVal = other.get(i);
  54
  55             if(fEnum != -1) {
  56                 const UnicodeString& fieldName = udbg_enumString(
  57                         fEnum, i);
  58
  59                 str = str + fieldName + UnicodeString("=")+myVal+UnicodeString(" not ")+theirVal+UnicodeString(", ");
  60             } else {
  61                 str = str + UnicodeString("some field") + "=" + myVal+" not " + theirVal+", ";
  62             }
  63         }
  64     }
  65     return str;
  66 }
  67
  68 static UnicodeString *split(const UnicodeString &src, UChar ch, int32_t &splits)
  69 {
  70     int32_t offset = -1;
  71
  72     splits = 1;
  73     while((offset = src.indexOf(ch, offset + 1)) >= 0) {
  74         splits += 1;
  75     }
  76
  77     UnicodeString *result = new UnicodeString[splits];
  78
  79     int32_t start = 0;
  80     int32_t split = 0;
  81     int32_t end;
  82
  83     while((end = src.indexOf(ch, start)) >= 0) {
  84         src.extractBetween(start, end, result[split++]);
  85         start = end + 1;
  86     }
  87
  88     src.extractBetween(start, src.length(), result[split]);
  89
  90     return result;
  91 }
  92
  93 int32_t FieldsSet::parseFrom(const UnicodeString& str, const
  94         FieldsSet* inheritFrom, UErrorCode& status) {
  95
  96     int goodFields = 0;
  97
  98     if(U_FAILURE(status)) {
  99         return -1;
 100     }
 101
 102     int32_t destCount = 0;
 103     UnicodeString *dest = split(str, 0x002C /* ',' */, destCount);
 104
 105     for(int i = 0; i < destCount; i += 1) {
 106         int32_t dc = 0;
 107         UnicodeString *kv = split(dest[i], 0x003D /* '=' */, dc);
 108
 109         if(dc != 2) {
 110             it_errln(UnicodeString("dc == ") + dc + UnicodeString("?"));
 111         }
 112
 113         int32_t field = handleParseName(inheritFrom, kv[0], kv[1], status);
 114
 115         if(U_FAILURE(status)) {
 116             char ch[256];
 117             const UChar *u = kv[0].getBuffer();
 118             int32_t len = kv[0].length();
 119             u_UCharsToChars(u, ch, len);
 120             ch[len] = 0; /* include terminating \0 */
 121             it_errln(UnicodeString("Parse Failed: Field ") + UnicodeString(ch) + UnicodeString(", err ") + UnicodeString(u_errorName(status)));
 122             delete[] kv;
 123             delete[] dest;
 124             return -1;
 125         }
 126
 127         if(field != -1) {
 128             handleParseValue(inheritFrom, field, kv[1], status);
 129
 130             if(U_FAILURE(status)) {
 131                 char ch[256];
 132                 const UChar *u = kv[1].getBuffer();
 133                 int32_t len = kv[1].length();
 134                 u_UCharsToChars(u, ch, len);
 135                 ch[len] = 0; /* include terminating \0 */
 136                 it_errln(UnicodeString("Parse Failed: Value ") + UnicodeString(ch) + UnicodeString(", err ") + UnicodeString(u_errorName(status)));
 137                 delete[] kv;
 138                 delete[] dest;
 139                 return -1;
 140             }
 141
 142             goodFields += 1;
 143         }
 144
 145         delete[] kv;
 146     }
 147
 148     delete[] dest;
 149
 150     return goodFields;
 151 }
 152
 153 UBool FieldsSet::isSameType(const FieldsSet& other) const {
 154     return((&other==this)||
 155            ((other.fFieldCount==fFieldCount) && (other.fEnum==fEnum)));
 156 }
 157
 158 void FieldsSet::clear() {
 159     for (int i=0; i<fieldCount(); i++) {
 160         fValue[i]=-1;
 161         fIsSet[i]=FALSE;
 162     }
 163 }
 164
 165 void FieldsSet::clear(int32_t field) {
 166     if (field<0|| field>=fieldCount()) {
 167         return;
 168     }
 169     fValue[field] = -1;
 170     fIsSet[field] = FALSE;
 171 }
 172 void FieldsSet::set(int32_t field, int32_t amount) {
 173     if (field<0|| field>=fieldCount()) {
 174         return;
 175     }
 176     fValue[field] = amount;
 177     fIsSet[field] = TRUE;
 178 }
 179
 180 UBool FieldsSet::isSet(int32_t field) const {
 181     if (field<0|| field>=fieldCount()) {
 182         return FALSE;
 183     }
 184     return fIsSet[field];
 185 }
 186 int32_t FieldsSet::get(int32_t field) const {
 187     if (field<0|| field>=fieldCount()) {
 188         return -1;
 189     }
 190     return fValue[field];
 191 }
 192
 193
 194 int32_t FieldsSet::handleParseName(const FieldsSet* /* inheritFrom */, const UnicodeString& name, const UnicodeString& /* substr*/ , UErrorCode& status) {
 195     if(fEnum > -1) {
 196         int32_t which = udbg_enumByString(fEnum, name);
 197         if(which == UDBG_INVALID_ENUM) {
 198             status = U_UNSUPPORTED_ERROR;
 199         }
 200         return which;
 201     } else {
 202         status = U_UNSUPPORTED_ERROR;
 203         return -1;
 204     }
 205 }
 206
 207 void FieldsSet::parseValueDefault(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
 208     int32_t value = -1;
 209     if(substr.length()==0) { // inherit requested
 210         // inherit
 211         if((inheritFrom == NULL) || !inheritFrom->isSet((UCalendarDateFields)field)) {
 212             // couldn't inherit from field
 213             it_errln(UnicodeString("Parse Failed: Couldn't inherit field ") + field + UnicodeString(" [") + UnicodeString(udbg_enumName(fEnum, field)) + UnicodeString("]"));
 214             status = U_ILLEGAL_ARGUMENT_ERROR;
 215             return;
 216         }
 217         value = inheritFrom->get((UCalendarDateFields)field);
 218     } else {
 219         value = udbg_stoi(substr);
 220     }
 221     set(field, value);
 222 }
 223
 224 void FieldsSet::parseValueEnum(UDebugEnumType type, const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
 225     int32_t value = udbg_enumByString(type, substr);
 226     if(value>=0) {
 227         set(field, value);
 228     } else {
 229         // fallback
 230         parseValueDefault(inheritFrom,field,substr,status);
 231     }
 232 }
 233
 234 void FieldsSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
 235     parseValueDefault(inheritFrom, field, substr, status);
 236 }
 237
 238 /// CAL FIELDS
 239
 240
 241 CalendarFieldsSet::CalendarFieldsSet() :
 242 FieldsSet(UDBG_UCalendarDateFields) {
 243     // base class will call clear.
 244 }
 245
 246 CalendarFieldsSet::~CalendarFieldsSet() {
 247 }
 248
 249 void CalendarFieldsSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
 250     if(field==UCAL_MONTH) {
 251         parseValueEnum(UDBG_UCalendarMonths, inheritFrom, field, substr, status);
 252         // will fallback to default.
 253     } else {
 254         parseValueDefault(inheritFrom, field, substr, status);
 255     }
 256 }
 257
 258 /**
 259  * set the specified fields on this calendar. Doesn't clear first. Returns any errors the caller
 260  */
 261 void CalendarFieldsSet::setOnCalendar(Calendar *cal, UErrorCode& /*status*/) const {
 262     for (int i=0; i<UDAT_FIELD_COUNT; i++) {
 263         if (isSet((UCalendarDateFields)i)) {
 264             int32_t value = get((UCalendarDateFields)i);
 265             cal->set((UCalendarDateFields)i, value);
 266         }
 267     }
 268 }
 269
 270 /**
 271  * return true if the calendar matches in these fields
 272  */
 273 UBool CalendarFieldsSet::matches(Calendar *cal, CalendarFieldsSet &diffSet,
 274         UErrorCode& status) const {
 275     UBool match = TRUE;
 276     if (U_FAILURE(status)) {
 277         return FALSE;
 278     }
 279     for (int i=0; i<UDAT_FIELD_COUNT; i++) {
 280         if (isSet((UCalendarDateFields)i)) {
 281             int32_t calVal = cal->get((UCalendarDateFields)i, status);
 282             if (U_FAILURE(status))
 283                 return FALSE;
 284             if (calVal != get((UCalendarDateFields)i)) {
 285                 match = FALSE;
 286                 diffSet.set((UCalendarDateFields)i, calVal);
 287                 //fprintf(stderr, "match failed: %s#%d=%d != %d\n",udbg_enumName(UDBG_UCalendarDateFields,i),i,cal->get((UCalendarDateFields)i,status), get((UCalendarDateFields)i));;
 288             }
 289         }
 290     }
 291     return match;
 292 }
 293
 294
 295 /**
 296  * DateTimeStyleSet has two 'fields' -- date, and time.
 297  */
 298 enum DateTimeStyleSetFields {
 299     DTS_DATE = 0,  /** Field one: the date (long, medium, short, etc). */
 300     DTS_TIME,      /** Field two: the time (long, medium, short, etc). */
 301     DTS_COUNT      /** The number of fields */
 302 };
 303
 304 /**
 305  * DateTimeSet
 306  * */
 307 DateTimeStyleSet::DateTimeStyleSet() :
 308     FieldsSet(DTS_COUNT) {
 309 }
 310
 311 DateTimeStyleSet::~DateTimeStyleSet() {
 312
 313 }
 314
 315 UDateFormatStyle DateTimeStyleSet::getDateStyle() const {
 316     if(!isSet(DTS_DATE)) {
 317         return UDAT_NONE;
 318     } else {
 319         return (UDateFormatStyle)get(DTS_DATE);
 320     }
 321 }
 322
 323
 324 UDateFormatStyle DateTimeStyleSet::getTimeStyle() const {
 325     if(!isSet(DTS_TIME)) {
 326         return UDAT_NONE;
 327     } else {
 328         return (UDateFormatStyle)get(DTS_TIME);
 329     }
 330 }
 331
 332 void DateTimeStyleSet::handleParseValue(const FieldsSet* inheritFrom, int32_t field, const UnicodeString& substr, UErrorCode& status) {
 333     UnicodeString kRELATIVE_("RELATIVE_");
 334     if(substr.startsWith(kRELATIVE_)) {
 335         UnicodeString relativeas(substr,kRELATIVE_.length());
 336         parseValueEnum(UDBG_UDateFormatStyle, inheritFrom, field, relativeas, status);
 337         // fix relative value
 338         if(isSet(field) && U_SUCCESS(status)) {
 339             set(field, get(field) | UDAT_RELATIVE);
 340         }
 341     } else {
 342         parseValueEnum(UDBG_UDateFormatStyle, inheritFrom, field, substr, status);
 343     }
 344 }
 345
 346 int32_t DateTimeStyleSet::handleParseName(const FieldsSet* /* inheritFrom */, const UnicodeString& name, const UnicodeString& /* substr */, UErrorCode& status) {
 347     UnicodeString kDATE("DATE"); // TODO: static
 348     UnicodeString kTIME("TIME"); // TODO: static
 349     if(name == kDATE ) {
 350         return DTS_DATE;
 351     } else if(name == kTIME) {
 352         return DTS_TIME;
 353     } else {
 354         status = U_ILLEGAL_ARGUMENT_ERROR;
 355         return -1;
 356     }
 357 }
 358
 359 #endif /*!UCONFIG_NO_FORMAT*/