capped_collections 0.2.0

use core::panic;

use core::{array, ascii::escape_default, fmt::Display, mem, ops::{Index, IndexMut}, slice::{Iter, IterMut}};

use core::ops::Range;

//Disabled

//use corlib::inc_dec::*;

use inc_dec::*;

use core::fmt::Debug;

use core::mem::take;

#[cfg(feature = "serde")]
use serde::ser::SerializeSeq;

#[cfg(feature = "serde")]
use serde::{Serialize, Serializer};

///
/// An std::vec::Vec-like type with a compile-time maximum size.
/// 
/// Uses a stack allocated array to store pushed items internally. 
/// 
pub struct CappedVec<T, const N: usize>
    where T: Default //+ Copy
{

    array: [T; N],
    len: usize          //The length of valid items.

}

impl<T, const N: usize> CappedVec<T, N>
    where T: Default //+ Copy
{

    pub fn new() -> Self
    {

        Self
        {

            array: array::from_fn(|_| T::default()), //[T::default(); N],
            len: 0

        }

    }

    /*
    pub fn with_capacity<const N2: usize>() -> CappedVec<T, N2>
    {

        CappedVec::<T, N2>::new()

    }
    */

    pub fn push(&mut self, value: T) -> Option<T>
    {

        let next_last_index = self.len;

        if next_last_index >= self.capacity()
        {

            //Can't fit

            return Some(value);

        }

        self.array[next_last_index] = value;

        self.len.pp();

        None

    }

    pub fn pop(&mut self) -> Option<T>
    {

        if self.len == 0
        {

            return None;

        }

        let last_index = self.len - 1;

        let poped = take(&mut self.array[last_index]);

        self.len = last_index;

        Some(poped)

    }

    pub fn len(&self) -> usize
    {

        self.len

    }

    pub const fn capacity(&self) -> usize
    {

        self.array.len()

    }

    pub const fn has_capacity(&self) -> bool
    {

        self.capacity() > 0

    }

    pub fn last_index(&self) -> Option<usize>
    {

        let len = self.len;

        if len == 0
        {

            None

        }
        else
        {

            Some(len - 1)
            
        }

    }

    //Should array elements by mutable by reference? No.

    pub fn try_index(&mut self, index: usize) -> Option<&T>
    {

        if index < self.len()
        {

            Some(&self.array[index])

        }
        else
        {

            None
            
        }

    }

    pub fn try_index_mut(&mut self, index: usize) -> Option<&mut T>
    {

        if index < self.len()
        {

            Some(&mut self.array[index])

        }
        else
        {

            None
            
        }

    }

    pub fn is_full(&self) -> bool
    {

        if self.capacity() == 0
        {

            //An array with no capacity can never be full.

            return false;

        }

        self.len() == self.capacity()

    }

    pub fn is_empty(&self) -> bool
    {

        self.len() == 0

    }

    pub fn iter<'a>(&'a self) -> Iter<'a, T>
    {

        return self.array[..self.len].iter();

        //let slice_len;

        //let last_index;

        //if self.len > 1
        //{

            //last_index = self.len - 1;

            //slice_len = self.len;

        //}
        //else
        //{

            //slice_len = 0;

            //last_index = 0;

            //return self.array[..].iter();
            
        //}

        //self.array[..last_index].iter()

    }

    //Disabled

    /*
    pub fn iter<'a>(&'a self) -> CappedVecIterator<'a, T>
    {

        let last_index;

        if self.len > 1
        {

            last_index = self.len - 1;

        }
        else
        {

            return CappedVecIterator::new(self.array[..].iter());
            
        }

        CappedVecIterator::new(self.array[..last_index].iter())

    }
    */

    pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T>
    {

        self.array[..self.len].iter_mut()

        /*
        let last_index;

        if self.len > 1
        {

            last_index = self.len - 1;

        }
        else
        {

            return self.array[..].iter_mut();
            
        }

        self.array[..last_index].iter_mut()
        */

    }

    //Disabled

    /*
    pub fn iter_mut<'a>(&'a mut self) -> CappedVecIteratorMut<'a, T>
    {

        let last_index;

        if self.len > 1
        {

            last_index = self.len - 1;

        }
        else
        {

            return CappedVecIteratorMut::new(self.array[..].iter_mut());
            
        }

        CappedVecIteratorMut::new(self.array[..last_index].iter_mut())

    }
    */

    pub fn insert(&mut self, index: usize, item: T) -> Option<T>
    {

        if self.len == 0
        {

            //No room

            Some(item)

        }
        else if index <= self.len && !self.is_full()
        {

            let mut last_index = self.len - 1;

            //Move all items including that at the specified index to the right.

            while last_index >= index
            {

                let current_item = mem::take(&mut self.array[last_index]);

                self.array[last_index + 1] = current_item;

                last_index.mm();

            }

            //Finally insert the item at the specified index and increment the length. 

            self.array[index] = item;

            self.len.pp();

            None

        }
        else
        {

            Some(item)

        }

    }

    pub fn remove(&mut self, index: usize) -> Option<T>
    {

        if self.len == 0
        {

            None

        }
        else if index < self.len
        {

            let removed_item = mem::take(&mut self.array[index]);

            //Move all items to the left to close the gap.

            let mut last_index = index + 1;

            while last_index < self.len
            {

                let current_item = mem::take(&mut self.array[last_index]);

                self.array[last_index - 1] = current_item;

                last_index.pp();

            }

            self.len.mm();

            Some(removed_item)

        }
        else
        {

            None
            
        }

    }

    pub fn clear(&mut self)
    {

        if self.len > 0
        {

            let last_index = self.len - 1;

            for item in self.array[..last_index].iter_mut()
            {

                *item = T::default();

            }

            self.len = 0;            

        }

    }

    ///
    /// Sets the length to zero, skipping the process of resetting each valid element to its default value.
    /// 
    /// Quicker than clearing operations, however previously valid objects are now "lost" until the internal array is dropped.
    /// 
    pub fn reset(&mut self)
    {

        self.len = 0;

    }

    ///
    /// Clear the entire internal array, including invalid elements.
    /// 
    pub fn clear_completely(&mut self)
    {

        for item in self.array.iter_mut()
        {

            *item = T::default();

        }

        self.len = 0;

    }

    pub fn first(&self) -> Option<&T>
    {

        if self.len == 0
        {

            None

        }
        else
        {

            Some(&self.array[0])
            
        }

    }

    pub fn first_mut(&mut self) -> Option<&mut T>
    {

        if self.len == 0
        {

            None

        }
        else
        {

            Some(&mut self.array[0])
            
        }

    }

    pub fn last(&self) -> Option<&T>
    {

        if self.len == 0
        {

            None

        }
        else
        {

            Some(&self.array[self.len - 1])
            
        }

    }

    pub fn last_mut(&mut self) -> Option<&mut T>
    {

        if self.len == 0
        {

            None

        }
        else
        {

            Some(&mut self.array[self.len - 1])
            
        }

    }

    /*
    pub fn as_slice(&self) -> &[&T]
    {

        let array = [&T; self.len];



    }
    */

    pub fn as_slice(&self) -> &[T]
    {

        &self.array[..self.len]

        /*
        if self.len == 0
        {

            &self.array[..]

        }
        else
        {
            let last_index = self.len - 1;

            &self.array[..last_index]
            
        }
        */
        
    }

    pub fn as_slice_mut(&mut self) -> &mut [T]
    {

        &mut self.array[..self.len]

        /*
        if self.len == 0
        {

            self.array[..].as_mut()

        }
        else
        {
            let last_index = self.len - 1;

            self.array[..last_index].as_mut()
            
        }
        */
        
    }

    pub fn contains(&self, val_ref: &T) -> bool
        where T: PartialEq
    {

        let iter = self.iter();

        for item in iter
        {

            if item == val_ref
            {

                return true;

            }

        }

        false

    }

}

