cloudkit 0.3.3

Safe Rust bindings for Apple's CloudKit framework — iCloud databases and sync on macOS
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use crate::private::CKReferencePayload;
use crate::record::CKRecordID;

/// Mirrors `CKReferenceAction`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum CKReferenceAction {
    /// Mirrors `CKReferenceAction.none`.
    None,
    /// Mirrors `CKReferenceAction.deleteSelf`.
    DeleteSelf,
    /// Mirrors `CKReferenceAction.unknown`.
    Unknown(u64),
}

impl CKReferenceAction {
    pub(crate) const fn from_raw(raw: u64) -> Self {
        match raw {
            0 => Self::None,
            1 => Self::DeleteSelf,
            other => Self::Unknown(other),
        }
    }

    pub(crate) const fn to_raw(self) -> u64 {
        match self {
            Self::None => 0,
            Self::DeleteSelf => 1,
            Self::Unknown(raw) => raw,
        }
    }
}

/// Wraps `CKReference`.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CKReference {
    record_id: CKRecordID,
    action: CKReferenceAction,
}

impl CKReference {
    /// Creates a wrapper mirroring `CKReference`.
    pub fn new(record_id: CKRecordID, action: CKReferenceAction) -> Self {
        Self { record_id, action }
    }

    /// Mirrors `CKReference.recordID`.
    pub fn record_id(&self) -> &CKRecordID {
        &self.record_id
    }

    /// Mirrors `CKReference.action`.
    pub const fn action(&self) -> CKReferenceAction {
        self.action
    }

    /// Mirrors `CKReference.parent`.
    pub fn parent(record_id: CKRecordID) -> Self {
        Self::new(record_id, CKReferenceAction::None)
    }

    /// Mirrors `CKReference.deleteSelf`.
    pub fn delete_self(record_id: CKRecordID) -> Self {
        Self::new(record_id, CKReferenceAction::DeleteSelf)
    }

    pub(crate) fn from_payload(payload: CKReferencePayload) -> Self {
        Self::new(
            CKRecordID::from_payload(payload.record_id),
            CKReferenceAction::from_raw(payload.action),
        )
    }

    pub(crate) fn to_payload(&self) -> CKReferencePayload {
        CKReferencePayload {
            record_id: self.record_id.to_payload(),
            action: self.action.to_raw(),
        }
    }
}