Protocols

The CSFetchClause implement clauses used to configure NSFetchRequests.

The CSQueryClause implement clauses used to configure NSFetchRequests.

The CSDeleteClause implement clauses used to configure NSFetchRequests.

The CSDynamicSchema serves as the Objective-C bridging type for DynamicSchema.

Implement the CSListObserver protocol to observe changes to a list of NSManagedObjects. CSListObservers may register themselves to a CSListMonitor‘s -addListObserver: method:

CSListMonitor *monitor = [CSCoreStore 
    monitorListFrom:[CSFrom entityClass:[MyPersonEntity class]]
    fetchClauses:@[[CSOrderBy sortDescriptor:[CSSortKey withKeyPath:@"lastName" ascending:YES]]]];
[monitor addListObserver:self];

Implement the CSListObjectObserver protocol to observe detailed changes to a list’s object. CSListObjectObservers may register themselves to a CSListMonitor‘s -addListObjectObserver(_:) method:

CSListMonitor *monitor = [CSCoreStore
    monitorListFrom:[CSFrom entityClass:[MyPersonEntity class]]
    fetchClauses:@[[CSOrderBy sortDescriptor:[CSSortKey withKeyPath:@"lastName" ascending:YES]]]];
[monitor addListObjectObserver:self];

Implement the CSListSectionObserver protocol to observe changes to a list’s section info. CSListSectionObservers may register themselves to a CSListMonitor‘s -addListSectionObserver: method:

CSListMonitor *monitor = [CSCoreStore
    monitorSectionedListFrom:[CSFrom entityClass:[MyPersonEntity class]]
    sectionBy:[CSSectionBy keyPath:@"age"]
    fetchClauses:@[[CSOrderBy sortDescriptor:[CSSortKey withKeyPath:@"lastName" ascending:YES]]]];
[monitor addListSectionObserver:self];

Implement the CSObjectObserver protocol to observe changes to a single NSManagedObject instance. CSObjectObservers may register themselves to a CSObjectMonitor‘s -addObjectObserver: method:

CSObjectMonitor *monitor = [CSCoreStore monitorObject:myObject];
[monitor addObjectObserver:self];

The CSStorageInterface serves as the Objective-C bridging type for StorageInterface.

The CSLocalStorage serves as the Objective-C bridging type for LocalStorage.

Objective-C Foundation types that are natively supported by Core Data managed attributes all conform to CoreDataNativeType.

CoreStoreObjectiveCTypes are Objective-C accessible classes that represent CoreStore’s Swift types.

CoreStoreSwiftTypes are CoreStore’s Swift types that are bridgeable to Objective-C.

Custom loggers should implement the CoreStoreLogger protocol and pass its instance to CoreStore.logger. Calls to log(...), assert(...), and abort(...) are not tied to a specific queue/thread, so it is the implementer’s job to handle thread-safety.

Observation token for CoreStoreObject properties. Make sure to retain this instance to keep observing notifications.

invalidate() will be called automatically when an CoreStoreObjectKeyValueObservation is deinited.

All CoreStore’s utilities are designed around DynamicObject instances. NSManagedObject and CoreStoreObject instances all conform to DynamicObject.

Used only for utility methods.

DynamicSchema are types that provide NSManagedObjectModel instances for a single model version. CoreStore currently supports the following concrete types:

• XcodeDataModelSchema: describes models loaded from a .xcdatamodeld file.
• UnsafeDataModelSchema: describes models loaded directly from an existing NSManagedObjectModel. It is not advisable to continue using this model as its metadata are not available to CoreStore.
• CoreStoreSchema: describes models written for CoreStoreObject Swift class declarations.

Utility protocol for FetchChainBuilder. Used in fetch methods that support chained fetch builders.

Encapsulates containers which manages an internal NSManagedObjectContext, such as DataStacks and transactions, that can be used for fetching objects. CoreStore provides implementations for this protocol and should be used as a read-only abstraction.

Abstracts the GroupBy clause for protocol utilities.

Types supported by CoreStore as NSManagedObject and CoreStoreObject property types. Supported default types:

In addition, RawRepresentable types whose RawValue already implements ImportableAttributeType only need to declare conformance to ImportableAttributeType.

NSManagedObject and CoreStoreObject subclasses that conform to the ImportableObject protocol can be imported from a specified ImportSource. This allows transactions to create and insert instances this way:

class Person: NSManagedObject, ImportableObject {
    typealias ImportSource = NSDictionary
    // ...
}

