Chrono

https://docs.rs/chrono/latest
Admin
Chrono is a Rust library providing comprehensive date and time functionality with timezone support,...
Tokens:623,052
Snippets:4,978
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Localized Date Formatting Setup

Source: https://docs.rs/chrono/latest/src/chrono/format/strftime.rs.html

Setup for testing localized date formatting, requiring specific feature flags.

```rust
#[test]
#[cfg(all(feature = "unstable-locales", feature = "alloc"))]
fn test_strftime_docs_localized() {
    let dt = FixedOffset::east_opt(34200)
        .unwrap()
        .with_ymd_and_hms(2001, 7, 8, 0, 34, 59)
        .unwrap()
```

--------------------------------

### ISO Week Formatting Examples

Source: https://docs.rs/chrono/latest/src/chrono/naive/isoweek.rs.html

Examples demonstrating how IsoWeek formats dates into ISO 8601 strings, including handling of years outside the 0-9999 range.

```rust
assert_eq!(
    format!("{:?}", NaiveDate::from_ymd_opt(2015, 9, 5).unwrap().iso_week()),
    "2015-W36"
);
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(0, 1, 3).unwrap().iso_week()), "0000-W01");
assert_eq!(
    format!("{:?}", NaiveDate::from_ymd_opt(9999, 12, 31).unwrap().iso_week()),
    "9999-W52"
);
```

```rust
# use chrono::{NaiveDate, Datelike};
assert_eq!(format!("{:?}", NaiveDate::from_ymd_opt(0, 1, 2).unwrap().iso_week()), "-0001-W52");
assert_eq!(
    format!("{:?}", NaiveDate::from_ymd_opt(10000, 12, 31).unwrap().iso_week()),
    "+10000-W52"
);
```

--------------------------------

### Debug Formatting Example

Source: https://docs.rs/chrono/latest/src/chrono/naive/isoweek.rs.html

Shows the Debug output format for an ISO week.

```rust
use chrono::{Datelike, NaiveDate};

assert_eq!(
```

--------------------------------

### Retrieve the day of the month from NaiveDate

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html

Returns the day of the month starting from 1. Includes an example of calculating days in a month.

```rust
use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().day(), 8);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().day(), 14);
```

```rust
use chrono::{Datelike, NaiveDate};

fn ndays_in_month(year: i32, month: u32) -> u32 {
    // the first day of the next month...
    let (y, m) = if month == 12 { (year + 1, 1) } else { (year, month + 1) };
    let d = NaiveDate::from_ymd_opt(y, m, 1).unwrap();

    // ...is preceded by the last day of the original month
    d.pred_opt().unwrap().day()
}

assert_eq!(ndays_in_month(2015, 8), 31);
assert_eq!(ndays_in_month(2015, 9), 30);
assert_eq!(ndays_in_month(2015, 12), 31);
assert_eq!(ndays_in_month(2016, 2), 29);
assert_eq!(ndays_in_month(2017, 2), 28);
```

--------------------------------

### Add TimeDelta to NaiveDateTime

Source: https://docs.rs/chrono/latest/src/chrono/naive/datetime/mod.rs.html?search=

Demonstrates the setup for adding a TimeDelta to a NaiveDateTime.

```rust
use chrono::{NaiveDate, TimeDelta};

let from_ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();

let d = from_ymd(2016, 7, 8);
```

--------------------------------

### Get Last Weekday

Source: https://docs.rs/chrono/latest/src/chrono/weekday_set.rs.html

Retrieves the last weekday in the collection, starting from Sunday.

```rust
# use chrono::WeekdaySet;
use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).last(), Some(Mon));
assert_eq!(WeekdaySet::single(Sun).last(), Some(Sun));
assert_eq!(WeekdaySet::from_array([Mon, Tue]).last(), Some(Tue));
assert_eq!(WeekdaySet::EMPTY.last(), None);
```

--------------------------------

### Example search queries

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html?search=

Common search patterns used for finding types and functions in the documentation.

```text
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Get the day of the year from NaiveDateTime

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Retrieves the day of the year, starting from 1.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal(), 268);
```

--------------------------------

### Get the day of the month from NaiveDateTime

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Retrieves the day of the month, starting from 1.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day(), 25);
```

--------------------------------

### Create a standard StrftimeItems parser

Source: https://docs.rs/chrono/latest/chrono/format/strftime/struct.StrftimeItems.html

Demonstrates creating a parser for a standard ISO 8601 format string and verifying the resulting items.

```rust
use chrono::format::*;

let strftime_parser = StrftimeItems::new("%F"); // %F: year-month-day (ISO 8601)

