Struct RadioDateTimeUtils

pub struct RadioDateTimeUtils { /* private fields */ }

Represents a date and time transmitted over radio.

Implementations

impl RadioDateTimeUtils

pub fn new(sunday: u8) -> Self

Initialize a new RadioDateTimeUtils instance

Arguments

• sunday - the numeric value of Sunday, i.e. 7 for DCF77 or 0 for MSF

Examples found in repository

examples/utc_localtime.rs (line 8)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 26)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 26)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 7)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn reset(&mut self)

Reset the RadioDateTimeUtils instance, except for Sunday, UTC offset, and in-UTC.

Examples found in repository

examples/get_set_datetime.rs (line 130)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_year(&self) -> Option<u8>

Get the current year, truncated to two digits.

Examples found in repository

examples/utc_localtime.rs (line 21)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 38)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 44)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 29)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_month(&self) -> Option<u8>

Get the current month.

Examples found in repository

examples/utc_localtime.rs (line 22)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 39)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 45)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 30)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_day(&self) -> Option<u8>

Get the current day of the month.

Examples found in repository

examples/utc_localtime.rs (line 23)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 40)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 46)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 19)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_weekday(&self) -> Option<u8>

Get the current day of the week as a number.

Examples found in repository

examples/utc_localtime.rs (line 24)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 41)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 47)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 32)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_hour(&self) -> Option<u8>

Get the current hour.

Examples found in repository

examples/utc_localtime.rs (line 25)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 42)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 48)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 33)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_minute(&self) -> Option<u8>

Get the current minute.

Examples found in repository

examples/utc_localtime.rs (line 26)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 43)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 49)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 34)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_dst(&self) -> Option<u8>

Get the current bitmask value (if any) of the daylight saving time status.

Examples found in repository

examples/utc_localtime.rs (line 27)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 44)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/get_set_datetime.rs (line 91)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_leap_second(&self) -> Option<u8>

Get the current bitmask value of the leap second status.

Examples found in repository

examples/leapsecond.rs (line 50)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

pub fn get_dut1(&self) -> Option<i8>

Get the value of DUT1 (UT1 - UTC).

pub fn get_jump_dut1(&self) -> bool

Return if the DUT1 has jumped unexpectedly (not at midnight UTC).

pub fn get_jump_year(&self) -> bool

Return if the year has jumped unexpectedly.

pub fn get_jump_month(&self) -> bool

Return if the month has jumped unexpectedly.

pub fn get_jump_day(&self) -> bool

Return if the day-of-month has jumped unexpectedly.

pub fn get_jump_weekday(&self) -> bool

Return if the day-of-week has jumped unexpectedly.

pub fn get_jump_hour(&self) -> bool

Return if the hour has jumped unexpectedly.

Examples found in repository

examples/get_set_datetime.rs (line 112)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn get_jump_minute(&self) -> bool

Return if the minute has jumped unexpectedly.

Examples found in repository

examples/get_set_datetime.rs (line 35)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_utc_offset(&mut self, utc_offset: i16, is_utc: bool)

Set the time zone offset from local normal-time to UTC in minutes, eastwards being positive, and set whether the station transmits in UTC.

This function is needed until utc_offset and is_utc are part of new().

Arguments

• utc_offset - the offset in minutes, between -1080 and +1080 inclusive
• is_utc - indicates if the station transmits in UTC

Examples found in repository

examples/utc_localtime.rs (line 10)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/get_set_datetime.rs (line 121)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn is_valid(&self) -> bool

Returns if the current date/time is valid (date, time, DST are all is_some()).

pub fn clear_jumps(&mut self)

Clear all jump values.

pub fn add_minute(&mut self) -> bool

Add one minute to the current date and time, return if the operation succeeded.

• Years are limited to 2 digits, so this function wraps after 100 years.
• The operation is valid in local time and accounts for DST changes.

Examples found in repository

examples/dst.rs (line 52)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 58)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 49)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_year(&mut self, value: Option<u8>, terms: bool, check_jump: bool)

Set the year value, valid values are 0 through 99.

Arguments

• value - the new year value. None or invalid values keep the old value.
• terms - extra validations to pass.
• check_jump - check if the value has jumped unexpectedly compared to add_minute().

Examples found in repository

examples/utc_localtime.rs (line 11)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 29)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 29)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 15)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_month(&mut self, value: Option<u8>, terms: bool, check_jump: bool)

Set the month value, valid values are 1 through 12.

Arguments

• value - the new month value. None or invalid values keep the old value.
• terms - extra validations to pass.
• check_jump - check if the value has jumped unexpectedly compared to add_minute().

Examples found in repository

