Added array private extension to wrap indexes, added Sequence conformance, simplified read and write implementations, nilling out value when reading.

Author: alessandro-martin

Ring Buffer/RingBuffer.playground/Contents.swift

@@ -9,24 +9,20 @@ public struct RingBuffer<T> {
     array = [T?](repeating: nil, count: count)
   }
 
+  /* Returns false if out of space. */
+  @discardableResult
   public mutating func write(_ element: T) -> Bool {
-    if !isFull {
-      array[writeIndex % array.count] = element
-      writeIndex += 1
-      return true
-    } else {
-      return false
-    }
+    guard !isFull else { return false }
+    defer { writeIndex += 1 }
+    array[wrapped: writeIndex] = element
+    return true
   }
-
+    
+  /* Returns nil if the buffer is empty. */
   public mutating func read() -> T? {
-    if !isEmpty {
-      let element = array[readIndex % array.count]
-      readIndex += 1
-      return element
-    } else {
-      return nil
-    }
+    guard !isEmpty else { return nil }
+    defer { array[wrapped: readIndex] = nil ; readIndex += 1 }
+    return array[wrapped: readIndex]
   }
 
   fileprivate var availableSpaceForReading: Int {
@@ -46,6 +42,28 @@ public struct RingBuffer<T> {
   }
 }
 
+extension RingBuffer: Sequence {
+  public func makeIterator() -> AnyIterator<T> {
+    var index = readIndex
+    return AnyIterator {
+      guard index < self.writeIndex else { return nil }
+      defer { index += 1 }
+      return self.array[wrapped: index]
+    }
+  }
+}
+
+private extension Array {
+  subscript (wrapped index: Int) -> Element {
+    get {
+      return self[index % count]
+    }
+    set {
+      self[index % count] = newValue
+    }
+  }
+}
+
 var buffer = RingBuffer<Int>(count: 5)
 buffer.array          // [nil, nil, nil, nil, nil]
 buffer.readIndex      // 0

Ring Buffer/RingBuffer.swift

@@ -16,29 +16,23 @@ public struct RingBuffer<T> {
   private var writeIndex = 0
 
   public init(count: Int) {
-    array = [T?](count: count, repeatedValue: nil)
+    array = [T?](repeating: nil, count: count)
   }
 
   /* Returns false if out of space. */
-  public mutating func write(element: T) -> Bool {
-    if !isFull {
-      array[writeIndex % array.count] = element
-      writeIndex += 1
-      return true
-    } else {
-      return false
-    }
+  @discardableResult
+  public mutating func write(_ element: T) -> Bool {
+    guard !isFull else { return false }
+    defer { writeIndex += 1 }
+    array[wrapped: writeIndex] = element
+    return true
   }
 
   /* Returns nil if the buffer is empty. */
   public mutating func read() -> T? {
-    if !isEmpty {
-      let element = array[readIndex % array.count]
-      readIndex += 1
-      return element
-    } else {
-      return nil
-    }
+    guard !isEmpty else { return nil }
+    defer { array[wrapped: readIndex] = nil ; readIndex += 1 }
+    return array[wrapped: readIndex]
   }
 
   private var availableSpaceForReading: Int {
@@ -57,3 +51,25 @@ public struct RingBuffer<T> {
     return availableSpaceForWriting == 0
   }
 }
+
+public extension RingBuffer: Sequence {
+  public func makeIterator() -> AnyIterator<T> {
+    var index = readIndex
+    return AnyIterator {
+        guard index < self.writeIndex else { return nil }
+        defer { index += 1 }
+        return self.array[wrapped: index]
+    }
+  }
+}
+
+private extension Array {
+  subscript (wrapped index: Int) -> Element {
+    get {
+      return self[index % count]
+    }
+    set {
+      self[index % count] = newValue
+    }
+  }
+}