ximu3 1.9.1

use crate::command_message::*;
use crate::connection_status::*;
use crate::data_messages::*;
use crate::mux_message::*;
use crate::receive_error::*;
use crate::statistics::*;
use crossbeam::channel::Sender;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};

pub enum DispatcherData {
    ReceiveError(ReceiveError),
    Status(ConnectionStatus),
    Statistics(Statistics),
    Command(CommandMessage),
    Mux(MuxMessage),
    // Start of code block #0 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
    Inertial(InertialMessage),
    Magnetometer(MagnetometerMessage),
    HighGAccelerometer(HighGAccelerometerMessage),
    Quaternion(QuaternionMessage),
    RotationMatrix(RotationMatrixMessage),
    EulerAngles(EulerAnglesMessage),
    LinearAcceleration(LinearAccelerationMessage),
    EarthAcceleration(EarthAccelerationMessage),
    AhrsStatus(AhrsStatusMessage),
    SerialAccessory(SerialAccessoryMessage),
    Sync(SyncMessage),
    Ltc(LtcMessage),
    Temperature(TemperatureMessage),
    Battery(BatteryMessage),
    Rssi(RssiMessage),
    Button(ButtonMessage),
    Notification(NotificationMessage),
    Error(ErrorMessage),
    // End of code block #0 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
}

pub struct Dispatcher {
    pub sender: Sender<DispatcherData>,

    // Start of code block #1 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
    pub inertial_message: Arc<Mutex<Option<InertialMessage>>>,
    pub magnetometer_message: Arc<Mutex<Option<MagnetometerMessage>>>,
    pub high_g_accelerometer_message: Arc<Mutex<Option<HighGAccelerometerMessage>>>,
    pub quaternion_message: Arc<Mutex<Option<QuaternionMessage>>>,
    pub rotation_matrix_message: Arc<Mutex<Option<RotationMatrixMessage>>>,
    pub euler_angles_message: Arc<Mutex<Option<EulerAnglesMessage>>>,
    pub linear_acceleration_message: Arc<Mutex<Option<LinearAccelerationMessage>>>,
    pub earth_acceleration_message: Arc<Mutex<Option<EarthAccelerationMessage>>>,
    pub ahrs_status_message: Arc<Mutex<Option<AhrsStatusMessage>>>,
    pub serial_accessory_message: Arc<Mutex<Option<SerialAccessoryMessage>>>,
    pub sync_message: Arc<Mutex<Option<SyncMessage>>>,
    pub ltc_message: Arc<Mutex<Option<LtcMessage>>>,
    pub temperature_message: Arc<Mutex<Option<TemperatureMessage>>>,
    pub battery_message: Arc<Mutex<Option<BatteryMessage>>>,
    pub rssi_message: Arc<Mutex<Option<RssiMessage>>>,
    pub button_message: Arc<Mutex<Option<ButtonMessage>>>,
    pub notification_message: Arc<Mutex<Option<NotificationMessage>>>,
    pub error_message: Arc<Mutex<Option<ErrorMessage>>>,
    // End of code block #1 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
    closure_ids: AtomicU64,

