ListMonitor and ObjectMonitor objective C bridge

Sources/ObjectiveC/CSCoreStore+Observing.swift

@@ -0,0 +1,116 @@
+//
+//  CSCoreStore+Observing.swift
+//  CoreStore
+//
+//  Copyright © 2015 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - CSCoreStore
+
+@available(OSX, unavailable)
+public extension CSCoreStore {
+    
+    /**
+     Using the `defaultStack`, creates an `CSObjectMonitor` for the specified `NSManagedObject`. Multiple `CSObjectObserver`s may then register themselves to be notified when changes are made to the `NSManagedObject`.
+     
+     - parameter object: the `NSManagedObject` to observe changes from
+     - returns: a `CSObjectMonitor` that monitors changes to `object`
+     */
+    @objc
+    @warn_unused_result
+    public static func monitorObject(object: NSManagedObject) -> CSObjectMonitor {
+        
+        return self.defaultStack.monitorObject(object)
+    }
+    
+    /**
+     Using the `defaultStack`, creates a `CSListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `CSListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `CSFrom` clause indicating the entity type
+     - parameter fetchClauses: a series of `CSFetchClause` instances for fetching the object list. Accepts `CSWhere`, `CSOrderBy`, and `CSTweak` clauses.
+     - returns: a `CSListMonitor` instance that monitors changes to the list
+     */
+    @objc
+    @warn_unused_result
+    public static func monitorListFrom(from: CSFrom, fetchClauses: [CSFetchClause]) -> CSListMonitor {
+        
+        return self.defaultStack.monitorListFrom(from, fetchClauses: fetchClauses)
+    }
+    
+    /**
+     Using the `defaultStack`, asynchronously creates a `CSListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `CSListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `CSListMonitor` instance
+     - parameter from: a `CSFrom` clause indicating the entity type
+     - parameter fetchClauses: a series of `CSFetchClause` instances for fetching the object list. Accepts `CSWhere`, `CSOrderBy`, and `CSTweak` clauses.
+     */
+    @objc
+    public static func monitorListByCreatingAsynchronously(createAsynchronously: (CSListMonitor) -> Void, from: CSFrom, fetchClauses: [CSFetchClause])  {
+        
+        return self.defaultStack.monitorListByCreatingAsynchronously(
+            createAsynchronously,
+            from: from,
+            fetchClauses: fetchClauses
+        )
+    }
+    
+    /**
+     Using the `defaultStack`, creates a `CSListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `CSListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `CSFrom` clause indicating the entity type
+     - parameter sectionBy: a `CSSectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `CSFetchClause` instances for fetching the object list. Accepts `CSWhere`, `CSOrderBy`, and `CSTweak` clauses.
+     - returns: a `CSListMonitor` instance that monitors changes to the list
+     */
+    @objc
+    @warn_unused_result
+    public static func monitorSectionedListFrom(from: CSFrom, sectionBy: CSSectionBy, fetchClauses: [CSFetchClause]) -> CSListMonitor {
+        
+        return self.defaultStack.monitorSectionedListFrom(
+            from,
+            sectionBy: sectionBy,
+            fetchClauses: fetchClauses
+        )
+    }
+    
+    /**
+     Using the `defaultStack`, asynchronously creates a `CSListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `CSListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `CSListMonitor` instance
+     - parameter from: a `CSFrom` clause indicating the entity type
+     - parameter sectionBy: a `CSSectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `CSFetchClause` instances for fetching the object list. Accepts `CSWhere`, `CSOrderBy`, and `CSTweak` clauses.
+     */
+    @objc
+    public static func monitorSectionedListByCreatingAsynchronously(createAsynchronously: (CSListMonitor) -> Void, from: CSFrom, sectionBy: CSSectionBy, fetchClauses: [CSFetchClause]) {
+        
+        self.defaultStack.monitorSectionedListByCreatingAsynchronously(
+            createAsynchronously,
+            from: from,
+            sectionBy: sectionBy,
+            fetchClauses: fetchClauses
+        )
+    }
+}

Sources/ObjectiveC/CSDataStack+Observing.swift

