@@ -23,11 +23,10 @@ public struct Queue<T>: SequenceType {
23
23
initialCapacity = capacity
24
24
25
25
version = 0
26
- storage = [ ]
27
26
_count = 0
28
27
pushNextIndex = 0
29
-
30
- resizeTo ( capacity)
28
+
29
+ storage = [ T ? ] ( count : capacity, repeatedValue : nil )
31
30
}
32
31
33
32
private var dequeueIndex : Int {
@@ -56,19 +55,20 @@ public struct Queue<T>: SequenceType {
56
55
}
57
56
58
57
mutating private func resizeTo( size: Int ) {
59
- var newStorage : [ T ? ] = [ ]
60
- newStorage. reserveCapacity ( size)
58
+ var newStorage = [ T? ] ( count: size, repeatedValue: nil )
61
59
62
60
var count = _count
63
61
64
- for var i = 0 ; i < count; ++ i {
65
- // does swift array have some more efficient methods of copying?
66
- newStorage. append ( dequeue ( ) )
67
- }
62
+ let dequeueIndex = self . dequeueIndex
63
+ let spaceToEndOfQueue = self . storage. count - dequeueIndex
68
64
69
- while newStorage. count < size {
70
- newStorage. append ( nil )
71
- }
65
+ // first batch is from dequeue index to end of array
66
+ let countElementsInFirstBatch = min ( count, spaceToEndOfQueue)
67
+ // second batch is wrapped from start of array to end of queue
68
+ let numberOfElementsInSecondBatch = count - countElementsInFirstBatch
69
+
70
+ newStorage [ 0 ..< countElementsInFirstBatch] = self . storage [ dequeueIndex ..< ( dequeueIndex + countElementsInFirstBatch) ]
71
+ newStorage [ countElementsInFirstBatch ..< ( countElementsInFirstBatch + numberOfElementsInSecondBatch) ] = self . storage [ 0 ..< numberOfElementsInSecondBatch]
72
72
73
73
_count = count
74
74
pushNextIndex = count
@@ -92,18 +92,24 @@ public struct Queue<T>: SequenceType {
92
92
}
93
93
}
94
94
95
- public mutating func dequeue ( ) -> T {
95
+ private mutating func dequeueElementOnly ( ) -> T {
96
96
version++
97
97
98
98
contract ( count > 0 )
99
-
99
+
100
100
let index = dequeueIndex
101
101
let value = storage [ index] !
102
102
103
103
storage [ index] = nil
104
104
105
105
_count = _count - 1
106
106
107
+ return value
108
+ }
109
+
110
+ public mutating func dequeue( ) -> T {
111
+ let value = dequeueElementOnly ( )
112
+
107
113
let downsizeLimit = storage. count / ( resizeFactor * resizeFactor)
108
114
if _count < downsizeLimit && downsizeLimit >= initialCapacity {
109
115
resizeTo ( storage. count / resizeFactor)
0 commit comments