    receive_error_closures: Arc<Mutex<Vec<(Box<dyn Fn(ReceiveError) + Send>, u64)>>>,
    status_closures: Arc<Mutex<Vec<(Box<dyn Fn(ConnectionStatus) + Send>, u64)>>>,
    statistics_closures: Arc<Mutex<Vec<(Box<dyn Fn(Statistics) + Send>, u64)>>>,
    command_closures: Arc<Mutex<Vec<(Box<dyn Fn(CommandMessage) + Send>, u64)>>>,
    mux_closures: Arc<Mutex<Vec<(Box<dyn Fn(MuxMessage) + Send>, u64)>>>,
    data_closures: Arc<Mutex<Vec<(Box<dyn Fn(Box<dyn DataMessage>) + Send>, u64)>>>,
    // Start of code block #2 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
    inertial_closures: Arc<Mutex<Vec<(Box<dyn Fn(InertialMessage) + Send>, u64)>>>,
    magnetometer_closures: Arc<Mutex<Vec<(Box<dyn Fn(MagnetometerMessage) + Send>, u64)>>>,
    high_g_accelerometer_closures: Arc<Mutex<Vec<(Box<dyn Fn(HighGAccelerometerMessage) + Send>, u64)>>>,
    quaternion_closures: Arc<Mutex<Vec<(Box<dyn Fn(QuaternionMessage) + Send>, u64)>>>,
    rotation_matrix_closures: Arc<Mutex<Vec<(Box<dyn Fn(RotationMatrixMessage) + Send>, u64)>>>,
    euler_angles_closures: Arc<Mutex<Vec<(Box<dyn Fn(EulerAnglesMessage) + Send>, u64)>>>,
    linear_acceleration_closures: Arc<Mutex<Vec<(Box<dyn Fn(LinearAccelerationMessage) + Send>, u64)>>>,
    earth_acceleration_closures: Arc<Mutex<Vec<(Box<dyn Fn(EarthAccelerationMessage) + Send>, u64)>>>,
    ahrs_status_closures: Arc<Mutex<Vec<(Box<dyn Fn(AhrsStatusMessage) + Send>, u64)>>>,
    serial_accessory_closures: Arc<Mutex<Vec<(Box<dyn Fn(SerialAccessoryMessage) + Send>, u64)>>>,
    sync_closures: Arc<Mutex<Vec<(Box<dyn Fn(SyncMessage) + Send>, u64)>>>,
    ltc_closures: Arc<Mutex<Vec<(Box<dyn Fn(LtcMessage) + Send>, u64)>>>,
    temperature_closures: Arc<Mutex<Vec<(Box<dyn Fn(TemperatureMessage) + Send>, u64)>>>,
    battery_closures: Arc<Mutex<Vec<(Box<dyn Fn(BatteryMessage) + Send>, u64)>>>,
    rssi_closures: Arc<Mutex<Vec<(Box<dyn Fn(RssiMessage) + Send>, u64)>>>,
    button_closures: Arc<Mutex<Vec<(Box<dyn Fn(ButtonMessage) + Send>, u64)>>>,
    notification_closures: Arc<Mutex<Vec<(Box<dyn Fn(NotificationMessage) + Send>, u64)>>>,
    error_closures: Arc<Mutex<Vec<(Box<dyn Fn(ErrorMessage) + Send>, u64)>>>,
    // End of code block #2 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
}

