ccarp_helper 0.1.0

#![no_std]

/// A collection of Rust methods for emulating standard C behaviour for integers
/// (e.g. `i8`, `u8`, `i16`, etc.)
pub trait CFuncInt {
    /// Postfix increase
    /// 
    /// Equivalent to C's `i++` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=0;
    /// let j=i.inc_post();
    /// assert_eq!(i,1);
    /// assert_eq!(j,0);
    /// ```
    #[must_use]
    fn inc_post(&mut self) -> Self;
    /// Postfix decrease
    /// 
    /// Equivalent to C's `i--` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=1;
    /// let j=i.dec_post();
    /// assert_eq!(i,0);
    /// assert_eq!(j,1);
    /// ```
    #[must_use]
    fn dec_post(&mut self) -> Self;
    /// Prefix increase
    /// 
    /// Equivalent to C's `++i` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=0;
    /// let j=i.pre_inc();
    /// assert_eq!(i,1);
    /// assert_eq!(j,1);
    /// ```
    #[must_use]
    fn pre_inc(&mut self) -> Self;
    /// Prefix decrease
    /// 
    /// Equivalent to C's `--i` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=1;
    /// let j=i.pre_dec();
    /// assert_eq!(i,0);
    /// assert_eq!(j,0);
    /// ```
    #[must_use]
    fn pre_dec(&mut self) -> Self;
    /// C AddAssign
    /// 
    /// Equivalent to C's `i+=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=1;
    /// let j=i.c_add_assign(2);
    /// assert_eq!(i,3);
    /// assert_eq!(j,3);
    /// ```
    #[must_use]
    fn c_add_assign(&mut self, rhs: Self) -> Self;
    /// C SubAssign
    /// 
    /// Equivalent to C's `i-=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=3;
    /// let j=i.c_sub_assign(2);
    /// assert_eq!(i,1);
    /// assert_eq!(j,1);
    /// ```
    #[must_use]
    fn c_sub_assign(&mut self, rhs: Self) -> Self;
    /// C MulAssign
    /// 
    /// Equivalent to C's `i*=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=2;
    /// let j=i.c_mul_assign(3);
    /// assert_eq!(i,6);
    /// assert_eq!(j,6);
    /// ```
    #[must_use]
    fn c_mul_assign(&mut self, rhs: Self) -> Self;
    /// C DivAssign
    /// 
    /// Equivalent to C's `i/=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=6;
    /// let j=i.c_div_assign(3);
    /// assert_eq!(i,2);
    /// assert_eq!(j,2);
    /// ```
    #[must_use]
    fn c_div_assign(&mut self, rhs: Self) -> Self;
    /// C ModAssign
    /// 
    /// Equivalent to C's `i%=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=5;
    /// let j=i.c_mod_assign(3);
    /// assert_eq!(i,2);
    /// assert_eq!(j,2);
    /// ```
    #[must_use]
    fn c_mod_assign(&mut self, rhs: Self) -> Self;
    /// C ShrAssign
    /// 
    /// Equivalent to C's `i>>=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=2;
    /// let j=i.c_rshift_assign(1);
    /// assert_eq!(i,1);
    /// assert_eq!(j,1);
    /// ```
    #[must_use]
    fn c_rshift_assign(&mut self, rhs: Self) -> Self;
    /// C ShlAssign
    /// 
    /// Equivalent to C's `i<<=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=1;
    /// let j=i.c_lshift_assign(1);
    /// assert_eq!(i,2);
    /// assert_eq!(j,2);
    /// ```
    #[must_use]
    fn c_lshift_assign(&mut self, rhs: Self) -> Self;
    /// C BitAndAssign
    /// 
    /// Equivalent to C's `i&=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=15;
    /// let j=i.c_and_assign(22);
    /// assert_eq!(i,6);
    /// assert_eq!(j,6);
    /// ```
    #[must_use]
    fn c_and_assign(&mut self, rhs: Self) -> Self;
    /// C BitOrAssign
    /// 
    /// Equivalent to C's `i|=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=7;
    /// let j=i.c_or_assign(11);
    /// assert_eq!(i,15);
    /// assert_eq!(j,15);
    /// ```
    #[must_use]
    fn c_or_assign(&mut self, rhs: Self) -> Self;
    /// C BitXorAssign
    /// 
    /// Equivalent to C's `i^=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=15;
    /// let j=i.c_xor_assign(7);
    /// assert_eq!(i,8);
    /// assert_eq!(j,8);
    /// ```
    #[must_use]
    fn c_xor_assign(&mut self, rhs: Self) -> Self;
}

