Merge pull request #16 from thvdveld/cargo-formatting

Break long comments into lines

Author: thvdveld

dot15d4/src/csma/constants.rs

@@ -3,34 +3,44 @@
 // Constants from section 11.3, Table 11-1, PHY constants
 /// The maximum PSDU size (in octets) the PHY shall be able to receive.
 pub const MAX_PHY_PACKET_SIZE: u32 = 127;
-/// RX-to-TX or TX-to-RX turnaround time (in symbol periods), as defined in 10.2.2 and 10.2.3.
+/// RX-to-TX or TX-to-RX turnaround time (in symbol periods), as defined in
+/// 10.2.2 and 10.2.3.
 pub const TURNAROUND_TIME: u32 = 12;
-// /// The delay between the start of the SFD and the LEIP, as described in 18.6.
-// const A_LEIP_DELAY_TIME: u32 = 0.815 ms
 /// The time required to perform CCA detection in symbol periods.
 pub const CCA_TIME: u32 = 8;
 
+// /// The delay between the start of the SFD and the LEIP, as described in
+// /// 18.6.
+// const A_LEIP_DELAY_TIME: u32 = 0.815 ms
+
 // Constants of section 8.4.2, Table 8-93, MAC constants
-/// The number of symbols forming a superframe slot when the superframe order is equal to zero, as described in 6.2.1.
+/// The number of symbols forming a superframe slot when the superframe order is
+/// equal to zero, as described in 6.2.1.
 pub const BASE_SLOT_DURATION: u32 = 60;
-/// The number of symbols forming a superframe when the superframe order is equal to zero.
+/// The number of symbols forming a superframe when the superframe order is
+/// equal to zero.
 pub const BASE_SUPERFRAME_DURATION: u32 = BASE_SLOT_DURATION * NUM_SUPERFRAME_SLOTS;
-/// The number of superframes in which a GTS descriptor exists in the beacon frame of the PAN coordinator.
+/// The number of superframes in which a GTS descriptor exists in the beacon
+/// frame of the PAN coordinator.
 pub const GTS_DESC_PERSISTENCE_TIME: u32 = 4;
-/// The number of consecutive lost beacons that will cause the MAC sublayer of a receiving device to declare a loss of synchronization.
+/// The number of consecutive lost beacons that will cause the MAC sublayer of a
+/// receiving device to declare a loss of synchronization.
 pub const MAX_LOST_BEACONS: u32 = 4;
-/// The maximum size of an MPDU, in octets, that can be followed by a SIFS period.
+/// The maximum size of an MPDU, in octets, that can be followed by a SIFS
+/// period.
 pub const MAX_SIFS_FRAME_SIZE: u32 = 18;
-/// The minimum number of symbols forming the CAP. This ensures that MAC commands can still be transferred to devices when GTSs are being used.
+/// The minimum number of symbols forming the CAP. This ensures that MAC
+/// commands can still be transferred to devices when GTSs are being used.
 ///
 /// An exception to this minimum shall be allowed for the accommodation of the
-/// temporary increase in the beacon frame length needed to perform GTS maintenance,
-/// as described in 7.3.1.5. Additional restrictions apply when PCA is enabled,
-/// as described in 6.2.5.4.
+/// temporary increase in the beacon frame length needed to perform GTS
+/// maintenance, as described in 7.3.1.5. Additional restrictions apply when PCA
+/// is enabled, as described in 6.2.5.4.
 pub const MIN_CAP_LENGTH: u32 = 440;
 /// The number of slots contained in any superframe.
 pub const NUM_SUPERFRAME_SLOTS: u32 = 440;
-/// The number of symbols forming the basic time period used by the CSMA-CA algorithm.
+/// The number of symbols forming the basic time period used by the CSMA-CA
+/// algorithm.
 pub const UNIT_BACKOFF_PERIOD: u32 = TURNAROUND_TIME + CCA_TIME;
 /// The number of symbols forming an RCCN superframe slot.
 pub const RCCN_BASE_SLOT_DURATION: u32 = 60;

dot15d4/src/csma/mod.rs

