Merge pull request #449 from orottier/feature/impl-debug-public-types

Implement `Debug` for all public facing types

Author: orottier

src/analysis.rs

@@ -156,6 +156,17 @@ pub(crate) struct Analyser {
     blackman: Vec<f32>,
 }
 
+impl std::fmt::Debug for Analyser {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Analyser")
+            .field("fft_size", &self.fft_size())
+            .field("smoothing_time_constant", &self.smoothing_time_constant())
+            .field("min_decibels", &self.min_decibels())
+            .field("max_decibels", &self.max_decibels())
+            .finish_non_exhaustive()
+    }
+}
+
 impl Analyser {
     pub fn new() -> Self {
         let ring_buffer = AnalyserRingBuffer::new();

src/buffer.rs

@@ -364,11 +364,19 @@ impl AudioBuffer {
 /// Single channel audio samples, basically wraps a `Arc<Vec<f32>>`
 ///
 /// ChannelData has copy-on-write semantics, so it is cheap to clone.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub(crate) struct ChannelData {
     data: Arc<Vec<f32>>,
 }
 
+impl std::fmt::Debug for ChannelData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ChannelData")
+            .field("len", &self.len())
+            .finish_non_exhaustive()
+    }
+}
+
 impl ChannelData {
     pub fn new(length: usize) -> Self {
         let buffer = vec![0.; length];

src/capacity.rs

@@ -5,13 +5,14 @@ use crate::context::{BaseAudioContext, ConcreteBaseAudioContext};
 use crate::events::{EventDispatch, EventHandler, EventPayload, EventType};
 use crate::Event;
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub(crate) struct AudioRenderCapacityLoad {
     pub render_timestamp: f64,
     pub load_value: f64,
 }
 
 /// Options for constructing an `AudioRenderCapacity`
+#[derive(Clone, Debug)]
 pub struct AudioRenderCapacityOptions {
     /// An update interval (in seconds) for dispatching [`AudioRenderCapacityEvent`]s
     pub update_interval: f64,
@@ -70,6 +71,17 @@ pub struct AudioRenderCapacity {
     stop_send: Arc<Mutex<Option<Sender<()>>>>,
 }
 
+impl std::fmt::Debug for AudioRenderCapacity {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AudioRenderCapacity")
+            .field(
+                "context",
+                &format!("BaseAudioContext@{}", self.context.address()),
+            )
+            .finish_non_exhaustive()
+    }
+}
+
 impl AudioRenderCapacity {
     pub(crate) fn new(
         context: ConcreteBaseAudioContext,

src/context/concrete_base.rs

@@ -52,12 +52,11 @@ impl AudioNodeIdProvider {
 /// [`OfflineAudioContext`](crate::context::OfflineAudioContext), and the `context()` method on
 /// `AudioNode`s.
 ///
-/// The `ConcreteBaseAudioContext` allows for cheap cloning (using an `Arc` internally).
+/// The `ConcreteBaseAudioContext` allows for shallow cloning (using an `Arc` internally).
 #[allow(clippy::module_name_repetitions)]
 #[derive(Clone)]
 #[doc(hidden)]
 pub struct ConcreteBaseAudioContext {
-    /// inner makes `ConcreteBaseAudioContext` cheap to clone
     inner: Arc<ConcreteBaseAudioContextInner>,
 }
 
@@ -67,6 +66,19 @@ impl PartialEq for ConcreteBaseAudioContext {
     }
 }
 
+impl std::fmt::Debug for ConcreteBaseAudioContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BaseAudioContext")
+            .field("id", &self.address())
+            .field("state", &self.state())
+            .field("sample_rate", &self.sample_rate())
+            .field("current_time", &self.current_time())
+            .field("max_channel_count", &self.max_channel_count())
+            .field("offline", &self.offline())
+            .finish_non_exhaustive()
+    }
+}
+
 /// Inner representation of the `ConcreteBaseAudioContext`
 ///
 /// These fields are wrapped inside an `Arc` in the actual `ConcreteBaseAudioContext`.
@@ -257,6 +269,10 @@ impl ConcreteBaseAudioContext {
         base
     }
 
+    pub(crate) fn address(&self) -> usize {
+        Arc::as_ptr(&self.inner) as usize
+    }
+
     /// Send a control message to the render thread
     ///
     /// When the render thread is closed or crashed, the message is discarded and a log warning is

src/context/mod.rs

@@ -1,4 +1,5 @@
 //! The `BaseAudioContext` interface and the `AudioContext` and `OfflineAudioContext` types
+
 use std::{any::Any, ops::Range};
 
 mod base;
@@ -94,6 +95,18 @@ pub struct AudioContextRegistration {
     id: AudioNodeId,
 }
 
+impl std::fmt::Debug for AudioContextRegistration {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AudioContextRegistration")
+            .field("id", &self.id)
+            .field(
+                "context",
+                &format!("BaseAudioContext@{}", self.context.address()),
+            )
+            .finish()
+    }
+}
+
 impl AudioContextRegistration {
     /// Get the audio node id of the registration
     #[must_use]

src/context/offline.rs

@@ -29,6 +29,15 @@ pub struct OfflineAudioContext {
     resume_sender: mpsc::Sender<()>,
 }
 
+impl std::fmt::Debug for OfflineAudioContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("OfflineAudioContext")
+            .field("length", &self.length())
+            .field("base", &self.base())
+            .finish_non_exhaustive()
+    }
+}
+
 struct OfflineAudioContextRenderer {
     /// the rendering 'thread', fully controlled by the offline context
     renderer: RenderThread,

src/context/online.rs

@@ -118,6 +118,17 @@ pub struct AudioContext {
     render_thread_init: RenderThreadInit,
 }
 
+impl std::fmt::Debug for AudioContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AudioContext")
+            .field("sink_id", &self.sink_id())
+            .field("base_latency", &self.base_latency())
+            .field("output_latency", &self.output_latency())
+            .field("base", &self.base())
+            .finish_non_exhaustive()
+    }
+}
+
 impl BaseAudioContext for AudioContext {
     fn base(&self) -> &ConcreteBaseAudioContext {
         &self.base

src/lib.rs

@@ -4,6 +4,7 @@
 #![warn(clippy::missing_panics_doc)]
 #![warn(clippy::clone_on_ref_ptr)]
 #![deny(trivial_numeric_casts)]
+#![deny(missing_debug_implementations)]
 
 use std::error::Error;
 use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
@@ -56,12 +57,17 @@ pub use media_element::MediaElement;
 mod resampling;
 pub mod worklet;
 
-#[derive(Debug)]
 #[repr(transparent)]
 pub(crate) struct AtomicF32 {
     bits: AtomicU32,
 }
 
+impl std::fmt::Debug for AtomicF32 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{}", self.load(Ordering::Relaxed)))
+    }
+}
+
 impl AtomicF32 {
     #[must_use]
     pub fn new(value: f32) -> Self {
@@ -81,12 +87,17 @@ impl AtomicF32 {
 }
 
 /// Atomic float 64, only `load` and `store` are supported, no arithmetic
-#[derive(Debug)]
 #[repr(transparent)]
 pub(crate) struct AtomicF64 {
     bits: AtomicU64,
 }
 
+impl std::fmt::Debug for AtomicF64 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{}", self.load(Ordering::Relaxed)))
+    }
+}
+
 impl AtomicF64 {
     #[must_use]
     pub fn new(value: f64) -> Self {

src/media_devices/mod.rs

@@ -127,13 +127,14 @@ impl MediaDeviceInfo {
 
 /// Dictionary used to instruct what sort of tracks to include in the [`MediaStream`] returned by
 /// [`get_user_media_sync`]
+#[derive(Clone, Debug)]
 pub enum MediaStreamConstraints {
     Audio,
     AudioWithConstraints(MediaTrackConstraints),
 }
 
 /// Desired media stream track settings for [`MediaTrackConstraints`]
-#[derive(Default)]
+#[derive(Default, Debug, Clone)]
 #[non_exhaustive]
 pub struct MediaTrackConstraints {
     // ConstrainULong width;

src/media_element.rs

@@ -19,6 +19,14 @@ pub(crate) struct RTSStream {
     playback_rate: Arc<AtomicF64>,
 }
 
+impl std::fmt::Debug for RTSStream {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RTSStream")
+            .field("number_of_channels", &self.number_of_channels)
+            .finish_non_exhaustive()
+    }
+}
+
 /// Controller actions for a media element
 pub(crate) enum MediaElementAction {
     /// Seek to the given timestamp
@@ -46,6 +54,18 @@ pub struct MediaElement {
     playback_rate: Arc<AtomicF64>,
 }
 
+impl std::fmt::Debug for MediaElement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MediaElement")
+            .field("stream", &self.stream)
+            .field("current_time", &self.current_time())
+            .field("loop", &self.loop_())
+            .field("paused", &self.paused())
+            .field("playback_rate", &self.playback_rate())
+            .finish_non_exhaustive()
+    }
+}
+
 impl MediaElement {
     /// Create a new instance for a given file path
     pub fn new<P: Into<PathBuf>>(file: P) -> Result<Self, Box<dyn Error>> {