photokit 0.4.0

Safe Rust bindings for Apple's Photos framework — photo library access 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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::collections::BTreeMap;
use std::ptr;

use serde::{Deserialize, Serialize};

use crate::error::{NSErrorInfo, PhotoKitError};
use crate::ffi;
use crate::photo_library::PHPhotoLibrary;
use crate::private::{json_cstring, parse_json_ptr};

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
/// Wraps `PHCloudIdentifier`.
pub struct PHCloudIdentifier {
    /// Corresponds to `PHCloudIdentifier.stringValue`.
    pub string_value: String,
}

impl PHCloudIdentifier {
    /// Creates a helper value for the related Photos framework API.
    pub fn new(string_value: impl Into<String>) -> Self {
        Self {
            string_value: string_value.into(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
/// Identifier mapping returned by Photos framework cloud identifier lookups.
pub struct PHCloudIdentifierMapping {
    /// Corresponds to `PHCloudIdentifierMapping.cloudIdentifier`.
    pub cloud_identifier: Option<PHCloudIdentifier>,
    /// Corresponds to `PHCloudIdentifierMapping.error`.
    pub error: Option<NSErrorInfo>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
/// Identifier mapping returned by Photos framework local identifier lookups.
pub struct PHLocalIdentifierMapping {
    /// Corresponds to `PHLocalIdentifierMapping.localIdentifier`.
    pub local_identifier: Option<String>,
    /// Corresponds to `PHLocalIdentifierMapping.error`.
    pub error: Option<NSErrorInfo>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct PHCloudIdentifierMappingEntry {
    local_identifier: String,
    mapping: PHCloudIdentifierMapping,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct PHLocalIdentifierMappingEntry {
    cloud_identifier: PHCloudIdentifier,
    mapping: PHLocalIdentifierMapping,
}

impl PHPhotoLibrary {
    /// Wraps a Photos framework operation on `PHPhotoLibrary`.
    pub fn cloud_identifier_mappings_for_local_identifiers(
        &self,
        local_identifiers: &[String],
    ) -> Result<BTreeMap<String, PHCloudIdentifierMapping>, PhotoKitError> {
        let identifiers_json = json_cstring(local_identifiers, "local identifiers")?;
        let mut error = ptr::null_mut();
        let payload = unsafe {
            ffi::ph_photo_library_cloud_identifier_mappings_json(
                self.raw.as_ptr(),
                identifiers_json.as_ptr(),
                &mut error,
            )
        };
        if payload.is_null() {
            Err(unsafe {
                PhotoKitError::from_error_ptr(error, "cloud identifier mapping lookup failed")
            })
        } else {
            let entries: Vec<PHCloudIdentifierMappingEntry> =
                unsafe { parse_json_ptr(payload, "PHCloudIdentifierMapping list") }?;
            Ok(entries
                .into_iter()
                .map(|entry| (entry.local_identifier, entry.mapping))
                .collect())
        }
    }

    /// Wraps a Photos framework operation on `PHPhotoLibrary`.
    pub fn local_identifier_mappings_for_cloud_identifiers(
        &self,
        cloud_identifiers: &[PHCloudIdentifier],
    ) -> Result<BTreeMap<PHCloudIdentifier, PHLocalIdentifierMapping>, PhotoKitError> {
        let identifiers_json = json_cstring(cloud_identifiers, "cloud identifiers")?;
        let mut error = ptr::null_mut();
        let payload = unsafe {
            ffi::ph_photo_library_local_identifier_mappings_json(
                self.raw.as_ptr(),
                identifiers_json.as_ptr(),
                &mut error,
            )
        };
        if payload.is_null() {
            Err(unsafe {
                PhotoKitError::from_error_ptr(error, "local identifier mapping lookup failed")
            })
        } else {
            let entries: Vec<PHLocalIdentifierMappingEntry> =
                unsafe { parse_json_ptr(payload, "PHLocalIdentifierMapping list") }?;
            Ok(entries
                .into_iter()
                .map(|entry| (entry.cloud_identifier, entry.mapping))
                .collect())
        }
    }
}