@@ -0,0 +1,183 @@
+//
+//  CSDataStack+Observing.swift
+//  CoreStore
+//
+//  Copyright © 2016 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - CSDataStack
+
+@available(OSX, unavailable)
+public extension CSDataStack {
+    
+    /**
+     Creates a `CSObjectMonitor` for the specified `NSManagedObject`. Multiple `ObjectObserver`s may then register themselves to be notified when changes are made to the `NSManagedObject`.
+     
+     - parameter object: the `NSManagedObject` to observe changes from
+     - returns: a `ObjectMonitor` that monitors changes to `object`
+     */
+    @objc
+    @warn_unused_result
+    public func monitorObject(object: NSManagedObject) -> CSObjectMonitor {
+        
+        return bridge {
+            
+            self.bridgeToSwift.monitorObject(object)
+        }
+    }
+    
+    /**
+     Creates a `CSListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `CSListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `CSFrom` clause indicating the entity type
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `CSWhere`, `CSOrderBy`, and `CSTweak` clauses.
+     - returns: a `CSListMonitor` instance that monitors changes to the list
+     */
+    @objc
+    @warn_unused_result
+    public func monitorListFrom(from: CSFrom, fetchClauses: [CSFetchClause]) -> CSListMonitor {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        CoreStore.assert(
+            fetchClauses.contains { $0 is CSOrderBy },
+            "A CSListMonitor requires a CSOrderBy clause."
+        )
+        return bridge {
+            
+            ListMonitor(
+                dataStack: self.bridgeToSwift,
+                from: from.bridgeToSwift,
+                sectionBy: nil,
+                applyFetchClauses: { fetchRequest in
+                    
+                    fetchClauses.forEach { $0.applyToFetchRequest(fetchRequest) }
+                }
+            )
+        }
+    }
+    
+    /**
+     Asynchronously creates a `CSListMonitor` for a list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `CSListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `CSListMonitor` instance
+     - parameter from: a `CSFrom` clause indicating the entity type
+     - parameter fetchClauses: a series of `CSFetchClause` instances for fetching the object list. Accepts `CSWhere`, `CSOrderBy`, and `CSTweak` clauses.
+     */
+    @objc
+    public func monitorListByCreatingAsynchronously(createAsynchronously: (CSListMonitor) -> Void, from: CSFrom, fetchClauses: [CSFetchClause]) {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        CoreStore.assert(
+            fetchClauses.contains { $0 is CSOrderBy },
+            "A CSListMonitor requires an CSOrderBy clause."
+        )
+        _ = ListMonitor(
+            dataStack: self.bridgeToSwift,
+            from: from.bridgeToSwift,
+            sectionBy: nil,
+            applyFetchClauses: { fetchRequest in
+                
+                fetchClauses.forEach { $0.applyToFetchRequest(fetchRequest) }
+            },
+            createAsynchronously: {
+                
+                createAsynchronously($0.bridgeToObjectiveC)
+            }
+        )
+    }
+    
+    /**
+     Creates a `CSListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `ListObserver`s may then register themselves to be notified when changes are made to the list.
+     
+     - parameter from: a `CSFrom` clause indicating the entity type
+     - parameter sectionBy: a `CSSectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `CSWhere`, `CSOrderBy`, and `CSTweak` clauses.
+     - returns: a `CSListMonitor` instance that monitors changes to the list
+     */
+    @objc
+    @warn_unused_result
+    public func monitorSectionedListFrom(from: CSFrom, sectionBy: CSSectionBy, fetchClauses: [CSFetchClause]) -> CSListMonitor {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        CoreStore.assert(
+            fetchClauses.contains { $0 is CSOrderBy },
+            "A CSListMonitor requires an CSOrderBy clause."
+        )
+        return bridge {
+            
+            ListMonitor(
+                dataStack: self.bridgeToSwift,
+                from: from.bridgeToSwift,
+                sectionBy: sectionBy.bridgeToSwift,
+                applyFetchClauses: { fetchRequest in
+                    
+                    fetchClauses.forEach { $0.applyToFetchRequest(fetchRequest) }
+                }
+            )
+        }
+    }
+    
+    /**
+     Asynchronously creates a `CSListMonitor` for a sectioned list of `NSManagedObject`s that satisfy the specified fetch clauses. Multiple `CSListObserver`s may then register themselves to be notified when changes are made to the list. Since `NSFetchedResultsController` greedily locks the persistent store on initial fetch, you may prefer this method instead of the synchronous counterpart to avoid deadlocks while background updates/saves are being executed.
+     
+     - parameter createAsynchronously: the closure that receives the created `CSListMonitor` instance
+     - parameter from: a `CSFrom` clause indicating the entity type
+     - parameter sectionBy: a `CSSectionBy` clause indicating the keyPath for the attribute to use when sorting the list into sections.
+     - parameter fetchClauses: a series of `CSFetchClause` instances for fetching the object list. Accepts `CSWhere`, `CSOrderBy`, and `CSTweak` clauses.
+     */
+    public func monitorSectionedListByCreatingAsynchronously(createAsynchronously: (CSListMonitor) -> Void, from: CSFrom, sectionBy: CSSectionBy, fetchClauses: [CSFetchClause]) {
+        
+        CoreStore.assert(
+            NSThread.isMainThread(),
+            "Attempted to observe objects from \(typeName(self)) outside the main thread."
+        )
+        CoreStore.assert(
+            fetchClauses.contains { $0 is CSOrderBy },
+            "A CSListMonitor requires an CSOrderBy clause."
+        )
+        _ = ListMonitor(
+            dataStack: self.bridgeToSwift,
+            from: from.bridgeToSwift,
+            sectionBy: sectionBy.bridgeToSwift,
+            applyFetchClauses: { fetchRequest in
+                
+                fetchClauses.forEach { $0.applyToFetchRequest(fetchRequest) }
+            },
+            createAsynchronously: {
+                
+                createAsynchronously($0.bridgeToObjectiveC)
+            }
+        )
+    }
+}

