         }
     }
     
-    convenience init(forTESTRequest request: RealmRequest<T>, sectionKeyPath: String?, mapper: (T)->(U)) throws {
+    private 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)
-    }
-    
+    
+    //MARK: Fetch
+    
+    /**
+    Fetches the initial data for the RealmResultsController
+    
+    Atention: Must be called after creating
+    
+    - returns: [RealmSection<U>]
+    */
     public func performFetch() -> [RealmSection<U>] {
         populating = true
         let objects = self.request.execute().toArray(T.self).map(getMirror)

    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] = []

    /**
    Create a RealmResultsController with a Request, a SectionKeypath to group the results and a mapper.

        }
    }
    
    
    //MARK: Threads management
    
    /**
    Hackish!
    if a class has a generic T, and a method has another generic T (or even with another name)
    and considering that the map function is defined to return a generic T.
    If you want to map inside that method, you are going to have a bad time.
    This method is a wrapper of the map function to work with all the generic mess.
    
    NOTE: not used for the moment, leave it here in case we need it.
    
    :param: items Array of items to map, they should be of type T (defined by the class)
    if the items are not T, this will crash.
    
    :returns: Array of mapped items (they should be U, defined by the class)
    */
    func executeOnCorrectThread(block: ()->()) {
        _test ? dispatch_sync(backgroundQueue, block) : dispatch_async(backgroundQueue, block)
    }
    
    func executeOnMainThread(block: ()->()) {
        if NSThread.currentThread().isMainThread {
            block()
        }
        else {
            dispatch_async(dispatch_get_main_queue(), block)
        }
    }
    
}
