nt_time

Struct FileTime

Source 
pub struct FileTime(/* private fields */);
Expand description

FileTime is a type that represents a Windows file time.

This is a 64-bit unsigned integer value that represents the number of 100-nanosecond intervals that have elapsed since “1601-01-01 00:00:00 UTC”, and is used as timestamps such as NTFS and 7z.

This represents the same value as the FILETIME structure of the Win32 API, which represents a 64-bit unsigned integer value. Note that the maximum value of the FILETIME structure that can be input to the FileTimeToSystemTime function of the Win32 API is limited to “+30828-09-14 02:48:05.477580700 UTC”, which is equivalent to i64::MAX.

Implementations§

Source§

impl FileTime

Source

pub const NT_TIME_EPOCH: Self = _

The NT time epoch.

This is defined as “1601-01-01 00:00:00 UTC”.

§Examples
assert_eq!(FileTime::NT_TIME_EPOCH, datetime!(1601-01-01 00:00 UTC));
Source

pub const UNIX_EPOCH: Self = _

The Unix epoch.

This is defined as “1970-01-01 00:00:00 UTC”.

§Examples
assert_eq!(FileTime::UNIX_EPOCH, OffsetDateTime::UNIX_EPOCH);
Source

pub const MAX: Self = _

The largest value that can be represented by the file time.

This is “+60056-05-28 05:36:10.955161500 UTC”.

§Examples
assert_eq!(
    FileTime::MAX,
    datetime!(+60056-05-28 05:36:10.955_161_500 UTC)
);
Source§

impl FileTime

Source

pub fn to_dos_date_time( self, offset: Option<UtcOffset>, ) -> Result<(u16, u16, u8, Option<UtcOffset>), DosDateTimeRangeError>

Returns MS-DOS date and time which represents the same date and time as this FileTime. This date and time is used as the timestamp such as FAT, exFAT or ZIP file format.

This method returns a (date, time, resolution, offset) tuple if the result is Ok.

date and time represents the local date and time. This date and time has no notion of time zone. The resolution of MS-DOS date and time is 2 seconds, but additional finer resolution (10 ms units) can be provided. resolution represents this additional finer resolution.

When the offset parameter is Some, converts date and time from UTC to the local date and time in the provided time zone and returns it with the UTC offset. When the offset parameter is None or is not a multiple of 15 minute intervals, returns the UTC date and time as a date and time and None as the UTC offset.

§Errors

Returns Err if the resulting date and time is out of range for MS-DOS date and time.

§Panics

Panics if offset is out of range for the OffsetFromUtc field.

§Examples
// `1980-01-01 00:00:00 UTC`.
assert_eq!(
    FileTime::new(119_600_064_000_000_000)
        .to_dos_date_time(None)
        .unwrap(),
    (0x0021, u16::MIN, u8::MIN, None)
);
// `2107-12-31 23:59:59 UTC`.
assert_eq!(
    FileTime::new(159_992_927_990_000_000)
        .to_dos_date_time(None)
        .unwrap(),
    (0xff9f, 0xbf7d, 100, None)
);

// Before `1980-01-01 00:00:00 UTC`.
assert!(FileTime::new(119_600_063_990_000_000)
    .to_dos_date_time(None)
    .is_err());
// After `2107-12-31 23:59:59.990000000 UTC`.
assert!(FileTime::new(159_992_928_000_000_000)
    .to_dos_date_time(None)
    .is_err());

// From `2002-11-27 03:25:00 UTC` to `2002-11-26 19:25:00 -08:00`.
assert_eq!(
    FileTime::new(126_828_411_000_000_000)
        .to_dos_date_time(Some(offset!(-08:00)))
        .unwrap(),
    (0x2d7a, 0x9b20, u8::MIN, Some(offset!(-08:00)))
);

When the UTC offset is not a multiple of 15 minute intervals, returns the UTC date and time:

// `2002-11-27 03:25:00 UTC`.
assert_eq!(
    FileTime::new(126_828_411_000_000_000)
        .to_dos_date_time(Some(offset!(-08:01)))
        .unwrap(),
    (0x2d7b, 0x1b20, u8::MIN, None)
);
// `2002-11-27 03:25:00 UTC`.
assert_eq!(
    FileTime::new(126_828_411_000_000_000)
        .to_dos_date_time(Some(offset!(-08:14)))
        .unwrap(),
    (0x2d7b, 0x1b20, u8::MIN, None)
);

// From `2002-11-27 03:25:00 UTC` to `2002-11-26 19:10:00 -08:15`.
assert_eq!(
    FileTime::new(126_828_411_000_000_000)
        .to_dos_date_time(Some(offset!(-08:15)))
        .unwrap(),
    (0x2d7a, 0x9940, u8::MIN, Some(offset!(-08:15)))
);
Source

pub fn from_dos_date_time( date: u16, time: u16, resolution: Option<u8>, offset: Option<UtcOffset>, ) -> Result<Self, ComponentRange>

Creates a FileTime with the given MS-DOS date and time. This date and time is used as the timestamp such as FAT, exFAT or ZIP file format.

When resolution is Some, additional finer resolution (10 ms units) is added to time.

When offset is Some, converts date and time from the local date and time in the provided time zone to UTC. When offset is None or is not a multiple of 15 minute intervals, assumes the provided date and time is in UTC.

§Errors