Sources/ObjectiveC/CSListMonitor.swift

@@ -485,7 +485,7 @@ public final class CSListMonitor: NSObject, CoreStoreObjectiveCType {
      - parameter observer: a `CSListObserver` to unregister notifications to
      */
     @objc
-    public func removeObserver(observer: CSListObserver) {
+    public func removeListObserver(observer: CSListObserver) {
         
         self.bridgeToSwift.unregisterObserver(observer)
     }
@@ -509,6 +509,7 @@ public final class CSListMonitor: NSObject, CoreStoreObjectiveCType {
      
      - parameter fetchClauses: a series of `FetchClause` instances for fetching the object list. Accepts `Where`, `OrderBy`, and `Tweak` clauses. Note that only specified clauses will be changed; unspecified clauses will use previous values.
      */
+    @objc
     public func refetch(fetchClauses: [CSFetchClause]) {
         
         self.bridgeToSwift.refetch { (fetchRequest) in
@@ -537,6 +538,7 @@ public final class CSListMonitor: NSObject, CoreStoreObjectiveCType {
     
     // MARK: CoreStoreObjectiveCType
     
+    @nonobjc
     public let bridgeToSwift: ListMonitor<NSManagedObject>
     
     @nonobjc

Sources/ObjectiveC/CSObjectMonitor.swift

@@ -0,0 +1,141 @@
+//
+//  CSObjectMonitor.swift
+//  CoreStore
+//
+//  Copyright © 2016 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - CSObjectMonitor
+
+/**
+ The `CSObjectMonitor` serves as the Objective-C bridging type for `ObjectMonitor<T>`.
+ */
+@available(OSX, unavailable)
+@objc
+public final class CSObjectMonitor: NSObject, CoreStoreObjectiveCType {
+    
+    /**
+     Returns the `NSManagedObject` instance being observed, or `nil` if the object was already deleted.
+     */
+    public var object: NSManagedObject? {
+        
+        return self.bridgeToSwift.object
+    }
+    
+    /**
+     Returns `YES` if the `NSManagedObject` instance being observed still exists, or `NO` if the object was already deleted.
+     */
+    public var isObjectDeleted: Bool {
+        
+        return self.bridgeToSwift.isObjectDeleted
+    }
+    
+    /**
+     Registers a `CSObjectObserver` to be notified when changes to the receiver's `object` are made.
+     
+     To prevent retain-cycles, `CSObjectMonitor` only keeps `weak` references to its observers.
+     
+     For thread safety, this method needs to be called from the main thread. An assertion failure will occur (on debug builds only) if called from any thread other than the main thread.
+     
+     Calling `-addObjectObserver:` multiple times on the same observer is safe, as `CSObjectMonitor` unregisters previous notifications to the observer before re-registering them.
+     
+     - parameter observer: an `CSObjectObserver` to send change notifications to
+     */
+    public func addObjectObserver(observer: CSObjectObserver) {
+        
+        let swift = self.bridgeToSwift
+        swift.unregisterObserver(observer)
+        swift.registerObserver(
+            observer,
+            willChangeObject: { (observer, monitor, object) in
+                
+                observer.objectMonitor?(monitor.bridgeToObjectiveC, willUpdateObject: object)
+            },
+            didDeleteObject: { (observer, monitor, object) in
+                
+                observer.objectMonitor?(monitor.bridgeToObjectiveC, didDeleteObject: object)
+            },
+            didUpdateObject: { (observer, monitor, object, changedPersistentKeys) in
+                
+                observer.objectMonitor?(monitor.bridgeToObjectiveC, didUpdateObject: object, changedPersistentKeys: changedPersistentKeys)
+            }
+        )
+    }
+    
+    /**
+     Unregisters an `CSObjectObserver` from receiving notifications for changes to the receiver's `object`.
+     
+     For thread safety, this method needs to be called from the main thread. An assertion failure will occur (on debug builds only) if called from any thread other than the main thread.
+     
+     - parameter observer: an `CSObjectObserver` to unregister notifications to
+     */
+    public func removeObjectObserver(observer: CSObjectObserver) {
+        
+        self.bridgeToSwift.unregisterObserver(observer)
+    }
+    
+    
+    // MARK: NSObject
+    
+    public override var hash: Int {
+        
+        return self.bridgeToSwift.hashValue
+    }
+    
+    public override func isEqual(object: AnyObject?) -> Bool {
+        
+        guard let object = object as? CSObjectMonitor else {
+            
+            return false
+        }
+        return self.bridgeToSwift == object.bridgeToSwift
+    }
+    
+    
+    // MARK: CoreStoreObjectiveCType
+    
+    @nonobjc
+    public let bridgeToSwift: ObjectMonitor<NSManagedObject>
+    
+    @nonobjc
+    public required init<T: NSManagedObject>(_ swiftValue: ObjectMonitor<T>) {
+        
+        self.bridgeToSwift = swiftValue.upcast()
+        super.init()
+    }
+}
+
+
+// MARK: - ObjectMonitor
+
+extension ObjectMonitor: CoreStoreSwiftType {
+    
+    // MARK: CoreStoreSwiftType
+    
+    public var bridgeToObjectiveC: CSObjectMonitor {
+        
+        return CSObjectMonitor(self)
+    }
+}

Sources/ObjectiveC/CSObjectObserver.swift

@@ -0,0 +1,70 @@
+//
+//  CSObjectObserver.swift
+//  CoreStore
+//
+//  Copyright © 2016 John Rommel Estropia
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+import CoreData
+
+
+// MARK: - CSObjectObserver
+
+/**
+ Implement the `CSObjectObserver` protocol to observe changes  to a single `NSManagedObject` instance. `CSObjectObserver`s may register themselves to a `CSObjectMonitor`'s `-addObjectObserver:` method:
+ ```
+ CSObjectMonitor *monitor = [CSCoreStore monitorObject:myObject];
+ [monitor addObjectObserver:self];
+ ```
+ */
+@available(OSX, unavailable)
+@objc
+public protocol CSObjectObserver: class, AnyObject {
+    
+    /**
+     Handles processing just before a change to the observed `object` occurs
+     
+     - parameter monitor: the `CSObjectMonitor` monitoring the object being observed
+     - parameter object: the `NSManagedObject` instance being observed
+     */
+    @objc
+    optional func objectMonitor(monitor: CSObjectMonitor, willUpdateObject object: NSManagedObject)
+    
+    /**
+     Handles processing right after a change to the observed `object` occurs
+     
+     - parameter monitor: the `CSObjectMonitor` monitoring the object being observed
+     - parameter object: the `NSManagedObject` instance being observed
+     - parameter changedPersistentKeys: an `NSSet` of key paths for the attributes that were changed. Note that `changedPersistentKeys` only contains keys for attributes/relationships present in the persistent store, thus transient properties will not be reported.
+     */
+    @objc
+    optional func objectMonitor(monitor: CSObjectMonitor, didUpdateObject object: NSManagedObject, changedPersistentKeys: Set<KeyPath>)
+    
+    /**
+     Handles processing right after `object` is deleted
+     
+     - parameter monitor: the `CSObjectMonitor` monitoring the object being observed
+     - parameter object: the `NSManagedObject` instance being observed
+     */
+    @objc
+    optional func objectMonitor(monitor: CSObjectMonitor, didDeleteObject object: NSManagedObject)
+}