From 61e666078d15fea8b6d9f8545aea27b39afc9814 Mon Sep 17 00:00:00 2001 From: Michal Srb Date: Fri, 22 Nov 2019 19:32:05 +0100 Subject: [PATCH] Fix build with rust 1.13.0 --- src/format/mod.rs | 108 ++++++++++++++++++++++---------------------- src/format/parse.rs | 86 +++++++++++++++++------------------ src/format/scan.rs | 4 +- 3 files changed, 99 insertions(+), 99 deletions(-) diff --git a/src/format/mod.rs b/src/format/mod.rs index 1bc7ac39bd..40a72c6749 100644 --- a/src/format/mod.rs +++ b/src/format/mod.rs @@ -382,11 +382,11 @@ pub fn format<'a, I, B>( for item in items { match item.borrow() { - Item::Literal(s) | Item::Space(s) => result.push_str(s), + &Item::Literal(s) | &Item::Space(s) => result.push_str(s), #[cfg(any(feature = "alloc", feature = "std", test))] - Item::OwnedLiteral(ref s) | Item::OwnedSpace(ref s) => result.push_str(s), + &Item::OwnedLiteral(ref s) | &Item::OwnedSpace(ref s) => result.push_str(s), - Item::Numeric(spec, pad) => { + &Item::Numeric(ref spec, ref pad) => { use self::Numeric::*; let week_from_sun = |d: &NaiveDate| @@ -395,31 +395,31 @@ pub fn format<'a, I, B>( (d.ordinal() as i32 - d.weekday().num_days_from_monday() as i32 + 7) / 7; let (width, v) = match spec { - Year => (4, date.map(|d| i64::from(d.year()))), - YearDiv100 => (2, date.map(|d| div_floor(i64::from(d.year()), 100))), - YearMod100 => (2, date.map(|d| mod_floor(i64::from(d.year()), 100))), - IsoYear => (4, date.map(|d| i64::from(d.iso_week().year()))), - IsoYearDiv100 => (2, date.map(|d| div_floor( + &Year => (4, date.map(|d| i64::from(d.year()))), + &YearDiv100 => (2, date.map(|d| div_floor(i64::from(d.year()), 100))), + &YearMod100 => (2, date.map(|d| mod_floor(i64::from(d.year()), 100))), + &IsoYear => (4, date.map(|d| i64::from(d.iso_week().year()))), + &IsoYearDiv100 => (2, date.map(|d| div_floor( i64::from(d.iso_week().year()), 100))), - IsoYearMod100 => (2, date.map(|d| mod_floor( + &IsoYearMod100 => (2, date.map(|d| mod_floor( i64::from(d.iso_week().year()), 100))), - Month => (2, date.map(|d| i64::from(d.month()))), - Day => (2, date.map(|d| i64::from(d.day()))), - WeekFromSun => (2, date.map(|d| i64::from(week_from_sun(d)))), - WeekFromMon => (2, date.map(|d| i64::from(week_from_mon(d)))), - IsoWeek => (2, date.map(|d| i64::from(d.iso_week().week()))), - NumDaysFromSun => (1, date.map(|d| i64::from(d.weekday() + &Month => (2, date.map(|d| i64::from(d.month()))), + &Day => (2, date.map(|d| i64::from(d.day()))), + &WeekFromSun => (2, date.map(|d| i64::from(week_from_sun(d)))), + &WeekFromMon => (2, date.map(|d| i64::from(week_from_mon(d)))), + &IsoWeek => (2, date.map(|d| i64::from(d.iso_week().week()))), + &NumDaysFromSun => (1, date.map(|d| i64::from(d.weekday() .num_days_from_sunday()))), - WeekdayFromMon => (1, date.map(|d| i64::from(d.weekday() + &WeekdayFromMon => (1, date.map(|d| i64::from(d.weekday() .number_from_monday()))), - Ordinal => (3, date.map(|d| i64::from(d.ordinal()))), - Hour => (2, time.map(|t| i64::from(t.hour()))), - Hour12 => (2, time.map(|t| i64::from(t.hour12().1))), - Minute => (2, time.map(|t| i64::from(t.minute()))), - Second => (2, time.map(|t| i64::from(t.second() + + &Ordinal => (3, date.map(|d| i64::from(d.ordinal()))), + &Hour => (2, time.map(|t| i64::from(t.hour()))), + &Hour12 => (2, time.map(|t| i64::from(t.hour12().1))), + &Minute => (2, time.map(|t| i64::from(t.minute()))), + &Second => (2, time.map(|t| i64::from(t.second() + t.nanosecond() / 1_000_000_000))), - Nanosecond => (9, time.map(|t| i64::from(t.nanosecond() % 1_000_000_000))), - Timestamp => (1, match (date, time, off) { + &Nanosecond => (9, time.map(|t| i64::from(t.nanosecond() % 1_000_000_000))), + &Timestamp => (1, match (date, time, off) { (Some(d), Some(t), None) => Some(d.and_time(*t).timestamp()), (Some(d), Some(t), Some(&(_, off))) => @@ -428,24 +428,24 @@ pub fn format<'a, I, B>( }), // for the future expansion - Internal(ref int) => match int._dummy {}, + &Internal(ref int) => match int._dummy {}, }; if let Some(v) = v { try!( - if (*spec == Year || *spec == IsoYear) && !(0 <= v && v < 10_000) { + if (spec == &Year || spec == &IsoYear) && !(0 <= v && v < 10_000) { // non-four-digit years require an explicit sign as per ISO 8601 match pad { - Pad::None => write!(result, "{:+}", v), - Pad::Zero => write!(result, "{:+01$}", v, width + 1), - Pad::Space => write!(result, "{:+1$}", v, width + 1), + &Pad::None => write!(result, "{:+}", v), + &Pad::Zero => write!(result, "{:+01$}", v, width + 1), + &Pad::Space => write!(result, "{:+1$}", v, width + 1), } } else { match pad { - Pad::None => write!(result, "{}", v), - Pad::Zero => write!(result, "{:01$}", v, width), - Pad::Space => write!(result, "{:1$}", v, width), + &Pad::None => write!(result, "{}", v), + &Pad::Zero => write!(result, "{:01$}", v, width), + &Pad::Space => write!(result, "{:1$}", v, width), } } ) @@ -454,7 +454,7 @@ pub fn format<'a, I, B>( } }, - Item::Fixed(spec) => { + &Item::Fixed(ref spec) => { use self::Fixed::*; /// Prints an offset from UTC in the format of `+HHMM` or `+HH:MM`. @@ -480,41 +480,41 @@ pub fn format<'a, I, B>( } let ret = match spec { - ShortMonthName => + &ShortMonthName => date.map(|d| { result.push_str(SHORT_MONTHS[d.month0() as usize]); Ok(()) }), - LongMonthName => + &LongMonthName => date.map(|d| { result.push_str(LONG_MONTHS[d.month0() as usize]); Ok(()) }), - ShortWeekdayName => + &ShortWeekdayName => date.map(|d| { result.push_str( SHORT_WEEKDAYS[d.weekday().num_days_from_monday() as usize] ); Ok(()) }), - LongWeekdayName => + &LongWeekdayName => date.map(|d| { result.push_str( LONG_WEEKDAYS[d.weekday().num_days_from_monday() as usize] ); Ok(()) }), - LowerAmPm => + &LowerAmPm => time.map(|t| { result.push_str(if t.hour12().0 {"pm"} else {"am"}); Ok(()) }), - UpperAmPm => + &UpperAmPm => time.map(|t| { result.push_str(if t.hour12().0 {"PM"} else {"AM"}); Ok(()) }), - Nanosecond => + &Nanosecond => time.map(|t| { let nano = t.nanosecond() % 1_000_000_000; if nano == 0 { @@ -527,52 +527,52 @@ pub fn format<'a, I, B>( write!(result, ".{:09}", nano) } }), - Nanosecond3 => + &Nanosecond3 => time.map(|t| { let nano = t.nanosecond() % 1_000_000_000; write!(result, ".{:03}", nano / 1_000_000) }), - Nanosecond6 => + &Nanosecond6 => time.map(|t| { let nano = t.nanosecond() % 1_000_000_000; write!(result, ".{:06}", nano / 1_000) }), - Nanosecond9 => + &Nanosecond9 => time.map(|t| { let nano = t.nanosecond() % 1_000_000_000; write!(result, ".{:09}", nano) }), - Internal(InternalFixed { val: InternalInternal::Nanosecond3NoDot }) => + &Internal(InternalFixed { val: InternalInternal::Nanosecond3NoDot }) => time.map(|t| { let nano = t.nanosecond() % 1_000_000_000; write!(result, "{:03}", nano / 1_000_000) }), - Internal(InternalFixed { val: InternalInternal::Nanosecond6NoDot }) => + &Internal(InternalFixed { val: InternalInternal::Nanosecond6NoDot }) => time.map(|t| { let nano = t.nanosecond() % 1_000_000_000; write!(result, "{:06}", nano / 1_000) }), - Internal(InternalFixed { val: InternalInternal::Nanosecond9NoDot }) => + &Internal(InternalFixed { val: InternalInternal::Nanosecond9NoDot }) => time.map(|t| { let nano = t.nanosecond() % 1_000_000_000; write!(result, "{:09}", nano) }), - TimezoneName => + &TimezoneName => off.map(|&(ref name, _)| { result.push_str(name); Ok(()) }), - TimezoneOffsetColon => + &TimezoneOffsetColon => off.map(|&(_, off)| write_local_minus_utc(&mut result, off, false, true)), - TimezoneOffsetColonZ => + &TimezoneOffsetColonZ => off.map(|&(_, off)| write_local_minus_utc(&mut result, off, true, true)), - TimezoneOffset => + &TimezoneOffset => off.map(|&(_, off)| write_local_minus_utc(&mut result, off, false, false)), - TimezoneOffsetZ => + &TimezoneOffsetZ => off.map(|&(_, off)| write_local_minus_utc(&mut result, off, true, false)), - Internal(InternalFixed { val: InternalInternal::TimezoneOffsetPermissive }) => + &Internal(InternalFixed { val: InternalInternal::TimezoneOffsetPermissive }) => panic!("Do not try to write %#z it is undefined"), - RFC2822 => // same to `%a, %e %b %Y %H:%M:%S %z` + &RFC2822 => // same to `%a, %e %b %Y %H:%M:%S %z` if let (Some(d), Some(t), Some(&(_, off))) = (date, time, off) { let sec = t.second() + t.nanosecond() / 1_000_000_000; try!(write!( @@ -586,7 +586,7 @@ pub fn format<'a, I, B>( } else { None }, - RFC3339 => // same to `%Y-%m-%dT%H:%M:%S%.f%:z` + &RFC3339 => // same to `%Y-%m-%dT%H:%M:%S%.f%:z` if let (Some(d), Some(t), Some(&(_, off))) = (date, time, off) { // reuse `Debug` impls which already print ISO 8601 format. // this is faster in this way. @@ -603,7 +603,7 @@ pub fn format<'a, I, B>( } }, - Item::Error => return Err(fmt::Error), + &Item::Error => return Err(fmt::Error), } } diff --git a/src/format/parse.rs b/src/format/parse.rs index ed887226a8..0a7d6a7d6b 100644 --- a/src/format/parse.rs +++ b/src/format/parse.rs @@ -213,56 +213,56 @@ pub fn parse<'a, I, B>(parsed: &mut Parsed, mut s: &str, items: I) -> ParseResul for item in items { match item.borrow() { - Item::Literal(prefix) => { + &Item::Literal(prefix) => { if s.len() < prefix.len() { return Err(TOO_SHORT); } if !s.starts_with(prefix) { return Err(INVALID); } s = &s[prefix.len()..]; } #[cfg(any(feature = "alloc", feature = "std", test))] - Item::OwnedLiteral(ref prefix) => { + &Item::OwnedLiteral(ref prefix) => { if s.len() < prefix.len() { return Err(TOO_SHORT); } if !s.starts_with(&prefix[..]) { return Err(INVALID); } s = &s[prefix.len()..]; } - Item::Space(_) => { + &Item::Space(_) => { s = s.trim_left(); } #[cfg(any(feature = "alloc", feature = "std", test))] - Item::OwnedSpace(_) => { + &Item::OwnedSpace(_) => { s = s.trim_left(); } - Item::Numeric(spec, _pad) => { + &Item::Numeric(ref spec, ref _pad) => { use super::Numeric::*; type Setter = fn(&mut Parsed, i64) -> ParseResult<()>; let (width, signed, set): (usize, bool, Setter) = match spec { - Year => (4, true, Parsed::set_year), - YearDiv100 => (2, false, Parsed::set_year_div_100), - YearMod100 => (2, false, Parsed::set_year_mod_100), - IsoYear => (4, true, Parsed::set_isoyear), - IsoYearDiv100 => (2, false, Parsed::set_isoyear_div_100), - IsoYearMod100 => (2, false, Parsed::set_isoyear_mod_100), - Month => (2, false, Parsed::set_month), - Day => (2, false, Parsed::set_day), - WeekFromSun => (2, false, Parsed::set_week_from_sun), - WeekFromMon => (2, false, Parsed::set_week_from_mon), - IsoWeek => (2, false, Parsed::set_isoweek), - NumDaysFromSun => (1, false, set_weekday_with_num_days_from_sunday), - WeekdayFromMon => (1, false, set_weekday_with_number_from_monday), - Ordinal => (3, false, Parsed::set_ordinal), - Hour => (2, false, Parsed::set_hour), - Hour12 => (2, false, Parsed::set_hour12), - Minute => (2, false, Parsed::set_minute), - Second => (2, false, Parsed::set_second), - Nanosecond => (9, false, Parsed::set_nanosecond), - Timestamp => (usize::MAX, false, Parsed::set_timestamp), + &Year => (4, true, Parsed::set_year), + &YearDiv100 => (2, false, Parsed::set_year_div_100), + &YearMod100 => (2, false, Parsed::set_year_mod_100), + &IsoYear => (4, true, Parsed::set_isoyear), + &IsoYearDiv100 => (2, false, Parsed::set_isoyear_div_100), + &IsoYearMod100 => (2, false, Parsed::set_isoyear_mod_100), + &Month => (2, false, Parsed::set_month), + &Day => (2, false, Parsed::set_day), + &WeekFromSun => (2, false, Parsed::set_week_from_sun), + &WeekFromMon => (2, false, Parsed::set_week_from_mon), + &IsoWeek => (2, false, Parsed::set_isoweek), + &NumDaysFromSun => (1, false, set_weekday_with_num_days_from_sunday), + &WeekdayFromMon => (1, false, set_weekday_with_number_from_monday), + &Ordinal => (3, false, Parsed::set_ordinal), + &Hour => (2, false, Parsed::set_hour), + &Hour12 => (2, false, Parsed::set_hour12), + &Minute => (2, false, Parsed::set_minute), + &Second => (2, false, Parsed::set_second), + &Nanosecond => (9, false, Parsed::set_nanosecond), + &Timestamp => (usize::MAX, false, Parsed::set_timestamp), // for the future expansion - Internal(ref int) => match int._dummy {}, + &Internal(ref int) => match int._dummy {}, }; s = s.trim_left(); @@ -282,31 +282,31 @@ pub fn parse<'a, I, B>(parsed: &mut Parsed, mut s: &str, items: I) -> ParseResul try!(set(parsed, v)); } - Item::Fixed(spec) => { + &Item::Fixed(ref spec) => { use super::Fixed::*; match spec { - ShortMonthName => { + &ShortMonthName => { let month0 = try_consume!(scan::short_month0(s)); try!(parsed.set_month(i64::from(month0) + 1)); } - LongMonthName => { + &LongMonthName => { let month0 = try_consume!(scan::short_or_long_month0(s)); try!(parsed.set_month(i64::from(month0) + 1)); } - ShortWeekdayName => { + &ShortWeekdayName => { let weekday = try_consume!(scan::short_weekday(s)); try!(parsed.set_weekday(weekday)); } - LongWeekdayName => { + &LongWeekdayName => { let weekday = try_consume!(scan::short_or_long_weekday(s)); try!(parsed.set_weekday(weekday)); } - LowerAmPm | UpperAmPm => { + &LowerAmPm | &UpperAmPm => { if s.len() < 2 { return Err(TOO_SHORT); } let ampm = match (s.as_bytes()[0] | 32, s.as_bytes()[1] | 32) { (b'a',b'm') => false, @@ -317,56 +317,56 @@ pub fn parse<'a, I, B>(parsed: &mut Parsed, mut s: &str, items: I) -> ParseResul s = &s[2..]; } - Nanosecond | Nanosecond3 | Nanosecond6 | Nanosecond9 => { + &Nanosecond | &Nanosecond3 | &Nanosecond6 | &Nanosecond9 => { if s.starts_with('.') { let nano = try_consume!(scan::nanosecond(&s[1..])); try!(parsed.set_nanosecond(nano)); } } - Internal(InternalFixed { val: InternalInternal::Nanosecond3NoDot }) => { + &Internal(InternalFixed { val: InternalInternal::Nanosecond3NoDot }) => { if s.len() < 3 { return Err(TOO_SHORT); } let nano = try_consume!(scan::nanosecond_fixed(s, 3)); try!(parsed.set_nanosecond(nano)); } - Internal(InternalFixed { val: InternalInternal::Nanosecond6NoDot }) => { + &Internal(InternalFixed { val: InternalInternal::Nanosecond6NoDot }) => { if s.len() < 6 { return Err(TOO_SHORT); } let nano = try_consume!(scan::nanosecond_fixed(s, 6)); try!(parsed.set_nanosecond(nano)); } - Internal(InternalFixed { val: InternalInternal::Nanosecond9NoDot }) => { + &Internal(InternalFixed { val: InternalInternal::Nanosecond9NoDot }) => { if s.len() < 9 { return Err(TOO_SHORT); } let nano = try_consume!(scan::nanosecond_fixed(s, 9)); try!(parsed.set_nanosecond(nano)); } - TimezoneName => return Err(BAD_FORMAT), + &TimezoneName => return Err(BAD_FORMAT), - TimezoneOffsetColon | TimezoneOffset => { + &TimezoneOffsetColon | &TimezoneOffset => { let offset = try_consume!(scan::timezone_offset(s.trim_left(), scan::colon_or_space)); try!(parsed.set_offset(i64::from(offset))); } - TimezoneOffsetColonZ | TimezoneOffsetZ => { + &TimezoneOffsetColonZ | &TimezoneOffsetZ => { let offset = try_consume!(scan::timezone_offset_zulu(s.trim_left(), scan::colon_or_space)); try!(parsed.set_offset(i64::from(offset))); } - Internal(InternalFixed { val: InternalInternal::TimezoneOffsetPermissive }) => { + &Internal(InternalFixed { val: InternalInternal::TimezoneOffsetPermissive }) => { let offset = try_consume!(scan::timezone_offset_permissive( s.trim_left(), scan::colon_or_space)); try!(parsed.set_offset(i64::from(offset))); } - RFC2822 => try_consume!(parse_rfc2822(parsed, s)), - RFC3339 => try_consume!(parse_rfc3339(parsed, s)), + &RFC2822 => try_consume!(parse_rfc2822(parsed, s)), + &RFC3339 => try_consume!(parse_rfc3339(parsed, s)), } } - Item::Error => { + &Item::Error => { return Err(BAD_FORMAT); } } diff --git a/src/format/scan.rs b/src/format/scan.rs index acbc92f026..690326fa2a 100644 --- a/src/format/scan.rs +++ b/src/format/scan.rs @@ -43,7 +43,7 @@ pub fn number(s: &str, min: usize, max: usize) -> ParseResult<(&str, i64)> { } let mut n = 0i64; - for (i, c) in bytes.iter().take(max).copied().enumerate() { + for (i, c) in bytes.iter().take(max).cloned().enumerate() { // cloned() = copied() if c < b'0' || b'9' < c { if i < min { return Err(INVALID); @@ -58,7 +58,7 @@ pub fn number(s: &str, min: usize, max: usize) -> ParseResult<(&str, i64)> { }; } - Ok((&s[max.min(bytes.len())..], n)) + Ok((&s[::std::cmp::min(max, bytes.len())..], n)) } /// Tries to consume at least one digits as a fractional second.