[apple/icu.git] / icuSources / i18n / uatimeunitformat.cpp

/*
*****************************************************************************************
* Copyright (C) 2014-2015 Apple Inc. All Rights Reserved.
*****************************************************************************************
*/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/uatimeunitformat.h"
#include "unicode/fieldpos.h"
#include "unicode/localpointer.h"
#include "unicode/numfmt.h"
#include "unicode/measunit.h"
#include "unicode/measure.h"
#include "unicode/measfmt.h"
#include "unicode/unistr.h"
#include "unicode/unum.h"
#include "unicode/ures.h"
#include "unicode/ustring.h"
#include "ureslocs.h"
#include "uresimp.h"
#include "ustr_imp.h"

U_NAMESPACE_USE


U_CAPI UATimeUnitFormat* U_EXPORT2
uatmufmt_open(const char*  locale,
              UATimeUnitStyle style,
              UErrorCode*  status)
{
    return uatmufmt_openWithNumberFormat(locale, style, NULL, status);
}


U_CAPI UATimeUnitFormat* U_EXPORT2
uatmufmt_openWithNumberFormat(const char*  locale,
                            UATimeUnitStyle style,
                            UNumberFormat*  nfToAdopt,
                            UErrorCode*  status)
{
    if (U_FAILURE(*status)) {
        return NULL;
    }
    UMeasureFormatWidth mfWidth = UMEASFMT_WIDTH_WIDE;
    switch (style) {
        case UATIMEUNITSTYLE_FULL:
            break;
        case UATIMEUNITSTYLE_ABBREVIATED:
            mfWidth = UMEASFMT_WIDTH_SHORT; break;
        case UATIMEUNITSTYLE_NARROW:
            mfWidth = UMEASFMT_WIDTH_NARROW; break;
        case UATIMEUNITSTYLE_SHORTER:
            mfWidth = UMEASFMT_WIDTH_SHORTER; break;
        default:
            *status = U_ILLEGAL_ARGUMENT_ERROR; return NULL;
    }
    LocalPointer<MeasureFormat> mfmt( new MeasureFormat(Locale(locale), mfWidth, (NumberFormat*)nfToAdopt, *status) );
    if (U_FAILURE(*status)) {
        return NULL;
    }
    return (UATimeUnitFormat*)mfmt.orphan();
}


U_CAPI void U_EXPORT2
uatmufmt_close(UATimeUnitFormat *mfmt)
{
    delete (MeasureFormat*)mfmt;
}


U_CAPI void U_EXPORT2
uatmufmt_setNumberFormat(UATimeUnitFormat* mfmt,
                        UNumberFormat*  numfmt,
                        UErrorCode*     status)
{
    if (U_FAILURE(*status)) {
        return;
    }
    ((MeasureFormat*)mfmt)->adoptNumberFormat( (NumberFormat*)(((NumberFormat*)numfmt)->clone()), *status );
}


