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 frame_count(&self, locked: i32) -> super::Result<u32> {
85 match self {
86 $( $name::$t(inner) => inner.frame_count(locked) ),*
87 }
88 }
89
90 fn insert_frames(
91 &mut self,
92 page_size: std::ffi::c_int,
93 page_headers: &mut super::PageHeaders,
94 size_after: u32,
95 is_commit: bool,
96 sync_flags: std::ffi::c_int,
97 ) -> super::Result<usize> {
98 match self {
99 $( $name::$t(inner) => inner.insert_frames(page_size, page_headers, size_after, is_commit, sync_flags) ),*
100 }
101 }
102
103 fn checkpoint(
104 &mut self,
105 db: &mut super::Sqlite3Db,
106 mode: super::CheckpointMode,
107 busy_handler: Option<&mut dyn super::BusyHandler>,
108 sync_flags: u32,
109 buf: &mut [u8],
110 checkpoint_cb: Option<&mut dyn super::CheckpointCallback>,
111 in_wal: Option<&mut i32>,
112 backfilled: Option<&mut i32>,
113 ) -> super::Result<()> {
114 match self {
115 $( $name::$t(inner) => inner.checkpoint(db, mode, busy_handler, sync_flags, buf, checkpoint_cb, in_wal, backfilled) ),*
116 }
117 }
118
119 fn exclusive_mode(&mut self, op: std::ffi::c_int) -> super::Result<()> {
120 match self {
121 $( $name::$t(inner) => inner.exclusive_mode(op) ),*
122 }
123 }
124
125 fn uses_heap_memory(&self) -> bool {
126 match self {
127 $( $name::$t(inner) => inner.uses_heap_memory() ),*
128 }
129 }
130
131 fn set_db(&mut self, db: &mut super::Sqlite3Db) {
132 match self {
133 $( $name::$t(inner) => inner.set_db(db) ),*
134 }
135 }
136
137 fn callback(&self) -> i32 {
138 match self {
139 $( $name::$t(inner) => inner.callback() ),*
140 }
141 }
142
143 fn frames_in_wal(&self) -> u32 {
144 match self {
145 $( $name::$t(inner) => inner.frames_in_wal() ),*
146 }
147 }
148 }
149
150 impl< $( $t ),* > $crate::wal::WalManager for $name< $( $t ),* >
151 where
152 $( $t: $crate::wal::WalManager ),*
153 {
154 type Wal = $name< $( $t::Wal ),* >;
155
156 fn use_shared_memory(&self) -> bool {
157 match self {
158 $( $name::$t(inner) => inner.use_shared_memory() ),*
159 }
160 }
161
162 fn open(
163 &self,
164 vfs: &mut super::Vfs,
165 file: &mut super::Sqlite3File,
166 no_shm_mode: std::ffi::c_int,
167 max_log_size: i64,
168 db_path: &std::ffi::CStr,
169 ) -> super::Result<Self::Wal> {
170 match self {
171 $( $name::$t(inner) => inner.open(vfs, file, no_shm_mode, max_log_size, db_path).map($name::$t) ),*
172 }
173 }
174
175 fn close(
176 &self,
177 wal: &mut Self::Wal,
178 db: &mut super::Sqlite3Db,
179 sync_flags: std::ffi::c_int,
180 scratch: Option<&mut [u8]>,
181 ) -> super::Result<()> {
182 match (self, wal) {
183 $(
184 ($name::$t(inner), $name::$t(wal)) => inner.close(wal, db, sync_flags, scratch),
185 )*
186 _ => unreachable!(),
187 }
188 }
189
190 fn destroy_log(&self, vfs: &mut super::Vfs, db_path: &std::ffi::CStr) -> super::Result<()> {
191 match self {
192 $( $name::$t(inner) => inner.destroy_log(vfs, db_path) ),*
193 }
194 }
195
196 fn log_exists(&self, vfs: &mut super::Vfs, db_path: &std::ffi::CStr) -> super::Result<bool> {
197 match self {
198 $( $name::$t(inner) => inner.log_exists(vfs, db_path) ),*
199 }
200 }
201
202 fn destroy(self)
203 where
204 Self: Sized,
205 {
206 match self {
207 $( $name::$t(inner) => inner.destroy() ),*
208 }
209 }
210 }
211 };
212}
213
214create_either!(Either<A, B>);
215create_either!(Either3<A, B, C>);
216create_either!(Either4<A, B, C, D>);