pub fn prop_attach<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], AttachProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, params, _)) =

        (tag_no_case("ATTACH"), cut(property_params), char(':')).parse(input)?;

    let is_base_64 = params.iter().any(|p| {

        matches!(

            p,

    });

    let is_binary = params.iter().any(|p| {

        matches!(

            p,

    });

    // Use OR here rather than AND. It's not valid to set one of these and not the other so assume the

    // value is more likely to be binary if one is set and let the error happen later if so.

    if is_base_64 || is_binary {

        let (input, (v, _)) = (cut(prop_value_binary), tag("\r\n")).parse(input)?;

        Ok((

            input,

            AttachProperty {

                params,

                value: AttachValue::Binary(v),

            },

        ))

        let (input, (v, _)) = (cut(recognize(param_value_uri)), tag("\r\n")).parse(input)?;

        Ok((

            input,

            AttachProperty {

                params,

                value: AttachValue::Uri(v),

            },

        ))

}

pub fn prop_categories<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], CategoriesProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("CATEGORIES"),

        cut((

            property_params,

            char(':'),

            separated_list1(char(','), prop_value_text),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, CategoriesProperty { params, value }))

}

pub fn prop_classification<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], ClassificationProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("CLASS"),

        cut((

            other_params,

            char(':'),

            alt((

                tag_no_case("PUBLIC").map(|_| Classification::Public),

                tag_no_case("PRIVATE").map(|_| Classification::Private),

                tag_no_case("CONFIDENTIAL").map(|_| Classification::Confidential),

                x_name.map(Classification::XName),

                iana_token.map(Classification::IanaToken),

            )),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        ClassificationProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_comment<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], CommentProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("COMMENT"),

        cut((property_params, char(':'), prop_value_text, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((input, CommentProperty { params, value }))

}

pub fn prop_description<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], DescriptionProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("DESCRIPTION"),

        cut((

            property_params,

            char(':'),

            prop_value_text.map(|v| v),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, DescriptionProperty { params, value }))

}

pub fn prop_geographic_position<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], GeographicPositionProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, (latitude, _, longitude), _))) = (

        tag_no_case("GEO"),

        cut((

            other_params,

            char(':'),

            (prop_value_float, char(';'), prop_value_float),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        GeographicPositionProperty {

            other_params,

            latitude,

            longitude,

        },

    ))

}

pub fn prop_location<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], LocationProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("LOCATION"),

        cut((property_params, char(':'), prop_value_text, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((input, LocationProperty { params, value }))

}

pub fn prop_percent_complete<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], PercentCompleteProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("PERCENT-COMPLETE"),

        cut((

            other_params,

            char(':'),

            verify(prop_value_integer, |v| 0 <= *v && *v <= 100).map(|v| v as u8),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        PercentCompleteProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_priority<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], PriorityProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("PRIORITY"),

        cut((

            other_params,

            char(':'),

            verify(prop_value_integer, |v| 0 <= *v && *v <= 9).map(|v| v as u8),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        PriorityProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_resources<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], ResourcesProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("RESOURCES"),

        cut((

            property_params,

            char(':'),

            separated_list1(char(','), prop_value_text),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, ResourcesProperty { params, value }))

}

pub fn prop_status<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], StatusProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("STATUS"),

        cut((

            other_params,

            char(':'),

            alt((

                tag_no_case("TENTATIVE").map(|_| Status::Tentative),

                tag_no_case("CONFIRMED").map(|_| Status::Confirmed),

                tag_no_case("CANCELLED").map(|_| Status::Cancelled),

                tag_no_case("NEEDS-ACTION").map(|_| Status::NeedsAction),

                tag_no_case("COMPLETED").map(|_| Status::Completed),

                tag_no_case("IN-PROCESS").map(|_| Status::InProcess),

                tag_no_case("DRAFT").map(|_| Status::Draft),

                tag_no_case("FINAL").map(|_| Status::Final),

            )),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        StatusProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_summary<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], SummaryProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("SUMMARY"),

        cut((property_params, char(':'), prop_value_text, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((input, SummaryProperty { params, value }))

}

pub fn prop_date_time_completed<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], DateTimeCompletedProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("COMPLETED"),

        cut((other_params, char(':'), prop_value_date_time, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        DateTimeCompletedProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_date_time_end<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], DateTimeEndProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("DTEND"),

        cut((

            property_params,

            char(':'),

            alt((

                prop_value_date_time.map(DateOrDateTime::DateTime),

                prop_value_date.map(DateOrDateTime::Date),

            )),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, DateTimeEndProperty { params, value }))

}

pub fn prop_date_time_due<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], DateTimeDueProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("DUE"),

        cut((

            property_params,

            char(':'),

            alt((

                prop_value_date_time.map(DateOrDateTime::DateTime),

                prop_value_date.map(DateOrDateTime::Date),

            )),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, DateTimeDueProperty { params, value }))

}

