Struct Repr

pub(super) struct Repr {
    ptr: *const u8,
}

The internal representation of a TimeZone.

It has 6 different possible variants: UTC, Etc/Unknown, fixed offset, static TZif, Arc TZif or Arc POSIX time zone.

This design uses pointer tagging so that:

• The size of a TimeZone stays no bigger than a single word.
• In core-only environments, a TimeZone can be created from compile-time TZif data without allocating.
• UTC, unknown and fixed offset time zone does not require allocating.
• We can still alloc for TZif and POSIX time zones created at runtime. (Allocating for TZif at runtime is the intended common case, and corresponds to reading /usr/share/zoneinfo entries.)

We achieve this through pointer tagging and careful use of a strict provenance polyfill (because of MSRV). We use the lower 4 bits of a pointer to indicate which variant we have. This is sound because we require all types that we allocate for to have a minimum alignment of 8 bytes.

Fields

ptr: *const u8

Implementations

impl Repr

const BITS: usize = 7usize

pub(super) const UTC: usize = 1usize

pub(super) const UNKNOWN: usize = 2usize

pub(super) const FIXED: usize = 3usize

pub(super) const STATIC_TZIF: usize = 0usize

pub(super) const ARC_TZIF: usize = 4usize

pub(super) const ARC_POSIX: usize = 5usize

const ALIGN: usize = 8usize

pub(super) const fn utc() -> Repr

Creates a representation for a UTC time zone.

pub(super) const fn unknown() -> Repr

Creates a representation for a Etc/Unknown time zone.

pub(super) const fn fixed(offset: Offset) -> Repr

Creates a representation for a fixed offset time zone.

pub(super) const fn static_tzif( tzif: &'static Tzif<&'static str, &'static str, &'static [TzifLocalTimeType], &'static [i64], &'static [TzifDateTime], &'static [TzifDateTime], &'static [TzifTransitionInfo]>, ) -> Repr

Creates a representation for a created-at-compile-time TZif time zone.

This can only be correctly called by the jiff-static proc macro.

pub(super) fn arc_tzif( tzif: Arc<Tzif<String, ArrayStr<ABBREVIATION_MAX>, Vec<TzifLocalTimeType>, Vec<i64>, Vec<TzifDateTime>, Vec<TzifDateTime>, Vec<TzifTransitionInfo>>>, ) -> Repr

Creates a representation for a TZif time zone.

pub(super) fn arc_posix( posix_tz: Arc<PosixTimeZone<ArrayStr<ABBREVIATION_MAX>>>, ) -> Repr

Creates a representation for a POSIX time zone.

pub(super) unsafe fn get_fixed(&self) -> Offset

Gets the offset representation.

Safety

Callers must ensure that the pointer tag is FIXED.

pub(super) fn is_unknown(&self) -> bool

Returns true if and only if this representation corresponds to the Etc/Unknown time zone.

pub(super) unsafe fn get_static_tzif( &self, ) -> &'static Tzif<&'static str, &'static str, &'static [TzifLocalTimeType], &'static [i64], &'static [TzifDateTime], &'static [TzifDateTime], &'static [TzifTransitionInfo]>

Gets the static TZif representation.

Safety

Callers must ensure that the pointer tag is STATIC_TZIF.

pub(super) unsafe fn get_arc_tzif<'a>( &'a self, ) -> &'a Tzif<String, ArrayStr<ABBREVIATION_MAX>, Vec<TzifLocalTimeType>, Vec<i64>, Vec<TzifDateTime>, Vec<TzifDateTime>, Vec<TzifTransitionInfo>>

Gets the Arc TZif representation.

Safety

Callers must ensure that the pointer tag is ARC_TZIF.

pub(super) unsafe fn get_arc_posix<'a>( &'a self, ) -> &'a PosixTimeZone<ArrayStr<ABBREVIATION_MAX>>

Gets the Arc POSIX time zone representation.

Safety

Callers must ensure that the pointer tag is ARC_POSIX.

pub(super) fn tag(&self) -> usize

Returns the tag on the representation’s pointer.

The value is guaranteed to be one of the constant tag values.

pub(super) const unsafe fn copy(&self) -> Repr

Returns a dumb copy of this representation.

Safety

Callers must ensure that this representation’s tag is UTC, UNKNOWN, FIXED or STATIC_TZIF.

Namely, this specifically does not increment the ref count for the Arc pointers when the tag is ARC_TZIF or ARC_POSIX. This means that incorrect usage of this routine can lead to use-after-free.

NOTE: It would be nice if we could make this copy routine safe, or at least panic if it’s misused. But to do that, you need to know the time zone variant. And to know the time zone variant, you need to “look” at the tag in the pointer. And looking at the address of a pointer in a const context is precarious.

Trait Implementations

impl Clone for Repr

fn clone(&self) -> Repr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Repr

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

Formats the value using the given formatter.

impl Drop for Repr

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq for Repr

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Repr

impl Send for Repr

impl Sync for Repr