Returns Err if date or time is an invalid date and time.

§Panics

Panics if any of the following are true:

§Examples
// `1980-01-01 00:00:00 UTC`.
assert_eq!(
    FileTime::from_dos_date_time(0x0021, u16::MIN, None, None).unwrap(),
    FileTime::new(119_600_064_000_000_000)
);
// `2107-12-31 23:59:59 UTC`.
assert_eq!(
    FileTime::from_dos_date_time(0xff9f, 0xbf7d, Some(100), None).unwrap(),
    FileTime::new(159_992_927_990_000_000)
);

// From `2002-11-26 19:25:00 -08:00` to `2002-11-27 03:25:00 UTC`.
assert_eq!(
    FileTime::from_dos_date_time(0x2d7a, 0x9b20, None, Some(offset!(-08:00))).unwrap(),
    FileTime::new(126_828_411_000_000_000)
);

// The Day field is 0.
assert!(FileTime::from_dos_date_time(0x0020, u16::MIN, None, None).is_err());
// The DoubleSeconds field is 30.
assert!(FileTime::from_dos_date_time(0x0021, 0x001e, None, None).is_err());

When the UTC offset is not a multiple of 15 minute intervals, assumes the provided date and time is in UTC:

// From `2002-11-26 19:25:00 -08:01` to `2002-11-26 19:25:00 UTC`.
assert_eq!(
    FileTime::from_dos_date_time(0x2d7a, 0x9b20, None, Some(offset!(-08:01))).unwrap(),
    FileTime::new(126_828_123_000_000_000)
);
// From `2002-11-26 19:25:00 -08:14` to `2002-11-26 19:25:00 UTC`.
assert_eq!(
    FileTime::from_dos_date_time(0x2d7a, 0x9b20, None, Some(offset!(-08:14))).unwrap(),
    FileTime::new(126_828_123_000_000_000)
);

// From `2002-11-26 19:25:00 -08:15` to `2002-11-27 03:40:00 UTC`.
assert_eq!(
    FileTime::from_dos_date_time(0x2d7a, 0x9b20, None, Some(offset!(-08:15))).unwrap(),
    FileTime::new(126_828_420_000_000_000)
);

Additional finer resolution must be in the range 0 to 199:

ⓘ
let _: FileTime = FileTime::from_dos_date_time(0x0021, u16::MIN, Some(200), None).unwrap();
Source§

impl FileTime

Source

pub fn checked_add(self, rhs: Duration) -> Option<Self>

Computes self + rhs, returning None if overflow occurred. The part of rhs less than 100-nanosecond is truncated.

§Examples
assert_eq!(
    FileTime::NT_TIME_EPOCH.checked_add(Duration::from_nanos(1)),
    Some(FileTime::NT_TIME_EPOCH)
);
assert_eq!(
    FileTime::NT_TIME_EPOCH.checked_add(Duration::from_nanos(100)),
    Some(FileTime::new(1))
);

assert_eq!(FileTime::MAX.checked_add(Duration::from_nanos(100)), None);
Source

pub fn checked_sub(self, rhs: Duration) -> Option<Self>

Computes self - rhs, returning None if the result would be negative or if overflow occurred. The part of rhs less than 100-nanosecond is truncated.

§Examples
assert_eq!(
    FileTime::MAX.checked_sub(Duration::from_nanos(1)),
    Some(FileTime::MAX)
);
assert_eq!(
    FileTime::MAX.checked_sub(Duration::from_nanos(100)),
    Some(FileTime::new(u64::MAX - 1))
);

assert_eq!(
    FileTime::NT_TIME_EPOCH.checked_sub(Duration::from_nanos(100)),
    None
);
Source

pub fn saturating_add(self, rhs: Duration) -> Self

Computes self + rhs, returning FileTime::MAX if overflow occurred. The part of rhs less than 100-nanosecond is truncated.

§Examples
assert_eq!(
    FileTime::NT_TIME_EPOCH.saturating_add(Duration::from_nanos(1)),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::NT_TIME_EPOCH.saturating_add(Duration::from_nanos(100)),
    FileTime::new(1)
);

assert_eq!(
    FileTime::MAX.saturating_add(Duration::from_nanos(100)),
    FileTime::MAX
);
Source

pub fn saturating_sub(self, rhs: Duration) -> Self

Computes self - rhs, returning FileTime::NT_TIME_EPOCH if the result would be negative or if overflow occurred. The part of rhs less than 100-nanosecond is truncated.

§Examples
assert_eq!(
    FileTime::MAX.saturating_sub(Duration::from_nanos(1)),
    FileTime::MAX
);
assert_eq!(
    FileTime::MAX.saturating_sub(Duration::from_nanos(100)),
    FileTime::new(u64::MAX - 1)
);

assert_eq!(
    FileTime::NT_TIME_EPOCH.saturating_sub(Duration::from_nanos(100)),
    FileTime::NT_TIME_EPOCH
);
Source§

impl FileTime

Source

pub fn to_unix_time(self) -> (i64, u32)

Returns Unix time which represents the same date and time as this FileTime.

The first return value represents the number of whole seconds, and the second return value represents the number of additional nanoseconds.

§Examples
assert_eq!(FileTime::NT_TIME_EPOCH.to_unix_time(), (-11_644_473_600, 0));
assert_eq!(FileTime::UNIX_EPOCH.to_unix_time(), (0, 0));
assert_eq!(
    FileTime::MAX.to_unix_time(),
    (1_833_029_933_770, 955_161_500)
);
Source

