DifferentiableSection is now inherited from Differentiable

Sources/Algorithm.swift

@@ -65,7 +65,6 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
  target: targetElements,
  trackTargetIndexAsUpdated: false,
  mapIndex: { ElementPath(element: $0, section: section) },
- differentiable: { $0 },
  remainedInTarget: { firstStageElements.append($0) }
  )
 
@@ -124,7 +123,7 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
  /// - Complexity: O(n)
  public init(source: Collection, target: Collection) {
  typealias Section = Collection.Element
- typealias SectionIdentifier = Collection.Element.Model.DifferenceIdentifier
+ typealias SectionIdentifier = Collection.Element.DifferenceIdentifier
  typealias Element = Collection.Element.Collection.Element
  typealias ElementIdentifier = Collection.Element.Collection.Element.DifferenceIdentifier
 
@@ -161,8 +160,7 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
  source: sourceSections,
  target: targetSections,
  trackTargetIndexAsUpdated: true,
- mapIndex: { $0 },
- differentiable: { $0.model }
+ mapIndex: { $0 }
  )
 
  // Calculate the element differences.
@@ -265,7 +263,7 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
  offsetByDelete += 1
  }
 
- let section = Section(model: sourceSections[sourceSectionIndex].model, elements: firstStageElements)
+ let section = Section(source: sourceSections[sourceSectionIndex], elements: firstStageElements)
  firstStageSections.append(section)
  }
 
@@ -286,7 +284,7 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
  let secondStageSection = firstStageSections[sourceSectionIndex - sectionDeleteOffset]
  secondStageSections.append(secondStageSection)
 
