realm-db-reader 0.2.1

A Rust library for reading Realm database files
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

use std::fmt::Debug;
use std::sync::Arc;

use crate::array::RealmRef;
use crate::realm::{Realm, RealmNode};
use crate::traits::{ArrayLike, Node, NodeWithContext};
use std::str;
use tracing::{debug, instrument};

#[derive(Debug, Clone)]
pub(crate) struct ArrayStringShort {
    node: RealmNode,
}

impl NodeWithContext<()> for ArrayStringShort {
    fn from_ref_with_context(realm: Arc<Realm>, ref_: RealmRef, _: ()) -> crate::RealmResult<Self>
    where
        Self: Sized,
    {
        let node = RealmNode::from_ref(realm, ref_)?;

        Ok(Self { node })
    }
}

impl ArrayLike<Option<String>> for ArrayStringShort {
    #[instrument(level = "debug")]
    fn get(&self, index: usize) -> crate::RealmResult<Option<String>> {
        Ok(Self::get_static(&self.node, index).map(|s| s.to_string()))
    }

    fn get_direct(
        realm: Arc<Realm>,
        ref_: RealmRef,
        index: usize,
        _: (),
    ) -> crate::RealmResult<Option<String>> {
        let node = RealmNode::from_ref(realm, ref_)?;

        Ok(Self::get_static(&node, index).map(|s| s.to_string()))
    }

    fn is_null(&self, index: usize) -> crate::RealmResult<bool> {
        let width = self.node.header.width();
        if width == 0 {
            return Ok(true);
        }

        // Every element has an indicator of the number of zeroes ('\0') in its
        // last byte. Read only that last byte.
        let width_byte_index = index * width as usize + width as usize - 1;
        let zeroes = self.node.payload()[width_byte_index];

        // The element is null if all bytes are zeroes (equal to the width).
        Ok(zeroes == width)
    }

    fn size(&self) -> usize {
        self.node.header.size as usize
    }
}

impl ArrayLike<String> for ArrayStringShort {
    fn get(&self, index: usize) -> crate::RealmResult<String> {
        <Self as ArrayLike<Option<String>>>::get(self, index).map(|s| s.unwrap_or_default())
    }

    fn get_direct(
        realm: Arc<Realm>,
        ref_: RealmRef,
        index: usize,
        context: (),
    ) -> crate::RealmResult<String> {
        <Self as ArrayLike<Option<String>>>::get_direct(realm, ref_, index, context)
            .map(|s| s.unwrap_or_default())
    }

    fn is_null(&self, _: usize) -> crate::RealmResult<bool> {
        // Implementing for `String`, so we always return false.
        Ok(false)
    }

    fn size(&self) -> usize {
        self.node.header.size as usize
    }
}

impl ArrayStringShort {
    #[instrument(level = "debug")]
    fn get_static(node: &RealmNode, index: usize) -> Option<&str> {
        let width = node.header.width() as usize;
        if width == 0 {
            debug!("get: width is 0, returning None");
            return None;
        }

        let element_data = &node.payload()[index * width..(index + 1) * width];
        let zeroes = element_data[width - 1] as usize;
        if zeroes == width {
            return None;
        }

        debug!(
            "get: index={index} width={width} zeroes={zeroes} element_data=0x{}",
            hex::encode(element_data)
        );

        // e.g. width = 4, zeroes = 1, element_data = [xx, xx, 00, 01]
        Some(unsafe { str::from_utf8_unchecked(&element_data[..width - 1 - zeroes]) })
    }
}