@@ -95,9 +95,10 @@ impl<'r, Rng: RngCore> CCABackoffStrategy<'r, Rng> {
                 // delay periods = random(2^{BE} - 1) periods
                 // Page 63 IEEE 802.15.4 2015 edition
                 let max_backoff = (1u32 << *backoff_exponent) - 1;
-                // The +1 in (max_backoff + 1) comes from the interpretation that the random() function
-                // used in the specification includes max_backoff as a possible value. The possible
-                // values periods now can take are: [0, max_backoff].
+                // The +1 in (max_backoff + 1) comes from the interpretation that the random()
+                // function used in the specification includes max_backoff as a
+                // possible value. The possible values periods now can take are:
+                // [0, max_backoff].
                 let periods = rng.lock().await.next_u32() % (max_backoff + 1);
                 let delay = MAC_UNIT_BACKOFF_DURATION * periods as usize;
                 timer.delay_us(delay.as_us() as u32).await;

dot15d4/src/csma/transmission.rs

@@ -4,7 +4,8 @@ use crate::time::Duration;
 
 use super::constants::{SYMBOL_RATE_INV_US, UNIT_BACKOFF_PERIOD};
 
-// XXX These are just random numbers I picked by fair dice roll; what should they be?
+// XXX These are just random numbers I picked by fair dice roll; what should
+// they be?
 pub const MAC_MIN_BE: u16 = 0;
 pub const MAC_MAX_BE: u16 = 8;
 pub const MAC_MAX_CSMA_BACKOFFS: u16 = 16;

dot15d4/src/csma/user_configurable_constants.rs

@@ -1,8 +1,10 @@
 use crate::sync::channel::Sender;
 use crate::sync::mutex::{Mutex, MutexGuard};
 
-/// Acquire the lock on Mutex by repeatably calling the wants_lock channel to request access.
-/// The resulting guard will be made available through the out_guard and will first check if the guard is not already in our possession. If it is, spinning will be performed.
+/// Acquire the lock on Mutex by repeatably calling the wants_lock channel to
+/// request access. The resulting guard will be made available through the
+/// out_guard and will first check if the guard is not already in our
+/// possession. If it is, spinning will be performed.
 pub async fn acquire_lock<'a, 'b, T>(
     mutex: &'a Mutex<T>,
     wants_lock: &Sender<'b, ()>,
@@ -12,16 +14,21 @@ pub async fn acquire_lock<'a, 'b, T>(
         Some(_) => (),
         None => {
             'inner: loop {
-                // repeatably ask for the lock, as this might need a few tries to prevent deadlocks
+                // repeatably ask for the lock, as this might need a few tries to prevent
+                // deadlocks
                 match mutex.try_lock() {
                     Some(guard) => {
-                        // wants_to_transmit_signal.reset(); // reset signal, such that the receiving end may continue the next time it acquires the lock
+                        // wants_to_transmit_signal.reset();
+
+                        // reset signal, such that the receiving end may continue the next time it
+                        // acquires the lock
                         *out_guard = Some(guard);
                         return;
                     }
                     None => {
-                        wants_lock.send_async(()).await; // Ask the receiving loop to let go of the radio
-                                                         // yield_now().await; // Give the receiving end time to react
+                        // Ask the receiving loop to let go of the radio
+                        wants_lock.send_async(()).await;
+                        // yield_now().await; // Give the receiving end time to react
                         continue 'inner;
                     }
                 }

dot15d4/src/csma/utils.rs

@@ -141,8 +141,9 @@ impl<T: AsRef<[u8]>> AddressingFields<T> {
     ///
     /// # Errors
     ///
-    /// This function will check the length of the buffer to ensure it is large enough to contain
-    /// the addressing fields. If the buffer is too small, an error will be returned.
+    /// This function will check the length of the buffer to ensure it is large
+    /// enough to contain the addressing fields. If the buffer is too small,
+    /// an error will be returned.
     pub fn new(buffer: T, fc: &FrameControl<T>) -> Result<Self> {
         let af = Self::new_unchecked(buffer);
 
@@ -174,8 +175,8 @@ impl<T: AsRef<[u8]>> AddressingFields<T> {
         self.buffer.as_ref().len() >= expected_len
     }
 
-    /// Create a new [`AddressingFields`] reader/writer from a given buffer without checking the
-    /// length.
+    /// Create a new [`AddressingFields`] reader/writer from a given buffer
+    /// without checking the length.
     pub fn new_unchecked(buffer: T) -> Self {
         Self { buffer }
     }

dot15d4/src/frame/addressing.rs

@@ -74,12 +74,14 @@ impl<T: AsRef<[u8]>> FrameControl<T> {
         Ok(fc)
     }
 
-    /// Returns `false` if the buffer is too short to contain the Frame Control field.
+    /// Returns `false` if the buffer is too short to contain the Frame Control
+    /// field.
     fn check_len(&self) -> bool {
         self.buffer.as_ref().len() >= 2
     }
 
-    /// Create a new [`FrameControl`] reader/writer from a given buffer without length checking.
+    /// Create a new [`FrameControl`] reader/writer from a given buffer without
+    /// length checking.
     pub fn new_unchecked(buffer: T) -> Self {
         Self { buffer }
     }

dot15d4/src/frame/frame_control.rs

@@ -11,7 +11,8 @@ pub struct HeaderInformationElement<T: AsRef<[u8]>> {
 }
 
 impl<T: AsRef<[u8]>> HeaderInformationElement<T> {
-    /// Create a new [`HeaderInformationElement`] reader/writer from a given buffer.
+    /// Create a new [`HeaderInformationElement`] reader/writer from a given
+    /// buffer.
     ///
     /// # Errors
     ///
@@ -26,12 +27,14 @@ impl<T: AsRef<[u8]>> HeaderInformationElement<T> {
         Ok(ie)
     }
 
-    /// Returns `false` if the buffer is too short to contain the Header Information Element.
+    /// Returns `false` if the buffer is too short to contain the Header
+    /// Information Element.
     fn check_len(&self) -> bool {
         self.data.as_ref().len() >= 2
     }
 
-    /// Create a new [`HeaderInformationElement`] reader/writer from a given buffer without length checking.
+    /// Create a new [`HeaderInformationElement`] reader/writer from a given
+    /// buffer without length checking.
     pub fn new_unchecked(data: T) -> Self {
         Self { data }
     }
@@ -305,7 +308,8 @@ pub struct RendezvousTime {
     wake_up_interval: u16,
 }
 
-/// A reader/writer for the IEEE 802.15.4 Time Correction Header Information Element.
+/// A reader/writer for the IEEE 802.15.4 Time Correction Header Information
+/// Element.
 pub struct TimeCorrection<T: AsRef<[u8]>> {
     buffer: T,
 }
@@ -326,12 +330,14 @@ impl<T: AsRef<[u8]>> TimeCorrection<T> {
         Ok(ie)
     }
 
-    /// Returns `false` if the buffer is too short to contain the Time Correction field.
+    /// Returns `false` if the buffer is too short to contain the Time
+    /// Correction field.
     fn check_len(&self) -> bool {
         self.buffer.as_ref().len() >= 2
     }
 
-    /// Create a new [`TimeCorrection`] reader/writer from a given buffer without length checking.
+    /// Create a new [`TimeCorrection`] reader/writer from a given buffer
+    /// without length checking.
     pub fn new_unchecked(buffer: T) -> Self {
         Self { buffer }
     }
@@ -386,8 +392,8 @@ impl<T: AsRef<[u8]>> core::fmt::Display for TimeCorrection<T> {
 
 #[frame]
 #[derive(Debug)]
-/// A reader/writer for the IEEE 802.15.4 Simplified Superframe Specification Header
-/// Information Element.
+/// A reader/writer for the IEEE 802.15.4 Simplified Superframe Specification
+/// Header Information Element.
 pub struct SimplifiedSuperframeSpecification {
     /// Returns the timestamp field value.
     timestamp: u16,
@@ -401,7 +407,8 @@ pub struct SimplifiedSuperframeSpecification {
 
 #[frame]
 #[derive(Debug)]
-/// A reader/writer for the IEEE 802.15.4 Superframe Specification Header Information Element.
+/// A reader/writer for the IEEE 802.15.4 Superframe Specification Header
+/// Information Element.
 pub struct SuperframeSpecification {
     #[bits(4)]
     beacon_order: u8,
@@ -421,7 +428,8 @@ pub struct SuperframeSpecification {
 
 #[frame]
 #[derive(Debug)]
-/// A reader/writer for the IEEE 802.15.4 CFP Specification Header Information Element.
+/// A reader/writer for the IEEE 802.15.4 CFP Specification Header Information
+/// Element.
 pub struct CfpSpecification {
     #[bits(3)]
     gts_count: u8,

dot15d4/src/frame/ie/headers.rs

@@ -21,7 +21,8 @@ impl<T: AsRef<[u8]>> InformationElements<T> {
     ///
     /// # Errors
     ///
-    /// Returns an error if the buffer is too short to contain the information elements.
+    /// Returns an error if the buffer is too short to contain the information
+    /// elements.
     pub fn new(data: T) -> Result<Self> {
         let ie = Self::new_unchecked(data);
 
@@ -32,7 +33,8 @@ impl<T: AsRef<[u8]>> InformationElements<T> {
         Ok(ie)
     }
 
-    /// Returns `false` if the buffer is too short to contain the information elements.
+    /// Returns `false` if the buffer is too short to contain the information
+    /// elements.
     fn check_len(&self) -> bool {
         let mut len = 0;
 
@@ -51,7 +53,8 @@ impl<T: AsRef<[u8]>> InformationElements<T> {
         self.data.as_ref().len() >= len
     }
 
-    /// Create a new [`InformationElements`] reader from a given buffer without length checking.
+    /// Create a new [`InformationElements`] reader from a given buffer without
+    /// length checking.
     pub fn new_unchecked(data: T) -> Self {
         Self { data }
     }

dot15d4/src/frame/ie/mod.rs

@@ -17,18 +17,19 @@ use bitflags::bitflags;
 /// | Length | Sub-ID | Type=1 | Content (0-2046 octets)...|
 /// +--------+--------+--------+---------------------------+
 /// ```
-///
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub struct NestedInformationElement<T: AsRef<[u8]>> {
     data: T,
 }
 
 impl<T: AsRef<[u8]>> NestedInformationElement<T> {
-    /// Create a new [`NestedInformationElement`] reader/writer from a given buffer.
+    /// Create a new [`NestedInformationElement`] reader/writer from a given
+    /// buffer.
     ///
     /// # Errors
     ///
-    /// Returns an error if the buffer is too short to contain the nested information element.
+    /// Returns an error if the buffer is too short to contain the nested
+    /// information element.
     pub fn new(data: T) -> Result<Self> {
         let nested = Self::new_unchecked(data);
 
@@ -39,7 +40,8 @@ impl<T: AsRef<[u8]>> NestedInformationElement<T> {
         Ok(nested)
     }
 
-    /// Returns `false` if the buffer is too short to contain the nested information element.
+    /// Returns `false` if the buffer is too short to contain the nested
+    /// information element.
     fn check_len(&self) -> bool {
         if self.data.as_ref().len() < 2 {
             return false;
@@ -50,7 +52,8 @@ impl<T: AsRef<[u8]>> NestedInformationElement<T> {
         self.data.as_ref().len() >= len + 2
     }
 
-    /// Create a new [`NestedInformationElement`] reader/writer from a given buffer without length checking.
+    /// Create a new [`NestedInformationElement`] reader/writer from a given
+    /// buffer without length checking.
     pub fn new_unchecked(data: T) -> Self {
         Self { data }
     }
@@ -537,27 +540,32 @@ impl<T: AsRef<[u8]>> core::fmt::Display for TschTimeslot<T> {
 #[derive(Debug)]
 pub struct TschTimeslotTimings {
     id: u8,
-    /// Offset from the start of the time slot to the start of the CCA in microseconds.
+    /// Offset from the start of the time slot to the start of the CCA in
+    /// microseconds.
     cca_offset: Duration,
     /// Duration of the CCA in microseconds.
     cca: Duration,
     /// Radio turnaround time in microseconds.
     rx_tx: Duration,
 
-    /// Offset from the start of the time slot to the start of the TX in microseconds.
+    /// Offset from the start of the time slot to the start of the TX in
+    /// microseconds.
     tx_offset: Duration,
     /// Maximum transmission time for a frame in microseconds.
     max_tx: Duration,
-    /// Wait time between the end of the TX and the start of the ACK RX in microseconds.
+    /// Wait time between the end of the TX and the start of the ACK RX in
+    /// microseconds.
     rx_ack_delay: Duration,
     /// Maximum time to wait for receiving an ACK.
     ack_wait: Duration,
 
-    /// Offset from the start of the time slot to the start of the RX in microseconds.
+    /// Offset from the start of the time slot to the start of the RX in
+    /// microseconds.
     rx_offset: Duration,
     /// Maximum time to wait for receiving a frame.
     rx_wait: Duration,
-    /// Wait time between the end of the RX and the start of the ACK TX in microseconds.
+    /// Wait time between the end of the RX and the start of the ACK TX in
+    /// microseconds.
     tx_ack_delay: Duration,
     /// Maximum transmission time for an ACK in microseconds.
     max_ack: Duration,
@@ -1078,7 +1086,8 @@ impl<T: AsRef<[u8]>> ChannelHopping<T> {
         !self.data.as_ref().is_empty()
     }
 
-    /// Create a new [`ChannelHopping`] reader/writer from a given buffer without checking the length.
+    /// Create a new [`ChannelHopping`] reader/writer from a given buffer
+    /// without checking the length.
     pub fn new_unchecked(data: T) -> Self {
         Self { data }
     }