impl Dispatcher {
    pub fn new() -> Self {
        let (sender, receiver) = crossbeam::channel::unbounded();

        let dispatcher = Self {
            sender,

            // Start of code block #3 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
            inertial_message: Arc::new(Mutex::new(None)),
            magnetometer_message: Arc::new(Mutex::new(None)),
            high_g_accelerometer_message: Arc::new(Mutex::new(None)),
            quaternion_message: Arc::new(Mutex::new(None)),
            rotation_matrix_message: Arc::new(Mutex::new(None)),
            euler_angles_message: Arc::new(Mutex::new(None)),
            linear_acceleration_message: Arc::new(Mutex::new(None)),
            earth_acceleration_message: Arc::new(Mutex::new(None)),
            ahrs_status_message: Arc::new(Mutex::new(None)),
            serial_accessory_message: Arc::new(Mutex::new(None)),
            sync_message: Arc::new(Mutex::new(None)),
            ltc_message: Arc::new(Mutex::new(None)),
            temperature_message: Arc::new(Mutex::new(None)),
            battery_message: Arc::new(Mutex::new(None)),
            rssi_message: Arc::new(Mutex::new(None)),
            button_message: Arc::new(Mutex::new(None)),
            notification_message: Arc::new(Mutex::new(None)),
            error_message: Arc::new(Mutex::new(None)),
            // End of code block #3 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
            closure_ids: AtomicU64::new(0),

            receive_error_closures: Arc::new(Mutex::new(Vec::new())),
            status_closures: Arc::new(Mutex::new(Vec::new())),
            statistics_closures: Arc::new(Mutex::new(Vec::new())),
            command_closures: Arc::new(Mutex::new(Vec::new())),
            mux_closures: Arc::new(Mutex::new(Vec::new())),
            data_closures: Arc::new(Mutex::new(Vec::new())),
            // Start of code block #4 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
            inertial_closures: Arc::new(Mutex::new(Vec::new())),
            magnetometer_closures: Arc::new(Mutex::new(Vec::new())),
            high_g_accelerometer_closures: Arc::new(Mutex::new(Vec::new())),
            quaternion_closures: Arc::new(Mutex::new(Vec::new())),
            rotation_matrix_closures: Arc::new(Mutex::new(Vec::new())),
            euler_angles_closures: Arc::new(Mutex::new(Vec::new())),
            linear_acceleration_closures: Arc::new(Mutex::new(Vec::new())),
            earth_acceleration_closures: Arc::new(Mutex::new(Vec::new())),
            ahrs_status_closures: Arc::new(Mutex::new(Vec::new())),
            serial_accessory_closures: Arc::new(Mutex::new(Vec::new())),
            sync_closures: Arc::new(Mutex::new(Vec::new())),
            ltc_closures: Arc::new(Mutex::new(Vec::new())),
            temperature_closures: Arc::new(Mutex::new(Vec::new())),
            battery_closures: Arc::new(Mutex::new(Vec::new())),
            rssi_closures: Arc::new(Mutex::new(Vec::new())),
            button_closures: Arc::new(Mutex::new(Vec::new())),
            notification_closures: Arc::new(Mutex::new(Vec::new())),
            error_closures: Arc::new(Mutex::new(Vec::new())),
            // End of code block #4 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
        };

        // Start of code block #5 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
        let inertial_message = dispatcher.inertial_message.clone();
        let magnetometer_message = dispatcher.magnetometer_message.clone();
        let high_g_accelerometer_message = dispatcher.high_g_accelerometer_message.clone();
        let quaternion_message = dispatcher.quaternion_message.clone();
        let rotation_matrix_message = dispatcher.rotation_matrix_message.clone();
        let euler_angles_message = dispatcher.euler_angles_message.clone();
        let linear_acceleration_message = dispatcher.linear_acceleration_message.clone();
        let earth_acceleration_message = dispatcher.earth_acceleration_message.clone();
        let ahrs_status_message = dispatcher.ahrs_status_message.clone();
        let serial_accessory_message = dispatcher.serial_accessory_message.clone();
        let sync_message = dispatcher.sync_message.clone();
        let ltc_message = dispatcher.ltc_message.clone();
        let temperature_message = dispatcher.temperature_message.clone();
        let battery_message = dispatcher.battery_message.clone();
        let rssi_message = dispatcher.rssi_message.clone();
        let button_message = dispatcher.button_message.clone();
        let notification_message = dispatcher.notification_message.clone();
        let error_message = dispatcher.error_message.clone();
        // End of code block #5 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py

        let receive_error_closures = dispatcher.receive_error_closures.clone();
        let status_closures = dispatcher.status_closures.clone();
        let statistics_closures = dispatcher.statistics_closures.clone();
        let command_closures = dispatcher.command_closures.clone();
        let mux_closures = dispatcher.mux_closures.clone();
        let data_closures = dispatcher.data_closures.clone();
        // Start of code block #6 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
        let inertial_closures = dispatcher.inertial_closures.clone();
        let magnetometer_closures = dispatcher.magnetometer_closures.clone();
        let high_g_accelerometer_closures = dispatcher.high_g_accelerometer_closures.clone();
        let quaternion_closures = dispatcher.quaternion_closures.clone();
        let rotation_matrix_closures = dispatcher.rotation_matrix_closures.clone();
        let euler_angles_closures = dispatcher.euler_angles_closures.clone();
        let linear_acceleration_closures = dispatcher.linear_acceleration_closures.clone();
        let earth_acceleration_closures = dispatcher.earth_acceleration_closures.clone();
        let ahrs_status_closures = dispatcher.ahrs_status_closures.clone();
        let serial_accessory_closures = dispatcher.serial_accessory_closures.clone();
        let sync_closures = dispatcher.sync_closures.clone();
        let ltc_closures = dispatcher.ltc_closures.clone();
        let temperature_closures = dispatcher.temperature_closures.clone();
        let battery_closures = dispatcher.battery_closures.clone();
        let rssi_closures = dispatcher.rssi_closures.clone();
        let button_closures = dispatcher.button_closures.clone();
        let notification_closures = dispatcher.notification_closures.clone();
        let error_closures = dispatcher.error_closures.clone();
        // End of code block #6 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py

        std::thread::spawn(move || loop {
            let data = match receiver.recv() {
                Ok(data) => data,
                Err(_) => break,
            };

            match data {
                DispatcherData::ReceiveError(receive_error) => receive_error_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(receive_error)),

                DispatcherData::Status(status) => status_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(status)),

                DispatcherData::Statistics(statistics) => statistics_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(statistics)),

                DispatcherData::Command(command) => command_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(command.clone())),