pub fn to_unix_time_secs(self) -> i64

Returns Unix time in seconds which represents the same date and time as this FileTime.

§Examples
assert_eq!(FileTime::NT_TIME_EPOCH.to_unix_time_secs(), -11_644_473_600);
assert_eq!(FileTime::UNIX_EPOCH.to_unix_time_secs(), 0);
assert_eq!(FileTime::MAX.to_unix_time_secs(), 1_833_029_933_770);
Source

pub fn to_unix_time_millis(self) -> i64

Returns Unix time in milliseconds which represents the same date and time as this FileTime.

§Examples
assert_eq!(
    FileTime::NT_TIME_EPOCH.to_unix_time_millis(),
    -11_644_473_600_000
);
assert_eq!(FileTime::UNIX_EPOCH.to_unix_time_millis(), 0);
assert_eq!(FileTime::MAX.to_unix_time_millis(), 1_833_029_933_770_955);
Source

pub fn to_unix_time_micros(self) -> i64

Returns Unix time in microseconds which represents the same date and time as this FileTime.

§Examples
assert_eq!(
    FileTime::NT_TIME_EPOCH.to_unix_time_micros(),
    -11_644_473_600_000_000
);
assert_eq!(FileTime::UNIX_EPOCH.to_unix_time_micros(), 0);
assert_eq!(
    FileTime::MAX.to_unix_time_micros(),
    1_833_029_933_770_955_161
);
Source

pub fn to_unix_time_nanos(self) -> i128

Returns Unix time in nanoseconds which represents the same date and time as this FileTime.

§Examples
assert_eq!(
    FileTime::NT_TIME_EPOCH.to_unix_time_nanos(),
    -11_644_473_600_000_000_000
);
assert_eq!(FileTime::UNIX_EPOCH.to_unix_time_nanos(), 0);
assert_eq!(
    FileTime::MAX.to_unix_time_nanos(),
    1_833_029_933_770_955_161_500
);
Source

pub fn from_unix_time(secs: i64, nanos: u32) -> Result<Self, FileTimeRangeError>

Creates a FileTime with the given Unix time.

secs is the number of whole seconds, and nanos is the number of additional nanoseconds.

§Errors

Returns Err if the provided Unix time is out of range for the file time.

§Panics

Panics if nanos is not less than 1 second.

§Examples
assert_eq!(
    FileTime::from_unix_time(-11_644_473_600, 0).unwrap(),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::from_unix_time(0, 0).unwrap(),
    FileTime::UNIX_EPOCH
);
assert_eq!(
    FileTime::from_unix_time(1_833_029_933_770, 955_161_500).unwrap(),
    FileTime::MAX
);

// Before `1601-01-01 00:00:00 UTC`.
assert!(FileTime::from_unix_time(-11_644_473_601, 999_999_999).is_err());
// After `+60056-05-28 05:36:10.955161500 UTC`.
assert!(FileTime::from_unix_time(1_833_029_933_770, 955_161_501).is_err());

The number of additional nanoseconds must be less than 1 second:

ⓘ
let _: FileTime = FileTime::from_unix_time(0, 1_000_000_000).unwrap();
Source

pub fn from_unix_time_secs(secs: i64) -> Result<Self, FileTimeRangeError>

Creates a FileTime with the given Unix time in seconds.

§Errors

Returns Err if secs is out of range for the file time.

§Examples
assert_eq!(
    FileTime::from_unix_time_secs(-11_644_473_600).unwrap(),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::from_unix_time_secs(0).unwrap(),
    FileTime::UNIX_EPOCH
);
assert_eq!(
    FileTime::from_unix_time_secs(1_833_029_933_770).unwrap(),
    FileTime::MAX - Duration::from_nanos(955_161_500)
);

// Before `1601-01-01 00:00:00 UTC`.
assert!(FileTime::from_unix_time_secs(-11_644_473_601).is_err());
// After `+60056-05-28 05:36:10.955161500 UTC`.
assert!(FileTime::from_unix_time_secs(1_833_029_933_771).is_err());
Source

pub fn from_unix_time_millis(millis: i64) -> Result<Self, FileTimeRangeError>

Creates a FileTime with the given Unix time in milliseconds.

§Errors

Returns Err if millis is out of range for the file time.

§Examples
assert_eq!(
    FileTime::from_unix_time_millis(-11_644_473_600_000).unwrap(),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::from_unix_time_millis(0).unwrap(),
    FileTime::UNIX_EPOCH
);
assert_eq!(
    FileTime::from_unix_time_millis(1_833_029_933_770_955).unwrap(),
    FileTime::MAX - Duration::from_nanos(161_500)
);

// Before `1601-01-01 00:00:00 UTC`.
assert!(FileTime::from_unix_time_millis(-11_644_473_600_001).is_err());
// After `+60056-05-28 05:36:10.955161500 UTC`.
assert!(FileTime::from_unix_time_millis(1_833_029_933_770_956).is_err());
Source

pub fn from_unix_time_micros(micros: i64) -> Result<Self, FileTimeRangeError>

Creates a FileTime with the given Unix time in microseconds.

§Errors

Returns Err if micros is out of range for the file time.

