UnsafeDataTransaction

Saves the transaction changes asynchronously. For an UnsafeDataTransaction, multiple commits are allowed, although it is the developer’s responsibility to ensure a reasonable leeway to prevent blocking the main thread.

Saves the transaction changes and waits for completion synchronously. For an UnsafeDataTransaction, multiple commits are allowed, although it is the developer’s responsibility to ensure a reasonable leeway to prevent blocking the main thread.

Rolls back the transaction.

Undo’s the last change made to the transaction.

Immediately flushes all pending changes to the transaction’s observers. This is useful in conjunction with ListMonitors and ObjectMonitors created from UnsafeDataTransactions used to manage temporary “scratch” data.

Flushes all pending changes to the transaction’s observers at the end of the closure‘s execution. This is useful in conjunction with ListMonitors and ObjectMonitors created from UnsafeDataTransactions used to manage temporary “scratch” data.

Redo’s the last undone change to the transaction.

Begins a child transaction where NSManagedObject or CoreStoreObject creates, updates, and deletes can be made. This is useful for making temporary changes, such as partially filled forms.

Utility for creating an NSFetchedResultsController from the UnsafeDataTransaction. This is useful when an NSFetchedResultsController is preferred over the overhead of ListMonitors abstraction.

Utility for creating an NSFetchedResultsController from the UnsafeDataTransaction. This is useful when an NSFetchedResultsController is preferred over the overhead of ListMonitors abstraction.

Utility for creating an NSFetchedResultsController from the UnsafeDataTransaction. This is useful when an NSFetchedResultsController is preferred over the overhead of ListMonitors abstraction.

Utility for creating an NSFetchedResultsController from the UnsafeDataTransaction. This is useful when an NSFetchedResultsController is preferred over the overhead of ListMonitors abstraction.

Creates an ObjectMonitor for the specified DynamicObject. Multiple ObjectObservers may then register themselves to be notified when changes are made to the DynamicObject.

Creates a ListMonitor for a list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list.

Creates a ListMonitor for a list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list.

Asynchronously creates a ListMonitor for a list of DynamicObjects that satisfy the specified FetchChainableBuilderType built from a chain of clauses. 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.

transaction.monitorList(
    { (monitor) in
        self.monitor = monitor
    },
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Asynchronously creates a ListMonitor for a list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers 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.

Asynchronously creates a ListMonitor for a list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers 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.

Asynchronously creates a ListMonitor for a list of DynamicObjects that satisfy the specified FetchChainableBuilderType built from a chain of clauses. 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.

dataStack.monitorList(
    createAsynchronously: { (monitor) in
        self.monitor = monitor
    },
    From<MyPersonEntity>()
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list.

Creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers may then register themselves to be notified when changes are made to the list.

Creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified SectionMonitorBuilderType built from a chain of clauses.

let monitor = transaction.monitorSectionedList(
    From<MyPersonEntity>()
        .sectionBy(\.age, { "\($0!) years old" })
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)

Asynchronously creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers 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.

Asynchronously creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified fetch clauses. Multiple ListObservers 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.

Asynchronously creates a ListMonitor for a sectioned list of DynamicObjects that satisfy the specified SectionMonitorBuilderType built from a chain of clauses.

transaction.monitorSectionedList(
    { (monitor) in
        self.monitor = monitor
    },
    From<MyPersonEntity>()
        .sectionBy(\.age, { "\($0!) years old" })
        .where(\.age > 18)
        .orderBy(.ascending(\.age))
)