                DispatcherData::Mux(message) => mux_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message.clone())),

                // Start of code block #7 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py

                DispatcherData::Inertial(message) => {
                    *inertial_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    inertial_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Magnetometer(message) => {
                    *magnetometer_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    magnetometer_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::HighGAccelerometer(message) => {
                    *high_g_accelerometer_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    high_g_accelerometer_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Quaternion(message) => {
                    *quaternion_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    quaternion_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::RotationMatrix(message) => {
                    *rotation_matrix_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    rotation_matrix_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::EulerAngles(message) => {
                    *euler_angles_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    euler_angles_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::LinearAcceleration(message) => {
                    *linear_acceleration_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    linear_acceleration_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::EarthAcceleration(message) => {
                    *earth_acceleration_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    earth_acceleration_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::AhrsStatus(message) => {
                    *ahrs_status_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    ahrs_status_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::SerialAccessory(message) => {
                    *serial_accessory_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    serial_accessory_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Sync(message) => {
                    *sync_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    sync_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Ltc(message) => {
                    *ltc_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    ltc_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Temperature(message) => {
                    *temperature_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    temperature_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Battery(message) => {
                    *battery_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    battery_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Rssi(message) => {
                    *rssi_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    rssi_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Button(message) => {
                    *button_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    button_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Notification(message) => {
                    *notification_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    notification_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                DispatcherData::Error(message) => {
                    *error_message.lock().unwrap() = Some(message);
                    data_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(Box::new(message)));
                    error_closures.lock().unwrap().iter().for_each(|(closure, _)| closure(message));
                }

                // End of code block #7 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
            }
        });

        dispatcher
    }

    fn new_closure_id(&self) -> u64 {
        self.closure_ids.fetch_add(1, Ordering::SeqCst)
    }

    pub fn add_receive_error_closure(&self, closure: Box<dyn Fn(ReceiveError) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.receive_error_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_status_closure(&self, closure: Box<dyn Fn(ConnectionStatus) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.status_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_statistics_closure(&self, closure: Box<dyn Fn(Statistics) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.statistics_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_command_closure(&self, closure: Box<dyn Fn(CommandMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.command_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_mux_closure(&self, closure: Box<dyn Fn(MuxMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.mux_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_data_closure(&self, closure: Box<dyn Fn(Box<dyn DataMessage>) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.data_closures.lock().unwrap().push((closure, id));
        id
    }

    // Start of code block #8 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py

    pub fn add_inertial_closure(&self, closure: Box<dyn Fn(InertialMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.inertial_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_magnetometer_closure(&self, closure: Box<dyn Fn(MagnetometerMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.magnetometer_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_high_g_accelerometer_closure(&self, closure: Box<dyn Fn(HighGAccelerometerMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.high_g_accelerometer_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_quaternion_closure(&self, closure: Box<dyn Fn(QuaternionMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.quaternion_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_rotation_matrix_closure(&self, closure: Box<dyn Fn(RotationMatrixMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.rotation_matrix_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_euler_angles_closure(&self, closure: Box<dyn Fn(EulerAnglesMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.euler_angles_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_linear_acceleration_closure(&self, closure: Box<dyn Fn(LinearAccelerationMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.linear_acceleration_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_earth_acceleration_closure(&self, closure: Box<dyn Fn(EarthAccelerationMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.earth_acceleration_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_ahrs_status_closure(&self, closure: Box<dyn Fn(AhrsStatusMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.ahrs_status_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_serial_accessory_closure(&self, closure: Box<dyn Fn(SerialAccessoryMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.serial_accessory_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_sync_closure(&self, closure: Box<dyn Fn(SyncMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.sync_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_ltc_closure(&self, closure: Box<dyn Fn(LtcMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.ltc_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_temperature_closure(&self, closure: Box<dyn Fn(TemperatureMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.temperature_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_battery_closure(&self, closure: Box<dyn Fn(BatteryMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.battery_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_rssi_closure(&self, closure: Box<dyn Fn(RssiMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.rssi_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_button_closure(&self, closure: Box<dyn Fn(ButtonMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.button_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_notification_closure(&self, closure: Box<dyn Fn(NotificationMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.notification_closures.lock().unwrap().push((closure, id));
        id
    }

    pub fn add_error_closure(&self, closure: Box<dyn Fn(ErrorMessage) + Send>) -> u64 {
        let id = self.new_closure_id();
        self.error_closures.lock().unwrap().push((closure, id));
        id
    }

    // End of code block #8 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py

    pub fn remove_closure(&self, id: u64) {
        self.receive_error_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.status_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.statistics_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.command_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.mux_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.data_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        // Start of code block #9 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
        self.inertial_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.magnetometer_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.high_g_accelerometer_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.quaternion_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.rotation_matrix_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.euler_angles_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.linear_acceleration_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.earth_acceleration_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.ahrs_status_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.serial_accessory_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.sync_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.ltc_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.temperature_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.battery_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.rssi_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.button_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.notification_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        self.error_closures.lock().unwrap().retain(|(_, closure_id)| closure_id != &id);
        // End of code block #9 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
    }

    pub fn remove_all_closures(&self) {
        self.receive_error_closures.lock().unwrap().clear();
        self.status_closures.lock().unwrap().clear();
        self.statistics_closures.lock().unwrap().clear();
        self.command_closures.lock().unwrap().clear();
        self.mux_closures.lock().unwrap().clear();
        self.data_closures.lock().unwrap().clear();
        // Start of code block #10 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
        self.inertial_closures.lock().unwrap().clear();
        self.magnetometer_closures.lock().unwrap().clear();
        self.high_g_accelerometer_closures.lock().unwrap().clear();
        self.quaternion_closures.lock().unwrap().clear();
        self.rotation_matrix_closures.lock().unwrap().clear();
        self.euler_angles_closures.lock().unwrap().clear();
        self.linear_acceleration_closures.lock().unwrap().clear();
        self.earth_acceleration_closures.lock().unwrap().clear();
        self.ahrs_status_closures.lock().unwrap().clear();
        self.serial_accessory_closures.lock().unwrap().clear();
        self.sync_closures.lock().unwrap().clear();
        self.ltc_closures.lock().unwrap().clear();
        self.temperature_closures.lock().unwrap().clear();
        self.battery_closures.lock().unwrap().clear();
        self.rssi_closures.lock().unwrap().clear();
        self.button_closures.lock().unwrap().clear();
        self.notification_closures.lock().unwrap().clear();
        self.error_closures.lock().unwrap().clear();
        // End of code block #10 generated by x-IMU3-API/Rust/src/data_messages/generate_data_messages.py
    }

    pub fn pending(&self) -> bool {
        self.sender.is_empty() == false
    }
}