remove macro

Author: Migorithm

duva/src/adapters/loggers/op_logs.rs

@@ -10,15 +10,6 @@ pub enum OperationLogs {
     OnDisk(FileOpLogs),
 }
 
-macro_rules! delegate_wal_method {
-    ($self:ident.$method:ident($($arg:ident),*)) => {
-        match $self {
-            Self::Memory(wal) => wal.$method($($arg),*),
-            Self::OnDisk(wal) => wal.$method($($arg),*),
-        }
-    };
-}
-
 impl OperationLogs {
     pub fn new_inmemory() -> Self {
         Self::Memory(Default::default())
@@ -28,13 +19,23 @@ impl OperationLogs {
     }
     /// Append one or more `WriteOperation`s to the log.
     pub(crate) fn write_many(&mut self, ops: Vec<WriteOperation>) -> anyhow::Result<()> {
-        delegate_wal_method!(self.write_many(ops))
+        match self {
+            OperationLogs::Memory(memory_op_logs) => memory_op_logs.write_many(ops),
+            OperationLogs::OnDisk(file_op_logs) => file_op_logs.write_many(ops),
+        }
     }
 
     /// Retrieve logs that fall between the current 'commit' index and target 'log' index.
     /// This is NOT async as it is expected to be infallible and an in-memory operation.
     pub(crate) fn range(&self, start_exclusive: u64, end_inclusive: u64) -> Vec<WriteOperation> {
-        delegate_wal_method!(self.range(start_exclusive, end_inclusive))
+        match self {
+            OperationLogs::Memory(memory_op_logs) => {
+                memory_op_logs.range(start_exclusive, end_inclusive)
+            },
+            OperationLogs::OnDisk(file_op_logs) => {
+                file_op_logs.range(start_exclusive, end_inclusive)
+            },
+        }
     }
 
     /// Replays all logged operations from the beginning of the WAL, calling the provided callback `f` for each operation.
@@ -43,21 +44,33 @@ impl OperationLogs {
     where
         F: FnMut(WriteOperation) + Send,
     {
-        delegate_wal_method!(self.replay(f))
+        match self {
+            OperationLogs::Memory(memory_op_logs) => memory_op_logs.replay(f),
+            OperationLogs::OnDisk(file_op_logs) => file_op_logs.replay(f),
+        }
     }
 
     /// Retrieves the log at a given index.
     pub(crate) fn read_at(&mut self, at: u64) -> Option<WriteOperation> {
-        delegate_wal_method!(self.read_at(at))
+        match self {
+            OperationLogs::Memory(memory_op_logs) => memory_op_logs.read_at(at),
+            OperationLogs::OnDisk(file_op_logs) => file_op_logs.read_at(at),
+        }
     }
 
     /// Returns true if there are no logs. Otherwise, returns false.
     pub(crate) fn is_empty(&self) -> bool {
-        delegate_wal_method!(self.is_empty())
+        match self {
+            OperationLogs::Memory(memory_op_logs) => memory_op_logs.is_empty(),
+            OperationLogs::OnDisk(file_op_logs) => file_op_logs.is_empty(),
+        }
     }
 
     /// Truncate logs that are positioned after `log_index`.
     pub(crate) fn truncate_after(&mut self, log_index: u64) {
-        delegate_wal_method!(self.truncate_after(log_index))
+        match self {
+            OperationLogs::Memory(memory_op_logs) => memory_op_logs.truncate_after(log_index),
+            OperationLogs::OnDisk(file_op_logs) => file_op_logs.truncate_after(log_index),
+        }
     }
 }