iona 0.1.1

use core::slice;
use libc::{close, mmap, munmap};
use std::io;
use std::io::Error;
use std::marker::PhantomData;
use std::ops;
use std::ptr;

/// High performance, circular buffer.
pub struct IonaBuffer<
    T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable,
> {
    // Raw pointer to the buffer.
    addr: *mut u8,
    // Raw byte capacity of the buffer. Aligned to the system's page size.
    capacity: usize,
    // Byte mask to ensure pointer stays inbounds.
    mask: usize,
    // Number of elements that the buffer can contain.
    elem_capacity: usize,
    // Element mask to ensure the number of elements stays inbounds.
    elem_mask: usize,
    // IonaBuffer contains elements of type T.
    phantom: PhantomData<T>,
    // The write byte pointer, pointing to the current back of the circular buffer.
    ptr: usize,
    // The read byte pointer, pointing to the next initialized value.
    read_ptr: usize,
    // Number of T initialized in the buffer.
    len: usize,
}

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    IonaBuffer<T>
{
    /// Creates a page size aligned circular buffer.
    ///
    /// # Example
    ///
    /// ```
    /// use iona::IonaBuffer;
    ///
    /// let buffer: IonaBuffer<usize> = match IonaBuffer::with_capacity(512) {
    ///     Ok(buffer) => buffer,
    ///     Err(_) => panic!("Unable to allocate the buffer"),
    /// };
    ///
    /// assert_eq!(buffer.capacity(), 512);
    ///
    /// // On a 64 bit, 4kb page size computer requesting more than what can fit in a single page:
    /// let buffer: IonaBuffer<usize> = match IonaBuffer::with_capacity(513) {
    ///     Ok(buffer) => buffer,
    ///     Err(_) => panic!("Unable to allocate the buffer"),
    /// };
    ///
    /// assert_eq!(buffer.capacity(), 1024);
    /// ```
    #[cfg(all(any(target_arch = "x86_64", target_arch = "x86"), target_os = "linux"))]
    pub fn with_capacity(capacity: usize) -> Result<Self, Error> {
        unsafe {
            // Get page size and align capacity
            let page_size = usize::try_from(libc::sysconf(libc::_SC_PAGESIZE))
                // TODO: make this error better
                .map_err(|_| std::io::ErrorKind::Other)?;
            let capacity = capacity * size_of::<T>();
            let capacity = (capacity + page_size - 1) & !(page_size - 1);
            let capacity = capacity.next_power_of_two();

            let fd = libc::memfd_create(c"circular_buffer".as_ptr(), 0);

            if fd < 0 {
                return Err(Error::last_os_error());
            }

            // Set the size of the memory region
            if libc::ftruncate(fd, capacity as i64) != 0 {
                close(fd);
                return Err(Error::last_os_error());
            }

            // Reserve 2x capacity of virtual address space
            let addr = mmap(
                ptr::null_mut(),
                2 * capacity,
                libc::PROT_READ | libc::PROT_WRITE,
                libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
                -1,
                0,
            );

            if addr == libc::MAP_FAILED {
                close(fd);
                return Err(Error::last_os_error());
            }

            // Map first half to the memfd
            if mmap(
                addr,
                capacity,
                libc::PROT_READ | libc::PROT_WRITE,
                libc::MAP_SHARED | libc::MAP_FIXED,
                fd,
                0,
            ) == libc::MAP_FAILED
            {
                libc::munmap(addr, 2 * capacity);
                close(fd);
                return Err(Error::last_os_error());
            }

            // Map second half to the same memfd (mirror mapping!)
            if mmap(
                addr.add(capacity),
                capacity,
                libc::PROT_READ | libc::PROT_WRITE,
                libc::MAP_SHARED | libc::MAP_FIXED,
                fd,
                0,
            ) == libc::MAP_FAILED
            {
                munmap(addr, 2 * capacity);
                close(fd);
                return Err(Error::last_os_error());
            }

            // Can safely close the fd after the pages are allocated.
            close(fd);

            Ok(IonaBuffer::<T> {
                addr: addr.cast::<u8>(),
                capacity,
                elem_capacity: capacity / size_of::<T>(),
                mask: capacity - 1,
                elem_mask: (capacity / size_of::<T>()) - 1,
                phantom: PhantomData,
                ptr: 0,
                read_ptr: 0,
                len: 0,
            })
        }
    }

    /// Creates a new circular buffer.
    ///
    /// # Example
    ///
    /// ```
    /// use iona::IonaBuffer;
    ///
    /// let buffer: IonaBuffer<usize> = match IonaBuffer::new() {
    ///     Ok(buffer) => buffer,
    ///     Err(_) => panic!("Unable to allocate the buffer"),
    /// };
    ///
    /// assert_eq!(buffer.len(), 0);
    /// ```
    #[cfg(all(any(target_arch = "x86_64", target_arch = "x86"), target_os = "linux"))]
    pub fn new() -> Result<Self, Error> {
        // Align to the least number of pages to fit a single T.
        Self::with_capacity(1)
    }

    /// Gets the number of items that have been added to the buffer. Will always be <= the capacity
    /// of the buffer. Does not count uninitialized spaces between values. For example, pushing an
    /// item and then push(ing)_back another item will only increase the len to two.
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new()?;
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.push_back(&1);
    /// assert_eq!(buffer.len(), 1);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[must_use]
    pub fn len(&self) -> usize {
        self.len
    }

    /// Returns whether the buffer is empty or not.
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new()?;
    /// assert!(buffer.is_empty());
    ///
    /// buffer.push_back(&1);
    /// assert!(!buffer.is_empty());
    /// #
    /// #   Ok(())
    /// # }
    /// ```
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Shows how many elements of type T fit within the buffer.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new()?;
    /// assert_eq!(buffer.len(), 0);
    ///
    /// // On a 64 bit, 4kb page layout.
    /// assert_eq!(buffer.capacity(), 512);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[must_use]
    #[allow(
        clippy::misnamed_getters,
        reason = "this is getting the element capacity, rather than byte capacity"
    )]
    pub fn capacity(&self) -> usize {
        self.elem_capacity
    }

    /// Shows how much uninitialized memory remains in the buffer.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new()?;
    /// assert_eq!(buffer.len(), 0);
    /// assert_eq!(buffer.capacity(), 512);
    /// assert_eq!(buffer.capacity_available(), 512);
    ///
    /// buffer.push_back(&1);
    /// assert_eq!(buffer.len(), 1);
    /// assert_eq!(buffer.capacity(), 512);
    /// assert_eq!(buffer.capacity_available(), 511);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[must_use]
    pub fn capacity_available(&self) -> usize {
        self.elem_capacity - self.len()
    }

    ///// Gets the raw number byte capacity of the buffer.
    //pub(crate) fn byte_capacity(&self) -> usize {
    //    self.capacity
    //}

    /// Gets the nth value from the buffer. Masked to always be within the range.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new()?;
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.push_back(&22);
    /// buffer.push_back(&23);
    ///
    /// assert_eq!(buffer.get(0), Some(&22));
    /// assert_eq!(buffer.get(1), Some(&23));
    ///
    /// assert_eq!(buffer.get(buffer.capacity()), Some(&22));
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[must_use]
    pub fn get(&self, nth: usize) -> Option<&T> {
        let offset = (nth * size_of::<T>()) & self.mask;

        if self.is_in_range(offset) {
            return T::ref_from_bytes(self.read_from(offset, size_of::<T>())).ok();
        }
        None
    }

    fn is_in_range(&self, offset: usize) -> bool {
        // Buffer is full
        if self.ptr == self.read_ptr && self.len == self.elem_capacity {
            return true;
        }

        if self.ptr >= self.read_ptr {
            offset >= self.read_ptr && offset < self.ptr
        } else {
            offset >= self.read_ptr || offset < self.ptr
        }
    }

    /// Gets an exclusive reference to the nth value from the buffer.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new()?;
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.push_back(&22);
    /// buffer.push_back(&23);
    ///
    /// assert_eq!(buffer.get_mut(0), Some(&mut 22));
    /// assert_eq!(buffer.get_mut(1), Some(&mut 23));
    ///
    /// assert_eq!(buffer.get_mut(buffer.capacity()), Some(&mut 22));
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[must_use]
    pub fn get_mut(&mut self, nth: usize) -> Option<&mut T> {
        let offset = (nth * size_of::<T>()) & self.mask;

        if self.is_valid_offset(offset) {
            return T::mut_from_bytes(self.read_from_mut(offset, size_of::<T>())).ok();
        }
        None
    }

    /// Gets a slice from the buffer. Not a part of the public API. Expectation is for users to use
    /// the more idomatic range indexing, i.e. `buffer[0..22]`.
    pub(crate) fn get_slice(&self, rng: std::ops::Range<usize>) -> &[T] {
        zerocopy::FromBytes::ref_from_bytes(self.read_from(
            (rng.start * size_of::<T>()) & self.mask,
            (rng.end - rng.start) * size_of::<T>(),
        ))
        .expect("Failed here")
    }

    fn get_mut_slice_from_bytes(&mut self, rng: std::ops::Range<usize>) -> &mut [T] {
        let start = rng.start & self.mask;
        let mut len = rng.end & self.mask;
        if start > len {
            len = (start + self.capacity) - len;
        }
        assert!(len <= self.capacity);
        zerocopy::FromBytes::mut_from_bytes(self.read_from_mut(start, len))
            .expect("Failed in get_mut")
    }

    /// Gets a slice from the buffer with raw byte offsets.
    fn get_slice_from_bytes(&self, rng: std::ops::Range<usize>) -> &[T] {
        let start = rng.start & self.mask;
        let mut len = rng.end & self.mask;
        if start > len {
            len = (start + self.capacity) - len;
        }
        assert!(len <= self.capacity);
        zerocopy::FromBytes::ref_from_bytes(self.read_from(start, len)).expect("Failed here too")
    }

    /// Pushes a new item into the buffer. Overwrites the front of the buffer when it wraps around.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new().unwrap();
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.push_back(&22);
    ///
    /// assert_eq!(buffer.get(0), Some(&22));
    /// assert_eq!(buffer.len(), 1);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    pub fn push_back(&mut self, value: &T) {
        let offset = self.ptr & self.mask;
        self.write_at(offset, value.as_bytes());
        self.ptr = (self.ptr + size_of::<T>()) & self.mask;

        // If the buffer is full, advance the read pointer too.
        if self.is_full() {
            self.read_ptr = (self.read_ptr + size_of::<T>()) & self.mask;
        }

        self.update_len();
    }

    /// Pushes a new T to the front of the buffer.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new().unwrap();
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.push_back(&1);
    /// buffer.push_front(&0);
    /// buffer.push_front(&usize::MAX);
    ///
    /// assert_eq!(buffer.pop_front(), Some(usize::MAX));
    /// assert_eq!(buffer.pop_front(), Some(0));
    /// assert_eq!(buffer.pop_front(), Some(1));
    /// #
    /// # Ok(())
    /// # }
    /// ```
    pub fn push_front(&mut self, value: &T) {
        let offset = self.read_ptr.wrapping_sub(size_of::<T>()) & self.mask;
        self.write_at(offset, value.as_bytes());

        self.update_len();
        self.read_ptr = offset;
    }

    /// Pops the value at the read pointer. Will advance the read pointer and will return None
    /// when it reaches the write pointer. Equivalent to `next`.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new().unwrap();
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.push_back(&1);
    /// buffer.push_back(&2);
    /// assert_eq!(buffer.pop_front(), Some(1));
    /// assert_eq!(buffer.pop_front(), Some(2));
    /// buffer.push_back(&3);
    /// assert_eq!(buffer.pop_front(), Some(3));
    /// assert_eq!(buffer.len(), 0);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    pub fn pop_front(&mut self) -> Option<T> {
        if self.is_empty() {
            return None;
        }

        // Store the next element's position
        let next_idx = self.read_ptr;

        // Advance the read pointer
        self.read_ptr = (self.read_ptr + size_of::<T>()) & self.mask;
        self.decrease_len();

        // Return T
        let tmp = T::read_from_bytes(self.read_from(next_idx, size_of::<T>())).ok()?;

        // TODO: remove this allocation
        #[cfg(feature = "sensitive")]
        self.write_at(next_idx, &vec![0; size_of::<T>()]);

        Some(tmp)
    }

    /// Pops the value at the write pointer. Will move the write pointer back until it reaches the
    /// read pointer.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new().unwrap();
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.push_back(&1);
    /// buffer.push_back(&2);
    /// assert_eq!(buffer.pop_back(), Some(2));
    /// assert_eq!(buffer.pop_back(), Some(1));
    /// assert_eq!(buffer.pop_back(), None);
    /// assert_eq!(buffer.len(), 0);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    pub fn pop_back(&mut self) -> Option<T> {
        if self.is_empty() {
            return None;
        }

        #[cfg(feature = "sensitive")]
        // Don't need to save the poiter if we're not going to zero out the value.
        let tmp_ptr = self.ptr;

        // Decrement the write pointer
        self.ptr = (self.ptr.wrapping_sub(size_of::<T>())) & self.mask;
        self.decrease_len();

        let tmp = T::read_from_bytes(self.read_from(self.ptr, size_of::<T>())).ok()?;

        // TODO: remove this allocation
        #[cfg(feature = "sensitive")]
        self.write_at(tmp_ptr, &vec![0; size_of::<T>()]);

        Some(tmp)
    }

    /// Returns whether the buffer is filled to capacity
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new().unwrap();
    /// assert_eq!(buffer.len(), 0);
    /// assert!(!buffer.is_full());
    ///
    /// buffer.concat(&vec![1; buffer.capacity()]);
    /// assert!(buffer.is_full());
    /// #
    /// # Ok(())
    /// # }
    /// ```
    #[must_use]
    pub fn is_full(&self) -> bool {
        self.capacity() == self.len()
    }

    /// Fills the buffer with the same value
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new().unwrap();
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.fill(1);
    /// assert!(buffer.is_full());
    /// assert_eq!(buffer.get(buffer.capacity() - 1), Some(&1));
    /// #
    /// # Ok(())
    /// # }
    /// ```
    pub fn fill(&mut self, value: T)
    where
        T: Clone,
    {
        // TODO: This can't allocate a vec here!
        self.concat(&vec![value; self.capacity()]);
    }

    /// Write a slice of bytes to an offset.
    #[inline]
    fn write_at(&mut self, offset: usize, bytes: &[u8]) {
        assert!(
            bytes.len() <= self.capacity,
            "Cannot write more than capacity"
        );
        let start = offset & self.mask;
        unsafe {
            ptr::copy_nonoverlapping(bytes.as_ptr(), self.addr.add(start), bytes.len());
        }
    }

    /// Concats a slice of T to the end of the circular buffer's value. Will overwrite the front
    /// of the buffer when wrapping.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new().unwrap();
    /// assert_eq!(buffer.len(), 0);
    ///
    /// buffer.concat(&[1, 2, 3]);
    /// assert_eq!(&buffer[0..=2], &[1,2,3]);
    ///
    /// buffer.concat(&vec![22; buffer.capacity() - 1]);
    /// assert_eq!(&buffer[0..=2], &[22, 22, 3]);
    ///
    /// assert_eq!(buffer.len(), buffer.capacity());
    /// #
    /// # Ok(())
    /// # }
    /// ```
    pub fn concat(&mut self, slice: &[T]) {
        let bytes = zerocopy::IntoBytes::as_bytes(slice);
        self.write_at(self.ptr, bytes);

        if (self.ptr + bytes.len()) & self.mask >= self.read_ptr {
            self.read_ptr =
                ((self.ptr + bytes.len()) & self.mask).wrapping_sub(self.read_ptr) & self.mask;
        }

        // Move the write pointer forward
        self.ptr = (self.ptr + bytes.len()) & self.mask;
        // Update the len
        self.increase_len(slice.len());

        if self.is_full() {
            // Advance the read pointer to where the write pointer is pointing
            self.read_ptr = self.ptr;
        }
    }

    /// Increase the len of the buffer with
    #[inline]
    fn increase_len(&mut self, amount: usize) {
        let tmp_len = self.len() + amount;

        match tmp_len.cmp(&self.capacity()) {
            std::cmp::Ordering::Less => self.len = tmp_len,
            // The len can never exceed the capacity since it should always wrap.
            std::cmp::Ordering::Equal | std::cmp::Ordering::Greater => self.len = self.capacity(),
        }
    }

    /// Decreases the len of the buffer with
    #[inline]
    fn decrease_len(&mut self) {
        if self.is_empty() {
            return;
        }

        self.len -= 1;
    }

    /// Increases the len of the buffer by one.
    #[inline]
    fn update_len(&mut self) {
        self.increase_len(1);
    }

    /// Overwrites a single value of T to a specific place in the buffer.
    ///
    /// # Example
    ///
    /// ```
    /// # use iona::IonaBuffer;
    /// #
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut buffer: IonaBuffer<usize> = IonaBuffer::new().unwrap();
    /// assert_eq!(buffer.len(), 0);
    ///
    /// // Subsequent pushes are wrapped around.
    /// buffer.push_back(&1);
    /// let previous_value = buffer.overwrite(0, &usize::MAX).unwrap();
    /// assert_eq!(buffer.get(0), Some(&usize::MAX));
    /// assert_eq!(previous_value, 1);
    /// #
    /// # Ok(())
    /// # }
    /// ```
    /// TODO: improve the err type
    pub fn overwrite(&mut self, at: usize, value: &T) -> Result<T, io::Error> {
        // align the value
        let offset = at * size_of::<T>();

        if self.is_valid_offset(offset) {
            let tmp = T::read_from_bytes(self.read_from(offset, size_of::<T>()))
                .map_err(|_| std::io::ErrorKind::NotFound)?;
            self.write_at(offset, value.as_bytes());
            return Ok(tmp);
        }
        Err(io::ErrorKind::NotFound.into())
    }

    /// Takes a raw byte offset and determines whether the offset is between the read and write
    /// pointers.
    fn is_valid_offset(&self, offset: usize) -> bool {
        if self.ptr >= self.read_ptr {
            offset >= self.read_ptr && offset < self.ptr
        } else {
            offset >= self.read_ptr || offset < self.ptr
        }
    }

    #[inline]
    fn read_from(&self, offset: usize, len: usize) -> &[u8] {
        assert!(len <= self.capacity, "Cannot read more than capacity");
        let start = offset & self.mask;
        unsafe { std::slice::from_raw_parts(self.addr.add(start), len) }
    }

    #[inline]
    fn read_from_mut(&mut self, offset: usize, len: usize) -> &mut [u8] {
        assert!(len <= self.capacity, "Cannot read more than capacity");
        let start = offset & self.mask;
        unsafe { std::slice::from_raw_parts_mut(self.addr.add(start), len) }
    }

    pub fn iter(&self) -> slice::Iter<'_, T> {
        <&Self as IntoIterator>::into_iter(self)
    }

    pub fn iter_mut(&self) -> slice::Iter<'_, T> {
        <&Self as IntoIterator>::into_iter(self)
    }
}

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    Drop for IonaBuffer<T>
{
    /// Free the memory
    fn drop(&mut self) {
        unsafe {
            libc::munmap(self.addr.cast::<libc::c_void>(), 2 * self.capacity);
        }
    }
}

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    ops::Index<ops::Range<usize>> for IonaBuffer<T>
{
    type Output = [T];

    fn index(&self, index: ops::Range<usize>) -> &Self::Output {
        self.get_slice(index)
    }
}

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    ops::Index<ops::RangeInclusive<usize>> for IonaBuffer<T>
{
    type Output = [T];

    fn index(&self, index: ops::RangeInclusive<usize>) -> &Self::Output {
        self.get_slice(*index.start()..*index.end() + 1)
    }
}

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    ops::Index<ops::RangeTo<usize>> for IonaBuffer<T>
{
    type Output = [T];

    fn index(&self, index: ops::RangeTo<usize>) -> &Self::Output {
        self.get_slice(0..index.end)
    }
}

