A fairly straight forward but flexible implementation of a Linked List. 2 | No reason to use this over the standard libraries implementation though.
3 |A set of iterator types for a LinkedList
LinkedList is an implementation of a singly-linked-list.
A set of iterator types for a LinkedList
Owned iterator of a LinkedList
Borrowed iterator of a LinkedList
Mutable iterator of a LinkedList
fn:) to \
3 | restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \
4 | enum, trait, type, macro, \
5 | and const.","Search functions by type signature (e.g., vec -> usize or \
6 | * -> vec)","Search multiple things at once by splitting your query with comma (e.g., \
7 | str,u8 or String,struct:Vec,test)","You can look for items with an exact name by putting double quotes around \
8 | your request: \"string\"","Look for items inside another one by searching for a path: vec::Vec",].map(function(x){return""+x+"
"}).join("");var div_infos=document.createElement("div");addClass(div_infos,"infos");div_infos.innerHTML="LinkedList is an implementation of a singly-linked-list.","Add one linked list to the end of this linked list","","","","","","","","","View the first value in the linked list. This is O(1)","Modify the first value in the linked list. This is O(1)","","","","","","Determine if this linked list is empty. This is an O(1) …","A set of iterator types for a LinkedList","Create an iter over this linked list","Create a mutable iter over this linked list","View the last value in the linked list. This is O(n)","Modify the last value in the linked list. This is O(n)","Get the length of the linked list. This is an O(n) …","Create a new empty linked list","Pop from the back of the linked list. This is O(n)","Pop from the front of the linked list. This is O(1)","Push to the back of the linked list. This is O(n)","Push to the front of the linked list. This is O(1)","","","","","Owned iterator of a LinkedList","Borrowed iterator of a LinkedList","Mutable iterator of a LinkedList","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,2,3,4,2,3,4,4,4,2,3,4,2,3,4,2,3,4,2,3,4,4,2,3,4,2,3,4,2,3,4],"f":[null,[[]],[[]],[[]],[[],["linkedlist",3]],[[]],[[]],[[]],[[["linkedlist",3]],["bool",15]],[[["intoiterator",8]]],[[],["option",4]],[[],["option",4]],[[["formatter",3]],["result",6]],[[]],[[["intoiterator",8]]],[[]],[[]],[[],["bool",15]],null,[[],["iter",3]],[[],["itermut",3]],[[],["option",4]],[[],["option",4]],[[],["usize",15]],[[]],[[],["option",4]],[[],["option",4]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["iter",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["option",4]],[[],["option",4]],[[],["option",4]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]]],"p":[[3,"LinkedList"],[3,"IntoIter"],[3,"IterMut"],[3,"Iter"]]}\
3 | }');
4 | if (window.initSearch) {window.initSearch(searchIndex)};
--------------------------------------------------------------------------------
/docs/search.js:
--------------------------------------------------------------------------------
1 | (function(){var itemTypes=["mod","externcrate","import","struct","enum","fn","type","static","trait","impl","tymethod","method","structfield","variant","macro","primitive","associatedtype","constant","associatedconstant","union","foreigntype","keyword","existential","attr","derive","traitalias"];var TY_PRIMITIVE=itemTypes.indexOf("primitive");var TY_KEYWORD=itemTypes.indexOf("keyword");function printTab(nb){if(nb===0||nb===1||nb===2){searchState.currentTab=nb}var nb_copy=nb;onEachLazy(document.getElementById("titles").childNodes,function(elem){if(nb_copy===0){addClass(elem,"selected")}else{removeClass(elem,"selected")}nb_copy-=1});onEachLazy(document.getElementById("results").childNodes,function(elem){if(nb===0){addClass(elem,"active")}else{removeClass(elem,"active")}nb-=1})}function removeEmptyStringsFromArray(x){for(var i=0,len=x.length;i1 2 | 2 3 | 3 4 | 4 5 | 5 6 | 6 7 | 7 8 | 8 9 | 9 10 | 10 11 | 11 12 | 12 13 | 13 14 | 14 15 | 15 16 | 16 17 | 17 18 | 18 19 | 19 20 | 20 21 | 21 22 | 22 23 | 23 24 | 24 25 | 25 26 | 26 27 | 27 28 | 28 29 | 29 30 | 30 31 | 31 32 | 32 33 | 33 34 | 34 35 | 35 36 | 36 37 | 37 38 | 38 39 | 39 40 | 40 41 | 41 42 | 42 43 | 43 44 | 44 45 | 45 46 | 46 47 | 47 48 | 48 49 | 49 50 | 50 51 | 51 52 | 52 53 | 53 54 | 54 55 | 55 56 | 56 57 | 57 58 | 58 59 | 59 60 | 60 61 | 61 62 | 62 63 | 63 64 | 64 65 | 65 66 | 66 67 | 67 68 | 68 69 | 69 70 | 70 71 | 71 72 | 72 73 | 73 74 | 74 75 | 75 76 | 76 77 | 77 78 | 78 79 | 79 80 | 80 81 | 81 82 | 82 83 | 83 84 | 84 85 | 85 86 | 86 87 | 87 88 | 88 89 | 89 90 | 90 91 | 91 92 | 92 93 | 93 94 |
//! A set of iterator types for a [`LinkedList`]
95 |
96 | use std::{iter::FusedIterator, ptr::NonNull};
97 |
98 | use crate::{LinkedList, Node};
99 |
100 | impl<T> IntoIterator for LinkedList<T> {
101 | type IntoIter = IntoIter<T>;
102 | type Item = T;
103 | fn into_iter(self) -> Self::IntoIter {
104 | IntoIter(self)
105 | }
106 | }
107 |
108 | /// Owned iterator of a [`LinkedList`]
109 | pub struct IntoIter<T>(pub(crate) LinkedList<T>);
110 |
111 | impl<T> FusedIterator for IntoIter<T> {}
112 |
113 | impl<T> Iterator for IntoIter<T> {
114 | type Item = T;
115 |
116 | fn next(&mut self) -> Option<Self::Item> {
117 | self.0.pop_front()
118 | }
119 | }
120 |
121 | impl<'a, T> IntoIterator for &'a LinkedList<T> {
122 | type IntoIter = Iter<'a, T>;
123 | type Item = &'a T;
124 | fn into_iter(self) -> Self::IntoIter {
125 | Iter(&self.0)
126 | }
127 | }
128 |
129 | /// Borrowed iterator of a [`LinkedList`]
130 | #[derive(Clone)]
131 | pub struct Iter<'a, T>(pub(crate) &'a Option<NonNull<Node<T>>>);
132 |
133 | impl<'a, T> Iterator for Iter<'a, T> {
134 | type Item = &'a T;
135 |
136 | fn next(&mut self) -> Option<Self::Item> {
137 | self.0.map(|node| unsafe {
138 | let node = node.as_ref();
139 | self.0 = &node.next.0;
140 | &node.value
141 | })
142 | }
143 | }
144 |
145 | impl<'a, T> IntoIterator for &'a mut LinkedList<T> {
146 | type IntoIter = IterMut<'a, T>;
147 | type Item = &'a mut T;
148 | fn into_iter(self) -> Self::IntoIter {
149 | IterMut(&mut self.0)
150 | }
151 | }
152 |
153 | /// Mutable iterator of a [`LinkedList`]
154 | pub struct IterMut<'a, T>(pub(crate) &'a mut Option<NonNull<Node<T>>>);
155 |
156 | impl<'a, T> Iterator for IterMut<'a, T> {
157 | type Item = &'a mut T;
158 |
159 | fn next(&mut self) -> Option<Self::Item> {
160 | self.0.map(|mut node| unsafe {
161 | let node = node.as_mut();
162 | self.0 = &mut node.next.0;
163 | &mut node.value
164 | })
165 | }
166 | }
167 |
168 | #[cfg(test)]
169 | mod tests {
170 | use crate::LinkedList;
171 |
172 | #[test]
173 | fn iter() {
174 | let ll = LinkedList::from_iter([1, 2, 3]);
175 |
176 | assert_eq!(ll.iter().cloned().collect::<Vec<_>>(), vec![1, 2, 3]);
177 | }
178 |
179 | #[test]
180 | fn iter_mut() {
181 | let mut ll = LinkedList::from_iter([1, 2, 3]);
182 | ll.iter_mut().for_each(|i| *i *= 2);
183 |
184 | assert_eq!(ll.into_iter().collect::<Vec<_>>(), [2, 4, 6]);
185 | }
186 | }
187 |