CoreStore.perform(
    asynchronous: { (transaction) -> Void in
        let json: NSDictionary = // ...
        let person = try transaction.importObject(
            Into<Person>(),
            source: json
        )
        // ...
    },
    completion: { (result) in
        // ...
    }
)

NSManagedObject subclasses that conform to the ImportableUniqueObject protocol can be imported from a specified ImportSource. This allows transactions to either update existing objects or create new instances this way:

class Person: NSManagedObject, ImportableObject {
    typealias ImportSource = NSDictionary
    typealias UniqueIDType = NSString
    // ...
}

CoreStore.perform(
    asynchronous: { (transaction) -> Void in
        let json: NSDictionary = // ...
        let person = try transaction.importUniqueObject(
            Into<Person>(),
            source: json
        )
        // ...
    },
    completion: { (result) in
        // ...
    }
)

Used only for utility methods. Types allowed as Value generic type to KeyPath utilities.

Used only for utility methods. Types allowed as Value generic type to KeyPath utilities.

Used only for utility methods. Types allowed as Value generic type to KeyPath utilities.

Used only for utility methods. Types allowed as Value generic type to KeyPath utilities.

Used only for utility methods. Types allowed as Value generic type to KeyPath utilities.

Implement the ListObserver protocol to observe changes to a list of NSManagedObjects. ListObservers may register themselves to a ListMonitor‘s addObserver(_:) method:

let monitor = CoreStore.monitorList(
    From<Person>(),
    OrderBy(.ascending("lastName"))
)
monitor.addObserver(self)

Implement the ListObjectObserver protocol to observe detailed changes to a list’s object. ListObjectObservers may register themselves to a ListMonitor‘s addObserver(_:) method:

let monitor = CoreStore.monitorList(
    From<MyPersonEntity>(),
    OrderBy(.ascending("lastName"))
)
monitor.addObserver(self)

Implement the ListSectionObserver protocol to observe changes to a list’s section info. ListSectionObservers may register themselves to a ListMonitor‘s addObserver(_:) method:

let monitor = CoreStore.monitorSectionedList(
    From<MyPersonEntity>(),
    SectionBy("age") { "Age \($0)" },
    OrderBy(.ascending("lastName"))
)
monitor.addObserver(self)

Implement the ObjectObserver protocol to observe changes to a single DynamicObject instance. ObjectObservers may register themselves to a ObjectMonitor‘s addObserver(_:) method:

let monitor = CoreStore.monitorObject(object)
monitor.addObserver(self)

Abstracts the OrderBy clause for protocol utilities.

Utility protocol for QueryChainBuilder. Used in fetch methods that support chained query builders.

Types supported by CoreStore for querying, especially as generic type for Select clauses. Supported default types:

• Bool
• CGFloat
• Data
• Date
• Double
• Float
• Int
• Int8
• Int16
• Int32
• Int64
• NSData
• NSDate
• NSDecimalNumber
• NSManagedObjectID
• NSNull
• NSNumber
• NSString
• NSURL
• NSUUID
• String
• URL
• UUID

In addition, RawRepresentable types whose RawValue already implements QueryableAttributeType only need to declare conformance to QueryableAttributeType.

Encapsulates containers which manages an internal NSManagedObjectContext, such as DataStacks and transactions, that can be used for querying values. CoreStore provides implementations for this protocol and should be used as a read-only abstraction.

The SchemaMappingProvider provides migration mapping information between two DynamicSchema versions.

Utility protocol for SectionMonitorChainBuilder. Used in methods that support chained fetch builders.

The SelectResultType protocol is implemented by return types supported by the Select clause.

The SelectAttributesResultType protocol is implemented by return types supported by the queryAttributes(...) methods.

Abstracts the Select clause for protocol utilities.

The StorageInterface represents the data store managed (or to be managed) by the DataStack. When added to the DataStack, the StorageInterface serves as the interface for the NSPersistentStore. This may be a database file, an in-memory store, etc.

The LocalStorage represents StorageInterfaces that are backed by local files.

The CloudStorage represents StorageInterfaces that are synchronized from a cloud-based store.

The FetchClause implement clauses used to configure NSFetchRequests.

The QueryClause implement clauses used to configure NSFetchRequests.

The DeleteClause implement clauses used to configure NSFetchRequests.

Type-erased Where clause for protocol utilities.

Used only for Where.Expression type constraints. Currently supports SingleTarget and CollectionTarget.

Abstracts the Where clause for protocol utilities. Typically used only for utility method generic constraints.