     var mapper: (T) -> U
     var sectionKeyPath: String? = ""
     var backgroundQueue = dispatch_queue_create("com.RRC.\(arc4random_uniform(1000))", DISPATCH_QUEUE_SERIAL)
-    var sections: [RealmSection<U>] {
-        return cache.sections.map(realmSectionMapper)
-    }
-    public var numberOfSections: Int {
-        return cache.sections.count
-    }
     
     var temporaryAdded: [T] = []
     var temporaryUpdated: [T] = []
     var temporaryDeleted: [T] = []
+
+    /**
+    All results separated by the sectionKeyPath in RealmSection<U>
+    
+    Warning: This is computed variable that maps all the avaliable sections using the mapper. Could be an expensive operation
+    */
+    var sections: [RealmSection<U>] {
+        return cache.sections.map(realmSectionMapper)
+    }
+    
+    /// Number of sections in the RealmResultsController
+    public var numberOfSections: Int {
+        return cache.sections.count
+    }
+    
+    deinit {
+        NSNotificationCenter.defaultCenter().removeObserver(self)
+    }
+    
+    
+    //MARK: Initializers
 
     /**
     Create a RealmResultsController with a Request, a SectionKeypath to group the results and a mapper.

        }
    }
    
    convenience init(forTESTRequest request: RealmRequest<T>, sectionKeyPath: String?, mapper: (T)->(U)) throws {
        try self.init(request: request, sectionKeyPath: sectionKeyPath, mapper: mapper)
        self._test = true
    }
    
    deinit {
        NSNotificationCenter.defaultCenter().removeObserver(self)
    }
    
    public func keyPathIsValid(keyPath: String?, sorts: [SortDescriptor]) -> Bool {
        if keyPath == nil { return true }
        guard let firstSort = sorts.first else { return false }
        return keyPath == firstSort.property
    }
    
    public func numberOfObjectsAt(sectionIndex: Int) -> Int {
        
        return cache.sections[sectionIndex].objects.count
    }
    
    public func objectAt(indexPath: NSIndexPath) -> U {
        // TODO: make sure the indexPath exists
        let object = cache.sections[indexPath.section].allObjects[indexPath.row]
        return self.mapper(object)
    }
    
    public func performFetch() -> [RealmSection<U>] {
        populating = true
        let objects = self.request.execute().toArray(T.self).map(getMirror)

        populating = false
        return sections
    }

    
    //MARK: Helpers
    
    /**
    Returns the number of objects at a given section index
    
    - param: sectionIndex Int
    
    - returns: the objects count at the sectionIndex
    */
    public func numberOfObjectsAt(sectionIndex: Int) -> Int {
        return cache.sections[sectionIndex].objects.count
    }

    /**
    Returns the mapped object at a given NSIndexPath
    
    - param: indexPath IndexPath for the desired object
    
    - returns: the object as U (mapped)
    */
    public func objectAt(indexPath: NSIndexPath) -> U {
        let object = cache.sections[indexPath.section].allObjects[indexPath.row]
        return self.mapper(object)
    }

    private func keyPathIsValid(keyPath: String?, sorts: [SortDescriptor]) -> Bool {
        if keyPath == nil { return true }
        guard let firstSort = sorts.first else { return false }
        return keyPath == firstSort.property
    }
    
    private func realmSectionMapper<S>(section: Section<S>) -> RealmSection<U> {
        return RealmSection<U>(objects: nil, keyPath: section.keyPath)
    }
    
    
    //MARK: Cache delegate
    
