A simple queue in swift

Queue.swift

import Foundation

struct Queue<Element: Equatable>: IteratorProtocol {
    fileprivate var elements: [Element]!
    fileprivate var index = 0
    fileprivate var currentElement : Element?
    
    init(_ elements: [Element] = []) {
        self.elements = elements
    }

    public var count : Int {
        return self.elements.count
    }
    
    public var current: Element? {
        return self.currentElement
    }
    
    public var isFirst: Bool {
        return  self.index % self.count == 0
    }
    
    public var isLast: Bool {
        return self.index == self.count - 1
    }
    
    public var isEmpty: Bool {
        return self.elements.isEmpty
    }
    
    public var all : [Element] {
        return self.elements
    }
    
    public mutating func insertObject(at index: Int, item: Element) {
        self.elements[index] = item
    }
    
    public func indexFor(item: Element) -> Int {
        return self.elements.firstIndex(of: item)!
    }
    
    public func contains(item: Element) -> Bool {
        return self.elements.contains(item)
    }
    
    public mutating func removeAll() {
        self.elements.removeAll()
    }
    
    public mutating func rearrange(from: Int, to: Int) {
        self.elements.insert(self.elements.remove(at: from), at: to)
    }
    
    @discardableResult
    public mutating func remove(from: Int) -> Element? {
        return self.elements.remove(at: from)
    }
    
    public mutating func reset() {
        self.index = 0
    }
    
    public func peek() -> Element? {
        return self.elements.first
    }
    
    public mutating func next() -> Element? {
        defer {
            self.index += 1
        }
        return self.elements.count > self.index ? self.elements[index] : nil
    }
    
    public mutating func prev() -> Element? {
        guard self.index > 0 else {
            return nil
        }
        self.index -= 1
        return self.item(at: self.index)
    }
    
    public mutating func item(at index:Int) -> Element? {
        let item = self.elements[index]
        self.currentElement = item
        return item
    }
    
    public mutating func enqueue(new item: Element) {
        elements.append(item)
    }
    
    public mutating func dequeue() -> Element? {
        guard !elements.isEmpty else { return nil }
        return elements.removeFirst()
    }
    
    public func getElements() -> [Element] {
        return self.elements
    }
}

extension Queue: Sequence {
    func makeIterator() -> Queue {
        return Queue(self.elements)
    }
}