Allow custom views to consume ListSnapshot diffable data

Sources/DiffableDataSource.Target.swift

@@ -0,0 +1,211 @@
+//
+//  DiffableDataSource.Target.swift
+//  CoreStore
+//
+//  Copyright © 2018 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+
+// MARK: - DiffableDataSourc
+
+extension DiffableDataSource {
+
+    // MARK: - Target
+
+    /**
+     The `DiffableDataSource.Target` protocol allows custom views to consume `ListSnapshot` diffable data similar to how `DiffableDataSource.TableViewAdapter` and `DiffableDataSource.CollectionViewAdapter` reloads data for their corresponding views.
+     */
+    public typealias Target = DiffableDataSourceTarget
+}
+
+
+// MARK: - DiffableDataSource.Target
+
+/**
+ The `DiffableDataSource.Target` protocol allows custom views to consume `ListSnapshot` diffable data similar to how `DiffableDataSource.TableViewAdapter` and `DiffableDataSource.CollectionViewAdapter` reloads data for their corresponding views.
+ */
+public protocol DiffableDataSourceTarget {
+
+    // MARK: Public
+
+    /**
+     Whether `reloadData()` should be executed instead of `performBatchUpdates(updates:animated:)`.
+     */
+    var shouldSuspendBatchUpdates: Bool { get }
+
+    /**
+     Deletes one or more sections.
+     */
+    func deleteSections(at indices: IndexSet, animated: Bool)
+
+    /**
+     Inserts one or more sections
+     */
+    func insertSections(at indices: IndexSet, animated: Bool)
+
+    /**
+     Reloads the specified sections.
+     */
+    func reloadSections(at indices: IndexSet, animated: Bool)
+
+    /**
+     Moves a section to a new location.
+     */
+    func moveSection(at index: IndexSet.Element, to newIndex: IndexSet.Element, animated: Bool)
+
+    /**
+     Deletes the items specified by an array of index paths.
+     */
+    func deleteItems(at indexPaths: [IndexPath], animated: Bool)
+
+    /**
+     Inserts items at the locations identified by an array of index paths.
+     */
+    func insertItems(at indexPaths: [IndexPath], animated: Bool)
+
+    /**
+     Reloads the specified items.
+     */
+    func reloadItems(at indexPaths: [IndexPath], animated: Bool)
+
+    /**
+     Moves the item at a specified location to a destination location.
+     */
+    func moveItem(at indexPath: IndexPath, to newIndexPath: IndexPath, animated: Bool)
+
+    /**
+     Animates multiple insert, delete, reload, and move operations as a group.
+     */
+    func performBatchUpdates(updates: () -> Void, animated: Bool)
+
+    /**
+     Reloads all sections and items.
+     */
+    func reloadData()
+}
+
+extension DiffableDataSource.Target {
+
+    // MARK: Internal
+
+    internal func reload<C, O>(
+        using stagedChangeset: Internals.DiffableDataUIDispatcher<O>.StagedChangeset<C>,
+        animated: Bool,
+        interrupt: ((Internals.DiffableDataUIDispatcher<O>.Changeset<C>) -> Bool)? = nil,
+        setData: (C) -> Void
+    ) {
+
+        if self.shouldSuspendBatchUpdates, let data = stagedChangeset.last?.data {
+
+            setData(data)
+            self.reloadData()
+            return
+        }
+        for changeset in stagedChangeset {
+
+            if let interrupt = interrupt,
+                interrupt(changeset),
+                let data = stagedChangeset.last?.data {
+
+                setData(data)
+                self.reloadData()
+                return
+            }
+            self.performBatchUpdates(
+                updates: {
+
+                    setData(changeset.data)
+
+                    if !changeset.sectionDeleted.isEmpty {
+
+                        self.deleteSections(
+                            at: IndexSet(changeset.sectionDeleted),
+                            animated: animated
+                        )
+                    }
+                    if !changeset.sectionInserted.isEmpty {
+
+                        self.insertSections(
+                            at: IndexSet(changeset.sectionInserted),
+                            animated: animated
+                        )
+                    }
+                    if !changeset.sectionUpdated.isEmpty {
+
+                        self.reloadSections(
+                            at: IndexSet(changeset.sectionUpdated),
+                            animated: animated
+                        )
+                    }
+                    for (source, target) in changeset.sectionMoved {
+
+                        self.moveSection(
+                            at: source,
+                            to: target,
+                            animated: animated
+                        )
+                    }
+                    if !changeset.elementDeleted.isEmpty {
+
+                        self.deleteItems(
+                            at: changeset.elementDeleted.map {
+
+                                IndexPath(item: $0.element, section: $0.section)
+                            },
+                            animated: animated
+                        )
+                    }
+                    if !changeset.elementInserted.isEmpty {
+
+                        self.insertItems(
+                            at: changeset.elementInserted.map {
+
+                                IndexPath(item: $0.element, section: $0.section)
+                            },
+                            animated: animated
+                        )
+                    }
+                    if !changeset.elementUpdated.isEmpty {
+
+                        self.reloadItems(
+                            at: changeset.elementUpdated.map {
+
+                                IndexPath(item: $0.element, section: $0.section)
+                            },
+                            animated: animated
+                        )
+                    }
+                    for (source, target) in changeset.elementMoved {
+
+                        self.moveItem(
+                            at: IndexPath(item: source.element, section: source.section),
+                            to: IndexPath(item: target.element, section: target.section),
+                            animated: animated
+                        )
+                    }
+                },
+                animated: animated
+            )
+        }
+    }
+}