libadb 0.9.0

Low-level ADB protocol library for direct TCP and USB communication
Documentation
use super::channel::Channel;
use super::session::Session;
use crate::error::Error;

pub(crate) struct RecvBuf<'b> {
    buf: &'b mut [u8],
    head: usize,
    tail: usize,
}

impl<'b> RecvBuf<'b> {
    pub fn new(buf: &'b mut [u8]) -> Self {
        Self {
            buf,
            head: 0,
            tail: 0,
        }
    }

    pub fn capacity(&self) -> usize {
        self.buf.len()
    }

    pub fn peek(&self, n: usize) -> &[u8] {
        &self.buf[self.head..self.tail][..n]
    }

    pub fn take(&mut self, n: usize) -> &[u8] {
        let start = self.head;
        self.head += self.peek(n).len();
        &self.buf[start..self.head]
    }

    pub fn advance(&mut self, n: usize) {
        self.take(n);
    }

    pub fn window(&mut self) -> &mut [u8] {
        &mut self.buf[self.tail..]
    }

    pub fn compact(&mut self) {
        if self.head > 0 {
            self.buf.copy_within(self.head..self.tail, 0);
            self.tail -= self.head;
            self.head = 0;
        }
    }

    pub async fn fill_at_least<S: Session>(
        &mut self,
        channel: &mut Channel<'_, S>,
        n: usize,
    ) -> Result<(), Error<S::IoError>> {
        if n > self.buf.len() {
            return Err(Error::ReceiveBufferFull);
        }
        while self.tail - self.head < n {
            if self.tail >= self.buf.len() {
                self.compact();
                if self.tail >= self.buf.len() {
                    return Err(Error::ReceiveBufferFull);
                }
            }
            let read = channel.read(&mut self.buf[self.tail..]).await?;
            self.tail += read;
        }
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn new_starts_empty() {
        let mut storage = [0u8; 16];
        let rb = RecvBuf::new(&mut storage);
        assert_eq!(rb.head, 0);
        assert_eq!(rb.tail, 0);
        assert_eq!(rb.buf.len(), 16);
    }

    #[test]
    fn compact_with_head_at_zero_is_a_noop() {
        let mut storage = [1u8, 2, 3, 4, 5, 0, 0, 0];
        let mut rb = RecvBuf::new(&mut storage);
        rb.tail = 5;

        rb.compact();

        assert_eq!(rb.head, 0);
        assert_eq!(rb.tail, 5);
        assert_eq!(&rb.buf[..5], &[1, 2, 3, 4, 5]);
    }

    #[test]
    fn compact_shifts_unread_bytes_to_front() {
        let mut storage = [1u8, 2, 3, 4, 5, 6, 7, 8];
        let mut rb = RecvBuf::new(&mut storage);
        rb.head = 3;
        rb.tail = 7;

        rb.compact();

        assert_eq!(rb.head, 0);
        assert_eq!(rb.tail, 4);
        assert_eq!(&rb.buf[..4], &[4, 5, 6, 7]);
    }

    #[test]
    fn compact_resets_when_all_bytes_consumed() {
        let mut storage = [1u8, 2, 3, 4];
        let mut rb = RecvBuf::new(&mut storage);
        rb.head = 4;
        rb.tail = 4;

        rb.compact();

        assert_eq!(rb.head, 0);
        assert_eq!(rb.tail, 0);
    }

    #[test]
    fn compact_reclaims_full_buffer_when_tail_at_end() {
        let mut storage = [10u8, 20, 30, 40];
        let mut rb = RecvBuf::new(&mut storage);
        rb.head = 2;
        rb.tail = 4;

        rb.compact();

        assert_eq!(rb.head, 0);
        assert_eq!(rb.tail, 2);
        assert_eq!(&rb.buf[..2], &[30, 40]);
    }

    #[test]
    fn take_consumes_what_peek_shows() {
        let mut storage = [1u8, 2, 3, 4, 5, 6];
        let mut rb = RecvBuf::new(&mut storage);
        rb.tail = 5;

        assert_eq!(rb.peek(2), &[1, 2]);
        assert_eq!(rb.take(3), &[1, 2, 3]);
        rb.advance(1);

        assert_eq!(rb.head, 4);
        assert_eq!(rb.peek(1), &[5]);
    }

    #[test]
    #[should_panic]
    fn peek_past_the_buffered_bytes_panics() {
        let mut storage = [0u8; 8];
        let mut rb = RecvBuf::new(&mut storage);
        rb.tail = 2;

        rb.peek(3);
    }

    #[test]
    #[should_panic]
    fn advance_past_the_buffered_bytes_panics() {
        let mut storage = [0u8; 8];
        let mut rb = RecvBuf::new(&mut storage);
        rb.tail = 2;

        rb.advance(3);
    }

    #[test]
    fn the_window_is_the_space_past_the_buffered_bytes() {
        let mut storage = [0u8; 8];
        let mut rb = RecvBuf::new(&mut storage);
        rb.head = 1;
        rb.tail = 3;

        assert_eq!(rb.window().len(), 5);
        rb.window()[0] = 9;
        assert_eq!(rb.buf[3], 9);
        assert_eq!(rb.capacity(), 8);
    }

    #[test]
    fn compact_of_single_byte_window_preserves_byte() {
        let mut storage = [1u8, 2, 3, 4];
        let mut rb = RecvBuf::new(&mut storage);
        rb.head = 2;
        rb.tail = 3;

        rb.compact();

        assert_eq!(rb.head, 0);
        assert_eq!(rb.tail, 1);
        assert_eq!(rb.buf[0], 3);
    }
}