Debian Codegraph @

src/mpt/io/io_virtual_wrapper.hpp

raw
1 /* SPDX-License-Identifier: BSL-1.0 OR BSD-3-Clause */
2
3 #ifndef MPT_IO_IO_VIRTUAL_WRAPPER_HPP
4 #define MPT_IO_IO_VIRTUAL_WRAPPER_HPP
5
6
7
8 #include "mpt/base/memory.hpp"
9 #include "mpt/base/namespace.hpp"
10 #include "mpt/io/base.hpp"
11
12 #include <type_traits>
13
14
15
16 namespace mpt {
17 inline namespace MPT_INLINE_NS {
18
19
20
21 namespace IO {
22
23
24
25 class IFileBase {
26 protected:
27 IFileBase() = default;
28 virtual ~IFileBase() = default;
29
30 public:
31 virtual bool IsValid() = 0;
32 virtual bool IsReadSeekable() = 0;
33 virtual IO::Offset TellRead() = 0;
34 virtual bool SeekBegin() = 0;
35 virtual bool SeekEnd() = 0;
36 virtual bool SeekAbsolute(IO::Offset pos) = 0;
37 virtual bool SeekRelative(IO::Offset off) = 0;
38 virtual mpt::byte_span ReadRawImpl(mpt::byte_span data) = 0;
39 virtual bool IsEof() = 0;
40 };
41
42 template <typename Tfile>
43 class IFile
44 : public IFileBase {
45 private:
46 Tfile & f;
47
48 public:
49 IFile(Tfile & f_)
50 : f(f_) {
51 }
52 ~IFile() override = default;
53
54 public:
55 bool IsValid() override {
56 return mpt::IO::IsValid(f);
57 }
58 bool IsReadSeekable() override {
59 return mpt::IO::IsReadSeekable(f);
60 }
61 IO::Offset TellRead() override {
62 return mpt::IO::TellRead(f);
63 }
64 bool SeekBegin() override {
65 return mpt::IO::SeekBegin(f);
66 }
67 bool SeekEnd() override {
68 return mpt::IO::SeekEnd(f);
69 }
70 bool SeekAbsolute(IO::Offset pos) override {
71 return mpt::IO::SeekAbsolute(f, pos);
72 }
73 bool SeekRelative(IO::Offset off) override {
74 return mpt::IO::SeekRelative(f, off);
75 }
76 mpt::byte_span ReadRawImpl(mpt::byte_span data) override {
77 return mpt::IO::ReadRawImpl(f, data);
78 }
79 bool IsEof() override {
80 return mpt::IO::IsEof(f);
81 }
82 };
83
84
85
86 class OFileBase {
87 protected:
88 OFileBase() = default;
89 virtual ~OFileBase() = default;
90
91 public:
92 virtual bool IsValid() = 0;
93 virtual bool IsWriteSeekable() = 0;
94 virtual IO::Offset TellWrite() = 0;
95 virtual bool SeekBegin() = 0;
96 virtual bool SeekEnd() = 0;
97 virtual bool SeekAbsolute(IO::Offset pos) = 0;
98 virtual bool SeekRelative(IO::Offset off) = 0;
99 virtual bool WriteRawImpl(mpt::const_byte_span data) = 0;
100 virtual bool Flush() = 0;
101 };
102
103 template <typename Tfile>
104 class OFile
105 : public OFileBase {
106 private:
107 Tfile & f;
108
109 public:
110 OFile(Tfile & f_)
111 : f(f_) {
112 }
113 ~OFile() override = default;
114
115 public:
116 bool IsValid() override {
117 return mpt::IO::IsValid(f);
118 }
119 bool IsWriteSeekable() override {
120 return mpt::IO::IsWriteSeekable(f);
121 }
122 IO::Offset TellWrite() override {
123 return mpt::IO::TellWrite(f);
124 }
125 bool SeekBegin() override {
126 return mpt::IO::SeekBegin(f);
127 }
128 bool SeekEnd() override {
129 return mpt::IO::SeekEnd(f);
130 }
131 bool SeekAbsolute(IO::Offset pos) override {
132 return mpt::IO::SeekAbsolute(f, pos);
133 }
134 bool SeekRelative(IO::Offset off) override {
135 return mpt::IO::SeekRelative(f, off);
136 }
137 bool WriteRawImpl(mpt::const_byte_span data) override {
138 return mpt::IO::WriteRawImpl(f, data);
139 }
140 bool Flush() override {
141 return mpt::IO::Flush(f);
142 }
143 };
144
145
146
147 class IOFileBase {
148 protected:
149 IOFileBase() = default;
150 virtual ~IOFileBase() = default;
151
152 public:
153 virtual bool IsValid() = 0;
154 virtual bool IsReadSeekable() = 0;
155 virtual bool IsWriteSeekable() = 0;
156 virtual IO::Offset TellRead() = 0;
157 virtual IO::Offset TellWrite() = 0;
158 virtual bool SeekBegin() = 0;
159 virtual bool SeekEnd() = 0;
160 virtual bool SeekAbsolute(IO::Offset pos) = 0;
161 virtual bool SeekRelative(IO::Offset off) = 0;
162 virtual mpt::byte_span ReadRawImpl(mpt::byte_span data) = 0;
163 virtual bool WriteRawImpl(mpt::const_byte_span data) = 0;
164 virtual bool IsEof() = 0;
165 virtual bool Flush() = 0;
166 };
167
168 template <typename Tfile>
169 class IOFile
170 : public IOFileBase {
171 private:
172 Tfile & f;
173
174 public:
175 IOFile(Tfile & f_)
176 : f(f_) {
177 }
178 ~IOFile() override = default;
179
180 public:
181 bool IsValid() override {
182 return mpt::IO::IsValid(f);
183 }
184 bool IsReadSeekable() override {
185 return mpt::IO::IsReadSeekable(f);
186 }
187 bool IsWriteSeekable() override {
188 return mpt::IO::IsWriteSeekable(f);
189 }
190 IO::Offset TellRead() override {
191 return mpt::IO::TellRead(f);
192 }
193 IO::Offset TellWrite() override {
194 return mpt::IO::TellWrite(f);
195 }
196 bool SeekBegin() override {
197 return mpt::IO::SeekBegin(f);
198 }
199 bool SeekEnd() override {
200 return mpt::IO::SeekEnd(f);
201 }
202 bool SeekAbsolute(IO::Offset pos) override {
203 return mpt::IO::SeekAbsolute(f, pos);
204 }
205 bool SeekRelative(IO::Offset off) override {
206 return mpt::IO::SeekRelative(f, off);
207 }
208 mpt::byte_span ReadRawImpl(mpt::byte_span data) override {
209 return mpt::IO::ReadRawImpl(f, data);
210 }
211 bool WriteRawImpl(mpt::const_byte_span data) override {
212 return mpt::IO::WriteRawImpl(f, data);
213 }
214 bool IsEof() override {
215 return mpt::IO::IsEof(f);
216 }
217 bool Flush() override {
218 return mpt::IO::Flush(f);
219 }
220 };
221
222
223
224 template <typename Tfile>
225 struct FileOperations<Tfile, typename std::enable_if_t<std::is_base_of<IFileBase, Tfile>::value>> {
226
227 private:
228 IFileBase & f;
229
230 public:
231 FileOperations(IFileBase & f_)
232 : f(f_) {
233 return;
234 }
235
236 public:
237 // cppcheck false-positive
238 // cppcheck-suppress duplInheritedMember
239 inline bool IsValid() {
240 return f.IsValid();
241 }
242
243 // cppcheck false-positive
244 // cppcheck-suppress duplInheritedMember
245 inline bool IsReadSeekable() {
246 return f.IsReadSeekable();
247 }
248
249 // cppcheck false-positive
250 // cppcheck-suppress duplInheritedMember
251 inline IO::Offset TellRead() {
252 return f.TellRead();
253 }
254
255 // cppcheck false-positive
256 // cppcheck-suppress duplInheritedMember
257 inline bool SeekBegin() {
258 return f.SeekBegin();
259 }
260
261 // cppcheck false-positive
262 // cppcheck-suppress duplInheritedMember
263 inline bool SeekEnd() {
264 return f.SeekEnd();
265 }
266
267 // cppcheck false-positive
268 // cppcheck-suppress duplInheritedMember
269 inline bool SeekAbsolute(IO::Offset pos) {
270 return f.SeekAbsolute(pos);
271 }
272
273 // cppcheck false-positive
274 // cppcheck-suppress duplInheritedMember
275 inline bool SeekRelative(IO::Offset off) {
276 return f.SeekRelative(off);
277 }
278
279 // cppcheck false-positive
280 // cppcheck-suppress duplInheritedMember
281 inline mpt::byte_span ReadRawImpl(mpt::byte_span data) {
282 return f.ReadRawImpl(data);
283 }
284
285 // cppcheck false-positive
286 // cppcheck-suppress duplInheritedMember
287 inline bool IsEof() {
288 return f.IsEof();
289 }
290 };
291
292
293
294 template <typename Tfile>
295 struct FileOperations<Tfile, typename std::enable_if_t<std::is_base_of<OFileBase, Tfile>::value>> {
296
297 private:
298 OFileBase & f;
299
300 public:
301 FileOperations(OFileBase & f_)
302 : f(f_) {
303 return;
304 }
305
306 public:
307 // cppcheck false-positive
308 // cppcheck-suppress duplInheritedMember
309 inline bool IsValid() {
310 return f.IsValid();
311 }
312
313 // cppcheck false-positive
314 // cppcheck-suppress duplInheritedMember
315 inline bool IsWriteSeekable() {
316 return f.IsWriteSeekable();
317 }
318
319 // cppcheck false-positive
320 // cppcheck-suppress duplInheritedMember
321 inline IO::Offset TellWrite() {
322 return f.TellWrite();
323 }
324
325 // cppcheck false-positive
326 // cppcheck-suppress duplInheritedMember
327 inline bool SeekBegin() {
328 return f.SeekBegin();
329 }
330
331 // cppcheck false-positive
332 // cppcheck-suppress duplInheritedMember
333 inline bool SeekEnd() {
334 return f.SeekEnd();
335 }
336
337 // cppcheck false-positive
338 // cppcheck-suppress duplInheritedMember
339 inline bool SeekAbsolute(IO::Offset pos) {
340 return f.SeekAbsolute(pos);
341 }
342
343 // cppcheck false-positive
344 // cppcheck-suppress duplInheritedMember
345 inline bool SeekRelative(IO::Offset off) {
346 return f.SeekRelative(off);
347 }
348
349 // cppcheck false-positive
350 // cppcheck-suppress duplInheritedMember
351 inline bool WriteRawImpl(mpt::const_byte_span data) {
352 return f.WriteRawImpl(data);
353 }
354
355 // cppcheck false-positive
356 // cppcheck-suppress duplInheritedMember
357 inline bool Flush() {
358 return f.Flush();
359 }
360 };
361
362
363
364 template <typename Tfile>
365 struct FileOperations<Tfile, typename std::enable_if_t<std::is_base_of<IOFileBase, Tfile>::value>> {
366
367 private:
368 IOFileBase & f;
369
370 public:
371 FileOperations(IOFileBase & f_)
372 : f(f_) {
373 return;
374 }
375
376 public:
377 // cppcheck false-positive
378 // cppcheck-suppress duplInheritedMember
379 inline bool IsValid() {
380 return f.IsValid();
381 }
382
383 // cppcheck false-positive
384 // cppcheck-suppress duplInheritedMember
385 inline bool IsReadSeekable() {
386 return f.IsReadSeekable();
387 }
388
389 // cppcheck false-positive
390 // cppcheck-suppress duplInheritedMember
391 inline bool IsWriteSeekable() {
392 return f.IsWriteSeekable();
393 }
394
395 // cppcheck false-positive
396 // cppcheck-suppress duplInheritedMember
397 inline IO::Offset TellRead() {
398 return f.TellRead();
399 }
400
401 // cppcheck false-positive
402 // cppcheck-suppress duplInheritedMember
403 inline IO::Offset TellWrite() {
404 return f.TellWrite();
405 }
406
407 // cppcheck false-positive
408 // cppcheck-suppress duplInheritedMember
409 inline bool SeekBegin() {
410 return f.SeekBegin();
411 }
412
413 // cppcheck false-positive
414 // cppcheck-suppress duplInheritedMember
415 inline bool SeekEnd() {
416 return f.SeekEnd();
417 }
418
419 // cppcheck false-positive
420 // cppcheck-suppress duplInheritedMember
421 inline bool SeekAbsolute(IO::Offset pos) {
422 return f.SeekAbsolute(pos);
423 }
424
425 // cppcheck false-positive
426 // cppcheck-suppress duplInheritedMember
427 inline bool SeekRelative(IO::Offset off) {
428 return f.SeekRelative(off);
429 }
430
431 // cppcheck false-positive
432 // cppcheck-suppress duplInheritedMember
433 inline mpt::byte_span ReadRawImpl(mpt::byte_span data) {
434 return f.ReadRawImpl(data);
435 }
436
437 // cppcheck false-positive
438 // cppcheck-suppress duplInheritedMember
439 inline bool WriteRawImpl(mpt::const_byte_span data) {
440 return f.WriteRawImpl(data);
441 }
442
443 // cppcheck false-positive
444 // cppcheck-suppress duplInheritedMember
445 inline bool IsEof() {
446 return f.IsEof();
447 }
448
449 // cppcheck false-positive
450 // cppcheck-suppress duplInheritedMember
451 inline bool Flush() {
452 return f.Flush();
453 }
454 };
455
456
457
458 } // namespace IO
459
460
461
462 } // namespace MPT_INLINE_NS
463 } // namespace mpt
464
465
466
467 #endif // MPT_IO_IO_VIRTUAL_WRAPPER_HPP