pub fn prop_date_time_start<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], DateTimeStartProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("DTSTART"),

        cut((

            property_params,

            char(':'),

            alt((

                prop_value_date_time.map(DateOrDateTime::DateTime),

                prop_value_date.map(DateOrDateTime::Date),

            )),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, DateTimeStartProperty { params, value }))

}

pub fn prop_duration<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], DurationProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("DURATION"),

        cut((other_params, char(':'), prop_value_duration, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        DurationProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_free_busy_time<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], FreeBusyTimeProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("FREEBUSY"),

        cut((

            property_params,

            char(':'),

            separated_list1(char(','), prop_value_period),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, FreeBusyTimeProperty { params, value }))

}

pub fn prop_time_transparency<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], TimeTransparencyProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("TRANSP"),

        cut((

            other_params,

            char(':'),

            alt((

                tag_no_case("OPAQUE").map(|_| TimeTransparency::Opaque),

                tag_no_case("TRANSPARENT").map(|_| TimeTransparency::Transparent),

            )),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        TimeTransparencyProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_time_zone_id<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], TimeZoneIdProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, (unique, value), _))) = (

        tag_no_case("TZID"),

        cut((

            other_params,

            char(':'),

            (opt(char('/')), prop_value_text),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        TimeZoneIdProperty {

            other_params,

            unique_registry_id: unique.is_some(),

            value,

        },

    ))

}

pub fn prop_time_zone_name<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], TimeZoneNameProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("TZNAME"),

        cut((property_params, char(':'), prop_value_text, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((input, TimeZoneNameProperty { params, value }))

}

pub fn prop_time_zone_offset_from<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], TimeZoneOffsetProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("TZOFFSETFROM"),

        cut((other_params, char(':'), prop_value_utc_offset, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        TimeZoneOffsetProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_time_zone_offset_to<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], TimeZoneOffsetProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("TZOFFSETTO"),

        cut((other_params, char(':'), prop_value_utc_offset, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        TimeZoneOffsetProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_time_zone_url<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], TimeZoneUrlProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("TZURL"),

        cut((

            other_params,

            char(':'),

            cut(recognize(param_value_uri)),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        TimeZoneUrlProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_attendee<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], AttendeeProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, uri, _))) = (

        tag_no_case("ATTENDEE"),

        cut((

            property_params,

            char(':'),

            cut(recognize(prop_value_calendar_user_address)),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, AttendeeProperty { params, value: uri }))

}

pub fn prop_contact<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], ContactProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("CONTACT"),

        cut((property_params, char(':'), prop_value_text, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((input, ContactProperty { params, value }))

}

pub fn prop_organizer<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], OrganizerProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, uri, _))) = (

        tag_no_case("ORGANIZER"),

        cut((

            property_params,

            char(':'),

            recognize(prop_value_calendar_user_address),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, OrganizerProperty { params, value: uri }))

}

pub fn prop_recurrence_id<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], RecurrenceIdProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("RECURRENCE-ID"),

        cut((

            property_params,

            char(':'),

            alt((

                prop_value_date_time.map(DateOrDateTime::DateTime),

                prop_value_date.map(DateOrDateTime::Date),

            )),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, RecurrenceIdProperty { params, value }))

}