const ISO8601_YMD_ITEMS: &[Item<'static>] = &[
    Item::Numeric(Numeric::Year, Pad::Zero),
    Item::Literal("-"),
    Item::Numeric(Numeric::Month, Pad::Zero),
    Item::Literal("-"),
    Item::Numeric(Numeric::Day, Pad::Zero),
];
assert!(strftime_parser.eq(ISO8601_YMD_ITEMS.iter().cloned()));
```

--------------------------------

### Get the zero-indexed day of the year from NaiveDateTime

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Retrieves the day of the year, starting from 0.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal0(), 267);
```

--------------------------------

### Get the zero-indexed day of the month from NaiveDateTime

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Retrieves the day of the month, starting from 0.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day0(), 24);
```

--------------------------------

### DateTime Construction and Manipulation

Source: https://docs.rs/chrono/latest/src/chrono/lib.rs.html?search=std%3A%3Avec

Examples of how to retrieve current time, construct specific date-time instances, and access date/time properties.

```APIDOC
## DateTime Operations

### Description
Retrieve current time in UTC or Local time zones, or construct custom DateTime objects using various initialization methods.

### Usage
- `Utc::now()`: Get current UTC time.
- `Local::now()`: Get current local time.
- `Utc.with_ymd_and_hms(...)`: Construct a UTC DateTime.
- `Datelike` / `Timelike` traits: Access properties like year, month, day, hour, minute, second.

### Example
```rust
use chrono::prelude::*;

// Get current time
let utc: DateTime<Utc> = Utc::now();
let local: DateTime<Local> = Local::now();

// Construct custom date
let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap();

// Access properties
assert_eq!((dt.year(), dt.month(), dt.day()), (2014, 7, 8));
```
```

--------------------------------

### Get the last day in WeekdaySet

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html?search=

Retrieves the last day in the collection starting from Sunday, returning None if empty.

```rust
use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).last(), Some(Mon));
assert_eq!(WeekdaySet::single(Sun).last(), Some(Sun));
assert_eq!(WeekdaySet::from_array([Mon, Tue]).last(), Some(Tue));
assert_eq!(WeekdaySet::EMPTY.last(), None);
```

--------------------------------

### Parsing with format::parse

Source: https://docs.rs/chrono/latest/src/chrono/format/parsed.rs.html?search=

Demonstrates using the built-in parser and inspecting fields on failure.

```rust
# #[cfg(feature = "alloc")] {
use chrono::format::{parse, Fixed, Item, Parsed};
use chrono::Weekday;

let rfc_2822 = [Item::Fixed(Fixed::RFC2822)];

let mut parsed = Parsed::new();
parse(&mut parsed, "Wed, 31 Dec 2014 04:26:40 +0000", rfc_2822.iter())?;
let dt = parsed.to_datetime()?;

assert_eq!(dt.to_rfc2822(), "Wed, 31 Dec 2014 04:26:40 +0000");

let mut parsed = Parsed::new();
parse(&mut parsed, "Thu, 31 Dec 2014 04:26:40 +0000", rfc_2822.iter())?;
let result = parsed.to_datetime();

assert!(result.is_err());
if result.is_err() {
    // What is the weekday?
}
```

--------------------------------

### Get the first day in WeekdaySet

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html?search=

Retrieves the first day in the collection starting from Monday, returning None if empty.

```rust
use chrono::Weekday::*;
assert_eq!(WeekdaySet::single(Mon).first(), Some(Mon));
assert_eq!(WeekdaySet::single(Tue).first(), Some(Tue));
assert_eq!(WeekdaySet::ALL.first(), Some(Mon));
assert_eq!(WeekdaySet::EMPTY.first(), None);
```

--------------------------------

### Constructing and Querying TimeZones

Source: https://docs.rs/chrono/latest/src/chrono/offset/local/tz_info/timezone.rs.html

Demonstrates creating TimeZone instances with various transition rules and querying local time types.

```rust
let utc_local_time_types = vec![utc];
        let fixed_extra_rule = TransitionRule::from(cet);

        let time_zone_1 = TimeZone::new(vec![], utc_local_time_types.clone(), vec![], None)?;
        let time_zone_2 =
            TimeZone::new(vec![], utc_local_time_types.clone(), vec![], Some(fixed_extra_rule))?;
        let time_zone_3 =
            TimeZone::new(vec![Transition::new(0, 0)], utc_local_time_types.clone(), vec![], None)?;
        let time_zone_4 = TimeZone::new(
            vec![Transition::new(i32::MIN.into(), 0), Transition::new(0, 1)],
            vec![utc, cet],
            Vec::new(),
            Some(fixed_extra_rule),
        )?;

        assert_eq!(*time_zone_1.find_local_time_type(0)?, utc);
        assert_eq!(*time_zone_2.find_local_time_type(0)?, cet);

        assert_eq!(*time_zone_3.find_local_time_type(-1)?, utc);
        assert_eq!(*time_zone_3.find_local_time_type(0)?, utc);

        assert_eq!(*time_zone_4.find_local_time_type(-1)?, utc);
        assert_eq!(*time_zone_4.find_local_time_type(0)?, cet);

        let time_zone_err = TimeZone::new(
            vec![Transition::new(0, 0)],
            utc_local_time_types,
            vec![],
            Some(fixed_extra_rule),
        );
        assert!(time_zone_err.is_err());

        Ok(())