§Examples
assert_eq!(
    FileTime::from_unix_time_micros(-11_644_473_600_000_000).unwrap(),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::from_unix_time_micros(0).unwrap(),
    FileTime::UNIX_EPOCH
);
assert_eq!(
    FileTime::from_unix_time_micros(1_833_029_933_770_955_161).unwrap(),
    FileTime::MAX - Duration::from_nanos(500)
);

// Before `1601-01-01 00:00:00 UTC`.
assert!(FileTime::from_unix_time_micros(-11_644_473_600_000_001).is_err());
// After `+60056-05-28 05:36:10.955161500 UTC`.
assert!(FileTime::from_unix_time_micros(1_833_029_933_770_955_162).is_err());
Source

pub fn from_unix_time_nanos(nanos: i128) -> Result<Self, FileTimeRangeError>

Creates a FileTime with the given Unix time in nanoseconds.

§Errors

Returns Err if nanos is out of range for the file time.

§Examples
assert_eq!(
    FileTime::from_unix_time_nanos(-11_644_473_600_000_000_000).unwrap(),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::from_unix_time_nanos(0).unwrap(),
    FileTime::UNIX_EPOCH
);
assert_eq!(
    FileTime::from_unix_time_nanos(1_833_029_933_770_955_161_500).unwrap(),
    FileTime::MAX
);

// Before `1601-01-01 00:00:00 UTC`.
assert!(FileTime::from_unix_time_nanos(-11_644_473_600_000_000_001).is_err());
// After `+60056-05-28 05:36:10.955161500 UTC`.
assert!(FileTime::from_unix_time_nanos(1_833_029_933_770_955_161_501).is_err());
Source§

impl FileTime

Source

pub fn now() -> Self

Available on crate feature std only.

Returns the file time corresponding to “now”.

§Panics

Panics if “now” is out of range for the file time.

§Examples
let now = FileTime::now();
Source

pub const fn new(ft: u64) -> Self

Creates a new FileTime with the given file time.

§Examples
assert_eq!(FileTime::new(u64::MIN), FileTime::NT_TIME_EPOCH);
assert_eq!(FileTime::new(116_444_736_000_000_000), FileTime::UNIX_EPOCH);
assert_eq!(FileTime::new(u64::MAX), FileTime::MAX);
Source

pub const fn to_raw(self) -> u64

Returns the contents of this FileTime as the underlying u64 value.

§Examples
assert_eq!(FileTime::NT_TIME_EPOCH.to_raw(), u64::MIN);
assert_eq!(FileTime::UNIX_EPOCH.to_raw(), 116_444_736_000_000_000);
assert_eq!(FileTime::MAX.to_raw(), u64::MAX);
Source

pub const fn to_be_bytes(self) -> [u8; 8]

Returns the memory representation of this FileTime as a byte array in big-endian (network) byte order.

§Examples
assert_eq!(FileTime::NT_TIME_EPOCH.to_be_bytes(), [u8::MIN; 8]);
assert_eq!(
    FileTime::UNIX_EPOCH.to_be_bytes(),
    [0x01, 0x9d, 0xb1, 0xde, 0xd5, 0x3e, 0x80, 0x00]
);
assert_eq!(FileTime::MAX.to_be_bytes(), [u8::MAX; 8]);
Source

pub const fn to_le_bytes(self) -> [u8; 8]

Returns the memory representation of this FileTime as a byte array in little-endian byte order.

§Examples
assert_eq!(FileTime::NT_TIME_EPOCH.to_le_bytes(), [u8::MIN; 8]);
assert_eq!(
    FileTime::UNIX_EPOCH.to_le_bytes(),
    [0x00, 0x80, 0x3e, 0xd5, 0xde, 0xb1, 0x9d, 0x01]
);
assert_eq!(FileTime::MAX.to_le_bytes(), [u8::MAX; 8]);
Source

pub const fn to_ne_bytes(self) -> [u8; 8]

Returns the memory representation of this FileTime as a byte array in native byte order.

As the target platform’s native endianness is used, portable code should use FileTime::to_be_bytes or FileTime::to_le_bytes, as appropriate, instead.

§Examples
assert_eq!(FileTime::NT_TIME_EPOCH.to_ne_bytes(), [u8::MIN; 8]);
assert_eq!(
    FileTime::UNIX_EPOCH.to_ne_bytes(),
    if cfg!(target_endian = "big") {
        [0x01, 0x9d, 0xb1, 0xde, 0xd5, 0x3e, 0x80, 0x00]
    } else {
        [0x00, 0x80, 0x3e, 0xd5, 0xde, 0xb1, 0x9d, 0x01]
    }
);
assert_eq!(FileTime::MAX.to_ne_bytes(), [u8::MAX; 8]);
Source

pub const fn from_be_bytes(bytes: [u8; 8]) -> Self

Creates a native endian FileTime value from its representation as a byte array in big endian.

§Examples
assert_eq!(
    FileTime::from_be_bytes([u8::MIN; 8]),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::from_be_bytes([0x01, 0x9d, 0xb1, 0xde, 0xd5, 0x3e, 0x80, 0x00]),
    FileTime::UNIX_EPOCH
);
assert_eq!(FileTime::from_be_bytes([u8::MAX; 8]), FileTime::MAX);
Source

pub const fn from_le_bytes(bytes: [u8; 8]) -> Self

Creates a native endian FileTime value from its representation as a byte array in little endian.