examples/utc_localtime.rs (line 12)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 30)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 30)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 17)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_weekday(&mut self, value: Option<u8>, terms: bool, check_jump: bool)

Set the day-of-week value, valid values are 0/1 through 6/7, depending on how this instance was created.

Arguments

• value - the new day-of-week value. None or invalid values keep the old value.
• terms - extra validations to pass.
• check_jump - check if the value has jumped unexpectedly compared to add_minute().

Examples found in repository

examples/utc_localtime.rs (line 13)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 31)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 31)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 20)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_day(&mut self, value: Option<u8>, terms: bool, check_jump: bool)

Set the day-in-month value, valid values are 1 through the last day of that month.

If the year, month, or weekday are absent, the last day of the month cannot be calculated which means the old day-in-month value is kept.

Arguments

• value - the new day-in-month value. None or invalid values keep the old value.
• terms - extra validations to pass.
• check_jump - check if the value has jumped unexpectedly compared to add_minute().

Examples found in repository

examples/utc_localtime.rs (line 14)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 32)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 32)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 18)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_hour(&mut self, value: Option<u8>, terms: bool, check_jump: bool)

Set the hour value, valid values are 0 through 23.

Arguments

• value - the new hour value. None or invalid values keep the old value.
• terms - extra validations to pass.
• check_jump - check if the value has jumped unexpectedly compared to add_minute().

Examples found in repository

examples/utc_localtime.rs (line 15)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 33)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 33)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 22)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_minute(&mut self, value: Option<u8>, terms: bool, check_jump: bool)

Set the minute value, valid values are 0 through 59.

Arguments

• value - the new minute value. None or invalid values keep the old value.
• terms - extra validations to pass.
• check_jump - check if the value has jumped unexpectedly compared to add_minute().

Examples found in repository

examples/utc_localtime.rs (line 16)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 34)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 34)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 23)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_dut1(&mut self, value: Option<i8>, terms: bool, check_jump: bool)

Set the DUT1 value, valid values are -99 through 99.

Arguments

• value - the new DUT1 value. None or invalid values keep the old value.
• terms - extra validations to pass.
• check_jump - check if the value has jumped unexpectedly compared to IERS.

pub fn set_month_day( &mut self, day_in_year: Option<u16>, is_leap_year: Option<bool>, terms_month: bool, terms_day: bool, check_jump: bool, )

Set the month and day-in-month value from the given day-in-year and is-leap-year values.

Arguments

• day_in_year - the new day-in-year value.
• is_leap_year - this year is a leap year.
• terms_month - extra validation to pass for the month.
• terms_day - extra validation to pass for the day-in-month.
• check_jump - check if the day-in-month or month have jumped unexpectedly compared to add_minute()

Examples found in repository

examples/utc_localtime.rs (line 45)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/get_set_datetime.rs (line 120)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_dst( &mut self, value: Option<bool>, announce: Option<bool>, check_jump: bool, )

Set the DST mask value, both the actual value and any information on transitions.

Arguments

• value - the new DST value. A None value or unannounced changes keep the current value.
• announce - if any announcement is made on a transition. The history of this value of the last hour (or part thereof if started later) is kept to compensate for spurious True values.
• check_jump - check if the value changed unexpectedly.

Examples found in repository

examples/utc_localtime.rs (line 17)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

examples/dst.rs (line 35)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 40)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

examples/get_set_datetime.rs (line 48)