```

--------------------------------

### Retrieve the ordinal day of the year from NaiveDate

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html

Returns the day of the year starting from 1 (1-366). Includes an example of calculating days in a year.

```rust
use chrono::{Datelike, NaiveDate};

assert_eq!(NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().ordinal(), 251);
assert_eq!(NaiveDate::from_ymd_opt(-308, 3, 14).unwrap().ordinal(), 74);
```

```rust
use chrono::{Datelike, NaiveDate};

fn ndays_in_year(year: i32) -> u32 {
    // the first day of the next year...
    let d = NaiveDate::from_ymd_opt(year + 1, 1, 1).unwrap();

    // ...is preceded by the last day of the original year
    d.pred_opt().unwrap().ordinal()
}

assert_eq!(ndays_in_year(2015), 365);
assert_eq!(ndays_in_year(2016), 366);
assert_eq!(ndays_in_year(2017), 365);
assert_eq!(ndays_in_year(2000), 366);
assert_eq!(ndays_in_year(2100), 365);
```

--------------------------------

### Constructing Date and Time Objects

Source: https://docs.rs/chrono/latest/chrono/index.html

Demonstrates creating date and time instances using different calendar systems and precision levels. Note that these methods return Option or MappedLocalTime, requiring handling of invalid inputs.

```rust
use chrono::offset::MappedLocalTime;
use chrono::prelude::*;


let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap(); // `2014-07-08T09:10:11Z`
assert_eq!(
    dt,
    NaiveDate::from_ymd_opt(2014, 7, 8)?
        .and_hms_opt(9, 10, 11)?
        .and_utc()
);

// July 8 is 188th day of the year 2014 (`o` for "ordinal")
assert_eq!(dt, NaiveDate::from_yo_opt(2014, 189)?.and_hms_opt(9, 10, 11)?.and_utc());
// July 8 is Tuesday in ISO week 28 of the year 2014.
assert_eq!(
    dt,
    NaiveDate::from_isoywd_opt(2014, 28, Weekday::Tue)?.and_hms_opt(9, 10, 11)?.and_utc()
);

let dt = NaiveDate::from_ymd_opt(2014, 7, 8)?
    .and_hms_milli_opt(9, 10, 11, 12)?
    .and_utc(); // `2014-07-08T09:10:11.012Z`
assert_eq!(
    dt,
    NaiveDate::from_ymd_opt(2014, 7, 8)?
        .and_hms_micro_opt(9, 10, 11, 12_000)?
        .and_utc()
);
assert_eq!(
    dt,
    NaiveDate::from_ymd_opt(2014, 7, 8)?
        .and_hms_nano_opt(9, 10, 11, 12_000_000)?
        .and_utc()
);

// dynamic verification
assert_eq!(
    Utc.with_ymd_and_hms(2014, 7, 8, 21, 15, 33),
    MappedLocalTime::Single(
        NaiveDate::from_ymd_opt(2014, 7, 8)?.and_hms_opt(21, 15, 33)?.and_utc()
    )
);
assert_eq!(Utc.with_ymd_and_hms(2014, 7, 8, 80, 15, 33), MappedLocalTime::None);
assert_eq!(Utc.with_ymd_and_hms(2014, 7, 38, 21, 15, 33), MappedLocalTime::None);

// other time zone objects can be used to construct a local datetime.
// obviously, `local_dt` is normally different from `dt`, but `fixed_dt` should be identical.
let local_dt = Local
    .from_local_datetime(
        &NaiveDate::from_ymd_opt(2014, 7, 8).unwrap().and_hms_milli_opt(9, 10, 11, 12).unwrap(),
    )
    .unwrap();
let fixed_dt = FixedOffset::east_opt(9 * 3600)
    .unwrap()
    .from_local_datetime(
        &NaiveDate::from_ymd_opt(2014, 7, 8)
            .unwrap()
            .and_hms_milli_opt(18, 10, 11, 12)
            .unwrap(),
    )
    .unwrap();
assert_eq!(dt, fixed_dt);
```

--------------------------------

### Configuring TransitionRule with Negative Offsets

Source: https://docs.rs/chrono/latest/src/chrono/offset/local/tz_info/rule.rs.html?search=

Demonstrates creating TransitionRule instances with negative time offsets and verifying the resulting local time types.

```rust
assert_eq!(transition_rule_negative_dst.find_local_time_type(972781200)?.offset(), 0);