pub fn prop_related_to<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], RelatedToProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("RELATED-TO"),

        cut((property_params, char(':'), prop_value_text, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((input, RelatedToProperty { params, value }))

}

pub fn prop_url<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], UrlProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("URL"),

        cut((other_params, char(':'), param_value_uri, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        UrlProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_unique_identifier<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], UniqueIdentifierProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("UID"),

        cut((other_params, char(':'), prop_value_text, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        UniqueIdentifierProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_exception_date_times<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], ExceptionDateTimesProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("EXDATE"),

        cut((

            property_params,

            char(':'),

            separated_list1(

                char(','),

                alt((

                    prop_value_date_time.map(DateOrDateTime::DateTime),

                    prop_value_date.map(DateOrDateTime::Date),

                )),

            ),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, ExceptionDateTimesProperty { params, value }))

}

pub fn prop_recurrence_date_times<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], RecurrenceDateTimesProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _, value, _))) = (

        tag_no_case("RDATE"),

        cut((

            property_params,

            char(':'),

            separated_list1(

                char(','),

                alt((

                    prop_value_period.map(DateOrDateTimeOrPeriod::Period),

                    prop_value_date_time.map(DateOrDateTimeOrPeriod::DateTime),

                    prop_value_date.map(DateOrDateTimeOrPeriod::Date),

                )),

            ),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((input, RecurrenceDateTimesProperty { params, value }))

}

pub fn prop_recurrence_rule<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], RecurrenceRuleProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("RRULE"),

        cut((other_params, char(':'), prop_value_recur, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        RecurrenceRuleProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_action<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], ActionProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("ACTION"),

        cut((

            other_params,

            char(':'),

            alt((

                tag_no_case("AUDIO").map(|_| Action::Audio),

                tag_no_case("DISPLAY").map(|_| Action::Display),

                tag_no_case("EMAIL").map(|_| Action::Email),

                x_name.map(Action::XName),

                iana_token.map(Action::IanaToken),

            )),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        ActionProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_repeat<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], RepeatProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("REPEAT"),

        cut((

            other_params,

            char(':'),

            prop_value_integer.map(|v| v as u32),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        RepeatProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_trigger<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], TriggerProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    let (input, (_, (params, _))) =

        (tag_no_case("TRIGGER"), cut((property_params, char(':')))).parse(input)?;

    let value_choice = params

        .iter()

        .filter_map(|p| match p {

            } => Some(1),

            } => Some(2),

            _ => None,

        })

        .collect::<Vec<_>>();

    let (input, value) = match value_choice.as_slice() {

        [1] | [] => cut(prop_value_duration)

            .map(DurationOrDateTime::Duration)

            .parse(input),

        [2] => cut(prop_value_date_time)

            .map(DurationOrDateTime::DateTime)

            .parse(input),

    let (input, _) = cut(tag("\r\n")).parse(input)?;

    Ok((input, TriggerProperty { params, value }))

}

pub fn prop_date_time_created<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], DateTimeCreatedProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("CREATED"),

        cut((other_params, char(':'), prop_value_date_time, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        DateTimeCreatedProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_date_time_stamp<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], DateTimeStampProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("DTSTAMP"),

        cut((other_params, char(':'), prop_value_date_time, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        DateTimeStampProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_last_modified<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], LastModifiedProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("LAST-MODIFIED"),

        cut((other_params, char(':'), prop_value_date_time, tag("\r\n"))),

    )

        .parse(input)?;

    Ok((

        input,

        LastModifiedProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_sequence<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], SequenceProperty<'a>, E>

where

    E: ParseError<&'a [u8]> + From<Error<'a>>,

{

    let (input, (_, (other_params, _, value, _))) = (

        tag_no_case("SEQUENCE"),

        cut((

            other_params,

            char(':'),

            prop_value_integer.map(|v| v as u32),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        SequenceProperty {

            other_params,

            value,

        },

    ))

}

pub fn prop_request_status<'a, E>(

    input: &'a [u8],

) -> IResult<&'a [u8], RequestStatusProperty<'a>, E>

where

    E: ParseError<&'a [u8]>

        + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

        + From<Error<'a>>,

{

    fn status_code<'a, E>(input: &'a [u8]) -> IResult<&'a [u8], Vec<u32>, E>

    where

        E: ParseError<&'a [u8]>

            + nom::error::FromExternalError<&'a [u8], nom::Err<E>>

            + From<Error<'a>>,

    {

        let (input, (num, mut nums)) = (

            map_res(

                verify(take_while1(AsChar::is_dec_digit), |v: &[u8]| v.len() == 1),

                |v| read_int::<E, u32>(v),

            ),

            fold_many_m_n(

                1,

                2,

                map_res((char('.'), take_while1(AsChar::is_dec_digit)), |(_, v)| {

                    read_int::<E, u32>(v)

                }),

                Vec::new,

                |mut acc, item| {

                    acc.push(item);

                    acc

                },

            ),

        )

            .parse(input)?;

        nums.insert(0, num);

        Ok((input, nums))

    }

    let (input, (_, (params, _, status_code, _, status_description, extra_data, _))) = (

        tag_no_case("REQUEST-STATUS"),

        cut((

            property_params,

            char(':'),

            status_code,

            char(';'),

            prop_value_text,

            opt((char(';'), prop_value_text).map(|(_, v)| v)),

            tag("\r\n"),

        )),

    )

        .parse(input)?;

    Ok((

        input,

        RequestStatusProperty {

            params,

            status_code,

            status_description,

            exception_data: extra_data,

        },

    ))

}

    fn attach_uri() {

        let (rem, prop) =

            prop_attach::<Error>(b"ATTACH:CID:jsmith.part3.960817T083000.xyzMail@example.com\r\n;")

                .unwrap();

        check_rem(rem, 1);

        assert_eq!(

            prop,

            AttachProperty {

                params: vec![],

                value: AttachValue::Uri(b"CID:jsmith.part3.960817T083000.xyzMail@example.com"),

            }

        );

    }

    fn attach_binary() {

        let (rem, prop) =

            prop_attach::<Error>(b"ATTACH;VALUE=BINARY;ENCODING=BASE64:dGVzdA==\r\n;").unwrap();

        check_rem(rem, 1);

        let r = base64::prelude::BASE64_STANDARD.encode("test");

        assert_eq!(

            prop,

            AttachProperty {

                params: vec![

                    ParamValue::ValueType {

                        value: Value::Binary

                    },

                    ParamValue::Encoding {

                        encoding: Encoding::Base64,

                    },

                ],

                value: AttachValue::Binary(r.as_bytes()),

            }

        );

    }

    fn categories() {

        let (rem, prop) =

            prop_categories::<Error>(b"CATEGORIES:APPOINTMENT,EDUCATION\r\n;").unwrap();

        check_rem(rem, 1);

        assert_eq!(

            prop,

            CategoriesProperty {

                params: vec![],

                value: vec![b"APPOINTMENT".to_vec(), b"EDUCATION".to_vec()],

            }

        );

    }

    fn classification_public() {

        let (rem, prop) = prop_classification::<Error>(b"CLASS:PUBLIC\r\n;").unwrap();

        check_rem(rem, 1);

        assert_eq!(

            prop,

            ClassificationProperty {

                other_params: vec![],

                value: Classification::Public,

            }

        );

    }

    fn comment() {

        let (rem, prop) = prop_comment::<Error>(b"COMMENT:The meeting really needs to include both ourselves and the customer. We can't hold this meeting without them. As a matter of fact\\, the venue for the meeting ought to be at their site. - - John\r\n;").unwrap();

        check_rem(rem, 1);

        assert_eq!(

            prop,

            CommentProperty {

                params: vec![],

                value: b"The meeting really needs to include both ourselves and the customer. We can't hold this meeting without them. As a matter of fact, the venue for the meeting ought to be at their site. - - John".to_vec(),

            }

        );

    }

    fn description() {

        let (rem, prop) = prop_description::<Error>(b"DESCRIPTION:Meeting to provide technical review for \"Phoenix\"\r\n  design.\\nHappy Face Conference Room. Phoenix design team\r\n  MUST attend this meeting.\\nRSVP to team leader.\r\n;").unwrap();

        check_rem(rem, 1);

        assert_eq!(

            prop,

            DescriptionProperty {

                params: vec![],

                value: br#"Meeting to provide technical review for "Phoenix" design.

Happy Face Conference Room. Phoenix design team MUST attend this meeting.

RSVP to team leader."#

                    .to_vec(),

            }

        );

    }

    fn geographic_position() {

        let (rem, prop) =

            prop_geographic_position::<Error>(b"GEO:37.386013;-122.082932\r\n;").unwrap();

        check_rem(rem, 1);

        assert_eq!(

            prop,

            GeographicPositionProperty {

                other_params: vec![],

                latitude: 37.386013,

                longitude: -122.082932,

            }

        );

    }

    fn location() {

        let (rem, prop) =

            prop_location::<Error>(b"LOCATION:Conference Room - F123\\, Bldg. 002\r\n;").unwrap();

        check_rem(rem, 1);

        assert_eq!(

            prop,

            LocationProperty {

                params: vec![],

                value: b"Conference Room - F123, Bldg. 002".to_vec(),

            }

        );

    }

    fn location_with_params() {

        let (rem, prop) = prop_location::<Error>(b"LOCATION;ALTREP=\"http://xyzcorp.com/conf-rooms/f123.vcf\":\r\n Conference Room - F123\\, Bldg. 002\r\n;").unwrap();

        check_rem(rem, 1);

        assert_eq!(

            prop,

            LocationProperty {

                params: vec![ParamValue::AltRep {

                    uri: b"http://xyzcorp.com/conf-rooms/f123.vcf",