fn main() {
    let mut dcf77 = RadioDateTimeUtils::new(7);

    // set date of now, leave out extra checks, do not compare to previous non-existing value:

    // day must be set *after* year, month, and weekday because set_day() checks if its argument
    // is within the current month which could be 28 or 29 for February depending on the year and
    // day-of-week for 00 years.

    dcf77.set_year(Some(24), true, false);
    // year is clipped to century
    dcf77.set_month(Some(1), true, false);
    dcf77.set_day(Some(25), true, false);
    println!("Day-of-month: {:?}", dcf77.get_day());
    dcf77.set_weekday(Some(4), true, false);
    dcf77.set_day(Some(25), true, false);
    dcf77.set_hour(Some(22), true, false);
    dcf77.set_minute(Some(34), true, false);
    // seconds are not present in RadioDateTimeUtils

    // Show the date and time:
    println!(
        "Initial: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Going to the next minute without telling radio_datetime_utils about it
    // causes it to think the minute jumped:
    dcf77.set_minute(Some(35), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );
    // Advance the time by one minute and show new (predicted) datetime:
    // add_minute() wants DST to be defined and leaves jump values untouched
    dcf77.set_dst(Some(false), Some(false), false);
    println!("add_minute()={}", dcf77.add_minute());
    println!(
        "After add_minute(): date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} jumped={}",
        dcf77.get_year(),
        dcf77.get_month(),
        dcf77.get_day(),
        dcf77.get_weekday(),
        dcf77.get_hour(),
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // "Formally" set the minute:
    dcf77.set_minute(Some(36), true, true);
    println!(
        "Minute={:?}, jumped={}",
        dcf77.get_minute(),
        dcf77.get_jump_minute()
    );

    // Setting an illegal value leaves it untouched:
    dcf77.set_month(Some(14), true, false);
    println!("Month={:?}", dcf77.get_month());
    dcf77.set_year(None, true, false);
    println!("Year={:?}", dcf77.get_year());

    // New century
    let mut msf = RadioDateTimeUtils::new(0);
    msf.set_year(Some(99), true, false);
    msf.set_month(Some(12), true, false);
    msf.set_weekday(Some(5), true, false); // Friday
    msf.set_day(Some(31), true, false);
    msf.set_hour(Some(23), true, false);
    msf.set_minute(Some(59), true, false);
    println!(
        "Old century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // add_minute() wants DST to be defined.
    // announcements are honored because we omit calling bump_minutes_running() here
    msf.set_dst(Some(false), Some(true), false);
    println!("add_minute()={}", msf.add_minute());
    msf.set_dst(Some(true), Some(true), false);
    println!(
        "New century: date={:?}-{:?}-{:?} weekday={:?} time={:?}-{:?} {:?}",
        msf.get_year(),
        msf.get_month(),
        msf.get_day(),
        msf.get_weekday(),
        msf.get_hour(),
        msf.get_minute(),
        msf.get_dst()
    );

    // Setting the value twice with set_XXX() does not set the jumped flag the second time:
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());
    msf.set_hour(Some(2), true, true);
    println!("Hour={:?} jumped={:?}", msf.get_hour(), msf.get_jump_hour());

    // WWVB (the legacy AM version) transmits the date as year, is-leap-year, day-in-year, it
    // omits the day-of-week.
    let mut wwvb = RadioDateTimeUtils::new(0); // pick 0 (-1 is invalid)
    wwvb.set_year(Some(24), true, false); // year is 0-99
    wwvb.set_month_day(Some(60), Some(true), true, true, false);
    wwvb.set_utc_offset(-300, true);
    // leap day:
    println!(
        "WWVB: date={:?}-{:?}-{:?}",
        wwvb.get_year(),
        wwvb.get_month(),
        wwvb.get_day()
    );

    wwvb.reset();
    println!(" Reset WWVB: {:#?}", wwvb)
}

pub fn set_leap_second(&mut self, announce: Option<bool>, minute_length: u8)

Set the leap second value.

Arguments

• announce - if any announcement is made on a positive leap second. The history of this value of the last hour (or part thereof if started later) is kept to compensate for spurious Some(True) values.
• minute_length - the length of the decoded minute in seconds.

Examples found in repository

examples/leapsecond.rs (line 41)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

pub fn bump_minutes_running(&mut self)

Bump the internal minute counter needed for set_dst() and set_leap_second()

The code above this library must call this function, as this library cannot know which function got called first, or if just one of them should be called.

Examples found in repository

examples/dst.rs (line 56)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    rdt.set_dst(Some(false), Some(false), false);
    println!(
        "Initial           : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );

    // switch to DST, in the middle of a business week (nothing in this crate
    // dictates that DST switches should happen on Sunday nights). Normally,
    // time station start notifying one or more hours in advance. set_dst()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_dst(Some(false), Some(true), false);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before switch: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(true), false); // compulsory, sign off the new DST value
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after switch : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_dst(Some(true), Some(false), false);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business  : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} DST={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_dst(rdt.get_dst())
    );
}

examples/leapsecond.rs (line 62)

fn main() {
    let mut rdt = RadioDateTimeUtils::new(7);

    // initial values
    rdt.set_year(Some(24), true, false);
    rdt.set_month(Some(3), true, false);
    rdt.set_weekday(Some(3), true, false); // Wednesday
    rdt.set_day(Some(13), true, false);
    rdt.set_hour(Some(21), true, false);
    rdt.set_minute(Some(5), true, false);
    // Remember to initialize the DST field, otherwise add_minute() will
    // refuse to increase the time which ultimately results in a panic in
    // a test in set_leap_second() :
    //   thread 'main' panicked at src/lib.rs:
    //   attempt to multiply with overflow
    rdt.set_dst(Some(false), Some(false), false);
    rdt.set_leap_second(Some(false), 60);
    println!(
        "Initial                : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );

    // insert a leap second, in the middle of a business week (nothing in this crate
    // dictates that leap seconds should happen at midnight, UTC? local?). Normally,
    // time station start notifying one or more hours in advance. set_leap_second()
    // currently only supports notifications one hour in advance.
    while rdt.get_minute().unwrap() < 59 {
        rdt.add_minute();
        // Keep feeding the announcement, must be at least for 50% of the last hour or part thereof:
        rdt.set_leap_second(Some(true), 60);
        // Keep internal bookkeeping up-to-date:
        rdt.bump_minutes_running();
    }
    println!(
        "Just before leap second: date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    rdt.add_minute();
    rdt.set_leap_second(Some(true), 61); // insert the leap second
    rdt.bump_minutes_running(); // optional, but a good idea
    println!(
        "Just after leap second : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
    // in the new, now normal again, hour:
    rdt.add_minute();
    rdt.set_leap_second(Some(false), 60);
    rdt.bump_minutes_running(); // optional
    println!(
        "Back to business       : date={:?}-{:?}-{:?} weekday={:?} time={:?}:{:?} LS={}",
        rdt.get_year(),
        rdt.get_month(),
        rdt.get_day(),
        rdt.get_weekday(),
        rdt.get_hour(),
        rdt.get_minute(),
        parse_ls(rdt.get_leap_second())
    );
}

pub fn get_utc(&self) -> Option<RadioDateTimeUtils>

Return a copy of the current date/time in UTC (for local time sources), does nothing for incomplete inputs or results that are already converted to UTC.

The return type is Optional until utc_offset is part of new().

Examples found in repository

examples/utc_localtime.rs (line 29)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

pub fn get_local_time(&self) -> Option<RadioDateTimeUtils>

Return a copy of the current date/time in local time (for UTC sources), does nothing for incomplete inputs or results that are already converted to local time.

The return type is Optional until utc_offset is part of new().

Examples found in repository

examples/utc_localtime.rs (line 60)

fn main() {
    println!("*** DCF77 ***");
    let mut dcf77 = RadioDateTimeUtils::new(7);
    // set_utc_offset() will be part of new() in version 2.0 :
    dcf77.set_utc_offset(60, false);
    dcf77.set_year(Some(24), true, false);
    dcf77.set_month(Some(12), true, false);
    dcf77.set_weekday(Some(6), true, false);
    dcf77.set_day(Some(21), true, false);
    dcf77.set_hour(Some(18), true, false);
    dcf77.set_minute(Some(42), true, false);
    dcf77.set_dst(Some(false), Some(false), false);
    // Show local date/time:
    println!(
        "Local: {}-{}-{} {} {}:{} DST={:#02x?}",
        dcf77.get_year().unwrap(),
        dcf77.get_month().unwrap(),
        dcf77.get_day().unwrap(),
        dcf77.get_weekday().unwrap(),
        dcf77.get_hour().unwrap(),
        dcf77.get_minute().unwrap(),
        dcf77.get_dst()
    );
    let utc = dcf77.get_utc().unwrap();
    println!(
        "UTC  : {}-{}-{} {} {}:{} DST={:#02x?}",
        utc.get_year().unwrap(),
        utc.get_month().unwrap(),
        utc.get_day().unwrap(),
        utc.get_weekday().unwrap(),
        utc.get_hour().unwrap(),
        utc.get_minute().unwrap(),
        utc.get_dst()
    );

    println!("*** WWVB ****");
    let mut wwvb = RadioDateTimeUtils::new(0); // no day-of-week broadcast
    wwvb.set_utc_offset(-300, true);
    wwvb.set_year(Some(24), true, false);
    wwvb.set_month_day(Some(356), Some(true), true, true, false);
    wwvb.set_hour(Some(17), true, false);
    wwvb.set_minute(Some(42), true, false);
    wwvb.set_dst(Some(false), Some(false), false); // WWVB *does* transmit DST information.
    println!(
        "UTC  : {}-{}-{} -- {}:{} DST={:#02x?}",
        wwvb.get_year().unwrap(),
        wwvb.get_month().unwrap(),
        wwvb.get_day().unwrap(),
        wwvb.get_hour().unwrap(),
        wwvb.get_minute().unwrap(),
        wwvb.get_dst()
    );

    wwvb.set_weekday(Some(6), true, false); // simulate to get get_local_time() working
    let localtime = wwvb.get_local_time().unwrap();
    println!(
        "EST  : {}-{}-{} -- {}:{} DST={:#02x?}",
        localtime.get_year().unwrap(),
        localtime.get_month().unwrap(),
        localtime.get_day().unwrap(),
        localtime.get_hour().unwrap(),
        localtime.get_minute().unwrap(),
        localtime.get_dst()
    );
}

Trait Implementations

impl Clone for RadioDateTimeUtils

fn clone(&self) -> RadioDateTimeUtils

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RadioDateTimeUtils

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Copy for RadioDateTimeUtils