wtx 0.44.2

A collection of different transport implementations and related tools focused primarily on web technologies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::calendar::CalendarError;
use core::time::Duration;

cfg_select! {
  feature = "std" => {
    type LocalTy = std::time::SystemTime;
  },
  feature = "embassy-time" => {
    type LocalTy = embassy_time::Instant;
  },
  _ => {
    type LocalTy = ();
  },
}

/// Time provider suitable for operations involving intervals.
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Instant {
  _inner: LocalTy,
}

impl Instant {
  /// Creates an instance that refers the UNIX epoch (1970-01-01).
  ///
  #[doc = doc_epoch!()]
  #[inline]
  pub const fn epoch(_secs: u64) -> crate::Result<Self> {
    cfg_select! {
      feature = "std" => Ok(Self { _inner: std::time::UNIX_EPOCH }),
      feature = "embassy-time" => Ok(Self { _inner: embassy_time::Instant::from_secs(_secs) }),
      _ => Err(crate::Error::CalendarError(CalendarError::InstantNeedsBackend))
    }
  }

  /// Returns the system time corresponding to "now". Can have different durations
  /// depending on the underlying provider.
  #[inline]
  pub fn now() -> Self {
    cfg_select! {
      feature = "std" => Self { _inner: std::time::SystemTime::now() },
      feature = "embassy-time" => Self { _inner: embassy_time::Instant::now() },
      _ => Self { _inner: () }
    }
  }

  /// Returns a new `DateTime` instance with the current date and time in UTC based on the
  /// UNIX epoch.
  ///
  #[doc = doc_epoch!()]
  #[inline]
  pub fn now_date_time(
    secs: u64,
  ) -> crate::Result<crate::calendar::DateTime<crate::calendar::Utc>> {
    let timestamp = Instant::now_timestamp(secs)?;
    crate::calendar::DateTime::from_timestamp_secs_and_ns(
      timestamp.as_secs().cast_signed(),
      timestamp.subsec_nanos().try_into()?,
    )
  }

  /// Constructor that returns the number of non-leap seconds since the UNIX epoch.
  ///
  #[doc = doc_epoch!()]
  #[inline]
  pub fn now_timestamp(secs: u64) -> crate::Result<Duration> {
    Self::now().duration_since(Self::epoch(secs)?)
  }

  /// Returns the addition if the resulting value is within bounds.
  #[inline]
  pub fn add(&self, _duration: Duration) -> crate::Result<Self> {
    cfg_select! {
      feature = "std" => {
        let _inner = self._inner.checked_add(_duration).ok_or(CalendarError::ArithmeticOverflow)?;
        Ok(Self { _inner })
      },
      feature = "embassy-time" => {
        let _inner = self
          ._inner
          .checked_add(embassy_time::Duration::from_micros(_duration.as_micros() as u64))
          .ok_or(CalendarError::ArithmeticOverflow)?;
        Ok(Self { _inner })
      }
      _ => Err(crate::Error::CalendarError(CalendarError::InstantNeedsBackend))
    }
  }

  /// Returns the difference if the resulting value is within bounds.
  #[inline]
  pub fn sub(&self, _duration: Duration) -> crate::Result<Self> {
    cfg_select! {
      feature = "std" => {
        let _inner = self._inner.checked_sub(_duration).ok_or(CalendarError::ArithmeticOverflow)?;
        Ok(Self { _inner })
      },
      feature = "embassy-time" => {
        let _inner = self
          ._inner
          .checked_sub(embassy_time::Duration::from_micros(_duration.as_micros() as u64))
          .ok_or(CalendarError::ArithmeticOverflow)?;
        Ok(Self { _inner })
      },
      _ => Err(crate::Error::CalendarError(CalendarError::InstantNeedsBackend))
    }
  }

  /// Returns the amount of time elapsed from another instant to this one,
  /// or an error if that instant is later than this one.
  #[inline]
  pub fn duration_since(&self, _earlier: Self) -> crate::Result<Duration> {
    cfg_select! {
      feature = "std" => Ok(
        self
          ._inner
          .duration_since(_earlier._inner)
          .map_err(|_err| CalendarError::InvalidHardwareTime)?,
      ),
      feature = "embassy-time" => Ok(Duration::from_micros(
        self
          ._inner
          .checked_duration_since(_earlier._inner)
          .ok_or(CalendarError::ArithmeticOverflow)?
          .as_micros(),
      )),
      _ => Err(crate::Error::CalendarError(CalendarError::InstantNeedsBackend))
    }
  }

  /// Returns the amount of time elapsed since this instant was created.
  #[inline]
  pub fn elapsed(&self) -> crate::Result<Duration> {
    Self::now().duration_since(*self)
  }

  /// Non-constructor method that returns the number of non-leap seconds since the UNIX epoch based
  /// on the current instance.
  ///
  #[doc = doc_epoch!()]
  #[inline]
  pub fn timestamp(&self, secs: u64) -> crate::Result<Duration> {
    self.duration_since(Self::epoch(secs)?)
  }
}