§Examples
assert_eq!(
    FileTime::from_le_bytes([u8::MIN; 8]),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::from_le_bytes([0x00, 0x80, 0x3e, 0xd5, 0xde, 0xb1, 0x9d, 0x01]),
    FileTime::UNIX_EPOCH
);
assert_eq!(FileTime::from_le_bytes([u8::MAX; 8]), FileTime::MAX);
Source

pub const fn from_ne_bytes(bytes: [u8; 8]) -> Self

Creates a native endian FileTime value from its memory representation as a byte array in native endianness.

As the target platform’s native endianness is used, portable code likely wants to use FileTime::from_be_bytes or FileTime::from_le_bytes, as appropriate instead.

§Examples
assert_eq!(
    FileTime::from_ne_bytes([u8::MIN; 8]),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::from_ne_bytes(if cfg!(target_endian = "big") {
        [0x01, 0x9d, 0xb1, 0xde, 0xd5, 0x3e, 0x80, 0x00]
    } else {
        [0x00, 0x80, 0x3e, 0xd5, 0xde, 0xb1, 0x9d, 0x01]
    }),
    FileTime::UNIX_EPOCH
);
assert_eq!(FileTime::from_ne_bytes([u8::MAX; 8]), FileTime::MAX);

Trait Implementations§

Source§

impl Add<Duration> for FileTime

Source§

type Output = FileTime

The resulting type after applying the + operator.
Source§

fn add(self, rhs: Duration) -> Self::Output

Performs the + operation. Read more
Source§

impl Add<Duration> for FileTime

Source§

type Output = FileTime

The resulting type after applying the + operator.
Source§

fn add(self, rhs: Duration) -> Self::Output

Performs the + operation. Read more
Source§

impl Add<TimeDelta> for FileTime

Available on crate feature chrono only.
Source§

type Output = FileTime

The resulting type after applying the + operator.
Source§

fn add(self, rhs: TimeDelta) -> Self::Output

Performs the + operation. Read more
Source§

impl AddAssign<Duration> for FileTime

Source§

fn add_assign(&mut self, rhs: Duration)

Performs the += operation. Read more
Source§

impl AddAssign<Duration> for FileTime

Source§

fn add_assign(&mut self, rhs: Duration)

Performs the += operation. Read more
Source§

impl AddAssign<TimeDelta> for FileTime

Available on crate feature chrono only.
Source§

fn add_assign(&mut self, rhs: TimeDelta)

Performs the += operation. Read more
Source§

impl Binary for FileTime

Source§

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

Shows the underlying u64 value of this FileTime.

§Examples
assert_eq!(format!("{:#b}", FileTime::NT_TIME_EPOCH), "0b0");
assert_eq!(
    format!("{:064b}", FileTime::UNIX_EPOCH),
    "0000000110011101101100011101111011010101001111101000000000000000"
);
assert_eq!(
    format!("{:b}", FileTime::MAX),
    "1111111111111111111111111111111111111111111111111111111111111111"
);
Source§

impl Clone for FileTime

Source§

fn clone(&self) -> FileTime

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for FileTime

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for FileTime

Source§

fn default() -> Self

Returns the default value of “1601-01-01 00:00:00 UTC”.

Equivalent to FileTime::NT_TIME_EPOCH except that it is not callable in const contexts.

§Examples
assert_eq!(FileTime::default(), FileTime::NT_TIME_EPOCH);
Source§

impl<'de> Deserialize<'de> for FileTime

Available on crate feature serde only.
Source§

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserializes a FileTime from the given Serde deserializer.

This deserializes from its underlying u64 representation.

§Examples
#[derive(Deserialize)]
struct Time {
    time: FileTime,
}

