Package apple.coredata

Class NSPersistentStoreCoordinator

    • Constructor Detail

      • NSPersistentStoreCoordinator

        protected NSPersistentStoreCoordinator​(org.moe.natj.general.Pointer peer)

    • Method Detail

      • accessInstanceVariablesDirectly

        public static boolean accessInstanceVariablesDirectly()

      • allocWithZone

        public static java.lang.Object allocWithZone​(org.moe.natj.general.ptr.VoidPtr zone)

      • automaticallyNotifiesObserversForKey

        public static boolean automaticallyNotifiesObserversForKey​(java.lang.String key)

      • cancelPreviousPerformRequestsWithTarget

        public static void cancelPreviousPerformRequestsWithTarget​(java.lang.Object aTarget)

      • cancelPreviousPerformRequestsWithTargetSelectorObject

        public static void cancelPreviousPerformRequestsWithTargetSelectorObject​(java.lang.Object aTarget,
                                                                         org.moe.natj.objc.SEL aSelector,
                                                                         java.lang.Object anArgument)

      • classFallbacksForKeyedArchiver

        public static NSArray<java.lang.String> classFallbacksForKeyedArchiver()

      • classForKeyedUnarchiver

        public static org.moe.natj.objc.Class classForKeyedUnarchiver()

      • debugDescription_static

        public static java.lang.String debugDescription_static()

      • description_static

        public static java.lang.String description_static()

      • hash_static

        public static long hash_static()

      • instanceMethodSignatureForSelector

        public static NSMethodSignature instanceMethodSignatureForSelector​(org.moe.natj.objc.SEL aSelector)

      • instancesRespondToSelector

        public static boolean instancesRespondToSelector​(org.moe.natj.objc.SEL aSelector)

      • isSubclassOfClass

        public static boolean isSubclassOfClass​(org.moe.natj.objc.Class aClass)

      • keyPathsForValuesAffectingValueForKey

        public static NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey​(java.lang.String key)

      • metadataForPersistentStoreOfTypeURLError

        @Deprecated
public static NSDictionary<java.lang.String,​?> metadataForPersistentStoreOfTypeURLError​(java.lang.String storeType,
                                                                                              NSURL url,
                                                                                              org.moe.natj.general.ptr.Ptr<NSError> error)
        Deprecated.

      • metadataForPersistentStoreOfTypeURLOptionsError

        public static NSDictionary<java.lang.String,​?> metadataForPersistentStoreOfTypeURLOptionsError​(java.lang.String storeType,
                                                                                                     NSURL url,
                                                                                                     NSDictionary<?,​?> options,
                                                                                                     org.moe.natj.general.ptr.Ptr<NSError> error)
        Allows to access the metadata stored in a persistent store without warming up a CoreData stack; the guaranteed keys in this dictionary are NSStoreTypeKey and NSStoreUUIDKey. If storeType is nil, Core Data will guess which store class should be used to get/set the store file's metadata.

      • new_objc

        public static java.lang.Object new_objc()

      • registerStoreClassForStoreType

        public static void registerStoreClassForStoreType​(org.moe.natj.objc.Class storeClass,
                                                  java.lang.String storeType)
        Registers the specified NSPersistentStore subclass for the specified store type string. This method must be invoked before a custom subclass of NSPersistentStore can be loaded into a persistent store coordinator. Passing nil for the store class argument will unregister the specified store type.

      • registeredStoreTypes

        public static NSDictionary<java.lang.String,​? extends NSValue> registeredStoreTypes()
        Returns a dictionary of the registered store types: the keys are the store type strings and the values are the NSPersistentStore subclasses wrapped in NSValues.

      • removeUbiquitousContentAndPersistentStoreAtURLOptionsError

        public static boolean removeUbiquitousContentAndPersistentStoreAtURLOptionsError​(NSURL storeURL,
                                                                                 NSDictionary<?,​?> options,
                                                                                 org.moe.natj.general.ptr.Ptr<NSError> error)
        Delete all ubiquitous content for all peers for the persistent store at the given URL and also delete the local store file. storeOptions should contain the options normally passed to addPersistentStoreWithType:URL:options:error. Errors may be returned as a result of file I/O, iCloud network or iCloud account issues.

      • resolveClassMethod

        public static boolean resolveClassMethod​(org.moe.natj.objc.SEL sel)

      • resolveInstanceMethod

        public static boolean resolveInstanceMethod​(org.moe.natj.objc.SEL sel)

      • setMetadataForPersistentStoreOfTypeURLError

        @Deprecated