/// A collection of Rust methods for emulating standard C behaviour for floating point numbers
/// (`f32`, `f64`)
pub trait CFuncFloat {
    /// Postfix increase
    /// 
    /// Equivalent to C's `i++` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=0.0;
    /// let j=i.inc_post();
    /// assert_eq!(i,1.0);
    /// assert_eq!(j,0.0);
    /// ```
    #[must_use]
    fn inc_post(&mut self) -> Self;
    /// Postfix decrease
    /// 
    /// Equivalent to C's `i--` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=1.0;
    /// let j=i.dec_post();
    /// assert_eq!(i,0.0);
    /// assert_eq!(j,1.0);
    /// ```
    #[must_use]
    fn dec_post(&mut self) -> Self;
    /// Prefix increase
    /// 
    /// Equivalent to C's `++i` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=0.0;
    /// let j=i.pre_inc();
    /// assert_eq!(i,1.0);
    /// assert_eq!(j,1.0);
    /// ```
    #[must_use]
    fn pre_inc(&mut self) -> Self;
    /// Prefix decrease
    /// 
    /// Equivalent to C's `--i` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=1.0;
    /// let j=i.pre_dec();
    /// assert_eq!(i,0.0);
    /// assert_eq!(j,0.0);
    /// ```
    #[must_use]
    fn pre_dec(&mut self) -> Self;
    /// C AddAssign
    /// 
    /// Equivalent to C's `i+=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=1.0;
    /// let j=i.c_add_assign(2.0);
    /// assert_eq!(i,3.0);
    /// assert_eq!(j,3.0);
    /// ```
    #[must_use]
    fn c_add_assign(&mut self, rhs: Self) -> Self;
    /// C SubAssign
    /// 
    /// Equivalent to C's `i-=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=3.0;
    /// let j=i.c_sub_assign(2.0);
    /// assert_eq!(i,1.0);
    /// assert_eq!(j,1.0);
    /// ```
    #[must_use]
    fn c_sub_assign(&mut self, rhs: Self) -> Self;
    /// C MulAssign
    /// 
    /// Equivalent to C's `i*=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=2.0;
    /// let j=i.c_mul_assign(3.0);
    /// assert_eq!(i,6.0);
    /// assert_eq!(j,6.0);
    /// ```
    #[must_use]
    fn c_mul_assign(&mut self, rhs: Self) -> Self;
    /// C DivAssign
    /// 
    /// Equivalent to C's `i/=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=6.0;
    /// let j=i.c_div_assign(3.0);
    /// assert_eq!(i,2.0);
    /// assert_eq!(j,2.0);
    /// ```
    #[must_use]
    fn c_div_assign(&mut self, rhs: Self) -> Self;
}

