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