Struct rotary::interleaved::ChannelMut

pub struct ChannelMut<'a, T> { /* fields omitted */ }

A mutable reference to a channel in a buffer.

See crate::Interleaved::get_mut.

Implementations

impl<'a, T> ChannelMut<'a, T>

pub fn get(&self, frame: usize) -> Option<T> where
    T: Copy, 

Get a reference to a frame.

Examples

let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 256);

let left = buffer.get(0).unwrap();

assert_eq!(left.get(64), Some(0.0));
assert_eq!(left.get(255), Some(0.0));
assert_eq!(left.get(256), None);

pub fn get_mut(&mut self, frame: usize) -> Option<&mut T>

Get a mutable reference to a frame.

Examples

let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 256);

let mut left = buffer.get_mut(0).unwrap();

assert_eq!(left.get(64), Some(0.0));
*left.get_mut(64).unwrap() = 1.0;
assert_eq!(left.get(64), Some(1.0));

pub fn into_mut(self, frame: usize) -> Option<&'a mut T>

Convert the mutable channel into a single mutable frame.

This is necessary in case you need to build a structure which wraps a mutable channel and you want it to return the same lifetime as the mutable channel is associated with.

Examples

This does not build:

struct Foo<'a> {
    left: rotary::interleaved::ChannelMut<'a, f32>,
}

impl<'a> Foo<'a> {
    fn get_mut(&mut self, frame: usize) -> Option<&'a mut f32> {
        self.left.get_mut(frame)
    }
}

let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 256);

let mut foo = Foo {
    left: buffer.get_mut(0).unwrap(),
};

*foo.get_mut(64).unwrap() = 1.0;
assert_eq!(buffer.frame(0, 64), Some(1.0));

   error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
   --> examples\compile-fail.rs:7:19
    |
  7 |         self.left.get_mut(frame)
    |                   ^^^^^^^
    |

Because if it did, it would be permitted to extract multiple mutable references to potentially the same frame with the lifetime 'a, because Foo holds onto the mutable channel.

The way we can work around this is by allowing a function to consume the mutable channel. And we can do that with ChannelMut::into_mut.

impl<'a> Foo<'a> {
    fn into_mut(self, frame: usize) -> Option<&'a mut f32> {
        self.left.into_mut(frame)
    }
}

let mut buffer = rotary::Interleaved::<f32>::with_topology(2, 256);

let mut foo = Foo {
    left: buffer.get_mut(0).unwrap(),
};

*foo.into_mut(64).unwrap() = 1.0;
assert_eq!(buffer.frame(0, 64), Some(1.0));

pub fn iter(&self) -> ChannelIter<'_, T>

Construct an iterator over the current channel.

pub fn iter_mut(&mut self) -> ChannelIterMut<'_, T>

Construct a mutable iterator over the current channel.

Trait Implementations

impl<T> Debug for ChannelMut<'_, T> where
    T: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Eq for ChannelMut<'_, T> where
    T: Eq, 

impl<T> Hash for ChannelMut<'_, T> where
    T: Hash, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T> Ord for ChannelMut<'_, T> where
    T: Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T> PartialEq<ChannelMut<'_, T>> for ChannelMut<'_, T> where
    T: PartialEq, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> PartialOrd<ChannelMut<'_, T>> for ChannelMut<'_, T> where
    T: PartialOrd, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Send for ChannelMut<'_, T> where
    T: Send, 

impl<T> Sync for ChannelMut<'_, T> where
    T: Sync,