composer efficiency

Author: lkzhao

Sources/Provider/CollectionComposer.swift

@@ -11,31 +11,34 @@ import UIKit
 open class CollectionComposer: BaseCollectionProvider {
 
   public var sections: [AnyCollectionProvider] {
+    get { return dataProvider.data }
+    set { dataProvider.data = newValue }
+  }
+
+  public var presenter: CollectionPresenter? {
     didSet {
       setNeedsReload()
     }
   }
 
-  fileprivate var sectionBeginIndex: [Int] = []
-  fileprivate var sectionForIndex: [Int] = []
-
-  fileprivate var currentSections: [AnyCollectionProvider] = []
-
-  public var presenter: CollectionPresenter? { didSet { setNeedsReload() } }
-
   public var layout: CollectionLayout<AnyCollectionProvider> {
     didSet {
       setNeedsReload()
     }
   }
 
+  private var sectionBeginIndex: [Int] = []
+  private var dataProvider: ArrayDataProvider<AnyCollectionProvider>
+
   public init(identifier: String? = nil,
               layout: CollectionLayout<AnyCollectionProvider> = FlowLayout(),
               presenter: CollectionPresenter? = nil,
               sections: [AnyCollectionProvider]) {
-    self.sections = sections
     self.presenter = presenter
     self.layout = layout
+    self.dataProvider = ArrayDataProvider(data: sections, identifierMapper: {
+      return $1.identifier ?? "\($0)"
+    })
     super.init(identifier: identifier)
   }
 
@@ -47,37 +50,34 @@ open class CollectionComposer: BaseCollectionProvider {
   }
 
   func indexPath(_ index: Int) -> (Int, Int) {
-    let section = sectionForIndex[index]
-    let item = index - sectionBeginIndex[section]
-    return (section, item)
+    let sectionIndex = sectionBeginIndex.binarySearch { $0 <= index } - 1
+    return (sectionIndex, index - sectionBeginIndex[sectionIndex])
   }
 
   open override var numberOfItems: Int {
-    return sectionForIndex.count
+    return (sectionBeginIndex.last ?? 0) + (sections.last?.numberOfItems ?? 0)
   }
 
   open override func view(at: Int) -> UIView {
     let (sectionIndex, item) = indexPath(at)
-    return currentSections[sectionIndex].view(at: item)
+    return sections[sectionIndex].view(at: item)
   }
 
   open override func update(view: UIView, at: Int) {
     let (sectionIndex, item) = indexPath(at)
-    currentSections[sectionIndex].update(view: view, at: item)
+    sections[sectionIndex].update(view: view, at: item)
   }
 
   open override func identifier(at: Int) -> String {
     let (sectionIndex, item) = indexPath(at)
-    let sectionIdentifier = currentSections[sectionIndex].identifier ?? "\(sectionIndex)"
-    return "\(sectionIdentifier)." + currentSections[sectionIndex].identifier(at: item)
+    let sectionIdentifier = sections[sectionIndex].identifier ?? "\(sectionIndex)"
+    return "\(sectionIdentifier)." + sections[sectionIndex].identifier(at: item)
   }
 
   open override func layout(collectionSize: CGSize) {
     layout.layout(
       collectionSize: collectionSize,
-      dataProvider: ArrayDataProvider(data: currentSections, identifierMapper: {
-       return $1.identifier ?? "\($0)"
-      }),
+      dataProvider: dataProvider,
       sizeProvider: { (_, data, collectionSize) in
         data.layout(collectionSize: collectionSize)
         return data.contentSize
@@ -94,7 +94,7 @@ open class CollectionComposer: BaseCollectionProvider {
       let sectionFrame = layout.frame(at: sectionIndex)
       let intersectFrame = visibleFrame.intersection(sectionFrame)
       let visibleFrameForCell = CGRect(origin: intersectFrame.origin - sectionFrame.origin, size: intersectFrame.size)
-      let sectionVisible = currentSections[sectionIndex].visibleIndexes(visibleFrame: visibleFrameForCell)
+      let sectionVisible = sections[sectionIndex].visibleIndexes(visibleFrame: visibleFrameForCell)
       let beginIndex = sectionBeginIndex[sectionIndex]
       for item in sectionVisible {
         visible.append(item + beginIndex)
@@ -105,14 +105,14 @@ open class CollectionComposer: BaseCollectionProvider {
 
   open override func frame(at: Int) -> CGRect {
     let (sectionIndex, item) = indexPath(at)
-    var frame = currentSections[sectionIndex].frame(at: item)
+    var frame = sections[sectionIndex].frame(at: item)
     frame.origin += layout.frame(at: sectionIndex).origin
     return frame
   }
 
   open override func presenter(at: Int) -> CollectionPresenter? {
     let (sectionIndex, item) = indexPath(at)
-    return currentSections[sectionIndex].presenter(at: item) ?? presenter
+    return sections[sectionIndex].presenter(at: item) ?? presenter
   }
 
   open override func willReload() {
@@ -124,39 +124,29 @@ open class CollectionComposer: BaseCollectionProvider {
   }
 
   internal func prepareForReload() {
-    currentSections = sections
     sectionBeginIndex = []
-    sectionForIndex = []
-    sectionBeginIndex.reserveCapacity(currentSections.count)
-    for (sectionIndex, section) in currentSections.enumerated() {
-      let itemCount = section.numberOfItems
-      sectionBeginIndex.append(sectionForIndex.count)
-      for _ in 0..<itemCount {
-        sectionForIndex.append(sectionIndex)
-      }
+    sectionBeginIndex.reserveCapacity(sections.count)
+    var count = 0
+    for section in sections {
+      sectionBeginIndex.append(count)
+      count += section.numberOfItems
     }
   }
 
   open override func didReload() {
     super.didReload()
-    for section in currentSections {
+    for section in sections {
       section.didReload()
     }
   }
 
   open override func didTap(view: UIView, at: Int) {
     let (sectionIndex, item) = indexPath(at)
-    currentSections[sectionIndex].didTap(view: view, at: item)
+    sections[sectionIndex].didTap(view: view, at: item)
   }
 
   open override func hasReloadable(_ reloadable: CollectionReloadable) -> Bool {
-    if reloadable === self { return true }
-    for section in currentSections {
-      if section.hasReloadable(reloadable) {
-        return true
-      }
-    }
-    return false
+    return reloadable === self || reloadable === dataProvider ||
+      sections.contains(where: { $0.hasReloadable(reloadable) })
   }
-
 }