         // only the root data context has a direct assigned persistent store coordinator
         self.assignPersistentStoreCoordinator()
     }
-    
-    private required init(coder aDecoder: NSCoder) {
+
+    public required init(coder aDecoder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
-    
-    private override func addObservers() {
-        super.addObservers()
-        
-        // the root data context did save
-        self.addObserverForName(NSManagedObjectContextDidSaveNotification) { notification in
-            if let notificationRootSavingDataContext = notification.object as? RootSavingDataContext where notificationRootSavingDataContext.childDataContexts.count > 0,
-                let changeNotificationData = notification.userInfo {
-                    var excludedChildContextFromMerge: NSManagedObjectContext? = nil
-                    if let savedChildContext = notificationRootSavingDataContext.savedChildContext {
-                        excludedChildContextFromMerge = savedChildContext
-                        notificationRootSavingDataContext.savedChildContext = nil
-                    }
-                    
-                    let contextsToMerge = notificationRootSavingDataContext.childDataContexts.filter({ $0 != excludedChildContextFromMerge })
-                    let updatedObjects = changeNotificationData[NSUpdatedObjectsKey] as? Set<NSManagedObject>
-                    
-                    for contextToMerge in contextsToMerge {
-                        contextToMerge.performBlock {
-                            if let updatedObjects = updatedObjects where !updatedObjects.isEmpty {
-                                for objectObject in updatedObjects {
-                                    contextToMerge.objectWithID(objectObject.objectID).willAccessValueForKey(nil) // ensures that a fault has been fired
-                                }
-                            }
-                            
-                            contextToMerge.mergeChangesFromContextDidSaveNotification(notification)
-                        }
-                    }
-            }
-        }
-    }
-    
+
     private func assignPersistentStoreCoordinator() {
         // managed object model
-        if let managedObjectModelURL = self.rootSavingDataContextOptions.managedObjectModelURL, let managedObjectModel = NSManagedObjectModel(contentsOfURL: managedObjectModelURL) {
+        if let managedObjectModelURL = self.contextOptions.managedObjectModelURL, let managedObjectModel = NSManagedObjectModel(contentsOfURL: managedObjectModelURL) {
             // persistent store coordinator
             let persistentStoreCoordinator = NSPersistentStoreCoordinator(managedObjectModel: managedObjectModel)
             
             // persistent store
-            switch self.rootSavingDataContextOptions.storeType {
+            switch self.contextOptions.storeType {
             case .SQLite:
-                if let persistentStoreURL = self.rootSavingDataContextOptions.persistentStoreURL,
+                if let persistentStoreURL = self.contextOptions.persistentStoreURL,
                     let containerURL = persistentStoreURL.URLByDeletingLastPathComponent {
                         // if the directory does not exist, it will be created
                         var fileManagerError: NSError? = nil
                         if NSFileManager.defaultManager().createDirectoryAtURL(containerURL, withIntermediateDirectories: true, attributes: nil, error: &fileManagerError) {
                             var error: NSError? = nil
-                            persistentStoreCoordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: self.rootSavingDataContextOptions.configuration, URL: persistentStoreURL, options: self.rootSavingDataContextOptions.options as [NSObject : AnyObject], error: &error)
+                            persistentStoreCoordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: self.contextOptions.configuration, URL: persistentStoreURL, options: self.contextOptions.options as [NSObject : AnyObject], error: &error)
                             
                             if let error = error {
                                 var handled = false

    
}

// MARK: - public global functions - background contexts

// This functions will be removed in the next major version.

public func createBackgroundContext<T: Context>(parentContext: T, usingNewBackgroundManagedObjectContext: Bool) -> T {
    if !usingNewBackgroundManagedObjectContext {
        if let defaultBackgroundContext = parentContext.defaultCreatedBackgroundContext() {
            return defaultBackgroundContext
        }
    }
    
    let backgroundContext = T(parentContext: parentContext)
    
    if !usingNewBackgroundManagedObjectContext {
        parentContext._defaultBackgroundContext = backgroundContext
    }
    
    return backgroundContext
}

public func performInBackground<T: Context>(parentContext: T, closure: (T) -> Void) {

        
        self.addObservers()
    }

    public required init(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    deinit {
        self.removeObservers()
    }
    
    // MARK: - public methods
    
    public func save() -> (success: Bool, error: NSError?) {
        var error: NSError? = nil
