The Tor Browser / file revision

 /*

 *******************************************************************************

 * Copyright (C) 1997-2013, International Business Machines Corporation and    *

 * others. All Rights Reserved.                                                *

 *******************************************************************************

 *

 * File FMTABLE.CPP

 *

 * Modification History:

 *

 *   Date        Name        Description

 *   03/25/97    clhuang     Initial Implementation.

 ********************************************************************************

 */

 #include "unicode/utypes.h"

 #if !UCONFIG_NO_FORMATTING

 #include <math.h>

 #include "unicode/fmtable.h"

 #include "unicode/ustring.h"

 #include "unicode/measure.h"

 #include "unicode/curramt.h"

 #include "unicode/uformattable.h"

 #include "charstr.h"

 #include "cmemory.h"

 #include "cstring.h"

 #include "decNumber.h"

 #include "digitlst.h"

 // *****************************************************************************

 // class Formattable

 // *****************************************************************************

 U_NAMESPACE_BEGIN

 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Formattable)

 #include "fmtableimp.h"

 //-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.

 // NOTE: As of 3.0, there are limitations to the UObject API.  It does

 // not (yet) support cloning, operator=, nor operator==.  To

 // work around this, I implement some simple inlines here.  Later

 // these can be modified or removed.  [alan]

 // NOTE: These inlines assume that all fObjects are in fact instances

 // of the Measure class, which is true as of 3.0.  [alan]

 // Return TRUE if *a == *b.

 static inline UBool objectEquals(const UObject* a, const UObject* b) {

     // LATER: return *a == *b;

     return *((const Measure*) a) == *((const Measure*) b);

 }

 // Return a clone of *a.

 static inline UObject* objectClone(const UObject* a) {

     // LATER: return a->clone();

     return ((const Measure*) a)->clone();

 }

 // Return TRUE if *a is an instance of Measure.

 static inline UBool instanceOfMeasure(const UObject* a) {

     return dynamic_cast<const Measure*>(a) != NULL;

 }

 /**

  * Creates a new Formattable array and copies the values from the specified

  * original.

  * @param array the original array

  * @param count the original array count

  * @return the new Formattable array.

  */

 static Formattable* createArrayCopy(const Formattable* array, int32_t count) {

     Formattable *result = new Formattable[count];

     if (result != NULL) {

         for (int32_t i=0; i<count; ++i)

             result[i] = array[i]; // Don't memcpy!

     }

     return result;

 }

 //-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.

 /**

  * Set 'ec' to 'err' only if 'ec' is not already set to a failing UErrorCode.

  */

 static void setError(UErrorCode& ec, UErrorCode err) {

     if (U_SUCCESS(ec)) {

         ec = err;

     }

 }

 //

 //  Common initialization code, shared by constructors.

 //  Put everything into a known state.

 //

 void  Formattable::init() {

     fValue.fInt64 = 0;

     fType = kLong;

     fDecimalStr = NULL;

     fDecimalNum = NULL;

     fBogus.setToBogus(); 

 }

 // -------------------------------------

 // default constructor.

 // Creates a formattable object with a long value 0.

 Formattable::Formattable() {

     init();

 }

 // -------------------------------------

 // Creates a formattable object with a Date instance.

 Formattable::Formattable(UDate date, ISDATE /*isDate*/)

 {

     init();

     fType = kDate;

     fValue.fDate = date;

 }

 // -------------------------------------

 // Creates a formattable object with a double value.

 Formattable::Formattable(double value)

 {

     init();

     fType = kDouble;

     fValue.fDouble = value;

 }

 // -------------------------------------

 // Creates a formattable object with an int32_t value.

 Formattable::Formattable(int32_t value)

 {

     init();

     fValue.fInt64 = value;

 }

 // -------------------------------------

 // Creates a formattable object with an int64_t value.

 Formattable::Formattable(int64_t value)

 {

     init();

     fType = kInt64;

     fValue.fInt64 = value;

 }

 // -------------------------------------

 // Creates a formattable object with a decimal number value from a string.

 Formattable::Formattable(const StringPiece &number, UErrorCode &status) {

     init();

     setDecimalNumber(number, status);

 }

 // -------------------------------------

 // Creates a formattable object with a UnicodeString instance.

 Formattable::Formattable(const UnicodeString& stringToCopy)

 {

     init();

     fType = kString;

     fValue.fString = new UnicodeString(stringToCopy);

 }

 // -------------------------------------

 // Creates a formattable object with a UnicodeString* value.

 // (adopting symantics)

 Formattable::Formattable(UnicodeString* stringToAdopt)

 {

     init();

     fType = kString;

     fValue.fString = stringToAdopt;

 }

 Formattable::Formattable(UObject* objectToAdopt)

 {

     init();

     fType = kObject;

     fValue.fObject = objectToAdopt;

 }

 // -------------------------------------

 Formattable::Formattable(const Formattable* arrayToCopy, int32_t count)

     :   UObject(), fType(kArray)

 {

     init();

     fType = kArray;

     fValue.fArrayAndCount.fArray = createArrayCopy(arrayToCopy, count);

     fValue.fArrayAndCount.fCount = count;

 }

 // -------------------------------------

 // copy constructor

 Formattable::Formattable(const Formattable &source)

      :  UObject(*this)

 {

     init();

     *this = source;

 }

 // -------------------------------------

 // assignment operator

 Formattable&

 Formattable::operator=(const Formattable& source)

 {

     if (this != &source)

     {

         // Disposes the current formattable value/setting.

         dispose();

         // Sets the correct data type for this value.

         fType = source.fType;

         switch (fType)

         {

         case kArray:

             // Sets each element in the array one by one and records the array count.

             fValue.fArrayAndCount.fCount = source.fValue.fArrayAndCount.fCount;

             fValue.fArrayAndCount.fArray = createArrayCopy(source.fValue.fArrayAndCount.fArray,

                                                            source.fValue.fArrayAndCount.fCount);

             break;

         case kString:

             // Sets the string value.

             fValue.fString = new UnicodeString(*source.fValue.fString);

             break;

         case kDouble:

             // Sets the double value.

             fValue.fDouble = source.fValue.fDouble;

             break;

         case kLong:

         case kInt64:

             // Sets the long value.

             fValue.fInt64 = source.fValue.fInt64;

             break;

         case kDate:

             // Sets the Date value.

             fValue.fDate = source.fValue.fDate;

             break;

         case kObject:

             fValue.fObject = objectClone(source.fValue.fObject);

             break;

         }

         UErrorCode status = U_ZERO_ERROR;

         if (source.fDecimalNum != NULL) {

           fDecimalNum = new DigitList(*source.fDecimalNum); // TODO: use internal digit list

         }

         if (source.fDecimalStr != NULL) {

             fDecimalStr = new CharString(*source.fDecimalStr, status);

             if (U_FAILURE(status)) {

                 delete fDecimalStr;

                 fDecimalStr = NULL;

             }

         }

     }

     return *this;

 }

 // -------------------------------------

 UBool

 Formattable::operator==(const Formattable& that) const

 {

     int32_t i;

     if (this == &that) return TRUE;

     // Returns FALSE if the data types are different.

     if (fType != that.fType) return FALSE;

     // Compares the actual data values.

     UBool equal = TRUE;

     switch (fType) {

     case kDate:

         equal = (fValue.fDate == that.fValue.fDate);

         break;

     case kDouble:

         equal = (fValue.fDouble == that.fValue.fDouble);

         break;

     case kLong:

     case kInt64:

         equal = (fValue.fInt64 == that.fValue.fInt64);

         break;

     case kString:

         equal = (*(fValue.fString) == *(that.fValue.fString));

         break;

     case kArray:

         if (fValue.fArrayAndCount.fCount != that.fValue.fArrayAndCount.fCount) {

             equal = FALSE;

             break;

         }

         // Checks each element for equality.

         for (i=0; i<fValue.fArrayAndCount.fCount; ++i) {

             if (fValue.fArrayAndCount.fArray[i] != that.fValue.fArrayAndCount.fArray[i]) {

                 equal = FALSE;

                 break;

             }

         }

         break;

     case kObject:

         if (fValue.fObject == NULL || that.fValue.fObject == NULL) {

             equal = FALSE;

         } else {

             equal = objectEquals(fValue.fObject, that.fValue.fObject);

         }

         break;

     }

     // TODO:  compare digit lists if numeric.

     return equal;

 }

 // -------------------------------------

 Formattable::~Formattable()

 {

     dispose();

 }

 // -------------------------------------

 void Formattable::dispose()

 {

     // Deletes the data value if necessary.

     switch (fType) {

     case kString:

         delete fValue.fString;

         break;

     case kArray:

         delete[] fValue.fArrayAndCount.fArray;

         break;

     case kObject:

         delete fValue.fObject;

         break;

     default:

         break;

     }

     fType = kLong;

     fValue.fInt64 = 0;

     delete fDecimalStr;

     fDecimalStr = NULL;

     FmtStackData *stackData = (FmtStackData*)fStackData;

     if(fDecimalNum != &(stackData->stackDecimalNum)) {

       delete fDecimalNum;

     } else {

       fDecimalNum->~DigitList(); // destruct, don't deallocate

     }

     fDecimalNum = NULL;

 }

 Formattable *

 Formattable::clone() const {

     return new Formattable(*this);

 }

 // -------------------------------------

 // Gets the data type of this Formattable object. 

 Formattable::Type

 Formattable::getType() const

 {

     return fType;

 }

 UBool

 Formattable::isNumeric() const {

     switch (fType) {

     case kDouble:

     case kLong:

     case kInt64:

         return TRUE;

     default:

         return FALSE;

     }

 }

 // -------------------------------------

 int32_t

 //Formattable::getLong(UErrorCode* status) const

 Formattable::getLong(UErrorCode& status) const

 {

     if (U_FAILURE(status)) {

         return 0;

     }

     switch (fType) {

     case Formattable::kLong: 

         return (int32_t)fValue.fInt64;

     case Formattable::kInt64:

         if (fValue.fInt64 > INT32_MAX) {

             status = U_INVALID_FORMAT_ERROR;

             return INT32_MAX;

         } else if (fValue.fInt64 < INT32_MIN) {

             status = U_INVALID_FORMAT_ERROR;

             return INT32_MIN;

         } else {

             return (int32_t)fValue.fInt64;

         }

     case Formattable::kDouble:

         if (fValue.fDouble > INT32_MAX) {

             status = U_INVALID_FORMAT_ERROR;

             return INT32_MAX;

         } else if (fValue.fDouble < INT32_MIN) {

             status = U_INVALID_FORMAT_ERROR;

             return INT32_MIN;

         } else {

             return (int32_t)fValue.fDouble; // loses fraction

         }

     case Formattable::kObject:

         if (fValue.fObject == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             return 0;

         }

         // TODO Later replace this with instanceof call

         if (instanceOfMeasure(fValue.fObject)) {

             return ((const Measure*) fValue.fObject)->

                 getNumber().getLong(status);

         }

     default: 

         status = U_INVALID_FORMAT_ERROR;

         return 0;

     }

 }

 // -------------------------------------

 // Maximum int that can be represented exactly in a double.  (53 bits)

 //    Larger ints may be rounded to a near-by value as not all are representable.

 // TODO:  move this constant elsewhere, possibly configure it for different

 //        floating point formats, if any non-standard ones are still in use.

 static const int64_t U_DOUBLE_MAX_EXACT_INT = 9007199254740992LL;

 int64_t

 Formattable::getInt64(UErrorCode& status) const

 {

     if (U_FAILURE(status)) {

         return 0;

     }

     switch (fType) {

     case Formattable::kLong: 

     case Formattable::kInt64: 

         return fValue.fInt64;

     case Formattable::kDouble:

         if (fValue.fDouble > (double)U_INT64_MAX) {

             status = U_INVALID_FORMAT_ERROR;

             return U_INT64_MAX;

         } else if (fValue.fDouble < (double)U_INT64_MIN) {

             status = U_INVALID_FORMAT_ERROR;

             return U_INT64_MIN;

         } else if (fabs(fValue.fDouble) > U_DOUBLE_MAX_EXACT_INT && fDecimalNum != NULL) {

             int64_t val = fDecimalNum->getInt64();

             if (val != 0) {

                 return val;

             } else {

                 status = U_INVALID_FORMAT_ERROR;

                 return fValue.fDouble > 0 ? U_INT64_MAX : U_INT64_MIN;

             }

         } else {

             return (int64_t)fValue.fDouble;

         } 

     case Formattable::kObject:

         if (fValue.fObject == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             return 0;

         }

         if (instanceOfMeasure(fValue.fObject)) {

             return ((const Measure*) fValue.fObject)->

                 getNumber().getInt64(status);

         }

     default: 

         status = U_INVALID_FORMAT_ERROR;

         return 0;

     }

 }

 // -------------------------------------

 double

 Formattable::getDouble(UErrorCode& status) const

 {

     if (U_FAILURE(status)) {

         return 0;

     }

     switch (fType) {

     case Formattable::kLong: 

     case Formattable::kInt64: // loses precision

         return (double)fValue.fInt64;

     case Formattable::kDouble:

         return fValue.fDouble;

     case Formattable::kObject:

         if (fValue.fObject == NULL) {

             status = U_MEMORY_ALLOCATION_ERROR;

             return 0;

         }

         // TODO Later replace this with instanceof call

         if (instanceOfMeasure(fValue.fObject)) {

             return ((const Measure*) fValue.fObject)->

                 getNumber().getDouble(status);

         }

     default: 

         status = U_INVALID_FORMAT_ERROR;

         return 0;

     }

 }

 const UObject*

 Formattable::getObject() const {

     return (fType == kObject) ? fValue.fObject : NULL;

 }

 // -------------------------------------

 // Sets the value to a double value d.

 void

 Formattable::setDouble(double d)

 {

     dispose();

     fType = kDouble;

     fValue.fDouble = d;

 }

 // -------------------------------------

 // Sets the value to a long value l.

 void

 Formattable::setLong(int32_t l)

 {

     dispose();

     fType = kLong;

     fValue.fInt64 = l;

 }

 // -------------------------------------

 // Sets the value to an int64 value ll.

 void

 Formattable::setInt64(int64_t ll)

 {

     dispose();

     fType = kInt64;

     fValue.fInt64 = ll;

 }

 // -------------------------------------

 // Sets the value to a Date instance d.

 void

 Formattable::setDate(UDate d)

 {

     dispose();

     fType = kDate;

     fValue.fDate = d;

 }

 // -------------------------------------

 // Sets the value to a string value stringToCopy.

 void

 Formattable::setString(const UnicodeString& stringToCopy)

 {

     dispose();

     fType = kString;

     fValue.fString = new UnicodeString(stringToCopy);

 }

 // -------------------------------------

 // Sets the value to an array of Formattable objects.

 void

 Formattable::setArray(const Formattable* array, int32_t count)

 {

     dispose();

     fType = kArray;

     fValue.fArrayAndCount.fArray = createArrayCopy(array, count);

     fValue.fArrayAndCount.fCount = count;

 }

 // -------------------------------------

 // Adopts the stringToAdopt value.

 void

 Formattable::adoptString(UnicodeString* stringToAdopt)

 {

     dispose();

     fType = kString;

     fValue.fString = stringToAdopt;

 }

 // -------------------------------------

 // Adopts the array value and its count.

 void

 Formattable::adoptArray(Formattable* array, int32_t count)

 {

     dispose();

     fType = kArray;

     fValue.fArrayAndCount.fArray = array;

     fValue.fArrayAndCount.fCount = count;

 }

 void

 Formattable::adoptObject(UObject* objectToAdopt) {

     dispose();

     fType = kObject;

     fValue.fObject = objectToAdopt;

 }

 // -------------------------------------

 UnicodeString& 

 Formattable::getString(UnicodeString& result, UErrorCode& status) const 

 {

     if (fType != kString) {

         setError(status, U_INVALID_FORMAT_ERROR);

         result.setToBogus();

     } else {

         if (fValue.fString == NULL) {

             setError(status, U_MEMORY_ALLOCATION_ERROR);

         } else {

             result = *fValue.fString;

         }

     }

     return result;

 }

 // -------------------------------------

 const UnicodeString& 

 Formattable::getString(UErrorCode& status) const 

 {

     if (fType != kString) {

         setError(status, U_INVALID_FORMAT_ERROR);

         return *getBogus();

     }

     if (fValue.fString == NULL) {

         setError(status, U_MEMORY_ALLOCATION_ERROR);

         return *getBogus();

     }

     return *fValue.fString;

 }

 // -------------------------------------

 UnicodeString& 

 Formattable::getString(UErrorCode& status) 

 {

     if (fType != kString) {

         setError(status, U_INVALID_FORMAT_ERROR);

         return *getBogus();

     }

     if (fValue.fString == NULL) {

     	setError(status, U_MEMORY_ALLOCATION_ERROR);

     	return *getBogus();

     }

     return *fValue.fString;

 }

 // -------------------------------------

 const Formattable* 

 Formattable::getArray(int32_t& count, UErrorCode& status) const 

 {

     if (fType != kArray) {

         setError(status, U_INVALID_FORMAT_ERROR);

         count = 0;

         return NULL;

     }

     count = fValue.fArrayAndCount.fCount; 

     return fValue.fArrayAndCount.fArray;

 }

 // -------------------------------------

 // Gets the bogus string, ensures mondo bogosity.

 UnicodeString*

 Formattable::getBogus() const 

 {

     return (UnicodeString*)&fBogus; /* cast away const :-( */

 }

 // --------------------------------------

 StringPiece Formattable::getDecimalNumber(UErrorCode &status) {

     if (U_FAILURE(status)) {

         return "";

     }

     if (fDecimalStr != NULL) {

       return fDecimalStr->toStringPiece();

     }

     CharString *decimalStr = internalGetCharString(status);

     if(decimalStr == NULL) {

       return ""; // getDecimalNumber returns "" for error cases

     } else {

       return decimalStr->toStringPiece();

     }

 }

 CharString *Formattable::internalGetCharString(UErrorCode &status) {

     if(fDecimalStr == NULL) {

       if (fDecimalNum == NULL) {

         // No decimal number for the formattable yet.  Which means the value was

         // set directly by the user as an int, int64 or double.  If the value came

         // from parsing, or from the user setting a decimal number, fDecimalNum

         // would already be set.

         //

         fDecimalNum = new DigitList; // TODO: use internal digit list

         if (fDecimalNum == NULL) {

           status = U_MEMORY_ALLOCATION_ERROR;

           return NULL;

         }

         switch (fType) {

         case kDouble:

           fDecimalNum->set(this->getDouble());

           break;

         case kLong:

           fDecimalNum->set(this->getLong());

           break;

         case kInt64:

           fDecimalNum->set(this->getInt64());

           break;

         default:

           // The formattable's value is not a numeric type.

           status = U_INVALID_STATE_ERROR;

           return NULL;

         }

       }

       fDecimalStr = new CharString;

       if (fDecimalStr == NULL) {

         status = U_MEMORY_ALLOCATION_ERROR;

         return NULL;

       }

       fDecimalNum->getDecimal(*fDecimalStr, status);

     }

     return fDecimalStr;

 }

 DigitList *

 Formattable::getInternalDigitList() {

   FmtStackData *stackData = (FmtStackData*)fStackData;

   if(fDecimalNum != &(stackData->stackDecimalNum)) {

     delete fDecimalNum;

     fDecimalNum = new (&(stackData->stackDecimalNum), kOnStack) DigitList();

   } else {

     fDecimalNum->clear();

   }

   return fDecimalNum;

 }

 // ---------------------------------------

 void

 Formattable::adoptDigitList(DigitList *dl) {

   if(fDecimalNum==dl) {

     fDecimalNum = NULL; // don't delete

   }

   dispose();

   fDecimalNum = dl;

   if(dl==NULL) { // allow adoptDigitList(NULL) to clear

     return;

   }

     // Set the value into the Union of simple type values.

     // Cannot use the set() functions because they would delete the fDecimalNum value,

     if (fDecimalNum->fitsIntoLong(FALSE)) {

         fType = kLong;

         fValue.fInt64 = fDecimalNum->getLong();

     } else if (fDecimalNum->fitsIntoInt64(FALSE)) {

         fType = kInt64;

         fValue.fInt64 = fDecimalNum->getInt64();

     } else {

         fType = kDouble;

         fValue.fDouble = fDecimalNum->getDouble();

     }

 }

 // ---------------------------------------

 void

 Formattable::setDecimalNumber(const StringPiece &numberString, UErrorCode &status) {

     if (U_FAILURE(status)) {

         return;

     }

     dispose();

     // Copy the input string and nul-terminate it.

     //    The decNumber library requires nul-terminated input.  StringPiece input

     //    is not guaranteed nul-terminated.  Too bad.

     //    CharString automatically adds the nul.

     DigitList *dnum = new DigitList(); // TODO: use getInternalDigitList

     if (dnum == NULL) {

         status = U_MEMORY_ALLOCATION_ERROR;

         return;

     }

     dnum->set(CharString(numberString, status).toStringPiece(), status);

     if (U_FAILURE(status)) {

         delete dnum;

         return;   // String didn't contain a decimal number.

     }

     adoptDigitList(dnum);

     // Note that we do not hang on to the caller's input string.

     // If we are asked for the string, we will regenerate one from fDecimalNum.

 }

 #if 0

 //----------------------------------------------------

 // console I/O

 //----------------------------------------------------

 #ifdef _DEBUG

 #include <iostream>

 using namespace std;

 #include "unicode/datefmt.h"

 #include "unistrm.h"

 class FormattableStreamer /* not : public UObject because all methods are static */ {

 public:

     static void streamOut(ostream& stream, const Formattable& obj);

 private:

     FormattableStreamer() {} // private - forbid instantiation

 };

 // This is for debugging purposes only.  This will send a displayable

 // form of the Formattable object to the output stream.

 void

 FormattableStreamer::streamOut(ostream& stream, const Formattable& obj)

 {

     static DateFormat *defDateFormat = 0;

     UnicodeString buffer;

     switch(obj.getType()) {

         case Formattable::kDate : 

             // Creates a DateFormat instance for formatting the

             // Date instance.

             if (defDateFormat == 0) {

                 defDateFormat = DateFormat::createInstance();

             }

             defDateFormat->format(obj.getDate(), buffer);

             stream << buffer;

             break;

         case Formattable::kDouble :

             // Output the double as is.

             stream << obj.getDouble() << 'D';

             break;

         case Formattable::kLong :

             // Output the double as is.

             stream << obj.getLong() << 'L';

             break;

         case Formattable::kString:

             // Output the double as is.  Please see UnicodeString console

             // I/O routine for more details.

             stream << '"' << obj.getString(buffer) << '"';

             break;

         case Formattable::kArray:

             int32_t i, count;

             const Formattable* array;

             array = obj.getArray(count);

             stream << '[';

             // Recursively calling the console I/O routine for each element in the array.

             for (i=0; i<count; ++i) {

                 FormattableStreamer::streamOut(stream, array[i]);

                 stream << ( (i==(count-1)) ? "" : ", " );

             }

             stream << ']';

             break;

         default:

             // Not a recognizable Formattable object.

             stream << "INVALID_Formattable";

     }

     stream.flush();

 }

 #endif

 #endif

 U_NAMESPACE_END

 /* ---- UFormattable implementation ---- */

 U_NAMESPACE_USE

 U_DRAFT UFormattable* U_EXPORT2

 ufmt_open(UErrorCode *status) {

   if( U_FAILURE(*status) ) {

     return NULL;

   }

   UFormattable *fmt = (new Formattable())->toUFormattable();

   if( fmt == NULL ) {

     *status = U_MEMORY_ALLOCATION_ERROR;

   }

   return fmt;

 }

 U_DRAFT void U_EXPORT2

 ufmt_close(UFormattable *fmt) {

   Formattable *obj = Formattable::fromUFormattable(fmt);

   delete obj;

 }

 U_INTERNAL UFormattableType U_EXPORT2

 ufmt_getType(const UFormattable *fmt, UErrorCode *status) {

   if(U_FAILURE(*status)) {

     return (UFormattableType)UFMT_COUNT;

   }

   const Formattable *obj = Formattable::fromUFormattable(fmt);

   return (UFormattableType)obj->getType();

 }

 U_INTERNAL UBool U_EXPORT2

 ufmt_isNumeric(const UFormattable *fmt) {

   const Formattable *obj = Formattable::fromUFormattable(fmt);

   return obj->isNumeric();

 }

 U_DRAFT UDate U_EXPORT2

 ufmt_getDate(const UFormattable *fmt, UErrorCode *status) {

   const Formattable *obj = Formattable::fromUFormattable(fmt);

   return obj->getDate(*status);

 }

 U_DRAFT double U_EXPORT2

 ufmt_getDouble(UFormattable *fmt, UErrorCode *status) {

   Formattable *obj = Formattable::fromUFormattable(fmt);

   return obj->getDouble(*status);

 }

 U_DRAFT int32_t U_EXPORT2

 ufmt_getLong(UFormattable *fmt, UErrorCode *status) {

   Formattable *obj = Formattable::fromUFormattable(fmt);

   return obj->getLong(*status);

 }

 U_DRAFT const void *U_EXPORT2

 ufmt_getObject(const UFormattable *fmt, UErrorCode *status) {

   const Formattable *obj = Formattable::fromUFormattable(fmt);

   const void *ret = obj->getObject();

   if( ret==NULL &&

       (obj->getType() != Formattable::kObject) &&

       U_SUCCESS( *status )) {

     *status = U_INVALID_FORMAT_ERROR;

   }

   return ret;

 }

 U_DRAFT const UChar* U_EXPORT2

 ufmt_getUChars(UFormattable *fmt, int32_t *len, UErrorCode *status) {

   Formattable *obj = Formattable::fromUFormattable(fmt);

   // avoid bogosity by checking the type first.

   if( obj->getType() != Formattable::kString ) {

     if( U_SUCCESS(*status) ){

       *status = U_INVALID_FORMAT_ERROR;

     }

     return NULL;

   }

   // This should return a valid string

   UnicodeString &str = obj->getString(*status);

   if( U_SUCCESS(*status) && len != NULL ) {

     *len = str.length();

   }

   return str.getTerminatedBuffer();

 }

 U_DRAFT int32_t U_EXPORT2

 ufmt_getArrayLength(const UFormattable* fmt, UErrorCode *status) {

   const Formattable *obj = Formattable::fromUFormattable(fmt);

   int32_t count;

   (void)obj->getArray(count, *status);

   return count;

 }

 U_DRAFT UFormattable * U_EXPORT2

 ufmt_getArrayItemByIndex(UFormattable* fmt, int32_t n, UErrorCode *status) {

   Formattable *obj = Formattable::fromUFormattable(fmt);

   int32_t count;

   (void)obj->getArray(count, *status);

   if(U_FAILURE(*status)) {

     return NULL;

   } else if(n<0 || n>=count) {

     setError(*status, U_INDEX_OUTOFBOUNDS_ERROR);

     return NULL;

   } else {

     return (*obj)[n].toUFormattable(); // returns non-const Formattable

   }

 }

 U_DRAFT const char * U_EXPORT2

 ufmt_getDecNumChars(UFormattable *fmt, int32_t *len, UErrorCode *status) {

   if(U_FAILURE(*status)) {

     return "";

   }

   Formattable *obj = Formattable::fromUFormattable(fmt);

   CharString *charString = obj->internalGetCharString(*status);

   if(U_FAILURE(*status)) {

     return "";

   }

   if(charString == NULL) {

     *status = U_MEMORY_ALLOCATION_ERROR;

     return "";

   } else {

     if(len!=NULL) {

       *len = charString->length();

     }

     return charString->data();

   }

 }

 U_DRAFT int64_t U_EXPORT2

 ufmt_getInt64(UFormattable *fmt, UErrorCode *status) {

   Formattable *obj = Formattable::fromUFormattable(fmt);

   return obj->getInt64(*status);

 }

 #endif /* #if !UCONFIG_NO_FORMATTING */

 //eof