1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use super::*;

use std::{
    mem::{
	forget,
    },
    marker::{
	Send,Sync,
    },
    ops::{
	Drop,
    },
};
use ptr::{
    VoidPointer,
};

/// An iterator that consumes `HeapArray<T>` instance and ensures all memory is appropriately freed when consumed or dropped.
pub struct IntoIter<T>
{
    start: *mut T,
    current_offset: usize,
    sz: usize,
}

unsafe impl<T: Send> Send for IntoIter<T>{}
unsafe impl<T: Sync> Sync for IntoIter<T>{} //this is probably fine right?

impl<T> IntoIter<T>
{
    fn current(&mut self) -> *mut T
    {
	unsafe {
	    self.start.offset(self.current_offset as isize)
	}
    }
    fn free_if_needed(&mut self)
    {
	if self.start != ptr::null() && self.current_offset >= self.sz {
	    unsafe {
		alloc::free(self.start as VoidPointer);
	    }
	    self.start = ptr::null();
	}
    }
    fn drain_if_needed(&mut self)
    {
	if self.start != ptr::null() {

	    unsafe {
		if self.current_offset<self.sz {
		    for i in self.current_offset..self.sz
		    {
			drop(ptr::take(self.start.offset(i as isize)));
		    }
		}

		alloc::free(self.start as VoidPointer);
	    }
	    self.start = ptr::null();
	}
    }
}

impl<T> Drop for IntoIter<T>
{
    fn drop(&mut self)
    {
	self.drain_if_needed();
    }
}

impl<T> Iterator for IntoIter<T>
{
    type Item = T;
    fn next(&mut self) -> Option<Self::Item>
    {
	let output = if self.current_offset >= self.sz || self.sz == 0 {
	    None
	} else {
	    unsafe {
		let output = crate::ptr::take(self.current());//replace(&mut (*self.current), MaybeUninit::zeroed().assume_init());
		self.current_offset+=1;

		Some(output)
	    }
	};
	self.free_if_needed();
	output
    }
}

impl<T> ExactSizeIterator for IntoIter<T>
{
    fn len(&self) -> usize
    {
	self.sz
    }
}

impl<T> IntoIterator for HeapArray<T>
{
    type Item = T;
    type IntoIter = IntoIter<T>;

    fn into_iter(self) -> Self::IntoIter
    {
	let output = Self::IntoIter {
	    start: self.ptr,
	    current_offset: 0,
	    sz: self.len(),
	};
	forget(self);
	output
    }
}