| OLD | NEW |
|---|
| (Empty) |
| 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) co
nst { | |
| 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(c
h) + 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 Uni
codeString& 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, c
onst 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)fie
ld)) { | |
| 212 // couldn't inherit from field | |
| 213 it_errln(UnicodeString("Parse Failed: Couldn't inherit field ") + fi
eld + UnicodeString(" [") + UnicodeString(udbg_enumName(fEnum, field)) + Unicode
String("]")); | |
| 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, co
nst 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 f
ield, 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 e
rrors the caller | |
| 260 */ | |
| 261 void CalendarFieldsSet::setOnCalendar(Calendar *cal, UErrorCode& /*status*/) con
st { | |
| 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((UCa
lendarDateFields)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 fi
eld, 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, st
atus); | |
| 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 */, co
nst 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*/ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