/// A collection of Rust methods for emulating standard C behaviour for pointer arrays
pub trait CFuncPoint {
    /// Postfix increase
    /// 
    /// Equivalent to C's `p++` operator.
    /// 
    /// # Safety
    /// After calling this method accessing the last element of the original pointer is undefined
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3] as *const [i32];
    /// let q=p.inc_post();
    /// assert_eq!(unsafe { p.as_ref().unwrap() }[0..2],[2, 3]);
    /// assert_eq!(unsafe { q.as_ref().unwrap() }[0..2],[1, 2]);
    /// ```
    #[must_use]
    unsafe fn inc_post(&mut self) -> Self;
    /// Postfix decrease
    /// 
    /// Equivalent to C's `p--` operator.
    /// 
    /// # Safety
    /// After calling this method accessing the first element of the original pointer is undefined
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3] as *const [i32];
    /// let q=p.dec_post();
    /// assert_eq!(unsafe { p.as_ref().unwrap() }[1..3],[1, 2]);
    /// assert_eq!(unsafe { q.as_ref().unwrap() }[1..3],[2, 3]);
    /// ```
    #[must_use]
    unsafe fn dec_post(&mut self) -> Self;
    /// Prefix increase
    /// 
    /// Equivalent to C's `++p` operator.
    /// 
    /// # Safety
    /// After calling this method accessing the last element is undefined
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3] as *const [i32];
    /// let q=p.pre_inc();
    /// assert_eq!(unsafe { p.as_ref().unwrap() }[0..2],[2, 3]);
    /// assert_eq!(unsafe { q.as_ref().unwrap() }[0..2],[2, 3]);
    /// ```
    #[must_use]
    unsafe fn pre_inc(&mut self) -> Self;
    /// Prefix decrease
    /// 
    /// Equivalent to C's `++p` operator.
    /// 
    /// # Safety
    /// After calling this method accessing the first element is undefined
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3] as *const [i32];
    /// let q=p.pre_dec();
    /// assert_eq!(unsafe { p.as_ref().unwrap() }[1..3],[1, 2]);
    /// assert_eq!(unsafe { q.as_ref().unwrap() }[1..3],[1, 2]);
    /// ```
    #[must_use]
    unsafe fn pre_dec(&mut self) -> Self;
    /// C AddAssign
    /// 
    /// Equivalent to C's `p+=i` operator.
    /// 
    /// # Safety
    /// After calling this method accessing the last `rhs` elements is undefined
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3,4,5] as *const [i32];
    /// let q=p.c_add_assign(2);
    /// assert_eq!(unsafe { p.as_ref().unwrap() }[0..3],[3, 4, 5]);
    /// assert_eq!(unsafe { q.as_ref().unwrap() }[0..3],[3, 4, 5]);
    /// ```
    #[must_use]
    unsafe fn c_add_assign(&mut self, rhs: isize) -> Self;
    /// C SubAssign
    /// 
    /// Equivalent to C's `p-=i` operator.
    /// 
    /// # Safety
    /// After calling this method accessing the first `rhs` elements is undefined
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3,4,5] as *const [i32];
    /// let q=p.c_sub_assign(2);
    /// assert_eq!(unsafe { p.as_ref().unwrap() }[2..5],[1, 2, 3]);
    /// assert_eq!(unsafe { q.as_ref().unwrap() }[2..5],[1, 2, 3]);
    /// ```
    #[must_use]
    unsafe fn c_sub_assign(&mut self, rhs: isize) -> Self;
    /// C Add
    /// 
    /// Equivalent to C's `p+i` operator.
    /// 
    /// # Safety
    /// After calling this method accessing the last `rhs` elements of the result is undefined
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3,4,5] as *const [i32];
    /// let q=p.c_add(2);
    /// assert_eq!(unsafe { p.as_ref().unwrap() }[0..3],[1, 2, 3]);
    /// assert_eq!(unsafe { q.as_ref().unwrap() }[0..3],[3, 4, 5]);
    /// ```
    #[must_use]
    unsafe fn c_add(self, rhs: isize) -> Self;
    /// C Sub
    /// 
    /// Equivalent to C's `p-i` operator.
    /// 
    /// # Safety
    /// After calling this method accessing the first `rhs` elements of the result is undefined
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3,4,5] as *const [i32];
    /// let q=p.c_sub(2);
    /// assert_eq!(unsafe { p.as_ref().unwrap() }[2..5],[3, 4, 5]);
    /// assert_eq!(unsafe { q.as_ref().unwrap() }[2..5],[1, 2, 3]);
    /// ```
    #[must_use]
    unsafe fn c_sub(self, rhs: isize) -> Self;
}

/// Trait for C assign emulation in Rust
pub trait CAssign {
    /// C Assign
    /// 
    /// Equivalent to C's `i=j` operator.
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut i=1;
    /// let j=i.c_assign(2);
    /// assert_eq!(i,2);
    /// assert_eq!(j,2);
    /// ```
    #[must_use]
    fn c_assign(&mut self, rhs: Self) -> Self;
}

/// A trait for indexing raw pointers
/// 
/// It is unnecessary to say that, but this is highly unsafe
pub trait CIndex {
    /// Indexed type
    /// 
    /// What type does indexing return?
    type IndType;
    /// C Index
    /// 
    /// Equivalent to C's `p[i]` operator.
    /// 
    /// # Safety
    /// This operation is safe if and only if the pointer references a valid array
    /// and indices is inside the bounds of said array (`0 <= n < arr.len()`).
    /// 
    /// # Example:
    /// ```
    /// # use crate::ccarp_helper::*;
    /// let mut p=&[1,2,3] as *const i32;
    /// let val=p.index(0); // Overindexing is not checked!
    /// assert_eq!(val,1);
    /// ```
    unsafe fn index(&self, n: usize) -> Self::IndType;
}

macro_rules! impl_assign {
    ($name:ident,$op:tt) => {
        fn $name(&mut self, rhs: Self) -> Self {
            *self $op rhs;
            *self
        }
    };
}