let transition_rule_negative_time_1 = TransitionRule::from(AlternateTime::new(
    LocalTimeType::new(0, false, None)?,
    LocalTimeType::new(0, true, None)?,
    RuleDay::julian_0(100)?,
    0,
    RuleDay::julian_0(101)?,
    -86500,
)?);

assert!(transition_rule_negative_time_1.find_local_time_type(8639899)?.is_dst());
assert!(!transition_rule_negative_time_1.find_local_time_type(8639900)?.is_dst());
assert!(!transition_rule_negative_time_1.find_local_time_type(8639999)?.is_dst());
assert!(transition_rule_negative_time_1.find_local_time_type(8640000)?.is_dst());

let transition_rule_negative_time_2 = TransitionRule::from(AlternateTime::new(
    LocalTimeType::new(-10800, false, Some(b"-03"))?,
    LocalTimeType::new(-7200, true, Some(b"-02"))?,
    RuleDay::month_weekday(3, 5, 0)?,
    -7200,
    RuleDay::month_weekday(10, 5, 0)?,
    -3600,
)?);

assert_eq!(
    transition_rule_negative_time_2.find_local_time_type(954032399)?.offset(),
    -10800
);
assert_eq!(
    transition_rule_negative_time_2.find_local_time_type(954032400)?.offset(),
    -7200
);
assert_eq!(
    transition_rule_negative_time_2.find_local_time_type(972781199)?.offset(),
    -7200
);
assert_eq!(
    transition_rule_negative_time_2.find_local_time_type(972781200)?.offset(),
    -10800
);

let transition_rule_all_year_dst = TransitionRule::from(AlternateTime::new(
    LocalTimeType::new(-18000, false, Some(b"EST"))?,
    LocalTimeType::new(-14400, true, Some(b"EDT"))?,
    RuleDay::julian_0(0)?,
    0,
    RuleDay::julian_1(365)?,
    90000,
)?);

assert_eq!(transition_rule_all_year_dst.find_local_time_type(946702799)?.offset(), -14400);
assert_eq!(transition_rule_all_year_dst.find_local_time_type(946702800)?.offset(), -14400);

Ok(())
```

--------------------------------

### RoundingError Usage Examples

Source: https://docs.rs/chrono/latest/src/chrono/round.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples demonstrating scenarios where rounding operations return specific error variants.

```rust
# use chrono::{DurationRound, TimeDelta, RoundingError, NaiveDate};
let dt = NaiveDate::from_ymd_opt(2260, 12, 31)
    .unwrap()
    .and_hms_nano_opt(23, 59, 59, 1_75_500_000)
    .unwrap()
    .and_utc();

assert_eq!(
    dt.duration_round(TimeDelta::try_days(300 * 365).unwrap()),
    Err(RoundingError::DurationExceedsLimit)
);
```

```rust
# use chrono::{DurationRound, TimeDelta, RoundingError, TimeZone, Utc};
let dt = Utc.with_ymd_and_hms(2300, 12, 12, 0, 0, 0).unwrap();

assert_eq!(
    dt.duration_round(TimeDelta::try_days(1).unwrap()),
    Err(RoundingError::TimestampExceedsLimit)
);
```

--------------------------------

### Create NaiveTime from seconds since midnight and nanoseconds

Source: https://docs.rs/chrono/latest/src/chrono/naive/time/mod.rs.html

Demonstrates creating a NaiveTime instance using from_num_seconds_from_midnight_opt.

```rust
use chrono::NaiveTime;

let from_nsecs_opt = NaiveTime::from_num_seconds_from_midnight_opt;

assert!(from_nsecs_opt(0, 0).is_some());
```

--------------------------------

### Constructing TimeZone Instances

Source: https://docs.rs/chrono/latest/src/chrono/offset/local/tz_info/timezone.rs.html?search=std%3A%3Avec

Demonstrates creating TimeZone objects with different transition rules and local time types, including error handling for invalid configurations.

```rust
let utc_local_time_types = vec![utc];
let fixed_extra_rule = TransitionRule::from(cet);

let time_zone_1 = TimeZone::new(vec![], utc_local_time_types.clone(), vec![], None)?;
let time_zone_2 =
    TimeZone::new(vec![], utc_local_time_types.clone(), vec![], Some(fixed_extra_rule))?;
let time_zone_3 =
    TimeZone::new(vec![Transition::new(0, 0)], utc_local_time_types.clone(), vec![], None)?;
let time_zone_4 = TimeZone::new(
    vec![Transition::new(i32::MIN.into(), 0), Transition::new(0, 1)],
    vec![utc, cet],
    Vec::new(),
    Some(fixed_extra_rule),
)?;

assert_eq!(*time_zone_1.find_local_time_type(0)?, utc);
assert_eq!(*time_zone_2.find_local_time_type(0)?, cet);

