1macro_rules! create_either {
2 ( $name:ident< $($t:ident),* >) => {
3 #[derive(Debug, Clone)]
4 pub enum $name< $( $t ),* > {
5 $( $t($t) ),*
6 }
7
8 impl< $( $t ),* > $crate::wal::Wal for $name< $( $t ),* >
9 where
10 $( $t: $crate::wal::Wal ),*
11 {
12 fn limit(&mut self, size: i64) {
13 match self {
14 $( $name::$t(inner) => inner.limit(size) ),*
15 }
16 }
17
18 fn begin_read_txn(&mut self) -> super::Result<bool> {
19 match self {
20 $( $name::$t(inner) => inner.begin_read_txn() ),*
21 }
22 }
23
24 fn end_read_txn(&mut self) {
25 match self {
26 $( $name::$t(inner) => inner.end_read_txn() ),*
27 }
28 }
29
30 fn find_frame(&mut self, page_no: std::num::NonZeroU32) -> super::Result<Option<std::num::NonZeroU32>> {
31 match self {
32 $( $name::$t(inner) => inner.find_frame(page_no) ),*
33 }
34 }
35
36 fn read_frame(&mut self, frame_no: std::num::NonZeroU32, buffer: &mut [u8]) -> super::Result<()> {
37 match self {
38 $( $name::$t(inner) => inner.read_frame(frame_no, buffer) ),*
39 }
40 }
41
42 fn read_frame_raw(&mut self, frame_no: std::num::NonZeroU32, buffer: &mut [u8]) -> super::Result<()> {
43 match self {
44 $( $name::$t(inner) => inner.read_frame_raw(frame_no, buffer) ),*
45 }
46 }
47
48 fn db_size(&self) -> u32 {
49 match self {
50 $( $name::$t(inner) => inner.db_size() ),*
51 }
52 }
53
54 fn begin_write_txn(&mut self) -> super::Result<()> {
55 match self {
56 $( $name::$t(inner) => inner.begin_write_txn() ),*
57 }
58 }
59
60 fn end_write_txn(&mut self) -> super::Result<()> {
61 match self {
62 $( $name::$t(inner) => inner.end_write_txn() ),*
63 }
64 }
65
66 fn undo<U: super::UndoHandler>(&mut self, handler: Option<&mut U>) -> super::Result<()> {
67 match self {
68 $( $name::$t(inner) => inner.undo(handler) ),*
69 }
70 }
71
72 fn savepoint(&mut self, rollback_data: &mut [u32]) {
73 match self {
74 $( $name::$t(inner) => inner.savepoint(rollback_data) ),*
75 }
76 }
77
78 fn savepoint_undo(&mut self, rollback_data: &mut [u32]) -> super::Result<()> {
79 match self {
80 $( $name::$t(inner) => inner.savepoint_undo(rollback_data) ),*
81 }
82 }
83
84 fn savepoint_forget(&mut self, rollback_data: &mut [u32]) {
85 match self {
86 $( $name::$t(inner) => inner.savepoint_forget(rollback_data) ),*
87 }
88 }
89
90 fn frame_count(&self, locked: i32) -> super::Result<u32> {
91 match self {
92 $( $name::$t(inner) => inner.frame_count(locked) ),*
93 }
94 }
95
96 fn insert_frames(
97 &mut self,
98 page_size: std::ffi::c_int,
99 page_headers: &mut super::PageHeaders,
100 size_after: u32,
101 is_commit: bool,
102 sync_flags: std::ffi::c_int,
103 ) -> super::Result<usize> {
104 match self {
105 $( $name::$t(inner) => inner.insert_frames(page_size, page_headers, size_after, is_commit, sync_flags) ),*
106 }
107 }
108
109 fn checkpoint(
110 &mut self,
111 db: &mut super::Sqlite3Db,
112 mode: super::CheckpointMode,
113 busy_handler: Option<&mut dyn super::BusyHandler>,
114 sync_flags: u32,
115 buf: &mut [u8],
116 checkpoint_cb: Option<&mut dyn super::CheckpointCallback>,
117 in_wal: Option<&mut i32>,
118 backfilled: Option<&mut i32>,
119 ) -> super::Result<()> {
120 match self {
121 $( $name::$t(inner) => inner.checkpoint(db, mode, busy_handler, sync_flags, buf, checkpoint_cb, in_wal, backfilled) ),*
122 }
123 }
124
125 fn exclusive_mode(&mut self, op: std::ffi::c_int) -> super::Result<()> {
126 match self {
127 $( $name::$t(inner) => inner.exclusive_mode(op) ),*
128 }
129 }
130
131 fn uses_heap_memory(&self) -> bool {
132 match self {
133 $( $name::$t(inner) => inner.uses_heap_memory() ),*
134 }
135 }
136
137 fn set_db(&mut self, db: &mut super::Sqlite3Db) {
138 match self {
139 $( $name::$t(inner) => inner.set_db(db) ),*
140 }
141 }
142
143 fn callback(&self) -> i32 {
144 match self {
145 $( $name::$t(inner) => inner.callback() ),*
146 }
147 }
148
149 fn frames_in_wal(&self) -> u32 {
150 match self {
151 $( $name::$t(inner) => inner.frames_in_wal() ),*
152 }
153 }
154 }
155
156 impl< $( $t ),* > $crate::wal::WalManager for $name< $( $t ),* >
157 where
158 $( $t: $crate::wal::WalManager ),*
159 {
160 type Wal = $name< $( $t::Wal ),* >;
161
162 fn use_shared_memory(&self) -> bool {
163 match self {
164 $( $name::$t(inner) => inner.use_shared_memory() ),*
165 }
166 }
167
168 fn open(
169 &self,
170 vfs: &mut super::Vfs,
171 file: &mut super::Sqlite3File,
172 no_shm_mode: std::ffi::c_int,
173 max_log_size: i64,
174 db_path: &std::ffi::CStr,
175 ) -> super::Result<Self::Wal> {
176 match self {
177 $( $name::$t(inner) => inner.open(vfs, file, no_shm_mode, max_log_size, db_path).map($name::$t) ),*
178 }
179 }
180
181 fn close(
182 &self,
183 wal: &mut Self::Wal,
184 db: &mut super::Sqlite3Db,
185 sync_flags: std::ffi::c_int,
186 scratch: Option<&mut [u8]>,
187 ) -> super::Result<()> {
188 match (self, wal) {
189 $(
190 ($name::$t(inner), $name::$t(wal)) => inner.close(wal, db, sync_flags, scratch),
191 )*
192 _ => unreachable!(),
193 }
194 }
195
196 fn destroy_log(&self, vfs: &mut super::Vfs, db_path: &std::ffi::CStr) -> super::Result<()> {
197 match self {
198 $( $name::$t(inner) => inner.destroy_log(vfs, db_path) ),*
199 }
200 }
201
202 fn log_exists(&self, vfs: &mut super::Vfs, db_path: &std::ffi::CStr) -> super::Result<bool> {
203 match self {
204 $( $name::$t(inner) => inner.log_exists(vfs, db_path) ),*
205 }
206 }
207
208 fn destroy(self)
209 where
210 Self: Sized,
211 {
212 match self {
213 $( $name::$t(inner) => inner.destroy() ),*
214 }
215 }
216 }
217 };
218}
219
220create_either!(Either<A, B>);
221create_either!(Either3<A, B, C>);
222create_either!(Either4<A, B, C, D>);