sea-orm-ffi 0.1.3

Compatibility layer for Sea-ORM when crossing a Rust-to-Rust FFI boundary
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
144
145
146
147
148
149

//! Structs that support bridging [`time`] types.
//!
//! Note that these types need to be present _at all times_, regardless of compilation
//! flags. The C representation of the values must not change with feature flags!
//!
//! The [`From`] implementations should of course be cfg-ed out if the feature is not
//! enabled.

#[cfg(feature = "with-time")]
use time::{Date, OffsetDateTime, PrimitiveDateTime, Time, UtcOffset};

#[derive(Clone, Copy)]
#[repr(C)]
pub(crate) struct OrdinalDate {
	year: i32,
	ordinal: u16
}

#[cfg(feature = "with-time")]
impl From<Date> for OrdinalDate {
	fn from(value: Date) -> Self {
		let (year, ordinal) = value.to_ordinal_date();
		Self { year, ordinal }
	}
}

#[cfg(feature = "with-time")]
impl From<OrdinalDate> for Date {
	fn from(value: OrdinalDate) -> Self {
		Self::from_ordinal_date(value.year, value.ordinal).unwrap()
	}
}

#[derive(Clone, Copy)]
#[repr(C)]
pub(crate) struct HmsNano {
	nano: u32,
	hour: u8,
	minute: u8,
	second: u8
}

#[cfg(feature = "with-time")]
impl From<Time> for HmsNano {
	fn from(value: Time) -> Self {
		Self {
			nano: value.nanosecond(),
			hour: value.hour(),
			minute: value.minute(),
			second: value.second()
		}
	}
}

#[cfg(feature = "with-time")]
impl From<HmsNano> for Time {
	fn from(value: HmsNano) -> Self {
		Self::from_hms_nano(value.hour, value.minute, value.second, value.nano).unwrap()
	}
}

#[derive(Clone, Copy)]
#[repr(C)]
pub(crate) struct OrdinalDateHmsNano {
	year: i32,
	ordinal: u16,
	hour: u8,
	minute: u8,
	nano: u32,
	second: u8
}

#[cfg(feature = "with-time")]
impl From<PrimitiveDateTime> for OrdinalDateHmsNano {
	fn from(value: PrimitiveDateTime) -> Self {
		let (year, ordinal) = value.date().to_ordinal_date();
		let time = value.time();
		Self {
			year,
			ordinal,
			hour: time.hour(),
			minute: time.minute(),
			nano: time.nanosecond(),
			second: time.second()
		}
	}
}

#[cfg(feature = "with-time")]
impl From<OrdinalDateHmsNano> for PrimitiveDateTime {
	fn from(value: OrdinalDateHmsNano) -> Self {
		let date = Date::from_ordinal_date(value.year, value.ordinal).unwrap();
		let time =
			Time::from_hms_nano(value.hour, value.minute, value.second, value.nano)
				.unwrap();
		Self::new(date, time)
	}
}

#[derive(Clone, Copy)]
#[repr(C)]
pub(crate) struct OrdinalDateHmsNanoOffset {
	year: i32,
	ordinal: u16,
	hour: u8,
	minute: u8,
	nano: u32,
	second: u8,
	offset_hour: i8,
	offset_minute: i8,
	offset_second: i8
}

#[cfg(feature = "with-time")]
impl From<OffsetDateTime> for OrdinalDateHmsNanoOffset {
	fn from(value: OffsetDateTime) -> Self {
		let (year, ordinal) = value.date().to_ordinal_date();
		let time = value.time();
		let (offset_hour, offset_minute, offset_second) = value.offset().as_hms();
		Self {
			year,
			ordinal,
			hour: time.hour(),
			minute: time.minute(),
			nano: time.nanosecond(),
			second: time.second(),
			offset_hour,
			offset_minute,
			offset_second
		}
	}
}

#[cfg(feature = "with-time")]
impl From<OrdinalDateHmsNanoOffset> for OffsetDateTime {
	fn from(value: OrdinalDateHmsNanoOffset) -> Self {
		let date = Date::from_ordinal_date(value.year, value.ordinal).unwrap();
		let time =
			Time::from_hms_nano(value.hour, value.minute, value.second, value.nano)
				.unwrap();
		let offset = UtcOffset::from_hms(
			value.offset_hour,
			value.offset_minute,
			value.offset_second
		)
		.unwrap();
		Self::new_in_offset(date, time, offset)
	}
}