Provides an iterator that allows for simple traversing over an dataSource's IndexPath's – including support for a header and footer per section.

1. IndexPathIterator.swift

public struct IndexPathIterator: IteratorProtocol {

    public let indexPaths: [IndexPath]
    private var index: Array<IndexPath>.Index

    /// Creates a new iterator for the specified indexPaths
    ///
    /// - Parameter indexPaths: The indexPaths to iterate over
    public init(indexPaths: Set<IndexPath>) {
        self.indexPaths = indexPaths.sorted()
        self.index = self.indexPaths.startIndex
    }

    /// Returns the next element. If there are no more elements, this returns nil.
    ///
    /// - Returns: Returns the next element. If the collection is empty, this returns nil
    public mutating func next() -> Array<IndexPath>.Element? {
        guard !indexPaths.isEmpty, index != indexPaths.endIndex else { return nil }

        let result = indexPaths[index]
        indexPaths.formIndex(after: &index)

        return result
    }

}

2. IndexPath+Kind.swift

public extension IndexPath {

    enum Kind: Int {
        case header
        case footer
        case item
    }

    struct KindMask: RawRepresentable, OptionSet {
        public let rawValue: Int

        public init(rawValue: Int) {
            self.rawValue = rawValue
        }

        public static let header = KindMask(rawValue: 1 << Kind.header.rawValue)
        public static let footer = KindMask(rawValue: 1 << Kind.footer.rawValue)
        public static let item = KindMask(rawValue: 1 << Kind.item.rawValue)

        public func contains(_ member: Kind) -> Bool {
            if member == .header && contains(KindMask.header) { return true }
            if member == .footer && contains(KindMask.footer) { return true }
            if member == .item && contains(KindMask.item) { return true }
            return false
        }
    }

    init(kind: Kind, item: Int, section: Int) {
        switch kind {
        case .header:
            self = [section, -1, 0]
        case .footer:
            self = [section, item, 1]
        case .item:
            self = IndexPath(item: item, section: section)
        }
    }

    var kind: Kind {
        guard count == 3 else { return .item }
        return self[2] == 0 ? .header : .footer
    }

    var section: Int {
        return self[0]
    }

    var item: Int {
        return self[1]
    }

}

3. IndexPath+Collection.swift

import Foundation

public extension Collection where Element == IndexPath {

    /// Returns indexPaths of the specified kinds, that are in the given section
    ///
    /// - Parameters:
    ///   - kinds: The kinds to match against
    ///   - section: The section to match against
    /// - Returns: An array of indexPaths, empty if no matches
    func filter(include kinds: IndexPath.KindMask, inSections sections: Int...) -> [SubSequence.Element] {
        return filter { sections.contains($0.section) && kinds.contains($0.kind) }
    }

    /// Returns indexPaths of the specified kinds, that are in the given section
    ///
    /// - Parameters:
    ///   - kinds: The kinds to match against
    ///   - section: The section to match against
    /// - Returns: An array of indexPaths, empty if no matches
    func filter(include kinds: IndexPath.KindMask, inSections sections: [Int]) -> [SubSequence.Element] {
        return filter { sections.contains($0.section) && kinds.contains($0.kind) }
    }

    /// Returns indexPaths of the specified kinds, that are in the specified sections
    ///
    /// - Parameters:
    ///   - kinds: The kinds to match against
    ///   - range: The range of sections to match against
    /// - Returns: An array of indexPaths, empty if no matches
    func filter(include kinds: IndexPath.KindMask, inSections range: Range<Int>) -> [SubSequence.Element] {
        return filter { range.contains($0.section) && kinds.contains($0.kind) }
    }

    /// Returns indexPaths of the specified kinds, that are in the specified sections
    ///
    /// - Parameters:
    ///   - kinds: The kinds to match against
    ///   - range: The range of sections to match against
    /// - Returns: An array of indexPaths, empty if no matches
    func filter(include kinds: IndexPath.KindMask, inSections range: ClosedRange<Int>) -> [SubSequence.Element] {
        return filter { range.contains($0.section) && kinds.contains($0.kind) }
    }

    /// Returns indexPaths of the specified kinds, in any section
    ///
    /// - Parameter kinds: The kinds to match against
    /// - Returns: an array of indexPaths, empty if no matches
    func filter(include kinds: IndexPath.KindMask) -> [SubSequence.Element] {
        return filter { kinds.contains($0.kind) }
    }

    /// Returns all header indexPaths only
    var headers: [SubSequence.Element] {
        return filter(include: .header)
    }

    /// Returns all footer indexPaths only
    var footers: [SubSequence.Element] {
        return filter(include: .footer)
    }

    /// Returns all item indexPaths only
    var items: [SubSequence.Element] {
        return filter(include: .item)
    }

}

4. IndexPath+Set.swift

public extension Set where Element == IndexPath {

    init(from view: UICollectionView) {
        var indexPaths: Set<IndexPath> = []

        for section in 0..<(view.dataSource?.numberOfSections?(in: view) ?? 0) {
            indexPaths.insert(IndexPath(kind: .header, item: -1, section: section))

            let itemCount = view.dataSource?.collectionView(view, numberOfItemsInSection: section) ?? 0
            for item in 0..<itemCount {
                indexPaths.insert(IndexPath(item: item, section: section))
            }

            indexPaths.insert(IndexPath(kind: .footer, item: itemCount, section: section))
        }

        self.init(indexPaths)
    }

    init(from view: UITableView) {
        var indexPaths: Set<IndexPath> = []

        for section in 0..<(view.dataSource?.numberOfSections?(in: view) ?? 0) {
            indexPaths.insert(IndexPath(kind: .header, item: -1, section: section))

            let itemCount = view.dataSource?.tableView(view, numberOfRowsInSection: section) ?? 0
            for item in 0..<itemCount {
                indexPaths.insert(IndexPath(item: item, section: section))
            }

            indexPaths.insert(IndexPath(kind: .footer, item: itemCount, section: section))
        }

        self.init(indexPaths)
    }

}

Example:

// provide an array of IndexPath's

let indexPaths: Set<IndexPath> = [
    IndexPath(kind: .header, item: -1, section: 0),
    IndexPath(item: 0, section: 0),
    IndexPath(item: 1, section: 0),
    IndexPath(item: 2, section: 0),
    IndexPath(item: 3, section: 0),
    IndexPath(kind: .footer, item: 4, section: 0),

    IndexPath(kind: .header, item: -1, section: 1),
    IndexPath(item: 0, section: 1),
    IndexPath(item: 1, section: 1),
    IndexPath(item: 2, section: 1),
    IndexPath(kind: .footer, item: 3, section: 1),
]

// Alternatively you can automatically fetch all indexPaths associated with a given collection or table view
let indexPaths = Set(from: tableView)

let paths = indexPaths
    .sorted()
    .filter(include: [.header, .item], inSections: 0...1)

var array = IndexPathIterator(indexPaths: Set(paths))
array.next() // [0, -1, 0]
array.next() // [0, 0]
array.next() // [0, 1]
array.next() // [0, 2]
array.next() // [0, 3]
array.next() // [1, -1, 0]
array.next() // [1, 0]
array.next() // [1, 1]
array.next() // [1, 2]
array.next() // nil