U_CAPI int32_t U_EXPORT2
uatmufmt_format(const UATimeUnitFormat* mfmt,
                double          value,
                UATimeUnitField field,
                UChar*          result,
                int32_t         resultCapacity,
                UErrorCode*     status)
{
    if (U_FAILURE(*status)) {
        return 0;
    }
    if ( ((result==NULL)? resultCapacity!=0: resultCapacity<0) ) {
        *status = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    MeasureUnit * munit = NULL;
    switch (field) {
        case UATIMEUNITFIELD_YEAR:    munit = MeasureUnit::createYear(*status);    break;
        case UATIMEUNITFIELD_MONTH:   munit = MeasureUnit::createMonth(*status);   break;
        case UATIMEUNITFIELD_DAY:     munit = MeasureUnit::createDay(*status);     break;
        case UATIMEUNITFIELD_WEEK:    munit = MeasureUnit::createWeek(*status);    break;
        case UATIMEUNITFIELD_HOUR:    munit = MeasureUnit::createHour(*status);    break;
        case UATIMEUNITFIELD_MINUTE:  munit = MeasureUnit::createMinute(*status);  break;
        case UATIMEUNITFIELD_SECOND:  munit = MeasureUnit::createSecond(*status);  break;
        case UATIMEUNITFIELD_MILLISECOND: munit = MeasureUnit::createMillisecond(*status); break;
        case UATIMEUNITFIELD_MICROSECOND: munit = MeasureUnit::createMicrosecond(*status); break;
        case UATIMEUNITFIELD_NANOSECOND:  munit = MeasureUnit::createNanosecond(*status);  break;
        default: *status = U_ILLEGAL_ARGUMENT_ERROR; break;
    }
    if (U_FAILURE(*status)) {
        return 0;
    }
    LocalPointer<Measure> meas(new Measure(value, munit, *status));
    if (U_FAILURE(*status)) {
        return 0;
    }
    Formattable fmt;
    fmt.adoptObject(meas.orphan());
    UnicodeString res;
    res.setTo(result, 0, resultCapacity);
    FieldPosition pos(0);
    ((MeasureFormat*)mfmt)->format(fmt, res, pos, *status);
    return res.extract(result, resultCapacity, *status);
}


U_CAPI double U_EXPORT2
uatmufmt_parse( const UATimeUnitFormat*,
                const UChar*,
                int32_t,
                int32_t*,
                UATimeUnitField*,
                UErrorCode*     status)
{
    if (!U_FAILURE(*status)) {
        *status = U_UNSUPPORTED_ERROR;
    }
    return 0.0;
}


U_CAPI int32_t U_EXPORT2
uatmufmt_getTimePattern(const char*     locale,
                        UATimeUnitTimePattern type,
                        UChar*          result,
                        int32_t         resultCapacity,
                        UErrorCode*     status)
{
    if (U_FAILURE(*status)) {
        return 0;
    }
    if ( (result==NULL)? resultCapacity!=0: resultCapacity<0 ) {
        *status = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    const char* key = NULL;
    switch (type) {
        case UATIMEUNITTIMEPAT_HM:  { key = "hm"; break; }
        case UATIMEUNITTIMEPAT_HMS: { key = "hms"; break; }
        case UATIMEUNITTIMEPAT_MS:  { key = "ms"; break; }
        default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
    }
    int32_t resLen = 0;
    const UChar* resPtr = NULL;
    UResourceBundle* rb =  ures_open(U_ICUDATA_UNIT, locale, status);
    rb = ures_getByKeyWithFallback(rb, "durationUnits", rb, status);
    resPtr = ures_getStringByKeyWithFallback(rb, key, &resLen, status);
    if (U_SUCCESS(*status)) {
        u_strncpy(result, resPtr, resultCapacity);
    }
    ures_close(rb);
    return u_terminateUChars(result, resultCapacity, resLen, status);
}


U_CAPI int32_t U_EXPORT2
uatmufmt_getListPattern(const char*     locale,
                        UATimeUnitStyle style,
                        UATimeUnitListPattern type,
                        UChar*          result,
                        int32_t         resultCapacity,
                        UErrorCode*     status)
{
    if (U_FAILURE(*status)) {
        return 0;
    }
    if ( (result==NULL)? resultCapacity!=0: resultCapacity<0 ) {
        *status = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    const char* styleKey = NULL;
    switch (style) {
        case UATIMEUNITSTYLE_FULL:          { styleKey = "unit"; break; }
        case UATIMEUNITSTYLE_ABBREVIATED:   { styleKey = "unit-short"; break; }
        case UATIMEUNITSTYLE_NARROW:        { styleKey = "unit-narrow"; break; }
        case UATIMEUNITSTYLE_SHORTER:       { styleKey = "unit-narrow"; break; }
        default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
    }
    const char* typeKey = NULL;
    switch (type) {
        case UATIMEUNITLISTPAT_TWO_ONLY:        { typeKey = "2"; break; }
        case UATIMEUNITLISTPAT_END_PIECE:       { typeKey = "end"; break; }
        case UATIMEUNITLISTPAT_MIDDLE_PIECE:    { typeKey = "middle"; break; }
        case UATIMEUNITLISTPAT_START_PIECE:     { typeKey = "start"; break; }
        default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
    }
    int32_t resLen = 0;
    const UChar* resPtr = NULL;
    UResourceBundle* rb =  ures_open(NULL, locale, status);
    rb = ures_getByKeyWithFallback(rb, "listPattern", rb, status);
    rb = ures_getByKeyWithFallback(rb, styleKey, rb, status);
    resPtr = ures_getStringByKeyWithFallback(rb, typeKey, &resLen, status);
    if (U_SUCCESS(*status)) {
        u_strncpy(result, resPtr, resultCapacity);
    }
    ures_close(rb);
    return u_terminateUChars(result, resultCapacity, resLen, status);
}


#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
57a6839d A	1	/*
57a6839d A	2	*****************************************************************************************
b331163b	3	* Copyright (C) 2014-2015 Apple Inc. All Rights Reserved.
57a6839d A	4	*****************************************************************************************
	5	*/
	6
	7	#include "unicode/utypes.h"
	8
	9	#if !UCONFIG_NO_FORMATTING
	10
	11	#include "unicode/uatimeunitformat.h"
	12	#include "unicode/fieldpos.h"
	13	#include "unicode/localpointer.h"
	14	#include "unicode/numfmt.h"
	15	#include "unicode/measunit.h"
	16	#include "unicode/measure.h"
	17	#include "unicode/measfmt.h"
	18	#include "unicode/unistr.h"
	19	#include "unicode/unum.h"
	20	#include "unicode/ures.h"
f3c0d7a5	21	#include "unicode/ustring.h"
b331163b	22	#include "ureslocs.h"
57a6839d A	23	#include "uresimp.h"
	24	#include "ustr_imp.h"
	25
	26	U_NAMESPACE_USE
	27
	28
	29	U_CAPI UATimeUnitFormat* U_EXPORT2
	30	uatmufmt_open(const char* locale,
	31	UATimeUnitStyle style,
	32	UErrorCode* status)
	33	{
	34	return uatmufmt_openWithNumberFormat(locale, style, NULL, status);
	35	}
	36
	37
	38	U_CAPI UATimeUnitFormat* U_EXPORT2
	39	uatmufmt_openWithNumberFormat(const char* locale,
	40	UATimeUnitStyle style,
	41	UNumberFormat* nfToAdopt,
	42	UErrorCode* status)
	43	{
	44	if (U_FAILURE(*status)) {
	45	return NULL;
	46	}
	47	UMeasureFormatWidth mfWidth = UMEASFMT_WIDTH_WIDE;
	48	switch (style) {
	49	case UATIMEUNITSTYLE_FULL:
	50	break;
	51	case UATIMEUNITSTYLE_ABBREVIATED:
	52	mfWidth = UMEASFMT_WIDTH_SHORT; break;
	53	case UATIMEUNITSTYLE_NARROW:
	54	mfWidth = UMEASFMT_WIDTH_NARROW; break;
2ca993e8 A	55	case UATIMEUNITSTYLE_SHORTER:
2ca993e8 A	56	mfWidth = UMEASFMT_WIDTH_SHORTER; break;
57a6839d A	57	default:
	58	*status = U_ILLEGAL_ARGUMENT_ERROR; return NULL;
	59	}
	60	LocalPointer<MeasureFormat> mfmt( new MeasureFormat(Locale(locale), mfWidth, (NumberFormat)nfToAdopt, status) );
	61	if (U_FAILURE(*status)) {
	62	return NULL;
	63	}
	64	return (UATimeUnitFormat*)mfmt.orphan();
	65	}
	66
	67
	68	U_CAPI void U_EXPORT2
	69	uatmufmt_close(UATimeUnitFormat *mfmt)
	70	{
	71	delete (MeasureFormat*)mfmt;
	72	}
	73
	74
	75	U_CAPI void U_EXPORT2
	76	uatmufmt_setNumberFormat(UATimeUnitFormat* mfmt,
	77	UNumberFormat* numfmt,
	78	UErrorCode* status)
	79	{
	80	if (U_FAILURE(*status)) {
	81	return;
	82	}
	83	((MeasureFormat)mfmt)->adoptNumberFormat( (NumberFormat)(((NumberFormat)numfmt)->clone()), status );
	84	}
	85
	86
	87	U_CAPI int32_t U_EXPORT2
	88	uatmufmt_format(const UATimeUnitFormat* mfmt,
	89	double value,
	90	UATimeUnitField field,
	91	UChar* result,
	92	int32_t resultCapacity,
	93	UErrorCode* status)
	94	{
	95	if (U_FAILURE(*status)) {
	96	return 0;
	97	}
	98	if ( ((result==NULL)? resultCapacity!=0: resultCapacity<0) ) {
	99	*status = U_ILLEGAL_ARGUMENT_ERROR;
	100	return 0;
	101	}
	102	MeasureUnit * munit = NULL;
	103	switch (field) {
	104	case UATIMEUNITFIELD_YEAR: munit = MeasureUnit::createYear(*status); break;
	105	case UATIMEUNITFIELD_MONTH: munit = MeasureUnit::createMonth(*status); break;
	106	case UATIMEUNITFIELD_DAY: munit = MeasureUnit::createDay(*status); break;
	107	case UATIMEUNITFIELD_WEEK: munit = MeasureUnit::createWeek(*status); break;
	108	case UATIMEUNITFIELD_HOUR: munit = MeasureUnit::createHour(*status); break;
	109	case UATIMEUNITFIELD_MINUTE: munit = MeasureUnit::createMinute(*status); break;
	110	case UATIMEUNITFIELD_SECOND: munit = MeasureUnit::createSecond(*status); break;
3d1f044b A	111	case UATIMEUNITFIELD_MILLISECOND: munit = MeasureUnit::createMillisecond(*status); break;
	112	case UATIMEUNITFIELD_MICROSECOND: munit = MeasureUnit::createMicrosecond(*status); break;
	113	case UATIMEUNITFIELD_NANOSECOND: munit = MeasureUnit::createNanosecond(*status); break;
57a6839d A	114	default: *status = U_ILLEGAL_ARGUMENT_ERROR; break;
	115	}
	116	if (U_FAILURE(*status)) {
	117	return 0;
	118	}
	119	LocalPointer<Measure> meas(new Measure(value, munit, *status));
	120	if (U_FAILURE(*status)) {
	121	return 0;
	122	}
	123	Formattable fmt;
	124	fmt.adoptObject(meas.orphan());
	125	UnicodeString res;
	126	res.setTo(result, 0, resultCapacity);
	127	FieldPosition pos(0);
	128	((MeasureFormat)mfmt)->format(fmt, res, pos, status);
	129	return res.extract(result, resultCapacity, *status);
	130	}
	131
	132
	133	U_CAPI double U_EXPORT2
3d1f044b A	134	uatmufmt_parse( const UATimeUnitFormat*,
	135	const UChar*,
	136	int32_t,
	137	int32_t*,
	138	UATimeUnitField*,
57a6839d A	139	UErrorCode* status)
57a6839d A	140	{
3d1f044b A	141	if (!U_FAILURE(*status)) {
3d1f044b A	142	*status = U_UNSUPPORTED_ERROR;
57a6839d	143	}
3d1f044b	144	return 0.0;
57a6839d A	145	}
	146
	147
	148	U_CAPI int32_t U_EXPORT2
	149	uatmufmt_getTimePattern(const char* locale,
	150	UATimeUnitTimePattern type,
	151	UChar* result,
	152	int32_t resultCapacity,
	153	UErrorCode* status)
	154	{
	155	if (U_FAILURE(*status)) {
	156	return 0;
	157	}
	158	if ( (result==NULL)? resultCapacity!=0: resultCapacity<0 ) {
	159	*status = U_ILLEGAL_ARGUMENT_ERROR;
	160	return 0;
	161	}
	162	const char* key = NULL;
	163	switch (type) {
	164	case UATIMEUNITTIMEPAT_HM: { key = "hm"; break; }
	165	case UATIMEUNITTIMEPAT_HMS: { key = "hms"; break; }
	166	case UATIMEUNITTIMEPAT_MS: { key = "ms"; break; }
	167	default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
	168	}
	169	int32_t resLen = 0;
	170	const UChar* resPtr = NULL;
b331163b	171	UResourceBundle* rb = ures_open(U_ICUDATA_UNIT, locale, status);
57a6839d A	172	rb = ures_getByKeyWithFallback(rb, "durationUnits", rb, status);
	173	resPtr = ures_getStringByKeyWithFallback(rb, key, &resLen, status);
	174	if (U_SUCCESS(*status)) {
	175	u_strncpy(result, resPtr, resultCapacity);
	176	}
	177	ures_close(rb);
	178	return u_terminateUChars(result, resultCapacity, resLen, status);
	179	}
	180
	181
	182	U_CAPI int32_t U_EXPORT2
	183	uatmufmt_getListPattern(const char* locale,
	184	UATimeUnitStyle style,
	185	UATimeUnitListPattern type,
	186	UChar* result,
	187	int32_t resultCapacity,
	188	UErrorCode* status)
	189	{
	190	if (U_FAILURE(*status)) {
	191	return 0;
	192	}
	193	if ( (result==NULL)? resultCapacity!=0: resultCapacity<0 ) {
	194	*status = U_ILLEGAL_ARGUMENT_ERROR;
	195	return 0;
	196	}
	197	const char* styleKey = NULL;
	198	switch (style) {
	199	case UATIMEUNITSTYLE_FULL: { styleKey = "unit"; break; }
	200	case UATIMEUNITSTYLE_ABBREVIATED: { styleKey = "unit-short"; break; }
	201	case UATIMEUNITSTYLE_NARROW: { styleKey = "unit-narrow"; break; }
2ca993e8	202	case UATIMEUNITSTYLE_SHORTER: { styleKey = "unit-narrow"; break; }
57a6839d A	203	default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
	204	}
	205	const char* typeKey = NULL;
	206	switch (type) {
	207	case UATIMEUNITLISTPAT_TWO_ONLY: { typeKey = "2"; break; }
	208	case UATIMEUNITLISTPAT_END_PIECE: { typeKey = "end"; break; }
	209	case UATIMEUNITLISTPAT_MIDDLE_PIECE: { typeKey = "middle"; break; }
	210	case UATIMEUNITLISTPAT_START_PIECE: { typeKey = "start"; break; }
	211	default: { *status = U_ILLEGAL_ARGUMENT_ERROR; return 0; }
	212	}
	213	int32_t resLen = 0;
	214	const UChar* resPtr = NULL;
	215	UResourceBundle* rb = ures_open(NULL, locale, status);
	216	rb = ures_getByKeyWithFallback(rb, "listPattern", rb, status);
	217	rb = ures_getByKeyWithFallback(rb, styleKey, rb, status);
	218	resPtr = ures_getStringByKeyWithFallback(rb, typeKey, &resLen, status);
	219	if (U_SUCCESS(*status)) {
	220	u_strncpy(result, resPtr, resultCapacity);
	221	}
	222	ures_close(rb);
	223	return u_terminateUChars(result, resultCapacity, resLen, status);
	224	}
	225
	226
	227	#endif /* #if !UCONFIG_NO_FORMATTING */