ReactiveNamespace

The DataStack instance

Reactive extension for CoreStore.DataStack‘s addStorage(...) API. Asynchronously adds a StorageInterface to the stack.

dataStack.reactive
    .addStorage(
        InMemoryStore(configuration: "Config1")
    )
    .sink(
        receiveCompletion: { result in
            // ...
        },
        receiveValue: { storage in
            // ...
        }
    )
    .store(in: &cancellables)

Reactive extension for CoreStore.DataStack‘s addStorage(...) API. Asynchronously adds a LocalStorage to the stack. Migrations are also initiated by default. The event emits MigrationProgress enum values.

dataStack.reactive
    .addStorage(
        SQLiteStore(
            fileName: "core_data.sqlite",
            configuration: "Config1"
        )
    )
    .sink(
        receiveCompletion: { result in
            // ...
        },
        receiveValue: { (progress) in
            print("\(round(progress.fractionCompleted * 100)) %") // 0.0 ~ 1.0
        }
    )
    .store(in: &cancellables)

Reactive extension for CoreStore.DataStack‘s importObject(...) API. Creates an ImportableObject by importing from the specified import source. The event value will be the object instance correctly associated for the DataStack.

dataStack.reactive
    .importObject(
        Into<Person>(),
        source: ["name": "John"]
    )
    .sink(
        receiveCompletion: { result in
            // ...
        },
        receiveValue: { (person) in
            XCTAssertNotNil(person)
            // ...
        }
    )
    .store(in: &cancellables)

Reactive extension for CoreStore.DataStack‘s importObject(...) API. Updates an existing ImportableObject by importing values from the specified import source. The event value will be the object instance correctly associated for the DataStack.

let existingPerson: Person = // ...
dataStack.reactive
    .importObject(
        existingPerson,
        source: ["name": "John", "age": 30]
    )
    .sink(
        receiveCompletion: { result in
            // ...
        },
        receiveValue: { (person) in
            XCTAssertEqual(person?.age, 30)
            // ...
        }
    )
    .store(in: &cancellables)

Reactive extension for CoreStore.DataStack‘s importUniqueObject(...) API. Updates an existing ImportableUniqueObject or creates a new instance by importing from the specified import source. The event value will be the object instance correctly associated for the DataStack.

dataStack.reactive
    .importUniqueObject(
        Into<Person>(),
        source: ["name": "John", "age": 30]
    )
    .sink(
        receiveCompletion: { result in
            // ...
        },
        receiveValue: { (person) in
            XCTAssertEqual(person?.age, 30)
            // ...
        }
    )
    .store(in: &cancellables)

Reactive extension for CoreStore.DataStack‘s importUniqueObjects(...) API. Updates existing ImportableUniqueObjects or creates them by importing from the specified array of import sources. ImportableUniqueObject methods are called on the objects in the same order as they are in the sourceArray, and are returned in an array with that same order. The event values will be object instances correctly associated for the DataStack.

dataStack.reactive
    .importUniqueObjects(
        Into<Person>(),
        sourceArray: [
            ["name": "John"],
            ["name": "Bob"],
            ["name": "Joe"]
        ]
    )
    .sink(
        receiveCompletion: { result in
            // ...
        },
        receiveValue: { (people) in
            XCTAssertEqual(people?.count, 3)
            // ...
        }
    )
    .store(in: &cancellables)

Reactive extension for CoreStore.DataStack‘s perform(asynchronous:...) API. Performs a transaction asynchronously where NSManagedObject creates, updates, and deletes can be made. The changes are commited automatically after the task closure returns. The event value will be the value returned from the task closure. Any errors thrown from inside the task will be wrapped in a CoreStoreError and reported to the completion .failure. To cancel/rollback changes, call transaction.cancel(), which throws a CoreStoreError.userCancelled.

dataStack.reactive
    .perform(
        asynchronous: { (transaction) -> (inserted: Set<NSManagedObject>, deleted: Set<NSManagedObject>) in

            // ...
            return (
                transaction.insertedObjects(),
                transaction.deletedObjects()
            )
        }
    )
    .sink(
        receiveCompletion: { result in
            // ...
        },
        receiveValue: { value in
            let inserted = dataStack.fetchExisting(value0.inserted)
            let deleted = dataStack.fetchExisting(value0.deleted)
            // ...
        }
    )
    .store(in: &cancellables)