//! Utility functions
use std::{
    borrow::{
	Borrow,
	ToOwned,
    },
};

/// Copy slice `src` into `dst` and return the number of elements copied.
#[inline] pub fn copy_slice<T,U,V,W,X>(mut dst: V, src: W) -> usize
where V: AsMut<[T]>,
      W: AsRef<[U]>,
      U: ToOwned<Owned=X>,
      X: Borrow<U> + Into<T>
{

    let mut i=0;
    for (d, s) in dst.as_mut().iter_mut().zip(src.as_ref().iter())
    {
	*d = s.to_owned().into();
	i+=1
    }
    i
}

pub mod bytes
{
    /// Copy `src`'s bytes into `dst`, returning the number of bytes copied.
    ///
    /// # Note
    /// The memory regions must not overlap
    pub fn copy_slice(dst: &mut [u8], src: &[u8]) -> usize
    {
	let sz = std::cmp::min(dst.len(), src.len());
	if sz != 0 {
	    unsafe {
		std::ptr::copy_nonoverlapping(&src[0] as *const u8, &mut dst[0] as *mut u8, sz);
	    }
	}
	sz
    }
    
    /// Copy `src`'s bytes into `dst`, returning the number of bytes copied.
    ///
    /// # Note
    /// The memory regions can overlap
    pub fn move_slice(dst: &mut [u8], src: &[u8]) -> usize
    {
	let sz = std::cmp::min(dst.len(), src.len());
	if sz != 0 {
	    unsafe {
		std::ptr::copy(&src[0] as *const u8, &mut dst[0] as *mut u8, sz);
	    }
	}
	sz
    }
}

#[cfg(test)]
mod tests
{
    #[test]
    fn copy_slice()
    {
	let mut to = [0u8; 40];
	let from = [10u8; 37];

	assert_eq!(super::copy_slice(&mut to, &from), 37);

	assert_eq!(from, &to[0..37]);
    }
}