let ft: Time = serde_json::from_str(r#"{"time":116444736000000000}"#).unwrap();
assert_eq!(ft.time, FileTime::UNIX_EPOCH);
#[derive(Deserialize)]
struct Time {
    time: Option<FileTime>,
}

let ft: Time = serde_json::from_str(r#"{"time":116444736000000000}"#).unwrap();
assert_eq!(ft.time, Some(FileTime::UNIX_EPOCH));

let ft: Time = serde_json::from_str(r#"{"time":null}"#).unwrap();
assert_eq!(ft.time, None);
Source§

impl Display for FileTime

Source§

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

Shows the underlying u64 value of this FileTime.

§Examples
assert_eq!(format!("{}", FileTime::NT_TIME_EPOCH), "0");
assert_eq!(format!("{}", FileTime::UNIX_EPOCH), "116444736000000000");
assert_eq!(format!("{}", FileTime::MAX), "18446744073709551615");
Source§

impl Distribution<FileTime> for Standard

Available on crate feature rand only.
Source§

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> FileTime

Generate a random value of T, using rng as the source of randomness.
Source§

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness. Read more
Source§

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>
where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more
Source§

impl From<FileTime> for DateTime<Utc>

Available on crate feature chrono only.
Source§

fn from(ft: FileTime) -> Self

Converts a FileTime to a DateTime<Utc>.

§Examples
assert_eq!(
    DateTime::<Utc>::from(FileTime::NT_TIME_EPOCH),
    "1601-01-01 00:00:00 UTC".parse::<DateTime<Utc>>().unwrap()
);
assert_eq!(
    DateTime::<Utc>::from(FileTime::UNIX_EPOCH),
    DateTime::<Utc>::UNIX_EPOCH
);
Source§

impl From<FileTime> for SystemTime

Available on crate feature std only.
Source§

fn from(ft: FileTime) -> Self

Converts a FileTime to a SystemTime.

§Panics

Panics if the resulting time cannot be represented by a SystemTime.

§Examples
assert_eq!(
    SystemTime::from(FileTime::NT_TIME_EPOCH),
    SystemTime::UNIX_EPOCH - Duration::from_secs(11_644_473_600)
);
assert_eq!(
    SystemTime::from(FileTime::UNIX_EPOCH),
    SystemTime::UNIX_EPOCH
);
Source§

impl From<FileTime> for u64

Source§

fn from(ft: FileTime) -> Self

Converts a FileTime to the file time.

Equivalent to FileTime::to_raw except that it is not callable in const contexts.

§Examples
assert_eq!(u64::from(FileTime::NT_TIME_EPOCH), u64::MIN);
assert_eq!(u64::from(FileTime::UNIX_EPOCH), 116_444_736_000_000_000);
assert_eq!(u64::from(FileTime::MAX), u64::MAX);
Source§

impl From<u64> for FileTime

Source§

fn from(ft: u64) -> Self

Converts the file time to a FileTime.

Equivalent to FileTime::new except that it is not callable in const contexts.

§Examples
assert_eq!(FileTime::from(u64::MIN), FileTime::NT_TIME_EPOCH);
assert_eq!(
    FileTime::from(116_444_736_000_000_000),
    FileTime::UNIX_EPOCH
);
assert_eq!(FileTime::from(u64::MAX), FileTime::MAX);
Source§

impl FromStr for FileTime

Source§

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of FileTime.

The string is expected to be a decimal non-negative integer. If the string is not a decimal integer, use u64::from_str_radix and FileTime::new instead.

§Errors

Returns Err if u64::from_str returns an error.

§Examples
assert_eq!(FileTime::from_str("0").unwrap(), FileTime::NT_TIME_EPOCH);
assert_eq!(
    FileTime::from_str("116444736000000000").unwrap(),
    FileTime::UNIX_EPOCH
);
assert_eq!(
    FileTime::from_str("+18446744073709551615").unwrap(),
    FileTime::MAX
);

assert!(FileTime::from_str("").is_err());

assert!(FileTime::from_str("a").is_err());
assert!(FileTime::from_str("-1").is_err());
assert!(FileTime::from_str("+").is_err());
assert!(FileTime::from_str("0 ").is_err());

assert!(FileTime::from_str("18446744073709551616").is_err());
Source§

type Err = ParseFileTimeError

The associated error which can be returned from parsing.
Source§

impl Hash for FileTime

Source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl LowerExp for FileTime

Source§

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

Shows the underlying u64 value of this FileTime.

§Examples
assert_eq!(
    format!("{:024e}", FileTime::NT_TIME_EPOCH),
    "0000000000000000000000e0"
);
assert_eq!(format!("{:e}", FileTime::UNIX_EPOCH), "1.16444736e17");
assert_eq!(format!("{:e}", FileTime::MAX), "1.8446744073709551615e19");
Source§

impl LowerHex for FileTime

Source§

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

Shows the underlying u64 value of this FileTime.

§Examples
assert_eq!(format!("{:#x}", FileTime::NT_TIME_EPOCH), "0x0");
assert_eq!(format!("{:016x}", FileTime::UNIX_EPOCH), "019db1ded53e8000");
assert_eq!(format!("{:x}", FileTime::MAX), "ffffffffffffffff");
Source§

impl Octal for FileTime

Source§

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

Shows the underlying u64 value of this FileTime.

§Examples
assert_eq!(format!("{:#o}", FileTime::NT_TIME_EPOCH), "0o0");
assert_eq!(
    format!("{:022o}", FileTime::UNIX_EPOCH),
    "0006355435732517500000"
);
assert_eq!(format!("{:o}", FileTime::MAX), "1777777777777777777777");
Source§

impl Ord for FileTime

Source§

fn cmp(&self, other: &FileTime) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · Source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · Source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · Source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

Restrict a value to a certain interval. Read more
Source§

impl PartialEq<DateTime<Utc>> for FileTime

Available on crate feature chrono only.
Source§

fn eq(&self, other: &DateTime<Utc>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialEq<FileTime> for DateTime<Utc>

Available on crate feature chrono only.
Source§

fn eq(&self, other: &FileTime) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialEq<FileTime> for OffsetDateTime

Source§

fn eq(&self, other: &FileTime) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialEq<FileTime> for SystemTime

Available on crate feature std only.
Source§

fn eq(&self, other: &FileTime) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialEq<OffsetDateTime> for FileTime

Source§

fn eq(&self, other: &OffsetDateTime) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialEq<SystemTime> for FileTime

Available on crate feature std only.
Source§

fn eq(&self, other: &SystemTime) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialEq for FileTime

Source§

fn eq(&self, other: &FileTime) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl PartialOrd<DateTime<Utc>> for FileTime

Available on crate feature chrono only.
Source§

fn partial_cmp(&self, other: &DateTime<Utc>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl PartialOrd<FileTime> for DateTime<Utc>

Available on crate feature chrono only.
Source§

fn partial_cmp(&self, other: &FileTime) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl PartialOrd<FileTime> for OffsetDateTime

Source§

fn partial_cmp(&self, other: &FileTime) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl PartialOrd<FileTime> for SystemTime

Available on crate feature std only.
Source§

fn partial_cmp(&self, other: &FileTime) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl PartialOrd<OffsetDateTime> for FileTime

Source§

fn partial_cmp(&self, other: &OffsetDateTime) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl PartialOrd<SystemTime> for FileTime

Available on crate feature std only.
Source§

fn partial_cmp(&self, other: &SystemTime) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl PartialOrd for FileTime

Source§

fn partial_cmp(&self, other: &FileTime) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more
Source§

impl Serialize for FileTime

Available on crate feature serde only.
Source§

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serializes a FileTime into the given Serde serializer.

This serializes using the underlying u64 format.

§Examples
#[derive(Serialize)]
struct Time {
    time: FileTime,
}

let ft = Time {
    time: FileTime::UNIX_EPOCH,
};
let json = serde_json::to_string(&ft).unwrap();
assert_eq!(json, r#"{"time":116444736000000000}"#);
#[derive(Serialize)]
struct Time {
    time: Option<FileTime>,
}

let ft = Time {
    time: Some(FileTime::UNIX_EPOCH),
};
let json = serde_json::to_string(&ft).unwrap();
assert_eq!(json, r#"{"time":116444736000000000}"#);

let ft = Time { time: None };
let json = serde_json::to_string(&ft).unwrap();
assert_eq!(json, r#"{"time":null}"#);
Source§

impl Sub<DateTime<Utc>> for FileTime

Available on crate feature chrono only.
Source§

type Output = TimeDelta

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: DateTime<Utc>) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub<Duration> for FileTime

Source§

type Output = FileTime

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: Duration) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub<Duration> for FileTime

Source§

type Output = FileTime

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: Duration) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub<FileTime> for DateTime<Utc>

Available on crate feature chrono only.
Source§

type Output = TimeDelta

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: FileTime) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub<FileTime> for OffsetDateTime

Source§

type Output = Duration

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: FileTime) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub<FileTime> for SystemTime

Available on crate feature std only.
Source§

type Output = Duration

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: FileTime) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub<OffsetDateTime> for FileTime

Source§

type Output = Duration

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: OffsetDateTime) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub<SystemTime> for FileTime

Available on crate feature std only.
Source§

type Output = Duration

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: SystemTime) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub<TimeDelta> for FileTime