// TODO: Add bounds checking to these range impls
impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    ops::Index<ops::RangeToInclusive<usize>> for IonaBuffer<T>
{
    type Output = [T];

    fn index(&self, index: ops::RangeToInclusive<usize>) -> &Self::Output {
        self.get_slice(0..index.end + 1)
    }
}

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    ops::Index<ops::RangeFrom<usize>> for IonaBuffer<T>
{
    type Output = [T];

    fn index(&self, index: ops::RangeFrom<usize>) -> &Self::Output {
        assert!(
            index.start > self.len,
            "index out of bounds: start {} >= len {}",
            index.start,
            self.len()
        );
        let start = (self.read_ptr / size_of::<T>() + index.start) & self.elem_mask;
        let count = self.len - index.start;
        self.get_slice(start..start + count)
    }
}

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    ops::Index<ops::RangeFull> for IonaBuffer<T>
{
    type Output = [T];

    fn index(&self, _: ops::RangeFull) -> &Self::Output {
        self.get_slice_from_bytes(self.read_ptr..self.ptr)
    }
}

unsafe impl<
    T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable,
> Send for IonaBuffer<T>
{
}
unsafe impl<
    T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable,
> Sync for IonaBuffer<T>
{
}

impl<'a, T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    IntoIterator for &'a IonaBuffer<T>
{
    type Item = &'a T;
    type IntoIter = slice::Iter<'a, T>;

    fn into_iter(self) -> Self::IntoIter {
        self[..].iter()
    }
}

impl<'a, T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    IntoIterator for &'a mut IonaBuffer<T>
{
    type Item = &'a mut T;
    type IntoIter = slice::IterMut<'a, T>;

    fn into_iter(self) -> Self::IntoIter {
        self.get_mut_slice_from_bytes(self.read_ptr..self.ptr)
            .iter_mut()
    }
}

pub struct IntoIter<
    T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable,
>(IonaBuffer<T>);

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    Iterator for IntoIter<T>
{
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.0.pop_front()
    }
}

impl<T: zerocopy::FromBytes + zerocopy::IntoBytes + zerocopy::KnownLayout + zerocopy::Immutable>
    IntoIterator for IonaBuffer<T>
{
    type Item = T;
    type IntoIter = IntoIter<T>;

    fn into_iter(self) -> Self::IntoIter {
        IntoIter(self)
    }
}