-
Notifications
You must be signed in to change notification settings - Fork 76
/
IndexChangeset.swift
187 lines (150 loc) · 6.6 KB
/
IndexChangeset.swift
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
// Created by Laura Skelton on 11/25/16.
// Copyright © 2016 Airbnb. All rights reserved.
import Foundation
// MARK: - IndexChangeset
/// A set of inserts, deletes, updates, and moves that define the changes between two collections.
public struct IndexChangeset {
// MARK: Lifecycle
public init(
inserts: [Int] = [],
deletes: [Int] = [],
updates: [(old: Int, new: Int)] = [],
moves: [(old: Int, new: Int)] = [],
newIndices: [Int?] = [],
duplicates: [[Int]] = [])
{
self.inserts = inserts
self.deletes = deletes
self.updates = updates
self.moves = moves
self.newIndices = newIndices
self.duplicates = duplicates
}
// MARK: Public
/// The inserted indices needed to get from the old collection to the new collection.
public var inserts: [Int]
/// The deleted indices needed to get from the old collection to the new collection.
public var deletes: [Int]
/// The updated indices needed to get from the old collection to the new collection.
public var updates: [(old: Int, new: Int)]
/// The moved indices needed to get from the old collection to the new collection.
public var moves: [(old: Int, new: Int)]
/// A record for each old collection item to its index (if any) is in the new collection.
///
/// The indexes of this `Array` represent the indexes old collection, with elements of the
/// corresponding index of the same item in the new collection it exists, else `nil`.
public var newIndices: [Int?]
/// A record of each element in the new collection that has an identical `diffIdentifier` with
/// another element in the same collection.
///
/// Each element in the outer `Array` corresponds to a duplicated identifier, with each inner
/// `[Int]` containing the indexes that share a duplicate identifier in the new collection.
///
/// While the diffing algorithm makes a best effort to handle duplicates, they can lead to
/// unexpected behavior since identity of elements cannot be established and should be avoided if
/// possible.
public var duplicates: [[Int]]
/// Whether there are any inserts, deletes, moves, or updates in this changeset.
public var isEmpty: Bool {
inserts.isEmpty && deletes.isEmpty && updates.isEmpty && moves.isEmpty
}
}
// MARK: - IndexPathChangeset
/// A set of inserts, deletes, updates, and moves that define the changes between two collections
/// with indexes stored as `IndexPath`s.
public struct IndexPathChangeset {
// MARK: Lifecycle
public init(
inserts: [IndexPath] = [],
deletes: [IndexPath] = [],
updates: [(old: IndexPath, new: IndexPath)] = [],
moves: [(old: IndexPath, new: IndexPath)] = [],
duplicates: [[IndexPath]] = [])
{
self.inserts = inserts
self.deletes = deletes
self.updates = updates
self.moves = moves
self.duplicates = duplicates
}
// MARK: Public
/// The inserted `IndexPath`s needed to get from the old collection to the new collection.
public var inserts: [IndexPath]
/// The deleted `IndexPath`s needed to get from the old collection to the new collection.
public var deletes: [IndexPath]
/// The updated `IndexPath`s needed to get from the old collection to the new collection.
public var updates: [(old: IndexPath, new: IndexPath)]
/// The moved `IndexPath`s needed to get from the old collection to the new collection.
public var moves: [(old: IndexPath, new: IndexPath)]
/// A record for each element in the new collection that has an identical `diffIdentifier` with
/// another element in the same collection.
///
/// Each element in the outer `Array` corresponds to a duplicated identifier, with each inner
/// `[IndexPath]` corresponding to the indexes that share a duplicate identifier in the new
/// collection.
///
/// While the diffing algorithm makes a best effort to handle duplicates, they can lead to
/// unexpected behavior since identity of elements cannot be established and should be avoided if
/// possible.
public var duplicates: [[IndexPath]]
/// Whether there are any inserts, deletes, moves, or updates in this changeset.
public var isEmpty: Bool {
inserts.isEmpty && deletes.isEmpty && updates.isEmpty && moves.isEmpty
}
public static func += (left: inout IndexPathChangeset, right: IndexPathChangeset) {
left.inserts += right.inserts
left.deletes += right.deletes
left.updates += right.updates
left.moves += right.moves
left.duplicates += right.duplicates
}
}
// MARK: - IndexSetChangeset
/// A set of inserts, deletes, updates, and moves that define the changes between two collections
/// with indexes stored as `IndexSet`.
public struct IndexSetChangeset {
// MARK: Lifecycle
public init(
inserts: IndexSet = [],
deletes: IndexSet = [],
updates: [(old: Int, new: Int)] = [],
moves: [(old: Int, new: Int)] = [],
newIndices: [Int?] = [],
duplicates: [IndexSet] = [])
{
self.inserts = inserts
self.deletes = deletes
self.updates = updates
self.moves = moves
self.newIndices = newIndices
self.duplicates = duplicates
}
// MARK: Public
/// An `IndexSet` of inserts needed to get from the old collection to the new collection.
public var inserts: IndexSet
/// An `IndexSet` of deletes needed to get from the old collection to the new collection.
public var deletes: IndexSet
/// The updated indices needed to get from the old collection to the new collection.
public var updates: [(old: Int, new: Int)]
/// The moved indices needed to get from the old collection to the new collection.
public var moves: [(old: Int, new: Int)]
/// A record for each old collection item of what its index (if any) is in the new collection.
///
/// The indexes of this `Array` represent the indexes old collection, with elements of the
/// corresponding index of the same item in the new collection it exists, else `nil`.
public var newIndices: [Int?]
/// A record for each element in the new collection that has an identical `diffIdentifier` with
/// another element in the same collection.
///
/// Each element in the `Array` corresponds to a duplicated identifier, with each `IndexSet`
/// containing the indexes that share a duplicate identifier in the new collection.
///
/// While the diffing algorithm makes a best effort to handle duplicates, they can lead to
/// unexpected behavior since identity of elements cannot be established and should be avoided if
/// possible.
public var duplicates: [IndexSet]
/// Whether there are any inserts, deletes, moves, or updates in this changeset.
public var isEmpty: Bool {
inserts.isEmpty && deletes.isEmpty && updates.isEmpty && moves.isEmpty
}
}