impl<T, const N: usize> Index<usize> for CappedVec<T, N>
    where T: Default //+ Copy
{

    //type Output = Option<&T>;

    type Output = T;

    fn index(&self, index: usize) -> &Self::Output
    {

        if index >= self.len
        {

            panic!("Error: The provided index is out of bounds")

        }

        &self.array[index]

        /*
        let len = self.len;

        if len == 0
        {

            &None

        }
        else
        {

            if index < len
            {
    
                &Some(&self.array[index])
    
            }
            else
            {
                
                &None
    
            }

        }
        */

    }

}

impl<T, const N: usize> IndexMut<usize> for CappedVec<T, N>
    where T: Default //+ Copy
{

    fn index_mut(&mut self, index: usize) -> &mut Self::Output
    {

        if index >= self.len
        {

            panic!("Error: The provided index is out of bounds")

        }

        &mut self.array[index]

        /*
        let panic_message: &'static str = "Error: Invalid index";

        let len = self.len;

        if len == 0
        {

            panic!("{}", panic_message)

            //&None

        }
        else
        {
        
            if index < len //self.last_index
            {

                &mut self.array[index]

            }
            else
            {

                panic!("{}", panic_message)
                
                //panic!("Error: Invalid index")

                //&mut None

            }

        }
        */

    }

}

