Struct CKSyncEngineConfiguration

Source

pub struct CKSyncEngineConfiguration { /* private fields */ }

Available on crate feature CKSyncEngineConfiguration only.

Expand description

Apple’s documentation

Implementations§

Source §

impl CKSyncEngineConfiguration

Source

pub unsafe fn initWithDatabase_stateSerialization_delegate( this: Allocated<Self>, database: &CKDatabase, state_serialization: Option<&CKSyncEngineStateSerialization>, delegate: &ProtocolObject<dyn CKSyncEngineDelegate>, ) -> Retained<Self>

Available on crate features CKDatabase and CKSyncEngine and CKSyncEngineState only.

Source

pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>

Source

pub unsafe fn new() -> Retained<Self>

Source

pub unsafe fn database(&self) -> Retained<CKDatabase>

Available on crate feature CKDatabase only.

The database for this sync engine to sync with.

You can have multiple instances of CKSyncEngine in the same process, each targeting a different database. For example, you might have one for your private database and one for your shared database.

It’s also technically possible to have multiple instances of CKSyncEngine for the same CKDatabase. This isn’t recommended for production code, but it can be helpful for testing your CKSyncEngine integration. For example, you might make multiple CKSyncEngine instances to simulate multiple devices syncing back and forth.

Source

pub unsafe fn setDatabase(&self, database: &CKDatabase)

Available on crate feature CKDatabase only.

Setter for database.

Source

pub unsafe fn stateSerialization( &self, ) -> Option<Retained<CKSyncEngineStateSerialization>>

Available on crate feature CKSyncEngineState only.

The state serialization you last received in a CKSyncEngine/Event/StateUpdate.

If this is the first time ever initializing your CKSyncEngine, you can provide nil.

Source

pub unsafe fn setStateSerialization( &self, state_serialization: Option<&CKSyncEngineStateSerialization>, )

Available on crate feature CKSyncEngineState only.

Setter for stateSerialization.

This is copied when set.

Source

pub unsafe fn delegate( &self, ) -> Option<Retained<ProtocolObject<dyn CKSyncEngineDelegate>>>

Available on crate feature CKSyncEngine only.

Your implementation of CKSyncEngineDelegate.

Source

pub unsafe fn setDelegate( &self, delegate: Option<&ProtocolObject<dyn CKSyncEngineDelegate>>, )

Available on crate feature CKSyncEngine only.

Setter for delegate.

This is a weak property.

Source

pub unsafe fn automaticallySync(&self) -> bool

Whether or not the sync engine should automatically sync on your behalf.

If true, then the sync engine will automatically sync using the system scheduler. This is the default value. When you add pending changes to the state, the sync engine will automatically schedule a sync task to send changes. When it receives a notification about new changes on the server, it will automatically schedule a sync task to fetch changes. It will also automatically re-schedule sync tasks for retryable errors such as network failures or server throttles.

If CKSyncEngineConfiguration/automaticallySync is off, then the sync engine will not perform any operations unless you tell it to do so via CKSyncEngine/fetchChanges(_:) or CKSyncEngine/sendChanges(_:).

Most applications likely want to enable automatic syncing during normal use. However, you might want to disable it if you have specific requirements for when you want to sync. For example, if you want to sync only once per day, you can turn off automatic sync and manually call CKSyncEngine/fetchChanges(_:) and CKSyncEngine/sendChanges(_:) once per day.

You might also disable automatic sync when writing automated tests for your integration with CKSyncEngine. This way, you can have fine grained control over exactly when the sync engine fetches or sends changes. This allows you to simulate edge cases and deterministically test your logic around scenarios like conflict resolution and error handling.

Source

pub unsafe fn setAutomaticallySync(&self, automatically_sync: bool)

Setter for automaticallySync.

Source

pub unsafe fn subscriptionID(&self) -> Option<Retained<CKSubscriptionID>>

Available on crate feature CKSubscription only.

An optional override for the sync engine’s default database subscription ID. Use this for backward compatibility with a previous CloudKit sync implementation.

