vendor/chrono-0.4.38/src/traits.rs - toolchain/rustc - Git at Google

 use crate::{IsoWeek, Weekday};

 /// The common set of methods for date component.
 ///
 /// Methods such as [`year`], [`month`], [`day`] and [`weekday`] can be used to get basic
 /// information about the date.
 ///
 /// The `with_*` methods can change the date.
 ///
 /// # Warning
 ///
 /// The `with_*` methods can be convenient to change a single component of a date, but they must be
 /// used with some care. Examples to watch out for:
 ///
 /// - [`with_year`] changes the year component of a year-month-day value. Don't use this method if
 ///   you want the ordinal to stay the same after changing the year, of if you want the week and
 ///   weekday values to stay the same.
 /// - Don't combine two `with_*` methods to change two components of the date. For example to
 ///   change both the year and month components of a date. This could fail because an intermediate
 ///   value does not exist, while the final date would be valid.
 ///
 /// For more complex changes to a date, it is best to use the methods on [`NaiveDate`] to create a
 /// new value instead of altering an existing date.
 ///
 /// [`year`]: Datelike::year
 /// [`month`]: Datelike::month
 /// [`day`]: Datelike::day
 /// [`weekday`]: Datelike::weekday
 /// [`with_year`]: Datelike::with_year
 /// [`NaiveDate`]: crate::NaiveDate
 pub trait Datelike: Sized {
     /// Returns the year number in the [calendar date](./naive/struct.NaiveDate.html#calendar-date).
     fn year(&self) -> i32;

     /// Returns the absolute year number starting from 1 with a boolean flag,
     /// which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD).
     #[inline]
     fn year_ce(&self) -> (bool, u32) {
         let year = self.year();
         if year < 1 {
             (false, (1 - year) as u32)
         } else {
             (true, year as u32)
         }
     }

     /// Returns the month number starting from 1.
     ///
     /// The return value ranges from 1 to 12.
     fn month(&self) -> u32;

     /// Returns the month number starting from 0.
     ///
     /// The return value ranges from 0 to 11.
     fn month0(&self) -> u32;

     /// Returns the day of month starting from 1.
     ///
     /// The return value ranges from 1 to 31. (The last day of month differs by months.)
     fn day(&self) -> u32;

     /// Returns the day of month starting from 0.
     ///
     /// The return value ranges from 0 to 30. (The last day of month differs by months.)
     fn day0(&self) -> u32;

     /// Returns the day of year starting from 1.
     ///
     /// The return value ranges from 1 to 366. (The last day of year differs by years.)
     fn ordinal(&self) -> u32;

     /// Returns the day of year starting from 0.
     ///
     /// The return value ranges from 0 to 365. (The last day of year differs by years.)
     fn ordinal0(&self) -> u32;

     /// Returns the day of week.
     fn weekday(&self) -> Weekday;

     /// Returns the ISO week.
     fn iso_week(&self) -> IsoWeek;

     /// Makes a new value with the year number changed, while keeping the same month and day.
     ///
     /// This method assumes you want to work on the date as a year-month-day value. Don't use it if
     /// you want the ordinal to stay the same after changing the year, of if you want the week and
     /// weekday values to stay the same.
     ///
     /// # Errors
     ///
     /// Returns `None` when:
     ///
     /// - The resulting date does not exist (February 29 in a non-leap year).
     /// - The year is out of range for [`NaiveDate`].
     /// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
     ///   transition such as from DST to standard time.
     ///
     /// [`NaiveDate`]: crate::NaiveDate
     /// [`DateTime<Tz>`]: crate::DateTime
     ///
     /// # Examples
     ///
     /// ```
     /// use chrono::{Datelike, NaiveDate};
     ///
     /// assert_eq!(
     ///     NaiveDate::from_ymd_opt(2020, 5, 13).unwrap().with_year(2023).unwrap(),
     ///     NaiveDate::from_ymd_opt(2023, 5, 13).unwrap()
     /// );
     /// // Resulting date 2023-02-29 does not exist:
     /// assert!(NaiveDate::from_ymd_opt(2020, 2, 29).unwrap().with_year(2023).is_none());
     ///
     /// // Don't use `with_year` if you want the ordinal date to stay the same:
     /// assert_ne!(
     ///     NaiveDate::from_yo_opt(2020, 100).unwrap().with_year(2023).unwrap(),
     ///     NaiveDate::from_yo_opt(2023, 100).unwrap() // result is 2023-101
     /// );
     /// ```
     fn with_year(&self, year: i32) -> Option<Self>;

     /// Makes a new value with the month number (starting from 1) changed.
     ///
     /// # Errors
     ///
     /// Returns `None` when:
     ///
     /// - The resulting date does not exist (for example `month(4)` when day of the month is 31).
     /// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
     ///   transition such as from DST to standard time.
     /// - The value for `month` is out of range.
     ///
     /// [`DateTime<Tz>`]: crate::DateTime
     ///
     /// # Examples
     ///
     /// ```
     /// use chrono::{Datelike, NaiveDate};
     ///
     /// assert_eq!(
     ///     NaiveDate::from_ymd_opt(2023, 5, 12).unwrap().with_month(9).unwrap(),
     ///     NaiveDate::from_ymd_opt(2023, 9, 12).unwrap()
     /// );
     /// // Resulting date 2023-09-31 does not exist:
     /// assert!(NaiveDate::from_ymd_opt(2023, 5, 31).unwrap().with_month(9).is_none());
     /// ```
     ///
     /// Don't combine multiple `Datelike::with_*` methods. The intermediate value may not exist.
     /// ```
     /// use chrono::{Datelike, NaiveDate};
     ///
     /// fn with_year_month(date: NaiveDate, year: i32, month: u32) -> Option<NaiveDate> {
     ///     date.with_year(year)?.with_month(month)
     /// }
     /// let d = NaiveDate::from_ymd_opt(2020, 2, 29).unwrap();
     /// assert!(with_year_month(d, 2019, 1).is_none()); // fails because of invalid intermediate value
     ///
     /// // Correct version:
     /// fn with_year_month_fixed(date: NaiveDate, year: i32, month: u32) -> Option<NaiveDate> {
     ///     NaiveDate::from_ymd_opt(year, month, date.day())
     /// }
     /// let d = NaiveDate::from_ymd_opt(2020, 2, 29).unwrap();
     /// assert_eq!(with_year_month_fixed(d, 2019, 1), NaiveDate::from_ymd_opt(2019, 1, 29));
     /// ```
     fn with_month(&self, month: u32) -> Option<Self>;

     /// Makes a new value with the month number (starting from 0) changed.
     ///
     /// # Errors
     ///
     /// Returns `None` when:
     ///
     /// - The resulting date does not exist (for example `month0(3)` when day of the month is 31).
     /// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
     ///   transition such as from DST to standard time.
     /// - The value for `month0` is out of range.
     ///
     /// [`DateTime<Tz>`]: crate::DateTime
     fn with_month0(&self, month0: u32) -> Option<Self>;

     /// Makes a new value with the day of month (starting from 1) changed.
     ///
     /// # Errors
     ///
     /// Returns `None` when:
     ///
     /// - The resulting date does not exist (for example `day(31)` in April).
     /// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
     ///   transition such as from DST to standard time.
     /// - The value for `day` is out of range.
     ///
     /// [`DateTime<Tz>`]: crate::DateTime
     fn with_day(&self, day: u32) -> Option<Self>;

     /// Makes a new value with the day of month (starting from 0) changed.
     ///
     /// # Errors
     ///
     /// Returns `None` when:
     ///
     /// - The resulting date does not exist (for example `day0(30)` in April).
     /// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
     ///   transition such as from DST to standard time.
     /// - The value for `day0` is out of range.
     ///
     /// [`DateTime<Tz>`]: crate::DateTime
     fn with_day0(&self, day0: u32) -> Option<Self>;

     /// Makes a new value with the day of year (starting from 1) changed.
     ///
     /// # Errors
     ///
     /// Returns `None` when:
     ///
     /// - The resulting date does not exist (`with_ordinal(366)` in a non-leap year).
     /// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
     ///   transition such as from DST to standard time.
     /// - The value for `ordinal` is out of range.
     ///
     /// [`DateTime<Tz>`]: crate::DateTime
     fn with_ordinal(&self, ordinal: u32) -> Option<Self>;

     /// Makes a new value with the day of year (starting from 0) changed.
     ///
     /// # Errors
     ///
     /// Returns `None` when:
     ///
     /// - The resulting date does not exist (`with_ordinal0(365)` in a non-leap year).
     /// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
     ///   transition such as from DST to standard time.
     /// - The value for `ordinal0` is out of range.
     ///
     /// [`DateTime<Tz>`]: crate::DateTime
     fn with_ordinal0(&self, ordinal0: u32) -> Option<Self>;

     /// Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1.
     ///
     /// # Examples
     ///
     /// ```
     /// use chrono::{Datelike, NaiveDate};
     ///
     /// assert_eq!(NaiveDate::from_ymd_opt(1970, 1, 1).unwrap().num_days_from_ce(), 719_163);
     /// assert_eq!(NaiveDate::from_ymd_opt(2, 1, 1).unwrap().num_days_from_ce(), 366);
     /// assert_eq!(NaiveDate::from_ymd_opt(1, 1, 1).unwrap().num_days_from_ce(), 1);
     /// assert_eq!(NaiveDate::from_ymd_opt(0, 1, 1).unwrap().num_days_from_ce(), -365);
     /// ```
     fn num_days_from_ce(&self) -> i32 {
         // See test_num_days_from_ce_against_alternative_impl below for a more straightforward
         // implementation.

         // we know this wouldn't overflow since year is limited to 1/2^13 of i32's full range.
         let mut year = self.year() - 1;
         let mut ndays = 0;
         if year < 0 {
             let excess = 1 + (-year) / 400;
             year += excess * 400;
             ndays -= excess * 146_097;
         }
         let div_100 = year / 100;
         ndays += ((year * 1461) >> 2) - div_100 + (div_100 >> 2);
         ndays + self.ordinal() as i32
     }
 }

 /// The common set of methods for time component.
 pub trait Timelike: Sized {
     /// Returns the hour number from 0 to 23.
     fn hour(&self) -> u32;

     /// Returns the hour number from 1 to 12 with a boolean flag,
     /// which is false for AM and true for PM.
     #[inline]
     fn hour12(&self) -> (bool, u32) {
         let hour = self.hour();
         let mut hour12 = hour % 12;
         if hour12 == 0 {
             hour12 = 12;
         }
         (hour >= 12, hour12)
     }

     /// Returns the minute number from 0 to 59.
     fn minute(&self) -> u32;

     /// Returns the second number from 0 to 59.
     fn second(&self) -> u32;

     /// Returns the number of nanoseconds since the whole non-leap second.
     /// The range from 1,000,000,000 to 1,999,999,999 represents
     /// the [leap second](./naive/struct.NaiveTime.html#leap-second-handling).
     fn nanosecond(&self) -> u32;

     /// Makes a new value with the hour number changed.
     ///
     /// Returns `None` when the resulting value would be invalid.
     fn with_hour(&self, hour: u32) -> Option<Self>;

     /// Makes a new value with the minute number changed.
     ///
     /// Returns `None` when the resulting value would be invalid.
     fn with_minute(&self, min: u32) -> Option<Self>;

     /// Makes a new value with the second number changed.
     ///
     /// Returns `None` when the resulting value would be invalid.
     /// As with the [`second`](#tymethod.second) method,
     /// the input range is restricted to 0 through 59.
     fn with_second(&self, sec: u32) -> Option<Self>;

     /// Makes a new value with nanoseconds since the whole non-leap second changed.
     ///
     /// Returns `None` when the resulting value would be invalid.
     /// As with the [`nanosecond`](#tymethod.nanosecond) method,
     /// the input range can exceed 1,000,000,000 for leap seconds.
     fn with_nanosecond(&self, nano: u32) -> Option<Self>;

     /// Returns the number of non-leap seconds past the last midnight.
     ///
     /// Every value in 00:00:00-23:59:59 maps to an integer in 0-86399.
     ///
     /// This method is not intended to provide the real number of seconds since midnight on a given
     /// day. It does not take things like DST transitions into account.
     #[inline]
     fn num_seconds_from_midnight(&self) -> u32 {
         self.hour() * 3600 + self.minute() * 60 + self.second()
     }
 }

 #[cfg(test)]
 mod tests {
     use super::Datelike;
     use crate::{Days, NaiveDate};

     /// Tests `Datelike::num_days_from_ce` against an alternative implementation.
     ///
     /// The alternative implementation is not as short as the current one but it is simpler to
     /// understand, with less unexplained magic constants.
     #[test]
     fn test_num_days_from_ce_against_alternative_impl() {
         /// Returns the number of multiples of `div` in the range `start..end`.
         ///
         /// If the range `start..end` is back-to-front, i.e. `start` is greater than `end`, the
         /// behaviour is defined by the following equation:
         /// `in_between(start, end, div) == - in_between(end, start, div)`.
         ///
         /// When `div` is 1, this is equivalent to `end - start`, i.e. the length of `start..end`.
         ///
         /// # Panics
         ///
         /// Panics if `div` is not positive.
         fn in_between(start: i32, end: i32, div: i32) -> i32 {
             assert!(div > 0, "in_between: nonpositive div = {}", div);
             let start = (start.div_euclid(div), start.rem_euclid(div));
             let end = (end.div_euclid(div), end.rem_euclid(div));
             // The lowest multiple of `div` greater than or equal to `start`, divided.
             let start = start.0 + (start.1 != 0) as i32;
             // The lowest multiple of `div` greater than or equal to   `end`, divided.
             let end = end.0 + (end.1 != 0) as i32;
             end - start
         }

         /// Alternative implementation to `Datelike::num_days_from_ce`
         fn num_days_from_ce<Date: Datelike>(date: &Date) -> i32 {
             let year = date.year();
             let diff = move |div| in_between(1, year, div);
             // 365 days a year, one more in leap years. In the gregorian calendar, leap years are all
             // the multiples of 4 except multiples of 100 but including multiples of 400.
             date.ordinal() as i32 + 365 * diff(1) + diff(4) - diff(100) + diff(400)
         }

         for year in NaiveDate::MIN.year()..=NaiveDate::MAX.year() {
             let jan1_year = NaiveDate::from_ymd_opt(year, 1, 1).unwrap();
             assert_eq!(
                 jan1_year.num_days_from_ce(),
                 num_days_from_ce(&jan1_year),
                 "on {:?}",
                 jan1_year
             );
             let mid_year = jan1_year + Days::new(133);
             assert_eq!(
                 mid_year.num_days_from_ce(),
                 num_days_from_ce(&mid_year),
                 "on {:?}",
                 mid_year
             );
         }
     }
 }
	use crate::{IsoWeek, Weekday};

	/// The common set of methods for date component.
	///
	/// Methods such as [`year`], [`month`], [`day`] and [`weekday`] can be used to get basic
	/// information about the date.
	///
	/// The `with_*` methods can change the date.
	///
	/// # Warning
	///
	/// The `with_*` methods can be convenient to change a single component of a date, but they must be
	/// used with some care. Examples to watch out for:
	///
	/// - [`with_year`] changes the year component of a year-month-day value. Don't use this method if
	/// you want the ordinal to stay the same after changing the year, of if you want the week and
	/// weekday values to stay the same.
	/// - Don't combine two `with_*` methods to change two components of the date. For example to
	/// change both the year and month components of a date. This could fail because an intermediate
	/// value does not exist, while the final date would be valid.
	///
	/// For more complex changes to a date, it is best to use the methods on [`NaiveDate`] to create a
	/// new value instead of altering an existing date.
	///
	/// [`year`]: Datelike::year
	/// [`month`]: Datelike::month
	/// [`day`]: Datelike::day
	/// [`weekday`]: Datelike::weekday
	/// [`with_year`]: Datelike::with_year
	/// [`NaiveDate`]: crate::NaiveDate
	pub trait Datelike: Sized {
	/// Returns the year number in the [calendar date](./naive/struct.NaiveDate.html#calendar-date).
	fn year(&self) -> i32;

	/// Returns the absolute year number starting from 1 with a boolean flag,
	/// which is false when the year predates the epoch (BCE/BC) and true otherwise (CE/AD).
	#[inline]
	fn year_ce(&self) -> (bool, u32) {
	let year = self.year();
	if year < 1 {
	(false, (1 - year) as u32)
	} else {
	(true, year as u32)
	}
	}

	/// Returns the month number starting from 1.
	///
	/// The return value ranges from 1 to 12.
	fn month(&self) -> u32;

	/// Returns the month number starting from 0.
	///
	/// The return value ranges from 0 to 11.
	fn month0(&self) -> u32;

	/// Returns the day of month starting from 1.
	///
	/// The return value ranges from 1 to 31. (The last day of month differs by months.)
	fn day(&self) -> u32;

	/// Returns the day of month starting from 0.
	///
	/// The return value ranges from 0 to 30. (The last day of month differs by months.)
	fn day0(&self) -> u32;

	/// Returns the day of year starting from 1.
	///
	/// The return value ranges from 1 to 366. (The last day of year differs by years.)
	fn ordinal(&self) -> u32;

	/// Returns the day of year starting from 0.
	///
	/// The return value ranges from 0 to 365. (The last day of year differs by years.)
	fn ordinal0(&self) -> u32;

	/// Returns the day of week.
	fn weekday(&self) -> Weekday;

	/// Returns the ISO week.
	fn iso_week(&self) -> IsoWeek;

	/// Makes a new value with the year number changed, while keeping the same month and day.
	///
	/// This method assumes you want to work on the date as a year-month-day value. Don't use it if
	/// you want the ordinal to stay the same after changing the year, of if you want the week and
	/// weekday values to stay the same.
	///
	/// # Errors
	///
	/// Returns `None` when:
	///
	/// - The resulting date does not exist (February 29 in a non-leap year).
	/// - The year is out of range for [`NaiveDate`].
	/// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
	/// transition such as from DST to standard time.
	///
	/// [`NaiveDate`]: crate::NaiveDate
	/// [`DateTime<Tz>`]: crate::DateTime
	///
	/// # Examples
	///
	/// ```
	/// use chrono::{Datelike, NaiveDate};
	///
	/// assert_eq!(
	/// NaiveDate::from_ymd_opt(2020, 5, 13).unwrap().with_year(2023).unwrap(),
	/// NaiveDate::from_ymd_opt(2023, 5, 13).unwrap()
	/// );
	/// // Resulting date 2023-02-29 does not exist:
	/// assert!(NaiveDate::from_ymd_opt(2020, 2, 29).unwrap().with_year(2023).is_none());
	///
	/// // Don't use `with_year` if you want the ordinal date to stay the same:
	/// assert_ne!(
	/// NaiveDate::from_yo_opt(2020, 100).unwrap().with_year(2023).unwrap(),
	/// NaiveDate::from_yo_opt(2023, 100).unwrap() // result is 2023-101
	/// );
	/// ```
	fn with_year(&self, year: i32) -> Option<Self>;

	/// Makes a new value with the month number (starting from 1) changed.
	///
	/// # Errors
	///
	/// Returns `None` when:
	///
	/// - The resulting date does not exist (for example `month(4)` when day of the month is 31).
	/// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
	/// transition such as from DST to standard time.
	/// - The value for `month` is out of range.
	///
	/// [`DateTime<Tz>`]: crate::DateTime
	///
	/// # Examples
	///
	/// ```
	/// use chrono::{Datelike, NaiveDate};
	///
	/// assert_eq!(
	/// NaiveDate::from_ymd_opt(2023, 5, 12).unwrap().with_month(9).unwrap(),
	/// NaiveDate::from_ymd_opt(2023, 9, 12).unwrap()
	/// );
	/// // Resulting date 2023-09-31 does not exist:
	/// assert!(NaiveDate::from_ymd_opt(2023, 5, 31).unwrap().with_month(9).is_none());
	/// ```
	///
	/// Don't combine multiple `Datelike::with_*` methods. The intermediate value may not exist.
	/// ```
	/// use chrono::{Datelike, NaiveDate};
	///
	/// fn with_year_month(date: NaiveDate, year: i32, month: u32) -> Option<NaiveDate> {
	/// date.with_year(year)?.with_month(month)
	/// }
	/// let d = NaiveDate::from_ymd_opt(2020, 2, 29).unwrap();
	/// assert!(with_year_month(d, 2019, 1).is_none()); // fails because of invalid intermediate value
	///
	/// // Correct version:
	/// fn with_year_month_fixed(date: NaiveDate, year: i32, month: u32) -> Option<NaiveDate> {
	/// NaiveDate::from_ymd_opt(year, month, date.day())
	/// }
	/// let d = NaiveDate::from_ymd_opt(2020, 2, 29).unwrap();
	/// assert_eq!(with_year_month_fixed(d, 2019, 1), NaiveDate::from_ymd_opt(2019, 1, 29));
	/// ```
	fn with_month(&self, month: u32) -> Option<Self>;

	/// Makes a new value with the month number (starting from 0) changed.
	///
	/// # Errors
	///
	/// Returns `None` when:
	///
	/// - The resulting date does not exist (for example `month0(3)` when day of the month is 31).
	/// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
	/// transition such as from DST to standard time.
	/// - The value for `month0` is out of range.
	///
	/// [`DateTime<Tz>`]: crate::DateTime
	fn with_month0(&self, month0: u32) -> Option<Self>;

	/// Makes a new value with the day of month (starting from 1) changed.
	///
	/// # Errors
	///
	/// Returns `None` when:
	///
	/// - The resulting date does not exist (for example `day(31)` in April).
	/// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
	/// transition such as from DST to standard time.
	/// - The value for `day` is out of range.
	///
	/// [`DateTime<Tz>`]: crate::DateTime
	fn with_day(&self, day: u32) -> Option<Self>;

	/// Makes a new value with the day of month (starting from 0) changed.
	///
	/// # Errors
	///
	/// Returns `None` when:
	///
	/// - The resulting date does not exist (for example `day0(30)` in April).
	/// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
	/// transition such as from DST to standard time.
	/// - The value for `day0` is out of range.
	///
	/// [`DateTime<Tz>`]: crate::DateTime
	fn with_day0(&self, day0: u32) -> Option<Self>;

	/// Makes a new value with the day of year (starting from 1) changed.
	///
	/// # Errors
	///
	/// Returns `None` when:
	///
	/// - The resulting date does not exist (`with_ordinal(366)` in a non-leap year).
	/// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
	/// transition such as from DST to standard time.
	/// - The value for `ordinal` is out of range.
	///
	/// [`DateTime<Tz>`]: crate::DateTime
	fn with_ordinal(&self, ordinal: u32) -> Option<Self>;

	/// Makes a new value with the day of year (starting from 0) changed.
	///
	/// # Errors
	///
	/// Returns `None` when:
	///
	/// - The resulting date does not exist (`with_ordinal0(365)` in a non-leap year).
	/// - In case of [`DateTime<Tz>`] if the resulting date and time fall within a timezone
	/// transition such as from DST to standard time.
	/// - The value for `ordinal0` is out of range.
	///
	/// [`DateTime<Tz>`]: crate::DateTime
	fn with_ordinal0(&self, ordinal0: u32) -> Option<Self>;

	/// Counts the days in the proleptic Gregorian calendar, with January 1, Year 1 (CE) as day 1.
	///
	/// # Examples
	///
	/// ```
	/// use chrono::{Datelike, NaiveDate};
	///
	/// assert_eq!(NaiveDate::from_ymd_opt(1970, 1, 1).unwrap().num_days_from_ce(), 719_163);
	/// assert_eq!(NaiveDate::from_ymd_opt(2, 1, 1).unwrap().num_days_from_ce(), 366);
	/// assert_eq!(NaiveDate::from_ymd_opt(1, 1, 1).unwrap().num_days_from_ce(), 1);
	/// assert_eq!(NaiveDate::from_ymd_opt(0, 1, 1).unwrap().num_days_from_ce(), -365);
	/// ```
	fn num_days_from_ce(&self) -> i32 {
	// See test_num_days_from_ce_against_alternative_impl below for a more straightforward
	// implementation.

	// we know this wouldn't overflow since year is limited to 1/2^13 of i32's full range.
	let mut year = self.year() - 1;
	let mut ndays = 0;
	if year < 0 {
	let excess = 1 + (-year) / 400;
	year += excess * 400;
	ndays -= excess * 146_097;
	}
	let div_100 = year / 100;
	ndays += ((year * 1461) >> 2) - div_100 + (div_100 >> 2);
	ndays + self.ordinal() as i32
	}
	}

	/// The common set of methods for time component.
	pub trait Timelike: Sized {
	/// Returns the hour number from 0 to 23.
	fn hour(&self) -> u32;

	/// Returns the hour number from 1 to 12 with a boolean flag,
	/// which is false for AM and true for PM.
	#[inline]
	fn hour12(&self) -> (bool, u32) {
	let hour = self.hour();
	let mut hour12 = hour % 12;
	if hour12 == 0 {
	hour12 = 12;
	}
	(hour >= 12, hour12)
	}

	/// Returns the minute number from 0 to 59.
	fn minute(&self) -> u32;

	/// Returns the second number from 0 to 59.
	fn second(&self) -> u32;

	/// Returns the number of nanoseconds since the whole non-leap second.
	/// The range from 1,000,000,000 to 1,999,999,999 represents
	/// the [leap second](./naive/struct.NaiveTime.html#leap-second-handling).
	fn nanosecond(&self) -> u32;

	/// Makes a new value with the hour number changed.
	///
	/// Returns `None` when the resulting value would be invalid.
	fn with_hour(&self, hour: u32) -> Option<Self>;

	/// Makes a new value with the minute number changed.
	///
	/// Returns `None` when the resulting value would be invalid.
	fn with_minute(&self, min: u32) -> Option<Self>;

	/// Makes a new value with the second number changed.
	///
	/// Returns `None` when the resulting value would be invalid.
	/// As with the [`second`](#tymethod.second) method,
	/// the input range is restricted to 0 through 59.
	fn with_second(&self, sec: u32) -> Option<Self>;

	/// Makes a new value with nanoseconds since the whole non-leap second changed.
	///
	/// Returns `None` when the resulting value would be invalid.
	/// As with the [`nanosecond`](#tymethod.nanosecond) method,
	/// the input range can exceed 1,000,000,000 for leap seconds.
	fn with_nanosecond(&self, nano: u32) -> Option<Self>;

	/// Returns the number of non-leap seconds past the last midnight.
	///
	/// Every value in 00:00:00-23:59:59 maps to an integer in 0-86399.
	///
	/// This method is not intended to provide the real number of seconds since midnight on a given
	/// day. It does not take things like DST transitions into account.
	#[inline]
	fn num_seconds_from_midnight(&self) -> u32 {
	self.hour() * 3600 + self.minute() * 60 + self.second()
	}
	}

	#[cfg(test)]
	mod tests {
	use super::Datelike;
	use crate::{Days, NaiveDate};

	/// Tests `Datelike::num_days_from_ce` against an alternative implementation.
	///
	/// The alternative implementation is not as short as the current one but it is simpler to
	/// understand, with less unexplained magic constants.
	#[test]
	fn test_num_days_from_ce_against_alternative_impl() {
	/// Returns the number of multiples of `div` in the range `start..end`.
	///
	/// If the range `start..end` is back-to-front, i.e. `start` is greater than `end`, the
	/// behaviour is defined by the following equation:
	/// `in_between(start, end, div) == - in_between(end, start, div)`.
	///
	/// When `div` is 1, this is equivalent to `end - start`, i.e. the length of `start..end`.
	///
	/// # Panics
	///
	/// Panics if `div` is not positive.
	fn in_between(start: i32, end: i32, div: i32) -> i32 {
	assert!(div > 0, "in_between: nonpositive div = {}", div);
	let start = (start.div_euclid(div), start.rem_euclid(div));
	let end = (end.div_euclid(div), end.rem_euclid(div));
	// The lowest multiple of `div` greater than or equal to `start`, divided.
	let start = start.0 + (start.1 != 0) as i32;
	// The lowest multiple of `div` greater than or equal to `end`, divided.
	let end = end.0 + (end.1 != 0) as i32;
	end - start
	}

	/// Alternative implementation to `Datelike::num_days_from_ce`
	fn num_days_from_ce<Date: Datelike>(date: &Date) -> i32 {
	let year = date.year();
	let diff = move \|div\| in_between(1, year, div);
	// 365 days a year, one more in leap years. In the gregorian calendar, leap years are all
	// the multiples of 4 except multiples of 100 but including multiples of 400.
	date.ordinal() as i32 + 365 * diff(1) + diff(4) - diff(100) + diff(400)
	}

	for year in NaiveDate::MIN.year()..=NaiveDate::MAX.year() {
	let jan1_year = NaiveDate::from_ymd_opt(year, 1, 1).unwrap();
	assert_eq!(
	jan1_year.num_days_from_ce(),
	num_days_from_ce(&jan1_year),
	"on {:?}",
	jan1_year
	);
	let mid_year = jan1_year + Days::new(133);
	assert_eq!(
	mid_year.num_days_from_ce(),
	num_days_from_ce(&mid_year),
	"on {:?}",
	mid_year
	);
	}
	}
	}