Available on crate feature chrono only.
Source§

type Output = FileTime

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: TimeDelta) -> Self::Output

Performs the - operation. Read more
Source§

impl Sub for FileTime

Source§

type Output = Duration

The resulting type after applying the - operator.
Source§

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation. Read more
Source§

impl SubAssign<Duration> for FileTime

Source§

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation. Read more
Source§

impl SubAssign<Duration> for FileTime

Source§

fn sub_assign(&mut self, rhs: Duration)

Performs the -= operation. Read more
Source§

impl SubAssign<TimeDelta> for FileTime

Available on crate feature chrono only.
Source§

fn sub_assign(&mut self, rhs: TimeDelta)

Performs the -= operation. Read more
Source§

impl TryFrom<DateTime<Utc>> for FileTime

Available on crate feature chrono only.
Source§

fn try_from(dt: DateTime<Utc>) -> Result<Self, Self::Error>

Converts a DateTime<Utc> to a FileTime.

§Errors

Returns Err if dt is out of range for the file time.

§Examples
assert_eq!(
    FileTime::try_from("1601-01-01 00:00:00 UTC".parse::<DateTime<Utc>>().unwrap()).unwrap(),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::try_from(DateTime::<Utc>::UNIX_EPOCH).unwrap(),
    FileTime::UNIX_EPOCH
);

// Before `1601-01-01 00:00:00 UTC`.
assert!(FileTime::try_from(
    "1601-01-01 00:00:00 UTC".parse::<DateTime<Utc>>().unwrap() - TimeDelta::nanoseconds(100)
)
.is_err());
// After `+60056-05-28 05:36:10.955161500 UTC`.
assert!(FileTime::try_from(
    "+60056-05-28 05:36:10.955161500 UTC"
        .parse::<DateTime<Utc>>()
        .unwrap()
        + TimeDelta::nanoseconds(100)
)
.is_err());
Source§

type Error = FileTimeRangeError

The type returned in the event of a conversion error.
Source§

impl TryFrom<FileTime> for OffsetDateTime

Source§

fn try_from(ft: FileTime) -> Result<Self, Self::Error>

Converts a FileTime to a OffsetDateTime.

§Errors

Returns Err if time is out of range for OffsetDateTime.

§Examples
assert_eq!(
    OffsetDateTime::try_from(FileTime::NT_TIME_EPOCH).unwrap(),
    datetime!(1601-01-01 00:00 UTC)
);
assert_eq!(
    OffsetDateTime::try_from(FileTime::UNIX_EPOCH).unwrap(),
    OffsetDateTime::UNIX_EPOCH
);

With the large-dates feature disabled, returns Err if the file time represents after “9999-12-31 23:59:59.999999900 UTC”:

assert!(OffsetDateTime::try_from(FileTime::new(2_650_467_744_000_000_000)).is_err());

With the large-dates feature enabled, this always succeeds:

