isl_rs/bindings/
id_to_ast_expr.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{ASTExpr, Context, Error, Id, LibISLError};
5use libc::uintptr_t;
6use std::ffi::{CStr, CString};
7use std::os::raw::c_char;
8
9/// Wraps `isl_id_to_ast_expr`.
10pub struct IdToASTExpr {
11    pub ptr: uintptr_t,
12    pub should_free_on_drop: bool,
13}
14
15extern "C" {
16
17    fn isl_id_to_ast_expr_alloc(ctx: uintptr_t, min_size: i32) -> uintptr_t;
18
19    fn isl_id_to_ast_expr_copy(hmap: uintptr_t) -> uintptr_t;
20
21    fn isl_id_to_ast_expr_drop(hmap: uintptr_t, key: uintptr_t) -> uintptr_t;
22
23    fn isl_id_to_ast_expr_dump(hmap: uintptr_t) -> ();
24
25    fn isl_id_to_ast_expr_free(hmap: uintptr_t) -> uintptr_t;
26
27    fn isl_id_to_ast_expr_get(hmap: uintptr_t, key: uintptr_t) -> uintptr_t;
28
29    fn isl_id_to_ast_expr_get_ctx(hmap: uintptr_t) -> uintptr_t;
30
31    fn isl_id_to_ast_expr_has(hmap: uintptr_t, key: uintptr_t) -> i32;
32
33    fn isl_id_to_ast_expr_is_equal(hmap1: uintptr_t, hmap2: uintptr_t) -> i32;
34
35    fn isl_id_to_ast_expr_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
36
37    fn isl_id_to_ast_expr_set(hmap: uintptr_t, key: uintptr_t, val: uintptr_t) -> uintptr_t;
38
39    fn isl_id_to_ast_expr_to_str(hmap: uintptr_t) -> *const c_char;
40
41}
42
43impl IdToASTExpr {
44    /// Wraps `isl_id_to_ast_expr_alloc`.
45    pub fn alloc(ctx: &Context, min_size: i32) -> Result<IdToASTExpr, LibISLError> {
46        let isl_rs_ctx = Context { ptr: ctx.ptr,
47                                   should_free_on_drop: false };
48        let ctx = ctx.ptr;
49        let isl_rs_result = unsafe { isl_id_to_ast_expr_alloc(ctx, min_size) };
50        let isl_rs_result = IdToASTExpr { ptr: isl_rs_result,
51                                          should_free_on_drop: true };
52        let err = isl_rs_ctx.last_error();
53        if err != Error::None_ {
54            let err_msg = isl_rs_ctx.last_error_msg();
55            isl_rs_ctx.reset_error();
56            return Err(LibISLError::new(err, err_msg));
57        }
58        Ok(isl_rs_result)
59    }
60
61    /// Wraps `isl_id_to_ast_expr_copy`.
62    pub fn copy(&self) -> Result<IdToASTExpr, LibISLError> {
63        let hmap = self;
64        let isl_rs_ctx = hmap.get_ctx();
65        let hmap = hmap.ptr;
66        let isl_rs_result = unsafe { isl_id_to_ast_expr_copy(hmap) };
67        let isl_rs_result = IdToASTExpr { ptr: isl_rs_result,
68                                          should_free_on_drop: true };
69        let err = isl_rs_ctx.last_error();
70        if err != Error::None_ {
71            let err_msg = isl_rs_ctx.last_error_msg();
72            isl_rs_ctx.reset_error();
73            return Err(LibISLError::new(err, err_msg));
74        }
75        Ok(isl_rs_result)
76    }
77
78    /// Wraps `isl_id_to_ast_expr_drop`.
79    pub fn drop(self, key: Id) -> Result<IdToASTExpr, LibISLError> {
80        let hmap = self;
81        let isl_rs_ctx = hmap.get_ctx();
82        let mut hmap = hmap;
83        hmap.do_not_free_on_drop();
84        let hmap = hmap.ptr;
85        let mut key = key;
86        key.do_not_free_on_drop();
87        let key = key.ptr;
88        let isl_rs_result = unsafe { isl_id_to_ast_expr_drop(hmap, key) };
89        let isl_rs_result = IdToASTExpr { ptr: isl_rs_result,
90                                          should_free_on_drop: true };
91        let err = isl_rs_ctx.last_error();
92        if err != Error::None_ {
93            let err_msg = isl_rs_ctx.last_error_msg();
94            isl_rs_ctx.reset_error();
95            return Err(LibISLError::new(err, err_msg));
96        }
97        Ok(isl_rs_result)
98    }
99
100    /// Wraps `isl_id_to_ast_expr_dump`.
101    pub fn dump(&self) -> Result<(), LibISLError> {
102        let hmap = self;
103        let isl_rs_ctx = hmap.get_ctx();
104        let hmap = hmap.ptr;
105        let isl_rs_result = unsafe { isl_id_to_ast_expr_dump(hmap) };
106        let err = isl_rs_ctx.last_error();
107        if err != Error::None_ {
108            let err_msg = isl_rs_ctx.last_error_msg();
109            isl_rs_ctx.reset_error();
110            return Err(LibISLError::new(err, err_msg));
111        }
112        Ok(isl_rs_result)
113    }
114
115    /// Wraps `isl_id_to_ast_expr_free`.
116    pub fn free(self) -> Result<IdToASTExpr, LibISLError> {
117        let hmap = self;
118        let isl_rs_ctx = hmap.get_ctx();
119        let mut hmap = hmap;
120        hmap.do_not_free_on_drop();
121        let hmap = hmap.ptr;
122        let isl_rs_result = unsafe { isl_id_to_ast_expr_free(hmap) };
123        let isl_rs_result = IdToASTExpr { ptr: isl_rs_result,
124                                          should_free_on_drop: true };
125        let err = isl_rs_ctx.last_error();
126        if err != Error::None_ {
127            let err_msg = isl_rs_ctx.last_error_msg();
128            isl_rs_ctx.reset_error();
129            return Err(LibISLError::new(err, err_msg));
130        }
131        Ok(isl_rs_result)
132    }
133
134    /// Wraps `isl_id_to_ast_expr_get`.
135    pub fn get(&self, key: Id) -> Result<ASTExpr, LibISLError> {
136        let hmap = self;
137        let isl_rs_ctx = hmap.get_ctx();
138        let hmap = hmap.ptr;
139        let mut key = key;
140        key.do_not_free_on_drop();
141        let key = key.ptr;
142        let isl_rs_result = unsafe { isl_id_to_ast_expr_get(hmap, key) };
143        let isl_rs_result = ASTExpr { ptr: isl_rs_result,
144                                      should_free_on_drop: true };
145        let err = isl_rs_ctx.last_error();
146        if err != Error::None_ {
147            let err_msg = isl_rs_ctx.last_error_msg();
148            isl_rs_ctx.reset_error();
149            return Err(LibISLError::new(err, err_msg));
150        }
151        Ok(isl_rs_result)
152    }
153
154    /// Wraps `isl_id_to_ast_expr_get_ctx`.
155    pub fn get_ctx(&self) -> Context {
156        let hmap = self;
157        let hmap = hmap.ptr;
158        let isl_rs_result = unsafe { isl_id_to_ast_expr_get_ctx(hmap) };
159        let isl_rs_result = Context { ptr: isl_rs_result,
160                                      should_free_on_drop: false };
161        isl_rs_result
162    }
163
164    /// Wraps `isl_id_to_ast_expr_has`.
165    pub fn has(&self, key: &Id) -> Result<bool, LibISLError> {
166        let hmap = self;
167        let isl_rs_ctx = hmap.get_ctx();
168        let hmap = hmap.ptr;
169        let key = key.ptr;
170        let isl_rs_result = unsafe { isl_id_to_ast_expr_has(hmap, key) };
171        let isl_rs_result = match isl_rs_result {
172            0 => false,
173            1 => true,
174            _ => {
175                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
176            }
177        };
178        let err = isl_rs_ctx.last_error();
179        if err != Error::None_ {
180            let err_msg = isl_rs_ctx.last_error_msg();
181            isl_rs_ctx.reset_error();
182            return Err(LibISLError::new(err, err_msg));
183        }
184        Ok(isl_rs_result)
185    }
186
187    /// Wraps `isl_id_to_ast_expr_is_equal`.
188    pub fn is_equal(&self, hmap2: &IdToASTExpr) -> Result<bool, LibISLError> {
189        let hmap1 = self;
190        let isl_rs_ctx = hmap1.get_ctx();
191        let hmap1 = hmap1.ptr;
192        let hmap2 = hmap2.ptr;
193        let isl_rs_result = unsafe { isl_id_to_ast_expr_is_equal(hmap1, hmap2) };
194        let isl_rs_result = match isl_rs_result {
195            0 => false,
196            1 => true,
197            _ => {
198                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
199            }
200        };
201        let err = isl_rs_ctx.last_error();
202        if err != Error::None_ {
203            let err_msg = isl_rs_ctx.last_error_msg();
204            isl_rs_ctx.reset_error();
205            return Err(LibISLError::new(err, err_msg));
206        }
207        Ok(isl_rs_result)
208    }
209
210    /// Wraps `isl_id_to_ast_expr_read_from_str`.
211    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<IdToASTExpr, LibISLError> {
212        let isl_rs_ctx = Context { ptr: ctx.ptr,
213                                   should_free_on_drop: false };
214        let ctx = ctx.ptr;
215        let str_ = CString::new(str_).unwrap();
216        let str_ = str_.as_ptr();
217        let isl_rs_result = unsafe { isl_id_to_ast_expr_read_from_str(ctx, str_) };
218        let isl_rs_result = IdToASTExpr { ptr: isl_rs_result,
219                                          should_free_on_drop: true };
220        let err = isl_rs_ctx.last_error();
221        if err != Error::None_ {
222            let err_msg = isl_rs_ctx.last_error_msg();
223            isl_rs_ctx.reset_error();
224            return Err(LibISLError::new(err, err_msg));
225        }
226        Ok(isl_rs_result)
227    }
228
229    /// Wraps `isl_id_to_ast_expr_set`.
230    pub fn set(self, key: Id, val: ASTExpr) -> Result<IdToASTExpr, LibISLError> {
231        let hmap = self;
232        let isl_rs_ctx = hmap.get_ctx();
233        let mut hmap = hmap;
234        hmap.do_not_free_on_drop();
235        let hmap = hmap.ptr;
236        let mut key = key;
237        key.do_not_free_on_drop();
238        let key = key.ptr;
239        let mut val = val;
240        val.do_not_free_on_drop();
241        let val = val.ptr;
242        let isl_rs_result = unsafe { isl_id_to_ast_expr_set(hmap, key, val) };
243        let isl_rs_result = IdToASTExpr { ptr: isl_rs_result,
244                                          should_free_on_drop: true };
245        let err = isl_rs_ctx.last_error();
246        if err != Error::None_ {
247            let err_msg = isl_rs_ctx.last_error_msg();
248            isl_rs_ctx.reset_error();
249            return Err(LibISLError::new(err, err_msg));
250        }
251        Ok(isl_rs_result)
252    }
253
254    /// Wraps `isl_id_to_ast_expr_to_str`.
255    pub fn to_str(&self) -> Result<&str, LibISLError> {
256        let hmap = self;
257        let isl_rs_ctx = hmap.get_ctx();
258        let hmap = hmap.ptr;
259        let isl_rs_result = unsafe { isl_id_to_ast_expr_to_str(hmap) };
260        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
261        let isl_rs_result = isl_rs_result.to_str().unwrap();
262        let err = isl_rs_ctx.last_error();
263        if err != Error::None_ {
264            let err_msg = isl_rs_ctx.last_error_msg();
265            isl_rs_ctx.reset_error();
266            return Err(LibISLError::new(err, err_msg));
267        }
268        Ok(isl_rs_result)
269    }
270
271    /// Does not call isl_id_to_ast_expr_free() on being dropped. (For internal
272    /// use only.)
273    pub fn do_not_free_on_drop(&mut self) {
274        self.should_free_on_drop = false;
275    }
276}
277
278impl Drop for IdToASTExpr {
279    fn drop(&mut self) {
280        if self.should_free_on_drop {
281            unsafe {
282                isl_id_to_ast_expr_free(self.ptr);
283            }
284        }
285    }
286}
isl_rs/bindings/id_to_ast_expr.rs

isl_rs/bindings/
id_to_ast_expr.rs