- let thirdStageSection = Section(model: secondStageSection.model, elements: targetElements)
+ let thirdStageSection = Section(source: secondStageSection, elements: targetElements)
  thirdStageSections.append(thirdStageSection)
 
  for targetElementIndex in targetElements.indices {
@@ -381,12 +379,11 @@ public extension StagedChangeset where Collection: RangeReplaceableCollection, C
 
 /// The shared algorithm to calculate differences between two linear collections.
 @discardableResult
-private func differentiate<E, D: Differentiable, I>(
+private func differentiate<E: Differentiable, I>(
  source: ContiguousArray<E>,
  target: ContiguousArray<E>,
  trackTargetIndexAsUpdated: Bool,
  mapIndex: (Int) -> I,
- differentiable: (E) -> D,
  remainedInTarget: ((E) -> Void)? = nil
  ) -> DifferentiateResult<I> {
  var deleted = [I]()
@@ -396,19 +393,19 @@ private func differentiate<E, D: Differentiable, I>(
 
  var sourceTraces = ContiguousArray<Trace<Int>>()
  var targetReferences = ContiguousArray<Int?>(repeating: nil, count: target.count)
- var sourceIdentifiers = ContiguousArray<D.DifferenceIdentifier>()
+ var sourceIdentifiers = ContiguousArray<E.DifferenceIdentifier>()
 
  sourceIdentifiers.reserveCapacity(source.count)
  sourceTraces.reserveCapacity(source.count)
 
  for sourceElement in source {
  sourceTraces.append(Trace())
- sourceIdentifiers.append(differentiable(sourceElement).differenceIdentifier)
+ sourceIdentifiers.append(sourceElement.differenceIdentifier)
  }
 
  sourceIdentifiers.withUnsafeBufferPointer { bufferPointer in
  // The pointer and the table key are for optimization.
- var sourceOccurrencesTable = [TableKey<D.DifferenceIdentifier>: Occurrence](minimumCapacity: source.count * 2)
+ var sourceOccurrencesTable = [TableKey<E.DifferenceIdentifier>: Occurrence](minimumCapacity: source.count * 2)
 
  // Record the index where the element was found in source collection into occurrences table.
  for sourceIndex in sourceIdentifiers.indices {
@@ -430,7 +427,7 @@ private func differentiate<E, D: Differentiable, I>(
 
  // Record the target index and the source index that the element having the same identifier.
  for targetIndex in target.indices {
- var targetIdentifier = differentiable(target[targetIndex]).differenceIdentifier
+ var targetIdentifier = target[targetIndex].differenceIdentifier
  let key = TableKey(pointer: &targetIdentifier)
 
  switch sourceOccurrencesTable[key] {
@@ -481,7 +478,7 @@ private func differentiate<E, D: Differentiable, I>(
  let sourceElement = source[sourceIndex]
  let targetElement = target[targetIndex]
 
- if !differentiable(targetElement).isContentEqual(to: differentiable(sourceElement)) {
+ if !targetElement.isContentEqual(to: sourceElement) {
  updated.append(mapIndex(trackTargetIndexAsUpdated ? targetIndex : sourceIndex))
  }
 

Sources/DifferentiableSection.swift

@@ -1,19 +1,15 @@
 /// Represents the section of collection that has model and elements that identified and can be compared to whether has updated.
-public protocol DifferentiableSection {
- /// A type representing the model for differentiated with other section.
- associatedtype Model: Differentiable
+public protocol DifferentiableSection: Differentiable {
  /// A type representing the elements in section.
  associatedtype Collection: Swift.Collection where Collection.Element: Differentiable
 
- /// The model of section for differentiated with other section.
- var model: Model { get }
  /// The collection of element in the section.
  var elements: Collection { get }
 
- /// Creates a section from the model and the elements.
+ /// Creates a new section reproding the given source section with replacing the elements.
  ///
  /// - Parameters:
- /// - model: A model of section.
- /// - elements: The collection of element in the section.
- init<C: Swift.Collection>(model: Model, elements: C) where C.Element == Collection.Element
+ /// - source: A source section to reproduce.
+ /// - elements: The collection of elements for the new section.
+ init<C: Swift.Collection>(source: Self, elements: C) where C.Element == Collection.Element
 }

Sources/Section.swift

@@ -8,15 +8,43 @@ public struct Section<Model: Differentiable, Element: Differentiable>: Different
  /// The array of element in the section.
  public var elements: [Element]
 
+ /// An identifier value that of model for difference calculation.
+ public var differenceIdentifier: Model.DifferenceIdentifier {
+ return model.differenceIdentifier
+ }
+
  /// Creates a section from the model and the elements.
  ///
  /// - Parameters:
- /// - model: A model of section.
+ /// - model: A differentiable model of section.
  /// - elements: The collection of element in the section.
  public init<C: Collection>(model: Model, elements: C) where C.Element == Element {
  self.model = model
  self.elements = Array(elements)
  }
+
+ /// Creates a new section reproding the given source section with replacing the elements.
+ ///
+ /// - Parameters:
+ /// - source: A source section to reproduce.
+ /// - elements: The collection of elements for the new section.
+ public init<C: Collection>(source: Section, elements: C) where C.Element == Element {
+ self.init(model: source.model, elements: elements)
+ }
+
+ /// Indicate whether the content of `self` is equals to the content of
+ /// the given source section.
+ ///
+ /// - Note: It's compared by the model of `self` and the specified section.
+ ///
+ /// - Parameters:
+ /// - source: A source section to compare.
+ ///
+ /// - Returns: A Boolean value indicating whether the content of `self` is equals
+ /// to the content of the given source section.
+ public func isContentEqual(to source: Section) -> Bool {
+ return model.isContentEqual(to: source.model)
+ }
 }
 
 extension Section: Equatable where Model: Equatable, Element: Equatable {

Tests/TestTools.swift

@@ -228,7 +228,7 @@ func XCTAssertReproducible<C: RangeReplaceableCollection & Equatable>(
  elements.insert(element, at: targetElementIndex)
  }
 
- subject[targetSectionIndex] = Section(model: section.model, elements: elements)
+ subject[targetSectionIndex] = Section(source: section, elements: elements)
  }
 
  let reproduced = C(subject)