public static boolean setMetadataForPersistentStoreOfTypeURLError​(NSDictionary<java.lang.String,​?> metadata,
                                                                  java.lang.String storeType,
                                                                  NSURL url,
                                                                  org.moe.natj.general.ptr.Ptr<NSError> error)
        Deprecated.

      • setMetadataForPersistentStoreOfTypeURLOptionsError

        public static boolean setMetadataForPersistentStoreOfTypeURLOptionsError​(NSDictionary<java.lang.String,​?> metadata,
                                                                         java.lang.String storeType,
                                                                         NSURL url,
                                                                         NSDictionary<?,​?> options,
                                                                         org.moe.natj.general.ptr.Ptr<NSError> error)

      • setVersion_static

        public static void setVersion_static​(long aVersion)

      • superclass_static

        public static org.moe.natj.objc.Class superclass_static()

      • version_static

        public static long version_static()

      • addPersistentStoreWithTypeConfigurationURLOptionsError

        public NSPersistentStore addPersistentStoreWithTypeConfigurationURLOptionsError​(java.lang.String storeType,
                                                                                java.lang.String configuration,
                                                                                NSURL storeURL,
                                                                                NSDictionary<?,​?> options,
                                                                                org.moe.natj.general.ptr.Ptr<NSError> error)
        Adds the store at the specified URL (of the specified type) to the coordinator with the model configuration and options. The configuration can be nil -- then it's the complete model; storeURL is usually the file location of the database

      • destroyPersistentStoreAtURLWithTypeOptionsError

        public boolean destroyPersistentStoreAtURLWithTypeOptionsError​(NSURL url,
                                                               java.lang.String storeType,
                                                               NSDictionary<?,​?> options,
                                                               org.moe.natj.general.ptr.Ptr<NSError> error)
        delete or truncate the target persistent store in accordance with the store class's requirements. It is important to pass similar options as addPersistentStoreWithType: ... SQLite stores will honor file locks, journal files, journaling modes, and other intricacies. It is not possible to unlink a database file safely out from underneath another thread or process, so this API performs a truncation. Other stores will default to using NSFileManager.

      • executeRequestWithContextError

        public java.lang.Object executeRequestWithContextError​(NSPersistentStoreRequest request,
                                                       NSManagedObjectContext context,
                                                       org.moe.natj.general.ptr.Ptr<NSError> error)
        Sends a request to all of the stores associated with this coordinator. Returns an array if successful, nil if not. The contents of the array will vary depending on the request type: NSFetchRequest results will be an array of managed objects, managed object IDs, or NSDictionaries; NSSaveChangesRequests will an empty array. User defined requests will return arrays of arrays, where the nested array is the result returned form a single store.

      • lock

        @Deprecated
public void lock()
        Deprecated.
        Specified by:
        lock in interface NSLocking

      • managedObjectIDForURIRepresentation

        public NSManagedObjectID managedObjectIDForURIRepresentation​(NSURL url)
        Given a URI representation of an object ID, returns an object ID if a matching store is available or nil if a matching store cannot be found (the URI representation contains a UUID of the store the ID is coming from, and the coordinator can match it against the stores added to it)

      • metadataForPersistentStore

        public NSDictionary<java.lang.String,​?> metadataForPersistentStore​(NSPersistentStore store)
        Returns the metadata currently stored or to-be-stored in the persistent store

      • migratePersistentStoreToURLOptionsWithTypeError

        public NSPersistentStore migratePersistentStoreToURLOptionsWithTypeError​(NSPersistentStore store,
                                                                         NSURL URL,
                                                                         NSDictionary<?,​?> options,
                                                                         java.lang.String storeType,
                                                                         org.moe.natj.general.ptr.Ptr<NSError> error)
        Used for save as - performance may vary depending on the type of old and new store; the old store is usually removed from the coordinator by the migration operation, and therefore is no longer a useful reference after invoking this method

      • name

        public java.lang.String name()
        custom name for a coordinator. Coordinators will set the label on their queue

      • removePersistentStoreError

        public boolean removePersistentStoreError​(NSPersistentStore store,
                                          org.moe.natj.general.ptr.Ptr<NSError> error)

      • replacePersistentStoreAtURLDestinationOptionsWithPersistentStoreFromURLSourceOptionsStoreTypeError

        public boolean replacePersistentStoreAtURLDestinationOptionsWithPersistentStoreFromURLSourceOptionsStoreTypeError​(NSURL destinationURL,
                                                                                                                  NSDictionary<?,​?> destinationOptions,
                                                                                                                  NSURL sourceURL,
                                                                                                                  NSDictionary<?,​?> sourceOptions,
                                                                                                                  java.lang.String storeType,
                                                                                                                  org.moe.natj.general.ptr.Ptr<NSError> error)
        copy or overwrite the target persistent store in accordance with the store class's requirements. It is important to pass similar options as addPersistentStoreWithType: ... SQLite stores will honor file locks, journal files, journaling modes, and other intricacies. Other stores will default to using NSFileManager.

      • setMetadataForPersistentStore

        public void setMetadataForPersistentStore​(NSDictionary<java.lang.String,​?> metadata,
                                          NSPersistentStore store)
        Sets the metadata stored in the persistent store during the next save operation executed on it; the store type and UUID (NSStoreTypeKey and NSStoreUUIDKey) are always added automatically (but NSStoreUUIDKey is only added if it is not set manually as part of the dictionary argument)

      • setName

        public void setName​(java.lang.String value)
        custom name for a coordinator. Coordinators will set the label on their queue

      • setURLForPersistentStore

        public boolean setURLForPersistentStore​(NSURL url,
                                        NSPersistentStore store)
        Sets the URL for the specified store in the coordinator. For atomic stores, this will alter the location to which the next save operation will persist the file; for non-atomic stores, invoking this method will release the existing connection and create a new one at the specified URL. (For non-atomic stores, a store must pre-exist at the destination URL; a new store will not be created.)

      • tryLock

        @Deprecated
public boolean tryLock()
        Deprecated.

      • unlock

        @Deprecated
public void unlock()
        Deprecated.
        Specified by:
        unlock in interface NSLocking

      • currentPersistentHistoryTokenFromStores

        public NSPersistentHistoryToken currentPersistentHistoryTokenFromStores​(NSArray<?> stores)
        Constructs a combined NSPersistentHistoryToken given an array of persistent stores. If stores is nil or an empty array, the NSPersistentHistoryToken will be constructed with all of the persistent stores in the coordinator.