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

use crate::array::{Array, RealmRef};
use crate::column::{Column, ColumnImpl, ColumnType};
use crate::realm::Realm;
use crate::table::ColumnAttributes;
use crate::traits::{ArrayLike, Node, NodeWithContext};
use crate::utils::read_array_value;
use crate::value::Link;
use std::sync::Arc;

pub(crate) struct LinkColumnType;

#[derive(Debug, Copy, Clone)]
pub(crate) struct LinkColumnContext {
    target_table_index: usize,
}

impl ColumnType for LinkColumnType {
    type Value = Option<Link>;
    type LeafType = LinkLeaf;
    type LeafContext = LinkColumnContext;
}

#[derive(Debug)]
pub(crate) struct LinkLeaf {
    root: Array,
    context: LinkColumnContext,
}

impl NodeWithContext<LinkColumnContext> for LinkLeaf {
    fn from_ref_with_context(
        realm: Arc<Realm>,
        ref_: RealmRef,
        context: LinkColumnContext,
    ) -> crate::RealmResult<Self>
    where
        Self: Sized,
    {
        let root = Array::from_ref(realm, ref_)?;
        Ok(Self { root, context })
    }
}

impl ArrayLike<Option<Link>, LinkColumnContext> for LinkLeaf {
    fn get(&self, index: usize) -> crate::RealmResult<Option<Link>> {
        let value = self.root.get(index);
        if value == 0 {
            return Ok(None);
        }

        Ok(Some(Link::new(
            self.context.target_table_index,
            value as usize - 1,
        )))
    }

    fn get_direct(
        realm: Arc<Realm>,
        ref_: RealmRef,
        index: usize,
        context: LinkColumnContext,
    ) -> crate::RealmResult<Option<Link>> {
        let header = realm.header(ref_)?;
        let payload = realm.payload(ref_, header.payload_len());

        match read_array_value(payload, header.width(), index) {
            0 => Ok(None),
            value => Ok(Some(Link::new(
                context.target_table_index,
                value as usize - 1,
            ))),
        }
    }

    fn is_null(&self, index: usize) -> crate::RealmResult<bool> {
        Ok(self.root.get(index) == 0)
    }

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

// Factory function for link columns
pub(crate) fn create_link_column(
    realm: Arc<Realm>,
    ref_: RealmRef,
    attributes: ColumnAttributes,
    target_table_index: usize,
    name: String,
) -> crate::RealmResult<Box<dyn Column>> {
    Ok(Box::new(LinkColumn::new(
        realm,
        ref_,
        // Link columns cannot be indexed
        None,
        attributes,
        Some(name),
        LinkColumnContext { target_table_index },
    )?))
}

pub(crate) type LinkColumn = ColumnImpl<LinkColumnType>;