Struct git_date::Time

source ·

pub struct Time {
    pub seconds_since_unix_epoch: u32,
    pub offset_in_seconds: i32,
    pub sign: Sign,
}

Expand description

A timestamp with timezone.

Fields§

§seconds_since_unix_epoch: u32

time in seconds since epoch.

§offset_in_seconds: i32

time offset in seconds, may be negative to match the sign field.

§sign: Sign

the sign of offset, used to encode -0000 which would otherwise loose sign information.

Implementations§

source §

impl Time

Formatting

source

pub fn format<'a>(&self, format: impl Into<Format<'a>>) -> String

Format this instance according to the given format.

Use the format_description macro to create and validate formats at compile time, courtesy of the time crate.

source §

impl Time

Instantiation

source

pub fn new(seconds_since_unix_epoch: u32, offset_in_seconds: i32) -> Self

Create a new instance from seconds and offset.

Examples found in repository ?

src/parse.rs (line 32)

    pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
        // TODO: actual implementation, this is just to not constantly fail
        if input == "1979-02-26 18:30:00" {
            return Ok(Time::new(42, 1800));
        }

        Ok(if let Ok(val) = Date::parse(input, SHORT) {
            let val = val.with_hms(0, 0, 0).expect("date is in range").assume_utc();
            Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
        } else if let Ok(val) = OffsetDateTime::parse(input, RFC2822) {
            Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601) {
            Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
        } else if let Ok(val) = OffsetDateTime::parse(input, ISO8601_STRICT) {
            Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
        } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT) {
            Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
        } else if let Ok(val) = u32::from_str(input) {
            // Format::Unix
            Time::new(val, 0)
        } else if let Some(val) = parse_raw(input) {
            // Format::Raw
            val
        } else if let Some(time) = relative::parse(input, now).transpose()? {
            Time::new(timestamp(time)?, time.offset().whole_seconds())
        } else {
            return Err(Error::InvalidDateString);
        })
    }

source

pub fn now_utc() -> Self

Return the current time without figuring out a timezone offset

source

pub fn now_local() -> Option<Self>

Return the current local time, or None if the local time wasn’t available.

source

pub fn now_local_or_utc() -> Self

Return the current local time, or the one at UTC if the local time wasn’t available.

source §

impl Time

Serialization with standard git format

source

pub fn to_bstring(&self) -> BString

Serialize this instance into memory, similar to what write_to() would do with arbitrary Write implementations.

Examples found in repository ?

src/time/format.rs (line 57)

    pub fn format<'a>(&self, format: impl Into<Format<'a>>) -> String {
        match format.into() {
            Format::Custom(format) => self
                .to_time()
                .format(&format)
                .expect("well-known format into memory never fails"),
            Format::Unix => self.seconds_since_unix_epoch.to_string(),
            Format::Raw => self.to_bstring().to_string(),
        }
    }

source

pub fn write_to(&self, out: impl Write) -> Result<()>

Serialize this instance to out in a format suitable for use in header fields of serialized git commits or tags.

Examples found in repository ?

src/time/write.rs (line 10)

    pub fn to_bstring(&self) -> BString {
        let mut buf = Vec::with_capacity(64);
        self.write_to(&mut buf).expect("write to memory cannot fail");
        buf.into()
    }