assert_eq!(*time_zone_3.find_local_time_type(-1)?, utc);
assert_eq!(*time_zone_3.find_local_time_type(0)?, utc);

assert_eq!(*time_zone_4.find_local_time_type(-1)?, utc);
assert_eq!(*time_zone_4.find_local_time_type(0)?, cet);

let time_zone_err = TimeZone::new(
    vec![Transition::new(0, 0)],
    utc_local_time_types,
    vec![],
    Some(fixed_extra_rule),
);
assert!(time_zone_err.is_err());

Ok(())
```

--------------------------------

### iter(start: Weekday)

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Iterates over the Weekdays in the collection starting from a given day, wrapping around from Sunday to Monday.

```APIDOC
## pub const fn iter(self, start: Weekday) -> WeekdaySetIter

### Description
Iterate over the Weekdays in the collection starting from a given day. Wraps around from Sunday to Monday if necessary.
```

--------------------------------

### Constructing Local DateTime Instances

Source: https://docs.rs/chrono/latest/chrono/offset/struct.Local.html

Demonstrates creating DateTime<Local> instances using the current time or a specific timestamp.

```rust
use chrono::{DateTime, Local, TimeZone};

let dt1: DateTime<Local> = Local::now();
let dt2: DateTime<Local> = Local.timestamp_opt(0, 0).unwrap();
assert!(dt1 >= dt2);
```

--------------------------------

### Format and Parse Date and Time

Source: https://docs.rs/chrono/latest/chrono/format/index.html

Demonstrates using format strings to convert a DateTime object to a string and parsing it back into a NaiveDateTime.

```rust
use chrono::{NaiveDateTime, TimeZone, Utc};

let date_time = Utc.with_ymd_and_hms(2020, 11, 10, 0, 1, 32).unwrap();

let formatted = format!("{}", date_time.format("%Y-%m-%d %H:%M:%S"));
assert_eq!(formatted, "2020-11-10 00:01:32");

let parsed = NaiveDateTime::parse_from_str(&formatted, "%Y-%m-%d %H:%M:%S")?.and_utc();
assert_eq!(parsed, date_time);
```

--------------------------------

### ordinal0()

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html?search=u32+-%3E+bool

Returns the day of year starting from 0.

```APIDOC
## fn ordinal0(&self) -> u32

### Description
Returns the day of year starting from 0. The return value ranges from 0 to 365.

### Returns
- **u32** - The day of year (0-365).
```

--------------------------------

### Create NaiveDateTime with Microseconds

Source: https://docs.rs/chrono/latest/src/chrono/naive/date/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating a NaiveDateTime from a date and time components with microsecond precision.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime, Timelike, Weekday};

let d = NaiveDate::from_ymd_opt(2015, 6, 3).unwrap();

let dt: NaiveDateTime = d.and_hms_micro_opt(12, 34, 56, 789_012).unwrap();
assert_eq!(dt.year(), 2015);
assert_eq!(dt.weekday(), Weekday::Wed);
assert_eq!(dt.second(), 56);
assert_eq!(dt.nanosecond(), 789_012_000);
```

--------------------------------

### ordinal()

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html?search=u32+-%3E+bool

Returns the day of year starting from 1.

```APIDOC
## fn ordinal(&self) -> u32

### Description
Returns the day of year starting from 1. The return value ranges from 1 to 366.

### Returns
- **u32** - The day of year (1-366).
```

--------------------------------

### Retrieve the first day of a week

Source: https://docs.rs/chrono/latest/src/chrono/naive/mod.rs.html

Demonstrates how to get the first day of a week using first_day and checked_first_day.

```rust
use chrono::{NaiveDate, Weekday};

let date = NaiveDate::from_ymd_opt(2022, 4, 18).unwrap();
let week = date.week(Weekday::Mon);
assert!(week.first_day() <= date);
```

```rust
use chrono::{NaiveDate, Weekday};

let date = NaiveDate::MIN;
let week = date.week(Weekday::Mon);
if let Some(first_day) = week.checked_first_day() {
    assert!(first_day == date);
} else {
    // error handling code
    return;
};
```

--------------------------------

### day0()

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html?search=u32+-%3E+bool

Returns the day of month starting from 0.

```APIDOC
## fn day0(&self) -> u32

### Description
Returns the day of month starting from 0. The return value ranges from 0 to 30.

### Returns
- **u32** - The day of month (0-30).
```

--------------------------------

### Create DateTime from components

Source: https://docs.rs/chrono/latest/chrono/struct.DateTime.html?search=

Demonstrates using from_naive_utc_and_offset to reconstruct a DateTime from its constituent parts, typically for FFI or serialization.

