Convert borrow_data and borrow_data_mut to a macro

Author: object-Object

src/logic/vm/buildings.rs

@@ -5,7 +5,7 @@ use widestring::U16String;
 
 use super::{
     LogicVMBuilder, VMLoadError, VMLoadResult,
-    processor::{Processor, ProcessorBuilder, ProcessorState},
+    processor::{Processor, ProcessorBuilder},
     variables::LValue,
 };
 use crate::types::{
@@ -178,39 +178,6 @@ impl Building {
     ) -> VMLoadResult<Self> {
         Self::from_config(name, (*position).into(), config, builder)
     }
-
-    pub fn borrow_data<T, U, R>(&self, state: &ProcessorState, f_processor: T, f_other: U) -> R
-    where
-        T: FnOnce(&ProcessorState) -> R,
-        U: FnOnce(&BuildingData) -> R,
-    {
-        match self.data.try_borrow() {
-            Ok(data) => match &*data {
-                BuildingData::Processor(p) => f_processor(&p.state),
-                other => f_other(other),
-            },
-            Err(_) => f_processor(state),
-        }
-    }
-
-    pub fn borrow_data_mut<T, U, R>(
-        &self,
-        state: &mut ProcessorState,
-        f_processor: T,
-        f_other: U,
-    ) -> R
-    where
-        T: FnOnce(&mut ProcessorState) -> R,
-        U: FnOnce(&mut BuildingData) -> R,
-    {
-        match self.data.try_borrow_mut() {
-            Ok(mut data) => match &mut *data {
-                BuildingData::Processor(p) => f_processor(&mut p.state),
-                other => f_other(other),
-            },
-            Err(_) => f_processor(state),
-        }
-    }
 }
 
 impl PartialEq for Building {
@@ -219,6 +186,52 @@ impl PartialEq for Building {
     }
 }
 
+macro_rules! borrow_data {
+    (
+        mut $ref:expr,
+        $state:ident => $expr1:expr,
+        $data:ident => $expr2:expr $(,)?
+    ) => {
+        borrow_data!(
+            @impl
+            mut, $ref.try_borrow_mut(),
+            $state => $expr1,
+            $data => $expr2
+        )
+    };
+    (
+        $ref:expr,
+        $state:ident => $expr1:expr,
+        $data:ident => $expr2:expr $(,)?
+    ) => {
+        borrow_data!(
+            @impl
+            $ref.try_borrow(),
+            $state => $expr1,
+            $data => $expr2
+        )
+    };
+    (
+        @impl
+        $($mut:ident,)? $ref:expr,
+        $state:ident => $expr1:expr,
+        $data:ident => $expr2:expr
+    ) => {
+        match $ref {
+            Ok($($mut)? data) => match &$($mut)? *data {
+                BuildingData::Processor(p) => {
+                    let $state = &$($mut)? p.state;
+                    $expr1
+                },
+                $data => $expr2,
+            },
+            Err(_) => $expr1,
+        }
+    };
+}
+
+pub(super) use borrow_data;
+
 #[derive(Debug, IntoStaticStr)]
 pub enum BuildingData {
     Processor(Box<Processor>),

src/logic/vm/instructions.rs

@@ -6,7 +6,7 @@ use noise::{NoiseFn, Simplex};
 use widestring::{U16Str, u16str};
 
 use super::{
-    Constants, LogicVM, VMLoadError, VMLoadResult,
+    Constants, LogicVM, VMLoadError, VMLoadResult, borrow_data,
     buildings::BuildingData,
     processor::{MAX_TEXT_BUFFER, ProcessorState},
     variables::{Content, LValue, LVar, RAD_DEG},
@@ -376,9 +376,9 @@ impl SimpleInstructionTrait for Read {
         let address = self.address.get(state);
 
         let result = match self.target.get(state) {
-            LValue::Building(building) => building.borrow_data(
-                state,
-                |state| match address.clone() {
+            LValue::Building(building) => borrow_data!(
+                building.data,
+                state => match address {
                     // read variable with name, returning null for constants and undefined
                     LValue::String(name) => {
                         if *name == u16str!("@counter") {
@@ -391,7 +391,7 @@ impl SimpleInstructionTrait for Read {
                     // no-op if the address is not a string
                     _ => None,
                 },
-                |data| match data {
+                data => match data {
                     // read value at index
                     BuildingData::Memory(memory) => {
                         // coerce the address to a number, and return null if the address is not in range
@@ -433,19 +433,19 @@ impl SimpleInstructionTrait for Write {
             let address = self.address.get(state);
             let value = self.value.get(state);
 
-            building.borrow_data_mut(
-                state,
-                |state| match address.clone() {
+            borrow_data!(
+                mut building.data,
+                state => match address {
                     LValue::String(name) if *name == u16str!("@counter") => {
-                        state.try_set_counter(value.clone());
+                        state.try_set_counter(value);
                         state.set_stopped(false);
                     }
                     LValue::String(name) if state.variables.contains_key(&*name) => {
-                        state.variables[&*name] = value.clone();
+                        state.variables[&*name] = value;
                     }
                     _ => {}
                 },
-                |data| {
+                data => {
                     if let BuildingData::Memory(memory) = data
                         && let Ok(address) = address.num_usize()
                         && address < memory.len()
@@ -608,10 +608,10 @@ impl SimpleInstructionTrait for Control {
             let enabled = self.p1.get(state);
             if !enabled.isobj() {
                 let enabled = enabled.numf() != 0.;
-                building.borrow_data_mut(
-                    state,
-                    |state| state.set_enabled(enabled),
-                    |data| {
+                borrow_data!(
+                    mut building.data,
+                    state => state.set_enabled(enabled),
+                    data => {
                         if let BuildingData::Switch(value) = data {
                             *value = enabled;
                         }
@@ -706,13 +706,13 @@ impl SimpleInstructionTrait for Sensor {
                     FirstItem => LValue::Null,
                     PayloadType => LValue::Null,
 
-                    _ => building.borrow_data(
-                        state,
-                        |state| match sensor {
+                    _ => borrow_data!(
+                        building.data,
+                        state => match sensor {
                             LAccess::Enabled => state.enabled().into(),
                             _ => LValue::Null,
                         },
-                        |data| match data {
+                        data => match data {
                             BuildingData::Memory(memory) => match sensor {
                                 MemoryCapacity => memory.len().into(),
                                 Enabled => true.into(),