off64 0.9.0

Read from and write to byte slices with u64 offsets
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

use crate::int::*;
use chrono::DateTime;
use chrono::TimeZone;
use chrono::Utc;
pub trait Off64ReadChrono<'a, T: 'a + AsRef<[u8]>>: Off64ReadInt<'a, T> {
  fn read_timestamp_be_at(&'a self, offset: u64) -> DateTime<Utc> {
    let sec = self.read_i64_be_at(offset);
    Utc.timestamp_millis_opt(sec * 1000).unwrap()
  }

  fn read_timestamp_millis_be_at(&'a self, offset: u64) -> DateTime<Utc> {
    let ms = self.read_i64_be_at(offset);
    Utc.timestamp_millis_opt(ms).unwrap()
  }

  fn read_timestamp_le_at(&'a self, offset: u64) -> DateTime<Utc> {
    let sec = self.read_i64_le_at(offset);
    Utc.timestamp_millis_opt(sec * 1000).unwrap()
  }

  fn read_timestamp_millis_le_at(&'a self, offset: u64) -> DateTime<Utc> {
    let ms = self.read_i64_le_at(offset);
    Utc.timestamp_millis_opt(ms).unwrap()
  }
}
#[async_trait::async_trait]
pub trait Off64AsyncReadChrono<'a, T: 'a + AsRef<[u8]>>: Off64AsyncReadInt<'a, T> {
  async fn read_timestamp_be_at(&'a self, offset: u64) -> DateTime<Utc> {
    let sec = self.read_i64_be_at(offset).await;
    Utc.timestamp_millis_opt(sec * 1000).unwrap()
  }

  async fn read_timestamp_millis_be_at(&'a self, offset: u64) -> DateTime<Utc> {
    let ms = self.read_i64_be_at(offset).await;
    Utc.timestamp_millis_opt(ms).unwrap()
  }

  async fn read_timestamp_le_at(&'a self, offset: u64) -> DateTime<Utc> {
    let sec = self.read_i64_le_at(offset).await;
    Utc.timestamp_millis_opt(sec * 1000).unwrap()
  }

  async fn read_timestamp_millis_le_at(&'a self, offset: u64) -> DateTime<Utc> {
    let ms = self.read_i64_le_at(offset).await;
    Utc.timestamp_millis_opt(ms).unwrap()
  }
}
#[async_trait::async_trait]
pub trait Off64AsyncWriteMutChrono: Off64AsyncWriteMutInt {
  async fn write_timestamp_be_at(&mut self, offset: u64, value: DateTime<Utc>) {
    let sec = value.timestamp();
    self.write_i64_be_at(offset, sec).await;
  }

  async fn write_timestamp_millis_be_at(&mut self, offset: u64, value: DateTime<Utc>) {
    let ms = value.timestamp_millis();
    self.write_i64_be_at(offset, ms).await;
  }

  async fn write_timestamp_le_at(&mut self, offset: u64, value: DateTime<Utc>) {
    let sec = value.timestamp();
    self.write_i64_le_at(offset, sec).await;
  }

  async fn write_timestamp_millis_le_at(&mut self, offset: u64, value: DateTime<Utc>) {
    let ms = value.timestamp_millis();
    self.write_i64_le_at(offset, ms).await;
  }
}
#[async_trait::async_trait]
pub trait Off64AsyncWriteChrono: Off64AsyncWriteInt {
  async fn write_timestamp_be_at(&self, offset: u64, value: DateTime<Utc>) {
    let sec = value.timestamp();
    self.write_i64_be_at(offset, sec).await;
  }

  async fn write_timestamp_millis_be_at(&self, offset: u64, value: DateTime<Utc>) {
    let ms = value.timestamp_millis();
    self.write_i64_be_at(offset, ms).await;
  }

  async fn write_timestamp_le_at(&self, offset: u64, value: DateTime<Utc>) {
    let sec = value.timestamp();
    self.write_i64_le_at(offset, sec).await;
  }

  async fn write_timestamp_millis_le_at(&self, offset: u64, value: DateTime<Utc>) {
    let ms = value.timestamp_millis();
    self.write_i64_le_at(offset, ms).await;
  }
}
pub trait Off64WriteMutChrono: Off64WriteMutInt {
  fn write_timestamp_be_at(&mut self, offset: u64, value: DateTime<Utc>) {
    let sec = value.timestamp();
    self.write_i64_be_at(offset, sec);
  }

  fn write_timestamp_millis_be_at(&mut self, offset: u64, value: DateTime<Utc>) {
    let ms = value.timestamp_millis();
    self.write_i64_be_at(offset, ms);
  }

  fn write_timestamp_le_at(&mut self, offset: u64, value: DateTime<Utc>) {
    let sec = value.timestamp();
    self.write_i64_le_at(offset, sec);
  }

  fn write_timestamp_millis_le_at(&mut self, offset: u64, value: DateTime<Utc>) {
    let ms = value.timestamp_millis();
    self.write_i64_le_at(offset, ms);
  }
}
pub trait Off64WriteChrono: Off64WriteInt {
  fn write_timestamp_be_at(&self, offset: u64, value: DateTime<Utc>) {
    let sec = value.timestamp();
    self.write_i64_be_at(offset, sec);
  }

  fn write_timestamp_millis_be_at(&self, offset: u64, value: DateTime<Utc>) {
    let ms = value.timestamp_millis();
    self.write_i64_be_at(offset, ms);
  }

  fn write_timestamp_le_at(&self, offset: u64, value: DateTime<Utc>) {
    let sec = value.timestamp();
    self.write_i64_le_at(offset, sec);
  }

  fn write_timestamp_millis_le_at(&self, offset: u64, value: DateTime<Utc>) {
    let ms = value.timestamp_millis();
    self.write_i64_le_at(offset, ms);
  }
}