```rust
use chrono::{DateTime, Local};

let dt = Local::now();
// Get components
let naive_utc = dt.naive_utc();
let offset = dt.offset().clone();
// Serialize, pass through FFI... and recreate the `DateTime`:
let dt_new = DateTime::<Local>::from_naive_utc_and_offset(naive_utc, offset);
assert_eq!(dt, dt_new);
```

--------------------------------

### day()

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html?search=u32+-%3E+bool

Returns the day of month starting from 1.

```APIDOC
## fn day(&self) -> u32

### Description
Returns the day of month starting from 1. The return value ranges from 1 to 31.

### Returns
- **u32** - The day of month (1-31).
```

--------------------------------

### month0()

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html?search=u32+-%3E+bool

Returns the month number starting from 0.

```APIDOC
## fn month0(&self) -> u32

### Description
Returns the month number starting from 0. The return value ranges from 0 to 11.

### Returns
- **u32** - The month number (0-11).
```

--------------------------------

### month()

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html?search=u32+-%3E+bool

Returns the month number starting from 1.

```APIDOC
## fn month(&self) -> u32

### Description
Returns the month number starting from 1. The return value ranges from 1 to 12.

### Returns
- **u32** - The month number (1-12).
```

--------------------------------

### Create DateTime from seconds

Source: https://docs.rs/chrono/latest/chrono/offset/trait.TimeZone.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Use timestamp_opt to create a DateTime from UNIX seconds without panicking.

```rust
use chrono::{TimeZone, Utc};

assert_eq!(Utc.timestamp_opt(1431648000, 0).unwrap().to_string(), "2015-05-15 00:00:00 UTC");
```

--------------------------------

### Parsing and using format items

Source: https://docs.rs/chrono/latest/chrono/format/strftime/struct.StrftimeItems.html

Demonstrates parsing a format string into a Vec of Items and using them for both formatting and parsing operations.

```rust
use chrono::format::{parse, Parsed, StrftimeItems};
use chrono::NaiveDate;

let fmt_items = StrftimeItems::new("%e %b %Y %k.%M").parse()?;
let datetime = NaiveDate::from_ymd_opt(2023, 7, 11).unwrap().and_hms_opt(9, 0, 0).unwrap();

// Formatting
assert_eq!(
    datetime.format_with_items(fmt_items.as_slice().iter()).to_string(),
    "11 Jul 2023  9.00"
);

// Parsing
let mut parsed = Parsed::new();
parse(&mut parsed, "11 Jul 2023  9.00", fmt_items.as_slice().iter())?;
let parsed_dt = parsed.to_naive_datetime_with_offset(0)?;
assert_eq!(parsed_dt, datetime);
```

--------------------------------

### Get the weekday from NaiveDateTime

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html

Retrieves the day of the week.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime, Weekday};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.weekday(), Weekday::Fri);
```

--------------------------------

### iter()

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html?search=

Iterates over the Weekdays in the collection starting from a given day.

```APIDOC
## pub const fn iter(self, start: Weekday) -> WeekdaySetIter

### Description
Iterates over the `Weekday`s in the collection starting from a given day. Wraps around from Sunday to Monday if necessary.
```

--------------------------------

### Weekday Usage Examples

Source: https://docs.rs/chrono/latest/chrono/enum.Weekday.html?search=std%3A%3Avec

Demonstrates parsing, conversion, and numerical indexing methods for the Weekday type.

```rust
use chrono::Weekday;

let monday = "Monday".parse::<Weekday>().unwrap();
assert_eq!(monday, Weekday::Mon);

let sunday = Weekday::try_from(6).unwrap();
assert_eq!(sunday, Weekday::Sun);

assert_eq!(sunday.num_days_from_monday(), 6); // starts counting with Monday = 0
assert_eq!(sunday.number_from_monday(), 7); // starts counting with Monday = 1
assert_eq!(sunday.num_days_from_sunday(), 0); // starts counting with Sunday = 0
assert_eq!(sunday.number_from_sunday(), 1); // starts counting with Sunday = 1

assert_eq!(sunday.succ(), monday);
assert_eq!(sunday.pred(), Weekday::Sat);
```

--------------------------------

### last()

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html?search=

Retrieves the last day in the collection, starting from Sunday.

```APIDOC
## pub fn last(self) -> Option<Weekday>

### Description
Returns the last day in the collection, starting from Sunday. Returns `None` if the collection is empty.
```

--------------------------------

### Indexing Weekdays with num_days_from_monday

Source: https://docs.rs/chrono/latest/chrono/enum.Weekday.html?search=std%3A%3Avec

Shows how to use num_days_from_monday to index into an array of characters.

```rust
// MTWRFSU is occasionally used as a single-letter abbreviation of the weekdays.
// Use `num_days_from_monday` to index into the array.
const MTWRFSU: [char; 7] = ['M', 'T', 'W', 'R', 'F', 'S', 'U'];

