icuSources/i18n/fmtable.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 1997-2008, International Business Machines Corporation and    *
   4 * others. All Rights Reserved.                                                *
   5 *******************************************************************************
   6 *
   7 * File FMTABLE.CPP
   8 *
   9 * Modification History:
  10 *
  11 *   Date        Name        Description
  12 *   03/25/97    clhuang     Initial Implementation.
  13 ********************************************************************************
  14 */
  15
  16 #include "unicode/utypes.h"
  17
  18 #if !UCONFIG_NO_FORMATTING
  19
  20 #include "unicode/fmtable.h"
  21 #include "unicode/ustring.h"
  22 #include "unicode/measure.h"
  23 #include "unicode/curramt.h"
  24 #include "cmemory.h"
  25
  26 // *****************************************************************************
  27 // class Formattable
  28 // *****************************************************************************
  29
  30 U_NAMESPACE_BEGIN
  31
  32 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Formattable)
  33
  34 //-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
  35
  36 // NOTE: As of 3.0, there are limitations to the UObject API.  It does
  37 // not (yet) support cloning, operator=, nor operator==.  RTTI is also
  38 // restricted in that subtype testing is not (yet) implemented.  To
  39 // work around this, I implement some simple inlines here.  Later
  40 // these can be modified or removed.  [alan]
  41
  42 // NOTE: These inlines assume that all fObjects are in fact instances
  43 // of the Measure class, which is true as of 3.0.  [alan]
  44
  45 // Return TRUE if *a == *b.
  46 static inline UBool objectEquals(const UObject* a, const UObject* b) {
  47     // LATER: return *a == *b;
  48     return *((const Measure*) a) == *((const Measure*) b);
  49 }
  50
  51 // Return a clone of *a.
  52 static inline UObject* objectClone(const UObject* a) {
  53     // LATER: return a->clone();
  54     return ((const Measure*) a)->clone();
  55 }
  56
  57 // Return TRUE if *a is an instance of Measure.
  58 static inline UBool instanceOfMeasure(const UObject* a) {
  59     // LATER: return a->instanceof(Measure::getStaticClassID());
  60     return a->getDynamicClassID() ==
  61         CurrencyAmount::getStaticClassID();
  62 }
  63
  64 /**
  65  * Creates a new Formattable array and copies the values from the specified
  66  * original.
  67  * @param array the original array
  68  * @param count the original array count
  69  * @return the new Formattable array.
  70  */
  71 static inline Formattable* createArrayCopy(const Formattable* array, int32_t count) {
  72     Formattable *result = new Formattable[count];
  73     if (result != NULL) {
  74         for (int32_t i=0; i<count; ++i)
  75             result[i] = array[i]; // Don't memcpy!
  76     }
  77     return result;
  78 }
  79
  80 //-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
  81
  82 /**
  83  * Set 'ec' to 'err' only if 'ec' is not already set to a failing UErrorCode.
  84  */
  85 static inline void setError(UErrorCode& ec, UErrorCode err) {
  86     if (U_SUCCESS(ec)) {
  87         ec = err;
  88     }
  89 }
  90
  91 // -------------------------------------
  92 // default constructor.
  93 // Creates a formattable object with a long value 0.
  94
  95 Formattable::Formattable()
  96     :   UObject(), fType(kLong)
  97 {
  98     fBogus.setToBogus();
  99     fValue.fInt64 = 0;
 100 }
 101
 102 // -------------------------------------
 103 // Creates a formattable object with a Date instance.
 104
 105 Formattable::Formattable(UDate date, ISDATE /*isDate*/)
 106     :   UObject(), fType(kDate)
 107 {
 108     fBogus.setToBogus();
 109     fValue.fDate = date;
 110 }
 111
 112 // -------------------------------------
 113 // Creates a formattable object with a double value.
 114
 115 Formattable::Formattable(double value)
 116     :   UObject(), fType(kDouble)
 117 {
 118     fBogus.setToBogus();
 119     fValue.fDouble = value;
 120 }
 121
 122 // -------------------------------------
 123 // Creates a formattable object with a long value.
 124
 125 Formattable::Formattable(int32_t value)
 126     :   UObject(), fType(kLong)
 127 {
 128     fBogus.setToBogus();
 129     fValue.fInt64 = value;
 130 }
 131
 132 // -------------------------------------
 133 // Creates a formattable object with a long value.
 134
 135 Formattable::Formattable(int64_t value)
 136     :   UObject(), fType(kInt64)
 137 {
 138     fBogus.setToBogus();
 139     fValue.fInt64 = value;
 140 }
 141
 142 // -------------------------------------
 143 // Creates a formattable object with a UnicodeString instance.
 144
 145 Formattable::Formattable(const UnicodeString& stringToCopy)
 146     :   UObject(), fType(kString)
 147 {
 148     fBogus.setToBogus();
 149     fValue.fString = new UnicodeString(stringToCopy);
 150 }
 151
 152 // -------------------------------------
 153 // Creates a formattable object with a UnicodeString* value.
 154 // (adopting symantics)
 155
 156 Formattable::Formattable(UnicodeString* stringToAdopt)
 157     :   UObject(), fType(kString)
 158 {
 159     fBogus.setToBogus();
 160     fValue.fString = stringToAdopt;
 161 }
 162
 163 Formattable::Formattable(UObject* objectToAdopt)
 164     :   UObject(), fType(kObject)
 165 {
 166     fBogus.setToBogus();
 167     fValue.fObject = objectToAdopt;
 168 }
 169
 170 // -------------------------------------
 171
 172 Formattable::Formattable(const Formattable* arrayToCopy, int32_t count)
 173     :   UObject(), fType(kArray)
 174 {
 175     fBogus.setToBogus();
 176     fValue.fArrayAndCount.fArray = createArrayCopy(arrayToCopy, count);
 177     fValue.fArrayAndCount.fCount = count;
 178 }
 179
 180 // -------------------------------------
 181 // copy constructor
 182
 183 Formattable::Formattable(const Formattable &source)
 184     :   UObject(source), fType(kLong)
 185 {
 186     fBogus.setToBogus();
 187     *this = source;
 188 }
 189
 190 // -------------------------------------
 191 // assignment operator
 192
 193 Formattable&
 194 Formattable::operator=(const Formattable& source)
 195 {
 196     if (this != &source)
 197     {
 198         // Disposes the current formattable value/setting.
 199         dispose();
 200
 201         // Sets the correct data type for this value.
 202         fType = source.fType;
 203         switch (fType)
 204         {
 205         case kArray:
 206             // Sets each element in the array one by one and records the array count.
 207             fValue.fArrayAndCount.fCount = source.fValue.fArrayAndCount.fCount;
 208             fValue.fArrayAndCount.fArray = createArrayCopy(source.fValue.fArrayAndCount.fArray,
 209                                                            source.fValue.fArrayAndCount.fCount);
 210             break;
 211         case kString:
 212             // Sets the string value.
 213             fValue.fString = new UnicodeString(*source.fValue.fString);
 214             break;
 215         case kDouble:
 216             // Sets the double value.
 217             fValue.fDouble = source.fValue.fDouble;
 218             break;
 219         case kLong:
 220         case kInt64:
 221             // Sets the long value.
 222             fValue.fInt64 = source.fValue.fInt64;
 223             break;
 224         case kDate:
 225             // Sets the Date value.
 226             fValue.fDate = source.fValue.fDate;
 227             break;
 228         case kObject:
 229             fValue.fObject = objectClone(source.fValue.fObject);
 230             break;
 231         }
 232     }
 233     return *this;
 234 }
 235
 236 // -------------------------------------
 237
 238 UBool
 239 Formattable::operator==(const Formattable& that) const
 240 {
 241     int32_t i;
 242
 243     if (this == &that) return TRUE;
 244
 245     // Returns FALSE if the data types are different.
 246     if (fType != that.fType) return FALSE;
 247
 248     // Compares the actual data values.
 249     UBool equal = TRUE;
 250     switch (fType) {
 251     case kDate:
 252         equal = (fValue.fDate == that.fValue.fDate);
 253         break;
 254     case kDouble:
 255         equal = (fValue.fDouble == that.fValue.fDouble);
 256         break;
 257     case kLong:
 258     case kInt64:
 259         equal = (fValue.fInt64 == that.fValue.fInt64);
 260         break;
 261     case kString:
 262         equal = (*(fValue.fString) == *(that.fValue.fString));
 263         break;
 264     case kArray:
 265         if (fValue.fArrayAndCount.fCount != that.fValue.fArrayAndCount.fCount) {
 266             equal = FALSE;
 267             break;
 268         }
 269         // Checks each element for equality.
 270         for (i=0; i<fValue.fArrayAndCount.fCount; ++i) {
 271             if (fValue.fArrayAndCount.fArray[i] != that.fValue.fArrayAndCount.fArray[i]) {
 272                 equal = FALSE;
 273                 break;
 274             }
 275         }
 276         break;
 277     case kObject:
 278         if (fValue.fObject == NULL || that.fValue.fObject == NULL) {
 279             equal = FALSE;
 280         } else {
 281             equal = objectEquals(fValue.fObject, that.fValue.fObject);
 282         }
 283         break;
 284     }
 285
 286     return equal;
 287 }
 288
 289 // -------------------------------------
 290
 291 Formattable::~Formattable()
 292 {
 293     dispose();
 294 }
 295
 296 // -------------------------------------
 297
 298 void Formattable::dispose()
 299 {
 300     // Deletes the data value if necessary.
 301     switch (fType) {
 302     case kString:
 303         delete fValue.fString;
 304         break;
 305     case kArray:
 306         delete[] fValue.fArrayAndCount.fArray;
 307         break;
 308     case kObject:
 309         delete fValue.fObject;
 310         break;
 311     default:
 312         break;
 313     }
 314 }
 315
 316 Formattable *
 317 Formattable::clone() const {
 318     return new Formattable(*this);
 319 }
 320
 321 // -------------------------------------
 322 // Gets the data type of this Formattable object.
 323 Formattable::Type
 324 Formattable::getType() const
 325 {
 326     return fType;
 327 }
 328
 329 UBool
 330 Formattable::isNumeric() const {
 331     switch (fType) {
 332     case kDouble:
 333     case kLong:
 334     case kInt64:
 335         return TRUE;
 336     default:
 337         return FALSE;
 338     }
 339 }
 340
 341 // -------------------------------------
 342 int32_t
 343 //Formattable::getLong(UErrorCode* status) const
 344 Formattable::getLong(UErrorCode& status) const
 345 {
 346     if (U_FAILURE(status)) {
 347         return 0;
 348     }
 349
 350     switch (fType) {
 351     case Formattable::kLong:
 352         return (int32_t)fValue.fInt64;
 353     case Formattable::kInt64:
 354         if (fValue.fInt64 > INT32_MAX) {
 355             status = U_INVALID_FORMAT_ERROR;
 356             return INT32_MAX;
 357         } else if (fValue.fInt64 < INT32_MIN) {
 358             status = U_INVALID_FORMAT_ERROR;
 359             return INT32_MIN;
 360         } else {
 361             return (int32_t)fValue.fInt64;
 362         }
 363     case Formattable::kDouble:
 364         if (fValue.fDouble > INT32_MAX) {
 365             status = U_INVALID_FORMAT_ERROR;
 366             return INT32_MAX;
 367         } else if (fValue.fDouble < INT32_MIN) {
 368             status = U_INVALID_FORMAT_ERROR;
 369             return INT32_MIN;
 370         } else {
 371             return (int32_t)fValue.fDouble; // loses fraction
 372         }
 373     case Formattable::kObject:
 374         if (fValue.fObject == NULL) {
 375             status = U_MEMORY_ALLOCATION_ERROR;
 376             return 0;
 377         }
 378         // TODO Later replace this with instanceof call
 379         if (instanceOfMeasure(fValue.fObject)) {
 380             return ((const Measure*) fValue.fObject)->
 381                 getNumber().getLong(status);
 382         }
 383     default:
 384         status = U_INVALID_FORMAT_ERROR;
 385         return 0;
 386     }
 387 }
 388
 389 // -------------------------------------
 390 int64_t
 391 Formattable::getInt64(UErrorCode& status) const
 392 {
 393     if (U_FAILURE(status)) {
 394         return 0;
 395     }
 396
 397     switch (fType) {
 398     case Formattable::kLong:
 399     case Formattable::kInt64:
 400         return fValue.fInt64;
 401     case Formattable::kDouble:
 402         if (fValue.fDouble > U_INT64_MAX) {
 403             status = U_INVALID_FORMAT_ERROR;
 404             return U_INT64_MAX;
 405         } else if (fValue.fDouble < U_INT64_MIN) {
 406             status = U_INVALID_FORMAT_ERROR;
 407             return U_INT64_MIN;
 408         } else {
 409             return (int64_t)fValue.fDouble;
 410         }
 411     case Formattable::kObject:
 412         if (fValue.fObject == NULL) {
 413             status = U_MEMORY_ALLOCATION_ERROR;
 414             return 0;
 415         }
 416         // TODO Later replace this with instanceof call
 417         if (instanceOfMeasure(fValue.fObject)) {
 418             return ((const Measure*) fValue.fObject)->
 419                 getNumber().getInt64(status);
 420         }
 421     default:
 422         status = U_INVALID_FORMAT_ERROR;
 423         return 0;
 424     }
 425 }
 426
 427 // -------------------------------------
 428 double
 429 Formattable::getDouble(UErrorCode& status) const
 430 {
 431     if (U_FAILURE(status)) {
 432         return 0;
 433     }
 434
 435     switch (fType) {
 436     case Formattable::kLong:
 437     case Formattable::kInt64: // loses precision
 438         return (double)fValue.fInt64;
 439     case Formattable::kDouble:
 440         return fValue.fDouble;
 441     case Formattable::kObject:
 442         if (fValue.fObject == NULL) {
 443             status = U_MEMORY_ALLOCATION_ERROR;
 444             return 0;
 445         }
 446         // TODO Later replace this with instanceof call
 447         if (instanceOfMeasure(fValue.fObject)) {
 448             return ((const Measure*) fValue.fObject)->
 449                 getNumber().getDouble(status);
 450         }
 451     default:
 452         status = U_INVALID_FORMAT_ERROR;
 453         return 0;
 454     }
 455 }
 456
 457 const UObject*
 458 Formattable::getObject() const {
 459     return (fType == kObject) ? fValue.fObject : NULL;
 460 }
 461
 462 // -------------------------------------
 463 // Sets the value to a double value d.
 464
 465 void
 466 Formattable::setDouble(double d)
 467 {
 468     dispose();
 469     fType = kDouble;
 470     fValue.fDouble = d;
 471 }
 472
 473 // -------------------------------------
 474 // Sets the value to a long value l.
 475
 476 void
 477 Formattable::setLong(int32_t l)
 478 {
 479     dispose();
 480     fType = kLong;
 481     fValue.fInt64 = l;
 482 }
 483
 484 // -------------------------------------
 485 // Sets the value to an int64 value ll.
 486
 487 void
 488 Formattable::setInt64(int64_t ll)
 489 {
 490     dispose();
 491     fType = kInt64;
 492     fValue.fInt64 = ll;
 493 }
 494
 495 // -------------------------------------
 496 // Sets the value to a Date instance d.
 497
 498 void
 499 Formattable::setDate(UDate d)
 500 {
 501     dispose();
 502     fType = kDate;
 503     fValue.fDate = d;
 504 }
 505
 506 // -------------------------------------
 507 // Sets the value to a string value stringToCopy.
 508
 509 void
 510 Formattable::setString(const UnicodeString& stringToCopy)
 511 {
 512     dispose();
 513     fType = kString;
 514     fValue.fString = new UnicodeString(stringToCopy);
 515 }
 516
 517 // -------------------------------------
 518 // Sets the value to an array of Formattable objects.
 519
 520 void
 521 Formattable::setArray(const Formattable* array, int32_t count)
 522 {
 523     dispose();
 524     fType = kArray;
 525     fValue.fArrayAndCount.fArray = createArrayCopy(array, count);
 526     fValue.fArrayAndCount.fCount = count;
 527 }
 528
 529 // -------------------------------------
 530 // Adopts the stringToAdopt value.
 531
 532 void
 533 Formattable::adoptString(UnicodeString* stringToAdopt)
 534 {
 535     dispose();
 536     fType = kString;
 537     fValue.fString = stringToAdopt;
 538 }
 539
 540 // -------------------------------------
 541 // Adopts the array value and its count.
 542
 543 void
 544 Formattable::adoptArray(Formattable* array, int32_t count)
 545 {
 546     dispose();
 547     fType = kArray;
 548     fValue.fArrayAndCount.fArray = array;
 549     fValue.fArrayAndCount.fCount = count;
 550 }
 551
 552 void
 553 Formattable::adoptObject(UObject* objectToAdopt) {
 554     dispose();
 555     fType = kObject;
 556     fValue.fObject = objectToAdopt;
 557 }
 558
 559 // -------------------------------------
 560 UnicodeString&
 561 Formattable::getString(UnicodeString& result, UErrorCode& status) const
 562 {
 563     if (fType != kString) {
 564         setError(status, U_INVALID_FORMAT_ERROR);
 565         result.setToBogus();
 566     } else {
 567         if (fValue.fString == NULL) {
 568             setError(status, U_MEMORY_ALLOCATION_ERROR);
 569         } else {
 570             result = *fValue.fString;
 571         }
 572     }
 573     return result;
 574 }
 575
 576 // -------------------------------------
 577 const UnicodeString&
 578 Formattable::getString(UErrorCode& status) const
 579 {
 580     if (fType != kString) {
 581         setError(status, U_INVALID_FORMAT_ERROR);
 582         return *getBogus();
 583     }
 584     if (fValue.fString == NULL) {
 585         setError(status, U_MEMORY_ALLOCATION_ERROR);
 586         return *getBogus();
 587     }
 588     return *fValue.fString;
 589 }
 590
 591 // -------------------------------------
 592 UnicodeString&
 593 Formattable::getString(UErrorCode& status)
 594 {
 595     if (fType != kString) {
 596         setError(status, U_INVALID_FORMAT_ERROR);
 597         return *getBogus();
 598     }
 599     if (fValue.fString == NULL) {
 600         setError(status, U_MEMORY_ALLOCATION_ERROR);
 601         return *getBogus();
 602     }
 603     return *fValue.fString;
 604 }
 605
 606 // -------------------------------------
 607 const Formattable*
 608 Formattable::getArray(int32_t& count, UErrorCode& status) const
 609 {
 610     if (fType != kArray) {
 611         setError(status, U_INVALID_FORMAT_ERROR);
 612         count = 0;
 613         return NULL;
 614     }
 615     count = fValue.fArrayAndCount.fCount;
 616     return fValue.fArrayAndCount.fArray;
 617 }
 618
 619 // -------------------------------------
 620 // Gets the bogus string, ensures mondo bogosity.
 621
 622 UnicodeString*
 623 Formattable::getBogus() const
 624 {
 625     return (UnicodeString*)&fBogus; /* cast away const :-( */
 626 }
 627
 628 #if 0
 629 //----------------------------------------------------
 630 // console I/O
 631 //----------------------------------------------------
 632 #ifdef _DEBUG
 633
 634 #if U_IOSTREAM_SOURCE >= 199711
 635 #include <iostream>
 636 using namespace std;
 637 #elif U_IOSTREAM_SOURCE >= 198506
 638 #include <iostream.h>
 639 #endif
 640
 641 #include "unicode/datefmt.h"
 642 #include "unistrm.h"
 643
 644 class FormattableStreamer /* not : public UObject because all methods are static */ {
 645 public:
 646     static void streamOut(ostream& stream, const Formattable& obj);
 647
 648 private:
 649     FormattableStreamer() {} // private - forbid instantiation
 650 };
 651
 652 // This is for debugging purposes only.  This will send a displayable
 653 // form of the Formattable object to the output stream.
 654
 655 void
 656 FormattableStreamer::streamOut(ostream& stream, const Formattable& obj)
 657 {
 658     static DateFormat *defDateFormat = 0;
 659
 660     UnicodeString buffer;
 661     switch(obj.getType()) {
 662         case Formattable::kDate :
 663             // Creates a DateFormat instance for formatting the
 664             // Date instance.
 665             if (defDateFormat == 0) {
 666                 defDateFormat = DateFormat::createInstance();
 667             }
 668             defDateFormat->format(obj.getDate(), buffer);
 669             stream << buffer;
 670             break;
 671         case Formattable::kDouble :
 672             // Output the double as is.
 673             stream << obj.getDouble() << 'D';
 674             break;
 675         case Formattable::kLong :
 676             // Output the double as is.
 677             stream << obj.getLong() << 'L';
 678             break;
 679         case Formattable::kString:
 680             // Output the double as is.  Please see UnicodeString console
 681             // I/O routine for more details.
 682             stream << '"' << obj.getString(buffer) << '"';
 683             break;
 684         case Formattable::kArray:
 685             int32_t i, count;
 686             const Formattable* array;
 687             array = obj.getArray(count);
 688             stream << '[';
 689             // Recursively calling the console I/O routine for each element in the array.
 690             for (i=0; i<count; ++i) {
 691                 FormattableStreamer::streamOut(stream, array[i]);
 692                 stream << ( (i==(count-1)) ? "" : ", " );
 693             }
 694             stream << ']';
 695             break;
 696         default:
 697             // Not a recognizable Formattable object.
 698             stream << "INVALID_Formattable";
 699     }
 700     stream.flush();
 701 }
 702 #endif
 703
 704 #endif
 705
 706 U_NAMESPACE_END
 707
 708 #endif /* #if !UCONFIG_NO_FORMATTING */
 709
 710 //eof