From bf10f4668c5b1ac9f71ff3d4794568a731872d31 Mon Sep 17 00:00:00 2001 From: John Estropia Date: Wed, 22 Sep 2021 15:03:46 +0900 Subject: [PATCH] revert Objc method changes --- Sources/CSDataStack+Transaction.swift | 134 +-------------------- Sources/CSSynchronousDataTransaction.swift | 5 +- Sources/CSUnsafeDataTransaction.swift | 72 ++--------- 3 files changed, 19 insertions(+), 192 deletions(-) diff --git a/Sources/CSDataStack+Transaction.swift b/Sources/CSDataStack+Transaction.swift index f3a74f8..e652e33 100644 --- a/Sources/CSDataStack+Transaction.swift +++ b/Sources/CSDataStack+Transaction.swift @@ -37,9 +37,7 @@ extension CSDataStack { - parameter closure: the block where creates, updates, and deletes can be made to the transaction. Transaction blocks are executed serially in a background queue, and all changes are made from a concurrent `NSManagedObjectContext`. */ @objc - public func beginAsynchronous( - _ closure: @escaping (_ transaction: CSAsynchronousDataTransaction) -> Void - ) { + public func beginAsynchronous(_ closure: @escaping (_ transaction: CSAsynchronousDataTransaction) -> Void) { self.bridgeToSwift.perform( asynchronous: { (transaction) in @@ -59,37 +57,6 @@ extension CSDataStack { ) } - /** - Begins a transaction asynchronously where `NSManagedObject` creates, updates, and deletes can be made. - - - parameter closure: the block where creates, updates, and deletes can be made to the transaction. Transaction blocks are executed serially in a background queue, and all changes are made from a concurrent `NSManagedObjectContext`. - - parameter sourceIdentifier: an optional value that identifies the source of this transaction. This identifier will be passed to the change notifications and callers can use it for custom handling that depends on the source. - */ - @objc - public func beginAsynchronous( - _ closure: @escaping (_ transaction: CSAsynchronousDataTransaction) -> Void, - _ sourceIdentifier: Any? - ) { - - self.bridgeToSwift.perform( - asynchronous: { (transaction) in - - let csTransaction = transaction.bridgeToObjectiveC - closure(csTransaction) - if !transaction.isCommitted && transaction.hasChanges { - - Internals.log( - .warning, - message: "The closure for the \(Internals.typeName(csTransaction)) completed without being committed. All changes made within the transaction were discarded." - ) - } - try transaction.cancel() - }, - sourceIdentifier: sourceIdentifier, - completion: { _ in } - ) - } - /** Begins a transaction synchronously where `NSManagedObject` creates, updates, and deletes can be made. @@ -98,9 +65,7 @@ extension CSDataStack { - returns: `YES` if the commit succeeded, `NO` if the commit failed. If `NO`, the `error` argument will hold error information. */ @objc - public func beginSynchronous( - _ closure: @escaping (_ transaction: CSSynchronousDataTransaction) -> Void, - error: NSErrorPointer) -> Bool { + public func beginSynchronous(_ closure: @escaping (_ transaction: CSSynchronousDataTransaction) -> Void, error: NSErrorPointer) -> Bool { return bridge(error) { @@ -129,49 +94,6 @@ extension CSDataStack { } } - /** - Begins a transaction synchronously where `NSManagedObject` creates, updates, and deletes can be made. - - - parameter closure: the block where creates, updates, and deletes can be made to the transaction. Transaction blocks are executed serially in a background queue, and all changes are made from a concurrent `NSManagedObjectContext`. - - parameter sourceIdentifier: an optional value that identifies the source of this transaction. This identifier will be passed to the change notifications and callers can use it for custom handling that depends on the source. - - parameter error: the `CSError` pointer that indicates the reason in case of an failure - - returns: `YES` if the commit succeeded, `NO` if the commit failed. If `NO`, the `error` argument will hold error information. - */ - @objc - public func beginSynchronous( - _ closure: @escaping (_ transaction: CSSynchronousDataTransaction) -> Void, - sourceIdentifier: Any?, - error: NSErrorPointer - ) -> Bool { - - return bridge(error) { - - do { - - try self.bridgeToSwift.perform( - synchronous: { (transaction) in - - let csTransaction = transaction.bridgeToObjectiveC - closure(csTransaction) - if !transaction.isCommitted && transaction.hasChanges { - - Internals.log( - .warning, - message: "The closure for the \(Internals.typeName(csTransaction)) completed without being committed. All changes made within the transaction were discarded." - ) - } - try transaction.cancel() - }, - sourceIdentifier: sourceIdentifier - ) - } - catch CoreStoreError.userCancelled { - - return - } - } - } - /** Begins a child transaction where `NSManagedObject` creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms. @@ -190,61 +112,15 @@ extension CSDataStack { /** Begins a child transaction where `NSManagedObject` creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms. - To support "undo" methods such as `-undo`, `-redo`, and `-rollback`, use the `-beginSafeWithSupportsUndo:` method passing `YES` to the argument. Without "undo" support, calling those methods will raise an exception. - - parameter sourceIdentifier: an optional value that identifies the source of this transaction. This identifier will be passed to the change notifications and callers can use it for custom handling that depends on the source. + - prameter supportsUndo: `-undo`, `-redo`, and `-rollback` methods are only available when this parameter is `YES`, otherwise those method will raise an exception. Note that turning on Undo support may heavily impact performance especially on iOS or watchOS where memory is limited. - returns: a `CSUnsafeDataTransaction` instance where creates, updates, and deletes can be made. */ @objc - public func beginUnsafeWithSourceIdentifier( - _ sourceIdentifier: Any? - ) -> CSUnsafeDataTransaction { + public func beginUnsafeWithSupportsUndo(_ supportsUndo: Bool) -> CSUnsafeDataTransaction { return bridge { - self.bridgeToSwift.beginUnsafe( - sourceIdentifier: sourceIdentifier - ) - } - } - - /** - Begins a child transaction where `NSManagedObject` creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms. - - - parameter supportsUndo: `-undo`, `-redo`, and `-rollback` methods are only available when this parameter is `YES`, otherwise those method will raise an exception. Note that turning on Undo support may heavily impact performance especially on iOS or watchOS where memory is limited. - - returns: a `CSUnsafeDataTransaction` instance where creates, updates, and deletes can be made. - */ - @objc - public func beginUnsafeWithSupportsUndo( - _ supportsUndo: Bool - ) -> CSUnsafeDataTransaction { - - return bridge { - - self.bridgeToSwift.beginUnsafe( - supportsUndo: supportsUndo - ) - } - } - - /** - Begins a child transaction where `NSManagedObject` creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms. - - - parameter supportsUndo: `-undo`, `-redo`, and `-rollback` methods are only available when this parameter is `YES`, otherwise those method will raise an exception. Note that turning on Undo support may heavily impact performance especially on iOS or watchOS where memory is limited. - - parameter sourceIdentifier: an optional value that identifies the source of this transaction. This identifier will be passed to the change notifications and callers can use it for custom handling that depends on the source. - - returns: a `CSUnsafeDataTransaction` instance where creates, updates, and deletes can be made. - */ - @objc - public func beginUnsafeWithSupportsUndo( - _ supportsUndo: Bool, - sourceIdentifier: Any? - ) -> CSUnsafeDataTransaction { - - return bridge { - - self.bridgeToSwift.beginUnsafe( - supportsUndo: supportsUndo, - sourceIdentifier: sourceIdentifier - ) + self.bridgeToSwift.beginUnsafe(supportsUndo: supportsUndo) } } diff --git a/Sources/CSSynchronousDataTransaction.swift b/Sources/CSSynchronousDataTransaction.swift index 27c2853..bdabd8b 100644 --- a/Sources/CSSynchronousDataTransaction.swift +++ b/Sources/CSSynchronousDataTransaction.swift @@ -49,10 +49,9 @@ public final class CSSynchronousDataTransaction: CSBaseDataTransaction, CoreStor return bridge(error) { - let transaction = self.bridgeToSwift - if case (_, let error?) = transaction.context.saveSynchronously( + if case (_, let error?) = self.bridgeToSwift.context.saveSynchronously( waitForMerge: true, - sourceIdentifier: transaction.sourceIdentifier + sourceIdentifier: nil ) { throw error diff --git a/Sources/CSUnsafeDataTransaction.swift b/Sources/CSUnsafeDataTransaction.swift index 8e331c3..455e5ae 100644 --- a/Sources/CSUnsafeDataTransaction.swift +++ b/Sources/CSUnsafeDataTransaction.swift @@ -46,21 +46,20 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction, CoreStoreObje @objc public func commitWithSuccess(_ success: (() -> Void)?, _ failure: ((CSError) -> Void)?) { - let transaction = self.bridgeToSwift - transaction.context.saveAsynchronously( - sourceIdentifier: transaction.sourceIdentifier, + self.bridgeToSwift.context.saveAsynchronously( + sourceIdentifier: nil, completion: { (_, error) in - + defer { - + withExtendedLifetime(self, {}) } if let error = error { - + failure?(error.bridgeToObjectiveC) } else { - + success?() } } @@ -75,13 +74,12 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction, CoreStoreObje */ @objc public func commitAndWait(error: NSErrorPointer) -> Bool { - + return bridge(error) { - let transaction = self.bridgeToSwift - if case (_, let error?) = transaction.context.saveSynchronously( + if case (_, let error?) = self.bridgeToSwift.context.saveSynchronously( waitForMerge: true, - sourceIdentifier: transaction.sourceIdentifier + sourceIdentifier: nil ) { throw error @@ -160,61 +158,15 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction, CoreStoreObje /** Begins a child transaction where `NSManagedObject` creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms. - To support "undo" methods such as `-undo`, `-redo`, and `-rollback`, use the `-beginSafeWithSupportsUndo:` method passing `YES` to the argument. Without "undo" support, calling those methods will raise an exception. - - parameter sourceIdentifier: an optional value that identifies the source of this transaction. This identifier will be passed to the change notifications and callers can use it for custom handling that depends on the source. + - prameter supportsUndo: `-undo`, `-redo`, and `-rollback` methods are only available when this parameter is `YES`, otherwise those method will raise an exception. Note that turning on Undo support may heavily impact performance especially on iOS or watchOS where memory is limited. - returns: a `CSUnsafeDataTransaction` instance where creates, updates, and deletes can be made. */ @objc - public func beginUnsafeWithSourceIdentifier( - _ sourceIdentifier: Any? - ) -> CSUnsafeDataTransaction { + public func beginUnsafeWithSupportsUndo(_ supportsUndo: Bool) -> CSUnsafeDataTransaction { return bridge { - self.bridgeToSwift.beginUnsafe( - sourceIdentifier: sourceIdentifier - ) - } - } - - /** - Begins a child transaction where `NSManagedObject` creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms. - - - parameter supportsUndo: `-undo`, `-redo`, and `-rollback` methods are only available when this parameter is `YES`, otherwise those method will raise an exception. Note that turning on Undo support may heavily impact performance especially on iOS or watchOS where memory is limited. - - returns: a `CSUnsafeDataTransaction` instance where creates, updates, and deletes can be made. - */ - @objc - public func beginUnsafeWithSupportsUndo( - _ supportsUndo: Bool - ) -> CSUnsafeDataTransaction { - - return bridge { - - self.bridgeToSwift.beginUnsafe( - supportsUndo: supportsUndo - ) - } - } - - /** - Begins a child transaction where `NSManagedObject` creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms. - - - parameter supportsUndo: `-undo`, `-redo`, and `-rollback` methods are only available when this parameter is `YES`, otherwise those method will raise an exception. Note that turning on Undo support may heavily impact performance especially on iOS or watchOS where memory is limited. - - parameter sourceIdentifier: an optional value that identifies the source of this transaction. This identifier will be passed to the change notifications and callers can use it for custom handling that depends on the source. - - returns: a `CSUnsafeDataTransaction` instance where creates, updates, and deletes can be made. - */ - @objc - public func beginUnsafeWithSupportsUndo( - _ supportsUndo: Bool, - sourceIdentifier: Any? - ) -> CSUnsafeDataTransaction { - - return bridge { - - self.bridgeToSwift.beginUnsafe( - supportsUndo: supportsUndo, - sourceIdentifier: sourceIdentifier - ) + self.bridgeToSwift.beginUnsafe(supportsUndo: supportsUndo) } }