irmin 0.3.3

Irmin bindings for rust
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use crate::internal::*;

/// Wrapper around OCaml values
pub struct Value {
    pub ty: Type,
    pub ptr: *mut IrminValue,
}

impl Drop for Value {
    fn drop(&mut self) {
        unsafe { irmin_value_free(self.ptr) }
    }
}

impl Clone for Value {
    fn clone(&self) -> Value {
        let ptr = unsafe { irmin_value_clone(self.ptr as *mut _) };
        Value {
            ty: self.ty.clone(),
            ptr,
        }
    }
}

impl PartialEq for Value {
    fn eq(&self, other: &Value) -> bool {
        let x = match (self.ty.name(), other.ty.name()) {
            (Ok(a), Ok(b)) => a == b,
            (_, _) => return false,
        };
        x && unsafe { irmin_value_equal(self.ty.ptr, self.ptr, other.ptr) }
    }
}

impl Value {
    /// OCaml string
    pub fn string(s: impl AsRef<str>) -> Result<Value, Error> {
        let s = s.as_ref();
        let ptr =
            unsafe { irmin_string_new(s.as_ptr() as *mut _, s.len() as i64) as *mut IrminValue };
        if ptr.is_null() {
            return Err(Error::NullPtr);
        };

        let ty = Type::string()?;

        Ok(Value { ptr, ty })
    }

    /// OCaml string from Rust &[u8]
    pub fn bytes(s: impl AsRef<[u8]>) -> Result<Value, Error> {
        let s = s.as_ref();
        let ptr =
            unsafe { irmin_string_new(s.as_ptr() as *mut _, s.len() as i64) as *mut IrminValue };
        if ptr.is_null() {
            return Err(Error::NullPtr);
        };

        let ty = Type::string()?;

        Ok(Value { ptr, ty })
    }

    /// OCaml int
    pub fn int(i: i64) -> Result<Value, Error> {
        let ptr = unsafe { irmin_value_int(i) };
        if ptr.is_null() {
            return Err(Error::NullPtr);
        };

        let ty = Type::int()?;

        Ok(Value { ptr, ty })
    }

    /// OCaml float
    pub fn float(i: f64) -> Result<Value, Error> {
        let ptr = unsafe { irmin_value_float(i) };
        if ptr.is_null() {
            return Err(Error::NullPtr);
        };

        let ty = Type::float()?;

        Ok(Value { ptr, ty })
    }

    /// OCaml bool
    pub fn bool(i: bool) -> Result<Value, Error> {
        let ptr = unsafe { irmin_value_bool(i) };
        if ptr.is_null() {
            return Err(Error::NullPtr);
        };

        let ty = Type::bool()?;

        Ok(Value { ptr, ty })
    }

    /// Parse a value of the specified type from Irmin's string encoding
    pub fn of_string(ty: Type, s: impl AsRef<str>) -> Result<Value, Error> {
        let s = s.as_ref();

        let ptr = unsafe { irmin_value_of_string(ty.ptr, s.as_ptr() as *mut _, s.len() as i64) };
        if ptr.is_null() {
            return Err(Error::NullPtr);
        }
        Ok(Value { ptr, ty })
    }

    /// Encode a value using Irmin's string encoding
    pub fn to_string(&self) -> Result<IrminString, Error> {
        let s = unsafe { irmin_value_to_string(self.ty.ptr, self.ptr) };
        crate::IrminString::wrap(s)
    }

    /// Parse a value of the specified type from Irmin's JSON encoding
    pub fn of_json(ty: Type, s: impl AsRef<str>) -> Result<Value, Error> {
        let s = s.as_ref();

        let ptr = unsafe { irmin_value_of_json(ty.ptr, s.as_ptr() as *mut _, s.len() as i64) };
        if ptr.is_null() {
            return Err(Error::NullPtr);
        }
        Ok(Value { ptr, ty })
    }

    /// Encode a value using Irmin's JSON encoding
    pub fn to_json(&self) -> Result<IrminString, Error> {
        let s = unsafe { irmin_value_to_json(self.ty.ptr, self.ptr) };
        crate::IrminString::wrap(s)
    }

    /// Parse a value of the specified type from Irmin's binary encoding
    pub fn of_bin(ty: Type, s: impl AsRef<[u8]>) -> Result<Value, Error> {
        let s = s.as_ref();
        let ptr = unsafe { irmin_value_of_bin(ty.ptr, s.as_ptr() as *mut _, s.len() as i64) };
        if ptr.is_null() {
            return Err(Error::NullPtr);
        }
        Ok(Value { ptr, ty })
    }

    /// Encode a value using Irmin's binary encoding
    pub fn to_bin(&self) -> Result<IrminString, Error> {
        let s = unsafe { irmin_value_to_bin(self.ty.ptr, self.ptr) };
        crate::IrminString::wrap(s)
    }

    /// Get IrminString from string value
    pub fn get_string(&self) -> Result<IrminString, Error> {
        let s = unsafe { irmin_value_get_string(self.ptr) };
        crate::IrminString::wrap(s)
    }
}