BloombergLP::bdlt::Iso8601Util::parse

parse overloads

Synopses

Declared in <bdlt_iso8601util.h>

Parse the specified ISO 8601 string as a bsls::TimeInterval value, and load the value into the specified result. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` <Parsed Duration> ` See "Summary of Supported ISO 8601 Duration Representations" for a complete description of this format.

static
int
parse(
    bsls::TimeInterval* result,
    std::string_view const& string);

Parse the specified ISO 8601 string as a Date value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DD{(+|‐)hh{:}mm|Z} Basic: YYYYMMDD{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If the optional zone designator is present in string, it is parsed but ignored. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    Date* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified ISO 8601 string as a Date or DateTz value, depending on the presence of a zone designator, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DD{(+|‐)hh{:}mm|Z} Basic: YYYYMMDD{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If the optional zone designator is present in the string, the input is parsed as a DateTz value, and as a Date value otherwise. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    DateOrDateTz* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified ISO 8601 string as a DateTz value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DD{(+|‐)hh{:}mm|Z} Basic: YYYYMMDD{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If the optional zone designator is not present in string, UTC is assumed. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    DateTz* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified ISO 8601 string as a Datetime value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DDThh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: YYYYMMDDThhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is present in string, the resulting Datetime value is converted to the equivalent UTC value; if the zone designator is absent, UTC is assumed. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    Datetime* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified ISO 8601 string as a Datetime or DatetimeTz value, depending on the presence of a zone designator, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DDThh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: YYYYMMDDThhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is present in the string, the input is parsed as a DatetimeTz value, and as a Datetime value otherwise. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    DatetimeOrDatetimeTz* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified ISO 8601 string as a DatetimeTz value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DDThh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: YYYYMMDDThhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is not present in string, UTC is assumed. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    DatetimeTz* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified ISO 8601 string as a Time value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: hh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: hhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is present in string, the resulting Time value is converted to the equivalent UTC time; if the zone designator is absent, UTC is assumed. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    Time* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a bsls::TimeInterval value, and load the value into the specified result. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` <Parsed Duration> ` See "Summary of Supported ISO 8601 Duration Representations" for a complete description of this format.

static
int
parse(
    bsls::TimeInterval* result,
    char const* string,
    ssize_t length);

Parse the specified ISO 8601 string as a Time or TimeTz value, depending on the presence of a zone designator, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: hh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: hhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is present in the string, the input is parsed as a TimeTz value, and as a Time value otherwise. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    TimeOrTimeTz* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified ISO 8601 string as a TimeTz value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: hh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: hhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly string.length() characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire string.length() characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is not present in string, UTC is assumed. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless string.data() is non‐null.

static
int
parse(
    TimeTz* result,
    std::string_view const& string,
    ParseConfiguration configuration = ParseConfiguration());

Parse the first length characters of ISO 8601 string as a Date.

static
int
parse(
    Date* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a Date or DateTz value, depending on the presence of a zone designator, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DD{(+|‐)hh{:}mm|Z} Basic: YYYYMMDD{(+|‐)hh{:}mm|Z} ` Exactly length characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire length characters do not. If the optional zone designator is present in the string, the input is parsed as a DateTz value, and as a Date value otherwise. The behavior is undefined unless 0 <= length.

static
int
parse(
    DateOrDateTz* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a DateTz value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DD{(+|‐)hh{:}mm|Z} Basic: YYYYMMDD{(+|‐)hh{:}mm|Z} ` Exactly length characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire length characters do not. If the optional zone designator is not present in string, UTC is assumed. The behavior is undefined unless 0 <= length.

static
int
parse(
    DateTz* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a Datetime value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DDThh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: YYYYMMDDThhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly length characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire length characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is present in string, the resulting Datetime value is converted to the equivalent UTC value; if the zone designator is absent, UTC is assumed. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless 0 <= length.

static
int
parse(
    Datetime* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a Datetime or DatetimeTz value, depending on the presence of a zone designator, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DDThh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: YYYYMMDDThhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly length characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire length characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is present in the string, the input is parsed as a DatetimeTz value, and as a Datetime value otherwise. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless 0 <= length.

static
int
parse(
    DatetimeOrDatetimeTz* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a DatetimeTz value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: YYYY‐MM‐DDThh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: YYYYMMDDThhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly length characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire length characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is not present in string, UTC is assumed. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless 0 <= length.

static
int
parse(
    DatetimeTz* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a Time value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: hh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: hhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly length characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire length characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is present in string, the resulting Time value is converted to the equivalent UTC time; if the zone designator is absent, UTC is assumed. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless 0 <= length.

static
int
parse(
    Time* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a Time or TimeTz value, depending on the presence of a zone designator, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: hh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: hhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly length characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire length characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is present in the string, the input is parsed as a TimeTz value, and as a Time value otherwise. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless 0 <= length.

static
int
parse(
    TimeOrTimeTz* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Parse the specified initial length characters of the specified ISO 8601 string as a TimeTz value, and load the value into the specified result, using the optionally specified configuration. Return 0 on success, and a non‐zero value (with no effect) otherwise. string is assumed to be of the form: ` Default: hh:mm:ss{(.|,)s+}{(+|‐)hh{:}mm|Z} Basic: hhmmss{(.|,)s+}{(+|‐)hh{:}mm|Z} ` Exactly length characters are parsed; parsing will fail if a proper prefix of string matches the expected format, but the entire length characters do not. If an optional fractional second having more than six digits is present in string, it is rounded to the nearest value in microseconds. If the optional zone designator is not present in string, UTC is assumed. If a leap second is detected (i.e., the parsed value of the second attribute is 60; see {Leap Seconds}), the second attribute is taken to be 59, then an additional second is added to result at the end. If the "hh:mm:ss" portion of string is "24:00:00", then the fractional second must be absent or 0, and the zone designator must be absent or indicate UTC. The behavior is undefined unless 0 <= length.

static
int
parse(
    TimeTz* result,
    char const* string,
    ssize_t length,
    ParseConfiguration configuration = ParseConfiguration());

Created with MrDocs