Lines Matching +full:is +full:- +full:generator +full:- +full:function
6 * Copyright (C) 2007-2015, International Business Machines
11 * encoding: UTF-8
35 * like "yy-MM-dd". The user can build up the generator by adding successive
36 * patterns. Once that is done, a query can be made using a "skeleton", which is
37 * a pattern which just includes the desired fields and lengths. The generator
39 * <p>The main method people will use is udatpg_getBestPattern, since normally
40 * UDateTimePatternGenerator is pre-built with data from a particular locale.
42 * <p><i>Issue: may be useful to also have a function that returns the list of
48 * Opaque type for a date/time pattern generator object.
56 * because some fields are merged for the date/time pattern generator.
94 * it is needed for layout of DateTimePatternGenerator object. */
136 UDATPG_MATCH_ALL_FIELDS_LENGTH = (1 << UDATPG_FIELD_COUNT) - 1
160 * Open a generator according to a given locale.
163 * failure before the function call.
171 * Open an empty generator, to be constructed with udatpg_addPattern(...) etc.
173 * failure before the function call.
181 * Close a generator.
208 * Create a copy pf a generator.
211 * failure before the function call.
219 * Get the best pattern matching the input skeleton. It is guaranteed to
222 * Note that this function uses a non-const UDateTimePatternGenerator:
223 * It uses a stateful pattern parser which is set up for each generator object,
224 * rather than creating one for each function call.
225 * Consecutive calls to this function do not affect each other,
226 * but this function cannot be used concurrently on a single generator object.
230 * The skeleton is a pattern containing only the variable fields.
237 * failure before the function call.
248 * Get the best pattern matching the input skeleton. It is guaranteed to
251 * Note that this function uses a non-const UDateTimePatternGenerator:
252 * It uses a stateful pattern parser which is set up for each generator object,
253 * rather than creating one for each function call.
254 * Consecutive calls to this function do not affect each other,
255 * but this function cannot be used concurrently on a single generator object.
259 * The skeleton is a pattern containing only the variable fields.
273 * failure before the function call.
286 * both "MMM-dd" and "dd/MMM" produce the skeleton "MMMdd".
288 * Note that this function uses a non-const UDateTimePatternGenerator:
289 * It uses a stateful pattern parser which is set up for each generator object,
290 * rather than creating one for each function call.
291 * Consecutive calls to this function do not affect each other,
292 * but this function cannot be used concurrently on a single generator object.
295 * This parameter is no longer used. Callers may pass NULL.
301 * failure before the function call.
312 * Get a unique base skeleton from a given pattern. This is the same
315 * for example, both "MMM-dd" and "d/MMM" produce the skeleton "MMMd"
318 * Note that this function uses a non-const UDateTimePatternGenerator:
319 * It uses a stateful pattern parser which is set up for each generator object,
320 * rather than creating one for each function call.
321 * Consecutive calls to this function do not affect each other,
322 * but this function cannot be used concurrently on a single generator object.
325 * This parameter is no longer used. Callers may pass NULL.
331 * failure before the function call.
342 * Adds a pattern to the generator. If the pattern has the same skeleton as
343 * an existing pattern, and the override parameter is set, then the previous
344 * value is overridden. Otherwise, the previous value is retained. In either
345 * case, the conflicting status is set and previous vale is stored in
348 * Note that single-field patterns (like "MMM") are automatically added, and
360 * failure before the function call.
373 * An AppendItem format is a pattern used to append a field if there is no
374 * good match. For example, suppose that the input skeleton is "GyyyyMMMd",
375 * and there is no matching pattern internally, but there is a pattern
376 * matching "yyyyMMMd", say "d-MM-yyyy". Then that pattern is used, plus the
377 * G. The way these two are conjoined is by using the AppendItemFormat for G
378 * (era). So if that value is, say "{0}, {1}" then the final resulting
379 * pattern is "d-MM-yyyy, G".
381 * There are actually three available variables: {0} is the pattern so far,
382 * {1} is the element we are adding, and {2} is the name of the element.
384 * This reflects the way that the CLDR data is organized.
414 * used if the corresponding AppendItemFormat is used, and if it contains a
417 * This reflects the way that the CLDR data is organized.
432 * UDATPG_FIELD_COUNT are illegal arguments. Note: The more general function
433 * for getting date/time field display names is udatpg_getFieldDisplayName.
459 * A pointer to a buffer to receive the NULL-terminated display name. If the name
460 * fits into fieldName but cannot be NULL-terminated (length == capacity) then
461 * the error code is set to U_STRING_NOT_TERMINATED_WARNING. If the name doesn't
462 * fit into fieldName then the error code is set to U_BUFFER_OVERFLOW_ERROR.
480 * The DateTimeFormat is a message format pattern used to compose date and
481 * time patterns. The default pattern in the root locale is "{1} {0}", where
486 * This is used when the input skeleton contains both date and time fields,
487 * but there is not a close match among the added patterns. For example,
488 * suppose that this object was created by adding "dd-MMM" and "hh:mm", and
489 * its DateTimeFormat is the default "{1} {0}". Then if the input skeleton
490 * is "MMMdhmm", there is not an exact match, so the input skeleton is
492 * for those two skeletons, so the result is put together with this pattern,
493 * resulting in "d-MMM h:mm".
533 * - UDAT_FULL (for date pattern with weekday and long month), else
534 * - UDAT_LONG (for a date pattern with long month), else
535 * - UDAT_MEDIUM (for a date pattern with abbreviated month), else
536 * - UDAT_SHORT (for any other date pattern).
538 * https://www.unicode.org/reports/tr35/tr35-dates.html#dateTimeFormats.
539 * The default pattern in the root locale for all styles is "{1} {0}".
548 * the length of dateTimeFormat, or -1 if unknown and pattern
549 * is null-terminated
552 * status is already set, it will be set according to result of the
553 * function (e.g. U_ILLEGAL_ARGUMENT_ERROR for style out of range).
571 * if length is not desired.
574 * status is already set, it will be set according to result of the
575 * function (e.g. U_ILLEGAL_ARGUMENT_ERROR for style out of range).
579 * may no longer be valid if udatpg_setDateTimeFormat is called, or
580 * udatpg_setDateTimeFormatForStyle for the same style is called, or the
581 * UDateTimePatternGenerator object is closed.
591 * The decimal value is used in formatting fractions of seconds. If the
592 * skeleton contains fractional seconds, then this is used with the
593 * fractional seconds. For example, suppose that the input pattern is
594 * "hhmmssSSSS", and the best matching pattern internally is "H:mm:ss", and
595 * the decimal string is ",". Then the resulting pattern is modified to be
620 * Adjusts the field types (width and subtype) of a pattern to match what is
621 * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
622 * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
623 * "dd-MMMM hh:mm". This is used internally to get the best match for the
626 * Note that this function uses a non-const UDateTimePatternGenerator:
627 * It uses a stateful pattern parser which is set up for each generator object,
628 * rather than creating one for each function call.
629 * Consecutive calls to this function do not affect each other,
630 * but this function cannot be used concurrently on a single generator object.
640 * failure before the function call.
652 * Adjusts the field types (width and subtype) of a pattern to match what is
653 * in a skeleton. That is, if you supply a pattern like "d-M H:m", and a
654 * skeleton of "MMMMddhhmm", then the input pattern is adjusted to be
655 * "dd-MMMM hh:mm". This is used internally to get the best match for the
658 * Note that this function uses a non-const UDateTimePatternGenerator:
659 * It uses a stateful pattern parser which is set up for each generator object,
660 * rather than creating one for each function call.
661 * Consecutive calls to this function do not affect each other,
662 * but this function cannot be used concurrently on a single generator object.
677 * failure before the function call.
695 * failure before the function call
708 * failure before the function call.
741 * failure before the function call. Set to U_UNSUPPORTED_ERROR