mirror of
https://github.com/JohnEstropia/CoreStore.git
synced 2026-01-16 14:06:53 +01:00
667 lines
24 KiB
Swift
667 lines
24 KiB
Swift
//
|
|
// ListSnapshot.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 CoreData
|
|
|
|
#if canImport(UIKit)
|
|
import UIKit
|
|
|
|
#elseif canImport(AppKit)
|
|
import AppKit
|
|
|
|
#endif
|
|
|
|
|
|
// MARK: - ListSnapshot
|
|
|
|
/**
|
|
A `ListSnapshot` holds a stable list of `DynamicObject` identifiers. This is typically created by a `ListPublisher` and are designed to work well with `DiffableDataSource.TableView`s and `DiffableDataSource.CollectionView`s. For detailed examples, see the documentation on `DiffableDataSource.TableView` and `DiffableDataSource.CollectionView`.
|
|
|
|
While the `ListSnapshot` stores only object identifiers, all accessors to its items return `ObjectPublisher`s, which are lazily created. For more details, see the documentation on `ListObject`.
|
|
|
|
Since `ListSnapshot` is a value type, you can freely modify its items.
|
|
*/
|
|
public struct ListSnapshot<O: DynamicObject>: RandomAccessCollection, Hashable {
|
|
|
|
// MARK: Public (Accessors)
|
|
|
|
/**
|
|
The `DynamicObject` type associated with this list
|
|
*/
|
|
public typealias ObjectType = O
|
|
|
|
/**
|
|
The type for the section IDs
|
|
*/
|
|
public typealias SectionID = String
|
|
|
|
/**
|
|
The type for the item IDs
|
|
*/
|
|
public typealias ItemID = O.ObjectID
|
|
|
|
/**
|
|
Returns the object at the given index.
|
|
|
|
- parameter index: the index of the object. Using an index above the valid range will raise an exception.
|
|
- returns: the `ObjectPublisher<O>` interfacing the object at the specified index
|
|
*/
|
|
public subscript(index: Index) -> ObjectPublisher<O> {
|
|
|
|
let context = self.context!
|
|
let itemID = self.diffableSnapshot.itemIdentifiers[index]
|
|
return context.objectPublisher(objectID: itemID)
|
|
}
|
|
|
|
/**
|
|
Returns the object at the given index, or `nil` if out of bounds.
|
|
|
|
- parameter index: the index for the object. Using an index above the valid range will return `nil`.
|
|
- returns: the `ObjectPublisher<O>` interfacing the object at the specified index, or `nil` if out of bounds
|
|
*/
|
|
public subscript(safeIndex index: Index) -> ObjectPublisher<O>? {
|
|
|
|
let context = self.context!
|
|
let itemIDs = self.diffableSnapshot.itemIdentifiers
|
|
guard itemIDs.indices.contains(index) else {
|
|
|
|
return nil
|
|
}
|
|
let itemID = itemIDs[index]
|
|
return context.objectPublisher(objectID: itemID)
|
|
}
|
|
|
|
/**
|
|
Returns the object at the given `sectionIndex` and `itemIndex`.
|
|
|
|
- parameter sectionIndex: the section index for the object. Using a `sectionIndex` with an invalid range will raise an exception.
|
|
- parameter itemIndex: the index for the object within the section. Using an `itemIndex` with an invalid range will raise an exception.
|
|
- returns: the `ObjectPublisher<O>` interfacing the object at the specified section and item index
|
|
*/
|
|
public subscript(sectionIndex: Int, itemIndex: Int) -> ObjectPublisher<O> {
|
|
|
|
let context = self.context!
|
|
let snapshot = self.diffableSnapshot
|
|
let sectionID = snapshot.sectionIdentifiers[sectionIndex]
|
|
let itemID = snapshot.itemIdentifiers(inSection: sectionID)[itemIndex]
|
|
return context.objectPublisher(objectID: itemID)
|
|
}
|
|
|
|
/**
|
|
Returns the object at the given section and item index, or `nil` if out of bounds.
|
|
|
|
- parameter sectionIndex: the section index for the object. Using a `sectionIndex` with an invalid range will return `nil`.
|
|
- parameter itemIndex: the index for the object within the section. Using an `itemIndex` with an invalid range will return `nil`.
|
|
- returns: the `ObjectPublisher<O>` interfacing the object at the specified section and item index, or `nil` if out of bounds
|
|
*/
|
|
public subscript(safeSectionIndex sectionIndex: Int, safeItemIndex itemIndex: Int) -> ObjectPublisher<O>? {
|
|
|
|
let context = self.context!
|
|
let snapshot = self.diffableSnapshot
|
|
let sectionIDs = snapshot.sectionIdentifiers
|
|
guard sectionIDs.indices.contains(sectionIndex) else {
|
|
|
|
return nil
|
|
}
|
|
let sectionID = sectionIDs[sectionIndex]
|
|
let itemIDs = snapshot.itemIdentifiers(inSection: sectionID)
|
|
guard itemIDs.indices.contains(itemIndex) else {
|
|
|
|
return nil
|
|
}
|
|
let itemID = itemIDs[itemIndex]
|
|
return context.objectPublisher(objectID: itemID)
|
|
}
|
|
|
|
/**
|
|
Returns the object at the given `IndexPath`.
|
|
|
|
- parameter indexPath: the `IndexPath` for the object. Using an `indexPath` with an invalid range will raise an exception.
|
|
- returns: the `ObjectPublisher<O>` interfacing the object at the specified index path
|
|
*/
|
|
public subscript(indexPath: IndexPath) -> ObjectPublisher<O> {
|
|
|
|
return self[indexPath[0], indexPath[1]]
|
|
}
|
|
|
|
/**
|
|
Returns the object at the given `IndexPath`, or `nil` if out of bounds.
|
|
|
|
- parameter indexPath: the `IndexPath` for the object. Using an `indexPath` with an invalid range will return `nil`.
|
|
- returns: the `ObjectPublisher<O>` interfacing the object at the specified index path, or `nil` if out of bounds
|
|
*/
|
|
public subscript(safeIndexPath indexPath: IndexPath) -> ObjectPublisher<O>? {
|
|
|
|
return self[
|
|
safeSectionIndex: indexPath[0],
|
|
safeItemIndex: indexPath[1]
|
|
]
|
|
}
|
|
|
|
/**
|
|
Checks if the `ListSnapshot` has at least one section
|
|
|
|
- returns: `true` if at least one section exists, `false` otherwise
|
|
*/
|
|
public func hasSections() -> Bool {
|
|
|
|
return self.diffableSnapshot.numberOfSections > 0
|
|
}
|
|
|
|
/**
|
|
Checks if the `ListSnapshot` has at least one object in any section.
|
|
|
|
- returns: `true` if at least one object in any section exists, `false` otherwise
|
|
*/
|
|
public func hasItems() -> Bool {
|
|
|
|
return self.diffableSnapshot.numberOfItems > 0
|
|
}
|
|
|
|
/**
|
|
Checks if the `ListSnapshot` has at least one object in the specified section.
|
|
|
|
- parameter sectionIndex: the section index. Using an index outside the valid range will return `false`.
|
|
- returns: `true` if at least one object in the specified section exists, `false` otherwise
|
|
*/
|
|
public func hasItems(inSectionIndex sectionIndex: Int) -> Bool {
|
|
|
|
let snapshot = self.diffableSnapshot
|
|
let sectionIDs = snapshot.sectionIdentifiers
|
|
guard sectionIDs.indices.contains(sectionIndex) else {
|
|
|
|
return false
|
|
}
|
|
let sectionID = sectionIDs[sectionIndex]
|
|
return snapshot.numberOfItems(inSection: sectionID) > 0
|
|
}
|
|
|
|
/**
|
|
Checks if the `ListSnapshot` has at least one object the specified section.
|
|
|
|
- parameter sectionID: the section identifier. Using an index outside the valid range will return `false`.
|
|
- returns: `true` if at least one object in the specified section exists, `false` otherwise
|
|
*/
|
|
public func hasItems(inSectionWithID sectionID: SectionID) -> Bool {
|
|
|
|
let snapshot = self.diffableSnapshot
|
|
guard snapshot.sectionIdentifiers.contains(sectionID) else {
|
|
|
|
return false
|
|
}
|
|
return snapshot.numberOfItems(inSection: sectionID) > 0
|
|
}
|
|
|
|
/**
|
|
The number of items in all sections in the `ListSnapshot`
|
|
*/
|
|
public var numberOfItems: Int {
|
|
|
|
return self.diffableSnapshot.numberOfItems
|
|
}
|
|
|
|
/**
|
|
The number of sections in the `ListSnapshot`
|
|
*/
|
|
public var numberOfSections: Int {
|
|
|
|
return self.diffableSnapshot.numberOfSections
|
|
}
|
|
|
|
/**
|
|
Returns the number of items for the specified `SectionID`.
|
|
|
|
- parameter sectionID: the `SectionID`. Specifying an invalid value will raise an exception.
|
|
- returns: The number of items in the given `SectionID`
|
|
*/
|
|
public func numberOfItems(inSectionWithID sectionID: SectionID) -> Int {
|
|
|
|
return self.diffableSnapshot.numberOfItems(inSection: sectionID)
|
|
}
|
|
|
|
/**
|
|
Returns the number of items at the specified section index.
|
|
|
|
- parameter sectionIndex: the index of the section. Specifying an invalid value will raise an exception.
|
|
- returns: The number of items in the given `SectionID`
|
|
*/
|
|
public func numberOfItems(inSectionIndex sectionIndex: Int) -> Int {
|
|
|
|
let snapshot = self.diffableSnapshot
|
|
let sectionID = snapshot.sectionIdentifiers[sectionIndex]
|
|
return snapshot.numberOfItems(inSection: sectionID)
|
|
}
|
|
|
|
/**
|
|
All section identifiers in the `ListSnapshot`
|
|
*/
|
|
public var sectionIDs: [SectionID] {
|
|
|
|
return self.diffableSnapshot.sectionIdentifiers
|
|
}
|
|
|
|
/**
|
|
Returns the `SectionID` that the specified `ItemID` belongs to, or `nil` if it is not in the list.
|
|
|
|
- parameter itemID: the `ItemID`
|
|
- returns: the `SectionID` that the specified `ItemID` belongs to, or `nil` if it is not in the list
|
|
*/
|
|
public func sectionID(containingItemWithID itemID: ItemID) -> SectionID? {
|
|
|
|
return self.diffableSnapshot.sectionIdentifier(containingItem: itemID)
|
|
}
|
|
|
|
/**
|
|
All object identifiers in the `ListSnapshot`
|
|
*/
|
|
public var itemIDs: [ItemID] {
|
|
|
|
return self.diffableSnapshot.itemIdentifiers
|
|
}
|
|
|
|
/**
|
|
Returns the item identifiers belonging to the specified `SectionID`.
|
|
|
|
- parameter sectionID: the `SectionID`. Specifying an invalid value will raise an exception.
|
|
- returns: the `ItemID` array belonging to the given `SectionID`
|
|
*/
|
|
public func itemIDs(inSectionWithID sectionID: SectionID) -> [ItemID] {
|
|
|
|
return self.diffableSnapshot.itemIdentifiers(inSection: sectionID)
|
|
}
|
|
|
|
/**
|
|
Returns the item identifiers belonging to the specified `SectionID` and a `Sequence` of item indices.
|
|
|
|
- parameter sectionID: the `SectionID`. Specifying an invalid value will raise an exception.
|
|
- parameter indices: the positions of the itemIDs to return. Specifying an invalid value will raise an exception.
|
|
- returns: the `ItemID` array belonging to the given `SectionID` at the specified indices
|
|
*/
|
|
public func itemIDs<S: Sequence>(inSectionWithID sectionID: SectionID, atIndices indices: S) -> [ItemID] where S.Element == Int {
|
|
|
|
let itemIDs = self.diffableSnapshot.itemIdentifiers(inSection: sectionID)
|
|
return indices.map({ itemIDs[$0] })
|
|
}
|
|
|
|
/**
|
|
Returns the index of the specified `ItemID` in the whole list, or `nil` if it is not in the list.
|
|
|
|
- parameter itemID: the `ItemID`
|
|
- returns: the index of the specified `ItemID`, or `nil` if it is not in the list
|
|
*/
|
|
public func indexOfItem(withID itemID: ItemID) -> Index? {
|
|
|
|
return self.diffableSnapshot.indexOfItem(itemID)
|
|
}
|
|
|
|
/**
|
|
Returns the index of the specified `SectionID`, or `nil` if it is not in the list.
|
|
|
|
- parameter sectionID: the `SectionID`
|
|
- returns: the index of the specified `SectionID`, or `nil` if it is not in the list
|
|
*/
|
|
public func indexOfSection(withID sectionID: SectionID) -> Int? {
|
|
|
|
return self.diffableSnapshot.indexOfSection(sectionID)
|
|
}
|
|
|
|
/**
|
|
Returns an array of `ObjectPublisher`s for the items at the specified indices
|
|
|
|
- parameter indices: the positions of items. Specifying an invalid value will raise an exception.
|
|
- returns: an array of `ObjectPublisher`s for the items at the specified indices
|
|
*/
|
|
public func items<S: Sequence>(atIndices indices: S) -> [ObjectPublisher<O>] where S.Element == Index {
|
|
|
|
let context = self.context!
|
|
let itemIDs = self.diffableSnapshot.itemIdentifiers
|
|
return indices.map { position in
|
|
|
|
let itemID = itemIDs[position]
|
|
return ObjectPublisher<O>(objectID: itemID, context: context)
|
|
}
|
|
}
|
|
|
|
/**
|
|
Returns an array of `ObjectPublisher`s for the items in the specified `SectionID`
|
|
|
|
- parameter sectionID: the `SectionID`. Specifying an invalid value will raise an exception.
|
|
- returns: an array of `ObjectPublisher`s for the items in the specified `SectionID`
|
|
*/
|
|
public func items(inSectionWithID sectionID: SectionID) -> [ObjectPublisher<O>] {
|
|
|
|
let context = self.context!
|
|
let itemIDs = self.diffableSnapshot.itemIdentifiers(inSection: sectionID)
|
|
return itemIDs.map {
|
|
|
|
return ObjectPublisher<O>(objectID: $0, context: context)
|
|
}
|
|
}
|
|
|
|
/**
|
|
Returns an array of `ObjectPublisher`s for the items in the specified `SectionID` and indices
|
|
|
|
- parameter sectionID: the `SectionID`. Specifying an invalid value will raise an exception.
|
|
- parameter itemIndices: the positions of items within the section. Specifying an invalid value will raise an exception.
|
|
- returns: an array of `ObjectPublisher`s for the items in the specified `SectionID` and indices
|
|
*/
|
|
public func items<S: Sequence>(inSectionWithID sectionID: SectionID, atIndices itemIndices: S) -> [ObjectPublisher<O>] where S.Element == Int {
|
|
|
|
let context = self.context!
|
|
let itemIDs = self.diffableSnapshot.itemIdentifiers(inSection: sectionID)
|
|
return itemIndices.map { position in
|
|
|
|
let itemID = itemIDs[position]
|
|
return ObjectPublisher<O>(objectID: itemID, context: context)
|
|
}
|
|
}
|
|
|
|
/**
|
|
Returns a lazy sequence of `ObjectPublisher`s for the items at the specified indices
|
|
|
|
- parameter indices: the positions of items. Specifying an invalid value will raise an exception.
|
|
- returns: a lazy sequence of `ObjectPublisher`s for the items at the specified indices
|
|
*/
|
|
public func lazy<S: Sequence>(atIndices indices: S) -> LazyMapSequence<S, ObjectPublisher<O>> where S.Element == Index {
|
|
|
|
let context = self.context!
|
|
let itemIDs = self.diffableSnapshot.itemIdentifiers
|
|
return indices.lazy.map { position in
|
|
|
|
let itemID = itemIDs[position]
|
|
return ObjectPublisher<O>(objectID: itemID, context: context)
|
|
}
|
|
}
|
|
|
|
/**
|
|
Returns a lazy sequence of `ObjectPublisher`s for the items in the specified `SectionID`
|
|
|
|
- parameter sectionID: the `SectionID`. Specifying an invalid value will raise an exception.
|
|
- returns: a lazy sequence of `ObjectPublisher`s for the items in the specified `SectionID`
|
|
*/
|
|
public func lazy(inSectionWithID sectionID: SectionID) -> LazyMapSequence<[NSManagedObjectID], ObjectPublisher<O>> {
|
|
|
|
let context = self.context!
|
|
let itemIDs = self.diffableSnapshot.itemIdentifiers(inSection: sectionID)
|
|
return itemIDs.lazy.map {
|
|
|
|
return ObjectPublisher<O>(objectID: $0, context: context)
|
|
}
|
|
}
|
|
|
|
/**
|
|
Returns a lazy sequence of `ObjectPublisher`s for the items in the specified `SectionID` and indices
|
|
|
|
- parameter sectionID: the `SectionID`. Specifying an invalid value will raise an exception.
|
|
- parameter itemIndices: the positions of items within the section. Specifying an invalid value will raise an exception.
|
|
- returns: a lazy sequence of `ObjectPublisher`s for the items in the specified `SectionID` and indices
|
|
*/
|
|
public func lazy<S: Sequence>(inSectionWithID sectionID: SectionID, atIndices itemIndices: S) -> LazyMapSequence<S, ObjectPublisher<O>> where S.Element == Int {
|
|
|
|
let context = self.context!
|
|
let itemIDs = self.diffableSnapshot.itemIdentifiers(inSection: sectionID)
|
|
return itemIndices.lazy.map { position in
|
|
|
|
let itemID = itemIDs[position]
|
|
return ObjectPublisher<O>(objectID: itemID, context: context)
|
|
}
|
|
}
|
|
|
|
|
|
// MARK: Public (Mutators)
|
|
|
|
/**
|
|
Appends extra items to the specified section
|
|
|
|
- parameter itemIDs: the object identifiers for the objects to append
|
|
- parameter sectionID: the section to append the items to
|
|
*/
|
|
public mutating func appendItems(withIDs itemIDs: [ItemID], toSectionWithID sectionID: SectionID? = nil) {
|
|
|
|
self.diffableSnapshot.appendItems(itemIDs, toSection: sectionID)
|
|
}
|
|
|
|
/**
|
|
Inserts extra items before a specified item
|
|
|
|
- parameter itemIDs: the object identifiers for the objects to insert
|
|
- parameter beforeItemID: an existing identifier to insert items before of. Specifying an invalid value will raise an exception.
|
|
*/
|
|
public mutating func insertItems(withIDs itemIDs: [ItemID], beforeItemID: ItemID) {
|
|
|
|
self.diffableSnapshot.insertItems(itemIDs, beforeItem: beforeItemID)
|
|
}
|
|
|
|
/**
|
|
Inserts extra items after a specified item
|
|
|
|
- parameter itemIDs: the object identifiers for the objects to insert
|
|
- parameter beforeItemID: an existing identifier to insert items after of. Specifying an invalid value will raise an exception.
|
|
*/
|
|
public mutating func insertItems(withIDs itemIDs: [ItemID], afterItemID: ItemID) {
|
|
|
|
self.diffableSnapshot.insertItems(itemIDs, afterItem: afterItemID)
|
|
}
|
|
|
|
/**
|
|
Deletes the specified items
|
|
|
|
- parameter itemIDs: the object identifiers for the objects to delete
|
|
*/
|
|
public mutating func deleteItems(withIDs itemIDs: [ItemID]) {
|
|
|
|
self.diffableSnapshot.deleteItems(itemIDs)
|
|
}
|
|
|
|
/**
|
|
Deletes all items
|
|
*/
|
|
public mutating func deleteAllItems() {
|
|
|
|
self.diffableSnapshot.deleteAllItems()
|
|
}
|
|
|
|
/**
|
|
Moves an item before another specified item
|
|
|
|
- parameter itemID: an object identifier in the list to move. Specifying an invalid value will raise an exception.
|
|
- parameter beforeItemID: another identifier to move the item before of. Specifying an invalid value will raise an exception.
|
|
*/
|
|
public mutating func moveItem(withID itemID: ItemID, beforeItemID: ItemID) {
|
|
|
|
self.diffableSnapshot.moveItem(itemID, beforeItem: beforeItemID)
|
|
}
|
|
|
|
/**
|
|
Moves an item after another specified item
|
|
|
|
- parameter itemID: an object identifier in the list to move. Specifying an invalid value will raise an exception.
|
|
- parameter beforeItemID: another identifier to move the item after of. Specifying an invalid value will raise an exception.
|
|
*/
|
|
public mutating func moveItem(withID itemID: ItemID, afterItemID: ItemID) {
|
|
|
|
self.diffableSnapshot.moveItem(itemID, afterItem: afterItemID)
|
|
}
|
|
|
|
/**
|
|
Marks the specified items as reloaded
|
|
|
|
- parameter itemIDs: the object identifiers to reload
|
|
*/
|
|
public mutating func reloadItems(withIDs itemIDs: [ItemID]) {
|
|
|
|
self.diffableSnapshot.reloadItems(itemIDs)
|
|
}
|
|
|
|
/**
|
|
Appends new section identifiers to the end of the list
|
|
|
|
- parameter sectionIDs: the sections to append
|
|
*/
|
|
public mutating func appendSections(withIDs sectionIDs: [SectionID]) {
|
|
|
|
self.diffableSnapshot.appendSections(sectionIDs)
|
|
}
|
|
|
|
/**
|
|
Inserts new sections before an existing section
|
|
|
|
- parameter sectionIDs: the section identifiers for the sections to insert
|
|
- parameter beforeSectionID: an existing identifier to insert items before of. Specifying an invalid value will raise an exception.
|
|
*/
|
|
public mutating func insertSections(withIDs sectionIDs: [SectionID], beforeSectionID: SectionID) {
|
|
|
|
self.diffableSnapshot.insertSections(sectionIDs, beforeSection: beforeSectionID)
|
|
}
|
|
|
|
/**
|
|
Inserts new sections after an existing section
|
|
|
|
- parameter sectionIDs: the section identifiers for the sections to insert
|
|
- parameter beforeSectionID: an existing identifier to insert items after of. Specifying an invalid value will raise an exception.
|
|
*/
|
|
public mutating func insertSections(withIDs sectionIDs: [SectionID], afterSectionID: SectionID) {
|
|
|
|
self.diffableSnapshot.insertSections(sectionIDs, afterSection: afterSectionID)
|
|
}
|
|
|
|
/**
|
|
Deletes the specified sections
|
|
|
|
- parameter sectionIDs: the section identifiers for the sections to delete
|
|
*/
|
|
public mutating func deleteSections(withIDs sectionIDs: [SectionID]) {
|
|
|
|
self.diffableSnapshot.deleteSections(sectionIDs)
|
|
}
|
|
|
|
/**
|
|
Moves a section before another specified section
|
|
|
|
- parameter sectionID: a section identifier in the list to move. Specifying an invalid value will raise an exception.
|
|
- parameter beforeSectionID: another identifier to move the section before of. Specifying an invalid value will raise an exception.
|
|
*/
|
|
public mutating func moveSection(withID sectionID: SectionID, beforeSectionID: SectionID) {
|
|
|
|
self.diffableSnapshot.moveSection(sectionID, beforeSection: beforeSectionID)
|
|
}
|
|
|
|
/**
|
|
Moves a section after another specified section
|
|
|
|
- parameter sectionID: a section identifier in the list to move. Specifying an invalid value will raise an exception.
|
|
- parameter afterSectionID: another identifier to move the section after of. Specifying an invalid value will raise an exception.
|
|
*/
|
|
public mutating func moveSection(withID sectionID: SectionID, afterSectionID: SectionID) {
|
|
|
|
self.diffableSnapshot.moveSection(sectionID, afterSection: afterSectionID)
|
|
}
|
|
|
|
/**
|
|
Marks the specified sections as reloaded
|
|
|
|
- parameter sectionIDs: the section identifiers to reload
|
|
*/
|
|
public mutating func reloadSections(withIDs sectionIDs: [SectionID]) {
|
|
|
|
self.diffableSnapshot.reloadSections(sectionIDs)
|
|
}
|
|
|
|
|
|
|
|
// MARK: RandomAccessCollection
|
|
|
|
public var startIndex: Index {
|
|
|
|
return self.diffableSnapshot.itemIdentifiers.startIndex
|
|
}
|
|
|
|
public var endIndex: Index {
|
|
|
|
return self.diffableSnapshot.itemIdentifiers.endIndex
|
|
}
|
|
|
|
|
|
// MARK: Sequence
|
|
|
|
public typealias Element = ObjectPublisher<O>
|
|
|
|
public typealias Index = Int
|
|
|
|
|
|
// MARK: Equatable
|
|
|
|
public static func == (_ lhs: Self, _ rhs: Self) -> Bool {
|
|
|
|
return lhs.id == rhs.id
|
|
}
|
|
|
|
|
|
// MARK: Hashable
|
|
|
|
public func hash(into hasher: inout Hasher) {
|
|
|
|
hasher.combine(self.id)
|
|
}
|
|
|
|
|
|
// MARK: Internal
|
|
|
|
internal private(set) var diffableSnapshot: DiffableDataSourceSnapshotProtocol
|
|
|
|
internal init() {
|
|
|
|
// if #available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) {
|
|
//
|
|
// self.diffableSnapshot = NSDiffableDataSourceSnapshot<String, NSManagedObjectID>()
|
|
// }
|
|
// else {
|
|
|
|
self.diffableSnapshot = Internals.DiffableDataSourceSnapshot()
|
|
// }
|
|
self.context = nil
|
|
}
|
|
|
|
// @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
|
|
// internal init(diffableSnapshot: NSDiffableDataSourceSnapshot<String, NSManagedObjectID>, context: NSManagedObjectContext) {
|
|
//
|
|
// self.diffableSnapshot = diffableSnapshot
|
|
// self.context = context
|
|
// }
|
|
|
|
internal init(diffableSnapshot: Internals.DiffableDataSourceSnapshot, context: NSManagedObjectContext) {
|
|
|
|
self.diffableSnapshot = diffableSnapshot
|
|
self.context = context
|
|
}
|
|
|
|
|
|
// MARK: Private
|
|
|
|
private let id: UUID = .init()
|
|
private let context: NSManagedObjectContext?
|
|
|
|
}
|