let today = Local::now().weekday();
println!("{}", MTWRFSU[today.num_days_from_monday() as usize]);
```

--------------------------------

### first()

Source: https://docs.rs/chrono/latest/chrono/struct.WeekdaySet.html?search=

Retrieves the first day in the collection, starting from Monday.

```APIDOC
## pub const fn first(self) -> Option<Weekday>

### Description
Returns the first day in the collection, starting from Monday. Returns `None` if the collection is empty.
```

--------------------------------

### Format and localize date-time strings

Source: https://docs.rs/chrono/latest/chrono/index.html

Demonstrates formatting date-time objects using standard specifiers, RFC formats, and localized strings.

```rust
use chrono::prelude::*;

let dt = Utc.with_ymd_and_hms(2014, 11, 28, 12, 0, 9).unwrap();
assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(), "2014-11-28 12:00:09");
assert_eq!(dt.format("%a %b %e %T %Y").to_string(), "Fri Nov 28 12:00:09 2014");
assert_eq!(
    dt.format_localized("%A %e %B %Y, %T", Locale::fr_BE).to_string(),
    "vendredi 28 novembre 2014, 12:00:09"
);

assert_eq!(dt.format("%a %b %e %T %Y").to_string(), dt.format("%c").to_string());
assert_eq!(dt.to_string(), "2014-11-28 12:00:09 UTC");
assert_eq!(dt.to_rfc2822(), "Fri, 28 Nov 2014 12:00:09 +0000");
assert_eq!(dt.to_rfc3339(), "2014-11-28T12:00:09+00:00");
assert_eq!(format!("{:?}", dt), "2014-11-28T12:00:09Z");

// Note that milli/nanoseconds are only printed if they are non-zero
let dt_nano = NaiveDate::from_ymd_opt(2014, 11, 28)
    .unwrap()
    .and_hms_nano_opt(12, 0, 9, 1)
    .unwrap()
    .and_utc();
assert_eq!(format!("{:?}", dt_nano), "2014-11-28T12:00:09.000000001Z");
```

--------------------------------

### Accessing time components

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html?search=

Examples of retrieving hour, minute, second, and nanosecond from a NaiveDateTime instance.

```rust
use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.hour(), 12);
```

```rust
use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.minute(), 34);
```

```rust
use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.second(), 56);
```

```rust
use chrono::{NaiveDate, NaiveDateTime, Timelike};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 8).unwrap().and_hms_milli_opt(12, 34, 56, 789).unwrap();
assert_eq!(dt.nanosecond(), 789_000_000);
```

--------------------------------

### week

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDate.html?search=std%3A%3Avec

Returns the NaiveWeek that the date belongs to, starting with the Weekday specified.

```APIDOC
## pub const fn week(&self, start: Weekday) -> NaiveWeek

### Description
Returns the `NaiveWeek` that the date belongs to, starting with the `Weekday` specified.
```

--------------------------------

### Accessing Date Components

Source: https://docs.rs/chrono/latest/chrono/naive/struct.NaiveDateTime.html?search=std%3A%3Avec

Examples of retrieving various date components from a NaiveDateTime instance.

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.year(), 2015);
```

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month(), 9);
```

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.month0(), 8);
```

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day(), 25);
```

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.day0(), 24);
```

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal(), 268);
```

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.ordinal0(), 267);
```

```rust
use chrono::{Datelike, NaiveDate, NaiveDateTime, Weekday};

let dt: NaiveDateTime =
    NaiveDate::from_ymd_opt(2015, 9, 25).unwrap().and_hms_opt(12, 34, 56).unwrap();
assert_eq!(dt.weekday(), Weekday::Fri);
```

--------------------------------

### IsoWeek::week0

Source: https://docs.rs/chrono/latest/chrono/naive/struct.IsoWeek.html?search=

Returns the ISO week number starting from 0.

```APIDOC
## pub const fn week0(&self) -> u32

### Description
Returns the ISO week number starting from 0. The return value ranges from 0 to 52.

### Signature
`pub const fn week0(&self) -> u32`

### Example
```rust
use chrono::{Datelike, NaiveDate, Weekday};
let d = NaiveDate::from_isoywd_opt(2015, 15, Weekday::Mon).unwrap();
assert_eq!(d.iso_week().week0(), 14);
```
```

--------------------------------

### Constructing and Querying TimeZones

Source: https://docs.rs/chrono/latest/src/chrono/offset/local/tz_info/timezone.rs.html?search=

Demonstrates creating a TimeZone from raw TZif bytes and manually constructing one using transitions and local time types.

