pub fn slices_mut(&mut self) -> (&mut[T], &mut [T]) {
        let (a,b) = if self.start <= self.end {
            let (x, y) = self.buffer.split_at_mut(self.end);
            (&mut x[self.start..self.end], &mut y[0..0])
        } else {
            let (x, y) = self.buffer.split_at_mut(self.start);
            (y,  &mut x[..self.end])
        };

        //ManuallyDrop is a zero-cost wrapper, can be safely converted into slice of T
        unsafe{(transmute(a), transmute(b))}
    }
/**
    Returns two mutable slices to the internal buffer.

    Because the internal buffer is circular, normally it is not possible to represent it
    as a single slice of data, but it is possible to represent it as two slices -
    one after another.

    # Example

    ```
    use advanced_collections::circular_buffer::CircularBuffer;

    fn main(){
      let mut cb = CircularBuffer::from(vec![1,2,3]);
      cb.push_back(4);
      cb.push_back(5);
      let (mut a, mut b) = cb.slices_mut();
      a[0] = 4;
      a[1] = 5;
      b[0] = 6;
      assert_eq!(cb, [4,5,6].as_ref());
    }
    ```
    */
Returns two mutable slices to the internal buffer.
Because the internal buffer is circular, normally it is not possible to represent it
as a single slice of data, but it is possible to represent it as two slices
one after another.
Returns two mutable slices to the internal buffer . Because the internal buffer is circular normally it is not possible to represent it as a single slice of data but it is possible to represent it as two slices one after another .
pub fn slices_mut(&mut self) -> (&mut[T], &mut [T]) {
        let (a,b) = if self.start <= self.end {
            let (x, y) = self.buffer.split_at_mut(self.end);
            (&mut x[self.start..self.end], &mut y[0..0])
        } else {
            let (x, y) = self.buffer.split_at_mut(self.start);
            (y,  &mut x[..self.end])
        };
        //ManuallyDrop is a zero-cost wrapper, can be safely converted into slice of T
        unsafe{(transmute(a), transmute(b))}
    }
pub fn slices_mut ( & mut self ) -> ( & mut [ T ] , & mut [ T ] ) { let ( a , b ) = if self . start <= self . end { let ( x , y ) = self . buffer . split_at_mut ( self . end ) ; ( & mut x [ self . start .. self . end ] , & mut y [ 0 .. 0 ] ) } else { let ( x , y ) = self . buffer . split_at_mut ( self . start ) ; ( y , & mut x [ .. self . end ] ) } ; //ManuallyDrop is a zero-cost wrapper, can be safely converted into slice of T unsafe { ( transmute ( a ) , transmute ( b ) ) } }
Returns two mutable slices to the internal buffer.
Returns two mutable slices to the internal buffer .
&mut self
&mut self
example
```
use advanced_collections::circular_buffer::CircularBuffer.


` ` ` use advanced_collections :: circular_buffer :: CircularBuffer .