By default, CKSyncEngine will create its own CKDatabaseSubscription with its own subscription ID. If you’re migrating to CKSyncEngine from a custom CloudKit sync implementation, you can specify your previous subscription ID here. This allows your CKSyncEngine integration to be backward compatible with previous versions of your app.

Note: CKSyncEngine will automatically attempt to discover any previous database subscriptions, but you can be more explicit by giving the subscription ID through this configuration option.

Source

pub unsafe fn setSubscriptionID( &self, subscription_id: Option<&CKSubscriptionID>, )

Available on crate feature CKSubscription only.

Setter for subscriptionID.

This is copied when set.

Methods from Deref<Target = NSObject>§

Source

pub fn doesNotRecognizeSelector(&self, sel: Sel) -> !

Handle messages the object doesn’t recognize.

See Apple’s documentation for details.

Methods from Deref<Target = AnyObject>§

Source

pub fn class(&self) -> &'static AnyClass

Dynamically find the class of this object.

§Panics

May panic if the object is invalid (which may be the case for objects returned from unavailable init/new methods).

§Example

Check that an instance of NSObject has the precise class NSObject.

use objc2::ClassType;
use objc2::runtime::NSObject;

let obj = NSObject::new();
assert_eq!(obj.class(), NSObject::class());

Source

pub unsafe fn get_ivar<T>(&self, name: &str) -> &T
where T: Encode,

👎Deprecated: this is difficult to use correctly, use Ivar::load instead.

Use Ivar::load instead.

§Safety

The object must have an instance variable with the given name, and it must be of type T.

See Ivar::load_ptr for details surrounding this.

Source

pub fn downcast_ref<T>(&self) -> Option<&T>
where T: DowncastTarget,

Attempt to downcast the object to a class of type T.

This is the reference-variant. Use Retained::downcast if you want to convert a retained object to another type.

§Mutable classes

Some classes have immutable and mutable variants, such as NSString and NSMutableString.

When some Objective-C API signature says it gives you an immutable class, it generally expects you to not mutate that, even though it may technically be mutable “under the hood”.

So using this method to convert a NSString to a NSMutableString, while not unsound, is generally frowned upon unless you created the string yourself, or the API explicitly documents the string to be mutable.

See Apple’s documentation on mutability and on isKindOfClass: for more details.

§Generic classes

Objective-C generics are called “lightweight generics”, and that’s because they aren’t exposed in the runtime. This makes it impossible to safely downcast to generic collections, so this is disallowed by this method.

You can, however, safely downcast to generic collections where all the type-parameters are AnyObject.

§Panics

This works internally by calling isKindOfClass:. That means that the object must have the instance method of that name, and an exception will be thrown (if CoreFoundation is linked) or the process will abort if that is not the case. In the vast majority of cases, you don’t need to worry about this, since both root objects NSObject and NSProxy implement this method.

§Examples

Cast an NSString back and forth from NSObject.

use objc2::rc::Retained;
use objc2_foundation::{NSObject, NSString};

let obj: Retained<NSObject> = NSString::new().into_super();
let string = obj.downcast_ref::<NSString>().unwrap();
// Or with `downcast`, if we do not need the object afterwards
let string = obj.downcast::<NSString>().unwrap();

Try (and fail) to cast an NSObject to an NSString.

use objc2_foundation::{NSObject, NSString};

let obj = NSObject::new();
assert!(obj.downcast_ref::<NSString>().is_none());

Try to cast to an array of strings.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);
// This is invalid and doesn't type check.
let arr = arr.downcast_ref::<NSArray<NSString>>();

This fails to compile, since it would require enumerating over the array to ensure that each element is of the desired type, which is a performance pitfall.

Downcast when processing each element instead.

use objc2_foundation::{NSArray, NSObject, NSString};

let arr = NSArray::from_retained_slice(&[NSObject::new()]);

for elem in arr {
    if let Some(data) = elem.downcast_ref::<NSString>() {
        // handle `data`
    }
}