Add FlatSection

Sources/Composed/Core/Section.swift

@@ -82,4 +82,13 @@ public protocol SectionUpdateDelegate: class {
     ///   - destinationIndex: The final index where the element will be moved to
     func section(_ section: Section, move sourceIndex: Int, to destinationIndex: Int)
 
+    /// Notifies the delegate that the section invalidated its header.
+    /// - Parameters:
+    ///   - section: The section that invalidated its header.
+    func sectionDidInvalidateHeader(_ section: Section)
+
+    /// Notifies the delegate that the section invalidated its footer.
+    /// - Parameters:
+    ///   - section: The section that invalidated its footer.
+    func sectionDidInvalidateFooter(_ section: Section)
 }

Sources/Composed/Core/SectionProviderMapping.swift

@@ -82,6 +82,16 @@ public protocol SectionProviderMappingDelegate: class {
     ///   - destinationIndexPath: The final indexPath
     func mapping(_ mapping: SectionProviderMapping, move sourceIndexPath: IndexPath, to destinationIndexPath: IndexPath)
 
+    /// Notifies the delegate that the section invalidated its header.
+    /// - Parameters:
+    ///   - sectionIndex: The index of the section that invalidated its header.
+    func mappingDidInvalidateHeader(at sectionIndex: Int)
+
+    /// Notifies the delegate that the section invalidated its footer.
+    /// - Parameters:
+    ///   - sectionIndex: The index of the section that invalidated its footer.
+    func mappingDidInvalidateFooter(at sectionIndex: Int)
+
 }
 
 /// An object that encapsulates the logic required to map `SectionProvider`s to a global context,
@@ -229,6 +239,16 @@ public final class SectionProviderMapping: SectionProviderUpdateDelegate, Sectio
         delegate?.mapping(self, didMoveElementsAt: [(source, destination)])
     }
 
+    public func sectionDidInvalidateHeader(_ section: Section) {
+        guard let sectionOffset = self.sectionOffset(of: section) else { return }
+        delegate?.mappingDidInvalidateHeader(at: sectionOffset)
+    }
+
+    public func sectionDidInvalidateFooter(_ section: Section) {
+        guard let sectionOffset = self.sectionOffset(of: section) else { return }
+        delegate?.mappingDidInvalidateFooter(at: sectionOffset)
+    }
+
     // Rebuilds the cached providers to improve lookup performance.
     // This is generally only required when a sections are either inserted or removed, so it should be fairly efficient.
     private func rebuildSectionOffsets() {

Sources/Composed/Sections/FlatSection+SelectionHandler.swift

@@ -0,0 +1,105 @@
+extension FlatSection: SelectionHandler {
+    public final var selectionHandlingSections: [SelectionHandler] {
+        sections.compactMap { $0 as? SelectionHandler }
+    }
+
+    open var allowsMultipleSelection: Bool {
+        let selectionHandlingSection = sections.compactMap { $0 as? SelectionHandler }
+        if selectionHandlingSection.isEmpty {
+            return false
+        } else if selectionHandlingSection.count == 1 {
+            return selectionHandlingSection.first!.allowsMultipleSelection
+        } else {
+            return true
+        }
+    }
+
+    /// Returns all element indexes that are currently selected
+    open var selectedIndexes: [Int] {
+        return sections.flatMap { section -> [Int] in
+            guard let section = section as? SelectionHandler else { return [] }
+            let offset = self.indexForFirstElement(of: section)!
+            return section.selectedIndexes.map { $0 + offset }
+        }
+    }
+
+    /// When a highlight is attempted, this method will be called giving the caller a chance to prevent it
+    /// - Parameter index: The element index
+    open func shouldHighlight(at index: Int) -> Bool {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return false }
+        guard let section = sectionMeta.section as? SelectionHandler else { return false }
+
+        let sectionIndex = index - sectionMeta.offset
+        return section.shouldHighlight(at: sectionIndex)
+    }
+
+    /// When a selection is attempted, this method will be called giving the caller a chance to prevent it
+    /// - Parameter index: The element index
+    open func shouldSelect(at index: Int) -> Bool {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return false }
+        guard let section = sectionMeta.section as? SelectionHandler else { return false }
+
+        let sectionIndex = index - sectionMeta.offset
+        return section.shouldSelect(at: sectionIndex)
+    }
+
+    /// When a selection occurs, this method will be called to notify the section
+    /// - Parameter index: The element index
+    open func didSelect(at index: Int) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+        guard let section = sectionMeta.section as? SelectionHandler else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+        section.didSelect(at: sectionIndex)
+    }
+
+    /// When a deselection is attempted, this method will be called giving the caller a chance to prevent it
+    /// - Parameter index: The element index
+    open func shouldDeselect(at index: Int) -> Bool {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return false }
+        guard let section = sectionMeta.section as? SelectionHandler else { return false }
+
+        let sectionIndex = index - sectionMeta.offset
+        return section.shouldDeselect(at: sectionIndex)
+    }
+
+    /// When a deselection occurs, this method will be called to notify the section
+    /// - Parameter index: The element index
+    open func didDeselect(at index: Int) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+        guard let section = sectionMeta.section as? SelectionHandler else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+        return section.didDeselect(at: sectionIndex)
+    }
+
+    /// Selects the element at the specified index
+    /// - Parameter index: The element index
+    open func select(index: Int) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+        guard let section = sectionMeta.section as? SelectionHandler else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+        section.select(index: sectionIndex)
+    }
+
+    /// Deselects the element at the specified index
+    /// - Parameter index: The element index
+    open func deselect(index: Int) {
+        guard let sectionMeta = self.sectionForElementIndex(index) else { return }
+        guard let section = sectionMeta.section as? SelectionHandler else { return }
+
+        let sectionIndex = index - sectionMeta.offset
+        section.deselect(index: sectionIndex)
+    }
+
+    /// Selects all elements in this section
+    open func selectAll() {
+        selectionHandlingSections.forEach { $0.selectAll() }
+    }
+
+    /// Deselects all elements in this section
+    open func deselectAll() {
+        selectionHandlingSections.forEach { $0.deselectAll() }
+    }
+}