assert_eq!(
    OffsetDateTime::try_from(FileTime::new(2_650_467_744_000_000_000)).unwrap(),
    datetime!(+10000-01-01 00:00 UTC)
);
assert_eq!(
    OffsetDateTime::try_from(FileTime::MAX).unwrap(),
    datetime!(+60056-05-28 05:36:10.955_161_500 UTC)
);
Source§

type Error = ComponentRange

The type returned in the event of a conversion error.
Source§

impl TryFrom<FileTime> for i64

Source§

fn try_from(ft: FileTime) -> Result<Self, Self::Error>

Converts a FileTime to the file time.

The file time is sometimes represented as an i64 value, such as the winrt::clock struct in WinRT, or the DateTime.FromFileTime method and the DateTime.ToFileTime method in .NET.

§Errors

Returns Err if ft is after “+30828-09-14 02:48:05.477580700 UTC”.

§Examples
assert_eq!(i64::try_from(FileTime::NT_TIME_EPOCH).unwrap(), 0);
assert_eq!(
    i64::try_from(FileTime::UNIX_EPOCH).unwrap(),
    116_444_736_000_000_000
);

assert!(i64::try_from(FileTime::MAX).is_err());
Source§

type Error = TryFromIntError

The type returned in the event of a conversion error.
Source§

impl TryFrom<OffsetDateTime> for FileTime

Source§

fn try_from(dt: OffsetDateTime) -> Result<Self, Self::Error>

Converts a OffsetDateTime to a FileTime.

§Errors

Returns Err if dt is out of range for the file time.

§Examples
assert_eq!(
    FileTime::try_from(datetime!(1601-01-01 00:00 UTC)).unwrap(),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::try_from(OffsetDateTime::UNIX_EPOCH).unwrap(),
    FileTime::UNIX_EPOCH
);

// Before `1601-01-01 00:00:00 UTC`.
assert!(
    FileTime::try_from(datetime!(1601-01-01 00:00 UTC) - Duration::nanoseconds(100)).is_err()
);

With the large-dates feature enabled, returns Err if OffsetDateTime represents after “+60056-05-28 05:36:10.955161500 UTC”:

assert!(FileTime::try_from(
    datetime!(+60056-05-28 05:36:10.955_161_500 UTC) + Duration::nanoseconds(100)
)
.is_err());
Source§

type Error = FileTimeRangeError

The type returned in the event of a conversion error.
Source§

impl TryFrom<SystemTime> for FileTime

Available on crate feature std only.
Source§

fn try_from(st: SystemTime) -> Result<Self, Self::Error>

Converts a SystemTime to a FileTime.

§Errors

Returns Err if time is out of range for the file time.

§Examples
assert_eq!(
    FileTime::try_from(SystemTime::UNIX_EPOCH - Duration::from_secs(11_644_473_600)).unwrap(),
    FileTime::NT_TIME_EPOCH
);
assert_eq!(
    FileTime::try_from(SystemTime::UNIX_EPOCH).unwrap(),
    FileTime::UNIX_EPOCH
);

// Before `1601-01-01 00:00:00 UTC`.
assert!(FileTime::try_from(
    SystemTime::UNIX_EPOCH - Duration::from_nanos(11_644_473_600_000_000_100)
)
.is_err());
// After `+60056-05-28 05:36:10.955161500 UTC`.
#[cfg(not(windows))]
assert!(FileTime::try_from(
    SystemTime::UNIX_EPOCH + Duration::new(1_833_029_933_770, 955_161_600)
)
.is_err());
Source§

type Error = FileTimeRangeError

The type returned in the event of a conversion error.
Source§

impl TryFrom<i64> for FileTime

Source§

fn try_from(ft: i64) -> Result<Self, Self::Error>

Converts the file time to a FileTime.

The file time is sometimes represented as an i64 value, such as the winrt::clock struct in WinRT, or the DateTime.FromFileTime method and the DateTime.ToFileTime method in .NET.

§Errors

Returns Err if ft is negative.

§Examples
assert_eq!(FileTime::try_from(0_i64).unwrap(), FileTime::NT_TIME_EPOCH);
assert_eq!(
    FileTime::try_from(116_444_736_000_000_000_i64).unwrap(),
    FileTime::UNIX_EPOCH
);

assert!(FileTime::try_from(i64::MIN).is_err());
Source§

type Error = FileTimeRangeError

The type returned in the event of a conversion error.
Source§

impl UpperExp for FileTime

Source§

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

Shows the underlying u64 value of this FileTime.

§Examples
assert_eq!(
    format!("{:024E}", FileTime::NT_TIME_EPOCH),
    "0000000000000000000000E0"
);
assert_eq!(format!("{:E}", FileTime::UNIX_EPOCH), "1.16444736E17");
assert_eq!(format!("{:E}", FileTime::MAX), "1.8446744073709551615E19");
Source§

impl UpperHex for FileTime

Source§

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

Shows the underlying u64 value of this FileTime.

§Examples
assert_eq!(format!("{:#X}", FileTime::NT_TIME_EPOCH), "0x0");
assert_eq!(format!("{:016X}", FileTime::UNIX_EPOCH), "019DB1DED53E8000");
assert_eq!(format!("{:X}", FileTime::MAX), "FFFFFFFFFFFFFFFF");
Source§

impl Copy for FileTime

Source§

impl Eq for FileTime

Source§

impl StructuralPartialEq for FileTime

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,