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

use std::any::type_name;
use std::error::Error;

use chrono::{DateTime, Utc};

use crate::error::ValueError;
use crate::table::Row;
use crate::value::{ARRAY_VALUE_KEY, Backlink, Link, Value};

macro_rules! value_try_into {
    (Option<$target:ty>, $source:ident) => {
        impl TryFrom<Value> for Option<$target> {
            type Error = ValueError;

            fn try_from(value: Value) -> Result<Self, Self::Error> {
                match value {
                    Value::$source(val) => Ok(Some(val)),
                    Value::None => Ok(None),
                    value => Err(ValueError::UnexpectedType {
                        expected: stringify!($target),
                        found: value,
                    }),
                }
            }
        }
    };

    ($target:ty, $source:ident) => {
        impl TryFrom<Value> for $target {
            type Error = ValueError;

            fn try_from(value: Value) -> Result<Self, Self::Error> {
                match value {
                    Value::$source(val) => Ok(val),
                    value => Err(ValueError::UnexpectedType {
                        expected: stringify!($target),
                        found: value,
                    }),
                }
            }
        }

        impl<'a> TryFrom<Row<'a>> for $target {
            type Error = ValueError;

            fn try_from(mut value: Row<'a>) -> Result<Self, Self::Error> {
                let Some(value) = value.take(ARRAY_VALUE_KEY) else {
                    return Err(ValueError::ExpectedArrayRow {
                        field: ARRAY_VALUE_KEY,
                        found: value.into_owned(),
                    });
                };

                value.try_into()
            }
        }
    };
}

value_try_into!(String, String);
value_try_into!(Option<String>, String);
value_try_into!(i64, Int);
value_try_into!(Option<i64>, Int);
value_try_into!(bool, Bool);
value_try_into!(f32, Float);
value_try_into!(f64, Double);
value_try_into!(DateTime<Utc>, Timestamp);
value_try_into!(Option<DateTime<Utc>>, Timestamp);
value_try_into!(Backlink, BackLink);
value_try_into!(Link, Link);
value_try_into!(Option<Link>, Link);

impl<'a, T> TryFrom<Value> for Vec<T>
where
    T: TryFrom<Row<'a>>,
    T::Error: Error + 'static,
{
    type Error = ValueError;

    fn try_from(value: Value) -> Result<Self, Self::Error> {
        match value {
            Value::Table(rows) => {
                let mut result = Vec::with_capacity(rows.len());
                for row in rows {
                    result.push(row.try_into().map_err(|e| ValueError::VecConversionError {
                        element_type: type_name::<T>(),
                        source: Box::new(e),
                    })?);
                }

                Ok(result)
            }
            value => Err(ValueError::ExpectedTable { found: value }),
        }
    }
}