impl<T, const N: usize> Display for CappedVec<T, N>
    where T: Display + Default //+ Copy
{

    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
    {

        let last_index;

        if self.capacity() == 0 || self.len() == 0
        {

            last_index = 0;

        }
        else
        {

            last_index = self.len() - 1;

        }

        let mut current_index = 0;

        f.write_str("[")?;

        for item in self.iter()
        {

            write!(f, "{}", item)?;

            if current_index < last_index
            {

                f.write_str(", ")?;

            }
            else
            {

                break;
                
            }

            current_index.pp();

        }

        f.write_str("]")?;

        Ok(())
        
    }

}

impl<T, const N: usize> Debug for CappedVec<T, N>
    where T: Debug + Default //+ Copy
{

    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("CappedVec").field("array", &self.array).field("len", &self.len).finish()
    }

}

impl<T, const N: usize> Clone for CappedVec<T, N>
    where T: Clone + Default //+ Copy
{

    fn clone(&self) -> Self {
        Self { array: self.array.clone(), len: self.len.clone() }
    }
    
}


impl<T, const N: usize> Copy for CappedVec<T, N>
    where T: Default + Copy
{
}

#[cfg(feature = "serde")]
impl<T, const N: usize> Serialize for CappedVec<T, N>
    where T: Default  + Serialize //+ Copy
{

    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer
    {

        let mut seq = serializer.serialize_seq(Some(self.len))?;

        let valid_range = self.as_slice();

        for item in valid_range
        {

            seq.serialize_element(item)?;

        }

        seq.end()

        //serializer.serialize_str(self.as_str())

    }

}

//https://doc.rust-lang.org/std/ops/index.html

//Disabled

/*
impl<T, const N: usize> Index<Range<usize>> for CappedVec<T, N>
    where T: Default
{

    //type Output = Option<&T>;

    type Output = T;

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

        if index >= self.len
        {

            panic!("Error: The provided index is out of bounds")

        }

        &self.array[index]

    }

}

impl<T, const N: usize> IndexMut<usize> for CappedVec<T, N>
    where T: Default
{

    fn index_mut(&mut self, index: usize) -> &mut Self::Output
    {

        if index >= self.len
        {

            panic!("Error: The provided index is out of bounds")

        }

        &mut self.array[index]

    }

}
*/

//CappedVecIterator

//Disabled

/*
///
/// The iterator for CappedVec which provides immutable references.
/// 
pub struct CappedVecIterator<'a, T>
{

    opt_iter: Iter<'a, T>

}

impl<'a, T> CappedVecIterator<'a, T>
{

    pub fn new(opt_iter: Iter<'a, T>) -> Self
    {

        Self
        {

            opt_iter

        }

    }

}

impl<'a, T> Iterator for CappedVecIterator<'a, T>
{

    type Item = &'a T;

    fn next(&mut self) -> Option<Self::Item>
    {

        match self.opt_iter.next()
        {

            Some(val) =>
            {

                Some(val)

            }
            None => None

        }

    }

}
*/

//Disabled

/*
///
/// The iterator for CappedVec which provides mutable references.
/// 
pub struct CappedVecIteratorMut<'a, T>
{

    opt_iter_mut: IterMut<'a, T>

}

impl<'a, T> CappedVecIteratorMut<'a, T>
{

    pub fn new(opt_iter_mut: IterMut<'a, T>) -> Self
    {

        Self
        {

            opt_iter_mut

        }

    }

}

impl<'a, T> Iterator for CappedVecIteratorMut<'a, T>
{

    type Item = &'a mut T;

    fn next(&mut self) -> Option<Self::Item>
    {

        match self.opt_iter_mut.next()
        {

            Some(val) =>
            {

                Some(val)

            }
            None => None
            
        }

    }

}
*/