```rust
let bytes = b"TZif2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x06\0\0\0\x06\0\0\0\0\0\0\0\x07\0\0\0\x06\0\0\0\x14\x80\0\0\0\xbb\x05\x43\x48\xbb\x21\x71\x58\xcb\x89\x3d\xc8\xd2\x23\xf4\x70\xd2\x61\x49\x38\xd5\x8d\x73\x48\x01\x02\x01\x03\x04\x01\x05\xff\xff\x6c\x02\0\0\xff\xff\x6c\x58\0\x04\xff\xff\x7a\x68\x01\x08\xff\xff\x7a\x68\x01\x0c\xff\xff\x7a\x68\x01\x10\xff\xff\x73\x60\0\x04LMT\0HST\0HDT\0HWT\0HPT\0\0\0\0\0\x01\0\0\0\0\0\x01\0TZif2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x06\0\0\0\x06\0\0\0\0\0\0\0\x07\0\0\0\x06\0\0\0\x14\xff\xff\xff\xff\x74\xe0\x70\xbe\xff\xff\xff\xff\xbb\x05\x43\x48\xff\xff\xff\xff\xbb\x21\x71\x58\xff\xff\xff\xff\xcb\x89\x3d\xc8\xff\xff\xff\xff\xd2\x23\xf4\x70\xff\xff\xff\xff\xd2\x61\x49\x38\xff\xff\xff\xff\xd5\x8d\x73\x48\x01\x02\x01\x03\x04\x01\x05\xff\xff\x6c\x02\0\0\xff\xff\x6c\x58\0\x04\xff\xff\x7a\x68\x01\x08\xff\xff\x7a\x68\x01\x0c\xff\xff\x7a\x68\x01\x10\xff\xff\x73\x60\0\x04LMT\0HST\0HDT\0HWT\0HPT\0\0\0\0\0\x01\0\0\0\0\0\x01\0\x0aHST10\x0a";

let time_zone = TimeZone::from_tz_data(bytes)?;

let time_zone_result = TimeZone::new(
    vec![
        Transition::new(-2334101314, 1),
        Transition::new(-1157283000, 2),
        Transition::new(-1155436200, 1),
        Transition::new(-880198200, 3),
        Transition::new(-769395600, 4),
        Transition::new(-765376200, 1),
        Transition::new(-712150200, 5),
    ],
    vec![
        LocalTimeType::new(-37886, false, Some(b"LMT"))?,
        LocalTimeType::new(-37800, false, Some(b"HST"))?,
        LocalTimeType::new(-34200, true, Some(b"HDT"))?,
        LocalTimeType::new(-34200, true, Some(b"HWT"))?,
        LocalTimeType::new(-34200, true, Some(b"HPT"))?,
        LocalTimeType::new(-36000, false, Some(b"HST"))?,
    ],
    Vec::new(),
    Some(TransitionRule::from(LocalTimeType::new(-36000, false, Some(b"HST"))?)),
)?;

assert_eq!(time_zone, time_zone_result);

assert_eq!(
    *time_zone.find_local_time_type(-1156939200)?,
    LocalTimeType::new(-34200, true, Some(b"HDT"))?
);
assert_eq!(
    *time_zone.find_local_time_type(1546300800)?,
    LocalTimeType::new(-36000, false, Some(b"HST"))?
);

Ok(())
```

```rust
let bytes = b"TZif\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02\0\0\0\x02\0\0\0\0\0\0\0\x01\0\0\0\x02\0\0\0\x08\xb6\xa4B\x18\x01\xff\xff\xb6h\0\0\xff\xff\xb9\xb0\0\x04QMT\0ECT\0\0\0\0\0";

let time_zone = TimeZone::from_tz_data(bytes)?;
dbg!(&time_zone);

let time_zone_result = TimeZone::new(
    vec![Transition::new(-1230749160, 1)],
    vec![
        LocalTimeType::new(-18840, false, Some(b"QMT"))?,
        LocalTimeType::new(-18000, false, Some(b"ECT"))?,
    ],
    Vec::new(),
    None,
)?;

assert_eq!(time_zone, time_zone_result);

assert_eq!(
    *time_zone.find_local_time_type(-1500000000)?,
    LocalTimeType::new(-18840, false, Some(b"QMT"))?
);
assert_eq!(
    *time_zone.find_local_time_type(0)?,
    LocalTimeType::new(-18000, false, Some(b"ECT"))?
);

Ok(())
```

--------------------------------

### IsoWeek::week

Source: https://docs.rs/chrono/latest/chrono/naive/struct.IsoWeek.html?search=

Returns the ISO week number starting from 1.

```APIDOC
## pub const fn week(&self) -> u32

### Description
Returns the ISO week number starting from 1. The return value ranges from 1 to 53.

### Signature
`pub const fn week(&self) -> u32`

### Example
```rust
use chrono::{Datelike, NaiveDate, Weekday};
let d = NaiveDate::from_isoywd_opt(2015, 15, Weekday::Mon).unwrap();
assert_eq!(d.iso_week().week(), 15);
```
```
Tokens:
Raw