     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.

    NOTE: If sectionKeyPath is used, it must be equal to the property used in the first SortDescriptor
    of the RealmRequest. If not, RRC will throw an error
    
    :param: request        Request to fetch objects
    :param: sectionKeyPath keyPath to group the results of the request
    
    :returns: self
    */
    public convenience init(request: RealmRequest<T>, sectionKeyPath: String?) throws {
        try self.init(request: request, sectionKeyPath: sectionKeyPath) { (object: T) -> (U) in

        }
    }
    
    
    //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)
        }
    }
    
}