macro_rules! impl_cfunc {
    ($t:ty) => {
        impl CFuncInt for $t {
            fn inc_post(&mut self) -> Self {
                let res=*self;
                *self+=1;
                res
            }
            fn dec_post(&mut self) -> Self {
                let res=*self;
                *self-=1;
                res
            }
            fn pre_inc(&mut self) -> Self {
                self.c_add_assign(1)
            }
            fn pre_dec(&mut self) -> Self {
                self.c_sub_assign(1)
            }
            impl_assign!(c_add_assign,+=);
            impl_assign!(c_sub_assign,-=);
            impl_assign!(c_mul_assign,*=);
            impl_assign!(c_div_assign,/=);
            impl_assign!(c_mod_assign,%=);
            impl_assign!(c_lshift_assign,<<=);
            impl_assign!(c_rshift_assign,>>=);
            impl_assign!(c_and_assign,&=);
            impl_assign!(c_xor_assign,^=);
            impl_assign!(c_or_assign,|=);
        }
    };
    ($t:ty,$($u:ty),*) => {
        impl_cfunc!($t);
        impl_cfunc!($($u),*);
    };
    (float $t:ty) => {
        impl CFuncFloat for $t {
            fn inc_post(&mut self) -> Self {
                let res=*self;
                *self+=1.0;
                res
            }
            fn dec_post(&mut self) -> Self {
                let res=*self;
                *self-=1.0;
                res
            }
            fn pre_inc(&mut self) -> Self {
                self.c_add_assign(1.0)
            }
            fn pre_dec(&mut self) -> Self {
                self.c_sub_assign(1.0)
            }
            impl_assign!(c_add_assign,+=);
            impl_assign!(c_sub_assign,-=);
            impl_assign!(c_mul_assign,*=);
            impl_assign!(c_div_assign,/=);
        }
    };
    (float $t:ty,$($u:ty),*) => {
        impl_cfunc!(float $t);
        impl_cfunc!(float $($u),*);
    };
}

impl_cfunc!(i8,u8,i16,u16,i32,u32,i64,u64,i128,u128,isize,usize);
impl_cfunc!(float f32,f64);

impl<T> CFuncPoint for *const [T] {
    unsafe fn inc_post(&mut self) -> Self {
        let res=*self;
        unsafe { *self=self.c_add(1) };
        res
    }
    unsafe fn dec_post(&mut self) -> Self {
        let res=*self;
        unsafe { *self=self.c_sub(1) };
        res
    }
    unsafe fn pre_inc(&mut self) -> Self {
        unsafe { self.c_add_assign(1) }
    }
    unsafe fn pre_dec(&mut self) -> Self {
        unsafe { self.c_sub_assign(1) }
    }
    unsafe fn c_add_assign(&mut self, rhs: isize) -> Self {
        unsafe { *self=self.c_add(rhs) };
        *self
    }
    unsafe fn c_sub_assign(&mut self, rhs: isize) -> Self {
        unsafe { *self=self.c_sub(rhs) };
        *self
    }
    #[allow(clippy::not_unsafe_ptr_arg_deref)]
    unsafe fn c_add(self, rhs: isize) -> Self {
        let n=rhs.unsigned_abs();
        if rhs>=0 { unsafe { self.byte_add(n*size_of::<T>()) } }
        else { unsafe { self.byte_sub(n*size_of::<T>()) } }
    }
    unsafe fn c_sub(self, rhs: isize) -> Self {
        unsafe { self.c_add(-rhs) }
    }
}

impl<T> CFuncPoint for *mut [T] {
    unsafe fn inc_post(&mut self) -> Self {
        let res=*self;
        unsafe { *self=self.c_add(1) };
        res
    }
    unsafe fn dec_post(&mut self) -> Self {
        let res=*self;
        unsafe { *self=self.c_sub(1) };
        res
    }
    unsafe fn pre_inc(&mut self) -> Self {
        unsafe { self.c_add_assign(1) }
    }
    unsafe fn pre_dec(&mut self) -> Self {
        unsafe { self.c_sub_assign(1) }
    }
    unsafe fn c_add_assign(&mut self, rhs: isize) -> Self {
        unsafe { *self=self.c_add(rhs) };
        *self
    }
    unsafe fn c_sub_assign(&mut self, rhs: isize) -> Self {
        unsafe { *self=self.c_sub(rhs) };
        *self
    }
    #[allow(clippy::not_unsafe_ptr_arg_deref)]
    unsafe fn c_add(self, rhs: isize) -> Self {
        let n=rhs.unsigned_abs();
        if rhs>=0 { unsafe { self.byte_add(n*size_of::<T>()) } }
        else { unsafe { self.byte_sub(n*size_of::<T>()) } }
    }
    unsafe fn c_sub(self, rhs: isize) -> Self {
        unsafe { self.c_add(-rhs) }
    }
}

impl<T: Copy> CAssign for T {
    fn c_assign(&mut self, rhs: Self) -> Self {
        *self=rhs;
        *self
    }
}

impl<T: Copy> CIndex for *const T {
    type IndType = T;
    unsafe fn index(&self,n: usize) -> Self::IndType {
        *unsafe { self.add(n).as_ref() }.unwrap()
    }
}

impl<T: Copy> CIndex for *mut T {
    type IndType = T;
    unsafe fn index(&self,n: usize) -> Self::IndType {
        *unsafe { self.add(n).as_ref() }.unwrap()
    }
}