isl_rs/bindings/
multi_val.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Context, DimType, Error, Id, LibISLError, Space, Val, ValList};
5use libc::uintptr_t;
6use std::ffi::{CStr, CString};
7use std::os::raw::c_char;
8
9/// Wraps `isl_multi_val`.
10pub struct MultiVal {
11    pub ptr: uintptr_t,
12    pub should_free_on_drop: bool,
13}
14
15extern "C" {
16
17    fn isl_multi_val_add(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
18
19    fn isl_multi_val_add_dims(multi: uintptr_t, type_: i32, n: u32) -> uintptr_t;
20
21    fn isl_multi_val_add_val(mv: uintptr_t, v: uintptr_t) -> uintptr_t;
22
23    fn isl_multi_val_align_params(multi: uintptr_t, model: uintptr_t) -> uintptr_t;
24
25    fn isl_multi_val_copy(multi: uintptr_t) -> uintptr_t;
26
27    fn isl_multi_val_dim(multi: uintptr_t, type_: i32) -> i32;
28
29    fn isl_multi_val_drop_dims(multi: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;
30
31    fn isl_multi_val_dump(mv: uintptr_t) -> ();
32
33    fn isl_multi_val_factor_range(multi: uintptr_t) -> uintptr_t;
34
35    fn isl_multi_val_find_dim_by_id(multi: uintptr_t, type_: i32, id: uintptr_t) -> i32;
36
37    fn isl_multi_val_find_dim_by_name(multi: uintptr_t, type_: i32, name: *const c_char) -> i32;
38
39    fn isl_multi_val_flat_range_product(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
40
41    fn isl_multi_val_flatten_range(multi: uintptr_t) -> uintptr_t;
42
43    fn isl_multi_val_free(multi: uintptr_t) -> uintptr_t;
44
45    fn isl_multi_val_from_range(multi: uintptr_t) -> uintptr_t;
46
47    fn isl_multi_val_from_val_list(space: uintptr_t, list: uintptr_t) -> uintptr_t;
48
49    fn isl_multi_val_get_at(multi: uintptr_t, pos: i32) -> uintptr_t;
50
51    fn isl_multi_val_get_ctx(multi: uintptr_t) -> uintptr_t;
52
53    fn isl_multi_val_get_dim_id(multi: uintptr_t, type_: i32, pos: u32) -> uintptr_t;
54
55    fn isl_multi_val_get_domain_space(multi: uintptr_t) -> uintptr_t;
56
57    fn isl_multi_val_get_list(multi: uintptr_t) -> uintptr_t;
58
59    fn isl_multi_val_get_range_tuple_id(multi: uintptr_t) -> uintptr_t;
60
61    fn isl_multi_val_get_space(multi: uintptr_t) -> uintptr_t;
62
63    fn isl_multi_val_get_tuple_id(multi: uintptr_t, type_: i32) -> uintptr_t;
64
65    fn isl_multi_val_get_tuple_name(multi: uintptr_t, type_: i32) -> *const c_char;
66
67    fn isl_multi_val_get_val(multi: uintptr_t, pos: i32) -> uintptr_t;
68
69    fn isl_multi_val_has_range_tuple_id(multi: uintptr_t) -> i32;
70
71    fn isl_multi_val_has_tuple_id(multi: uintptr_t, type_: i32) -> i32;
72
73    fn isl_multi_val_insert_dims(multi: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;
74
75    fn isl_multi_val_involves_dims(multi: uintptr_t, type_: i32, first: u32, n: u32) -> i32;
76
77    fn isl_multi_val_involves_nan(multi: uintptr_t) -> i32;
78
79    fn isl_multi_val_is_zero(mv: uintptr_t) -> i32;
80
81    fn isl_multi_val_max(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
82
83    fn isl_multi_val_min(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
84
85    fn isl_multi_val_mod_multi_val(multi: uintptr_t, mv: uintptr_t) -> uintptr_t;
86
87    fn isl_multi_val_mod_val(mv: uintptr_t, v: uintptr_t) -> uintptr_t;
88
89    fn isl_multi_val_neg(multi: uintptr_t) -> uintptr_t;
90
91    fn isl_multi_val_plain_is_equal(multi1: uintptr_t, multi2: uintptr_t) -> i32;
92
93    fn isl_multi_val_product(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
94
95    fn isl_multi_val_project_domain_on_params(multi: uintptr_t) -> uintptr_t;
96
97    fn isl_multi_val_range_factor_domain(multi: uintptr_t) -> uintptr_t;
98
99    fn isl_multi_val_range_factor_range(multi: uintptr_t) -> uintptr_t;
100
101    fn isl_multi_val_range_is_wrapping(multi: uintptr_t) -> i32;
102
103    fn isl_multi_val_range_product(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
104
105    fn isl_multi_val_range_splice(multi1: uintptr_t, pos: u32, multi2: uintptr_t) -> uintptr_t;
106
107    fn isl_multi_val_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
108
109    fn isl_multi_val_reset_range_tuple_id(multi: uintptr_t) -> uintptr_t;
110
111    fn isl_multi_val_reset_tuple_id(multi: uintptr_t, type_: i32) -> uintptr_t;
112
113    fn isl_multi_val_reset_user(multi: uintptr_t) -> uintptr_t;
114
115    fn isl_multi_val_scale_down_multi_val(multi: uintptr_t, mv: uintptr_t) -> uintptr_t;
116
117    fn isl_multi_val_scale_down_val(multi: uintptr_t, v: uintptr_t) -> uintptr_t;
118
119    fn isl_multi_val_scale_multi_val(multi: uintptr_t, mv: uintptr_t) -> uintptr_t;
120
121    fn isl_multi_val_scale_val(multi: uintptr_t, v: uintptr_t) -> uintptr_t;
122
123    fn isl_multi_val_set_at(multi: uintptr_t, pos: i32, el: uintptr_t) -> uintptr_t;
124
125    fn isl_multi_val_set_dim_id(multi: uintptr_t, type_: i32, pos: u32, id: uintptr_t)
126                                -> uintptr_t;
127
128    fn isl_multi_val_set_dim_name(multi: uintptr_t, type_: i32, pos: u32, s: *const c_char)
129                                  -> uintptr_t;
130
131    fn isl_multi_val_set_range_tuple_id(multi: uintptr_t, id: uintptr_t) -> uintptr_t;
132
133    fn isl_multi_val_set_tuple_id(multi: uintptr_t, type_: i32, id: uintptr_t) -> uintptr_t;
134
135    fn isl_multi_val_set_tuple_name(multi: uintptr_t, type_: i32, s: *const c_char) -> uintptr_t;
136
137    fn isl_multi_val_set_val(multi: uintptr_t, pos: i32, el: uintptr_t) -> uintptr_t;
138
139    fn isl_multi_val_size(multi: uintptr_t) -> i32;
140
141    fn isl_multi_val_splice(multi1: uintptr_t, in_pos: u32, out_pos: u32, multi2: uintptr_t)
142                            -> uintptr_t;
143
144    fn isl_multi_val_sub(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
145
146    fn isl_multi_val_to_str(mv: uintptr_t) -> *const c_char;
147
148    fn isl_multi_val_zero(space: uintptr_t) -> uintptr_t;
149
150}
151
152impl MultiVal {
153    /// Wraps `isl_multi_val_add`.
154    pub fn add(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
155        let multi1 = self;
156        let isl_rs_ctx = multi1.get_ctx();
157        let mut multi1 = multi1;
158        multi1.do_not_free_on_drop();
159        let multi1 = multi1.ptr;
160        let mut multi2 = multi2;
161        multi2.do_not_free_on_drop();
162        let multi2 = multi2.ptr;
163        let isl_rs_result = unsafe { isl_multi_val_add(multi1, multi2) };
164        let isl_rs_result = MultiVal { ptr: isl_rs_result,
165                                       should_free_on_drop: true };
166        let err = isl_rs_ctx.last_error();
167        if err != Error::None_ {
168            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
169        }
170        Ok(isl_rs_result)
171    }
172
173    /// Wraps `isl_multi_val_add_dims`.
174    pub fn add_dims(self, type_: DimType, n: u32) -> Result<MultiVal, LibISLError> {
175        let multi = self;
176        let isl_rs_ctx = multi.get_ctx();
177        let mut multi = multi;
178        multi.do_not_free_on_drop();
179        let multi = multi.ptr;
180        let type_ = type_.to_i32();
181        let isl_rs_result = unsafe { isl_multi_val_add_dims(multi, type_, n) };
182        let isl_rs_result = MultiVal { ptr: isl_rs_result,
183                                       should_free_on_drop: true };
184        let err = isl_rs_ctx.last_error();
185        if err != Error::None_ {
186            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
187        }
188        Ok(isl_rs_result)
189    }
190
191    /// Wraps `isl_multi_val_add_val`.
192    pub fn add_val(self, v: Val) -> Result<MultiVal, LibISLError> {
193        let mv = self;
194        let isl_rs_ctx = mv.get_ctx();
195        let mut mv = mv;
196        mv.do_not_free_on_drop();
197        let mv = mv.ptr;
198        let mut v = v;
199        v.do_not_free_on_drop();
200        let v = v.ptr;
201        let isl_rs_result = unsafe { isl_multi_val_add_val(mv, v) };
202        let isl_rs_result = MultiVal { ptr: isl_rs_result,
203                                       should_free_on_drop: true };
204        let err = isl_rs_ctx.last_error();
205        if err != Error::None_ {
206            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
207        }
208        Ok(isl_rs_result)
209    }
210
211    /// Wraps `isl_multi_val_align_params`.
212    pub fn align_params(self, model: Space) -> Result<MultiVal, LibISLError> {
213        let multi = self;
214        let isl_rs_ctx = multi.get_ctx();
215        let mut multi = multi;
216        multi.do_not_free_on_drop();
217        let multi = multi.ptr;
218        let mut model = model;
219        model.do_not_free_on_drop();
220        let model = model.ptr;
221        let isl_rs_result = unsafe { isl_multi_val_align_params(multi, model) };
222        let isl_rs_result = MultiVal { ptr: isl_rs_result,
223                                       should_free_on_drop: true };
224        let err = isl_rs_ctx.last_error();
225        if err != Error::None_ {
226            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
227        }
228        Ok(isl_rs_result)
229    }
230
231    /// Wraps `isl_multi_val_copy`.
232    pub fn copy(&self) -> Result<MultiVal, LibISLError> {
233        let multi = self;
234        let isl_rs_ctx = multi.get_ctx();
235        let multi = multi.ptr;
236        let isl_rs_result = unsafe { isl_multi_val_copy(multi) };
237        let isl_rs_result = MultiVal { ptr: isl_rs_result,
238                                       should_free_on_drop: true };
239        let err = isl_rs_ctx.last_error();
240        if err != Error::None_ {
241            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
242        }
243        Ok(isl_rs_result)
244    }
245
246    /// Wraps `isl_multi_val_dim`.
247    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
248        let multi = self;
249        let isl_rs_ctx = multi.get_ctx();
250        let multi = multi.ptr;
251        let type_ = type_.to_i32();
252        let isl_rs_result = unsafe { isl_multi_val_dim(multi, type_) };
253        let err = isl_rs_ctx.last_error();
254        if err != Error::None_ {
255            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
256        }
257        Ok(isl_rs_result)
258    }
259
260    /// Wraps `isl_multi_val_drop_dims`.
261    pub fn drop_dims(self, type_: DimType, first: u32, n: u32) -> Result<MultiVal, LibISLError> {
262        let multi = self;
263        let isl_rs_ctx = multi.get_ctx();
264        let mut multi = multi;
265        multi.do_not_free_on_drop();
266        let multi = multi.ptr;
267        let type_ = type_.to_i32();
268        let isl_rs_result = unsafe { isl_multi_val_drop_dims(multi, type_, first, n) };
269        let isl_rs_result = MultiVal { ptr: isl_rs_result,
270                                       should_free_on_drop: true };
271        let err = isl_rs_ctx.last_error();
272        if err != Error::None_ {
273            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
274        }
275        Ok(isl_rs_result)
276    }
277
278    /// Wraps `isl_multi_val_dump`.
279    pub fn dump(&self) -> Result<(), LibISLError> {
280        let mv = self;
281        let isl_rs_ctx = mv.get_ctx();
282        let mv = mv.ptr;
283        let isl_rs_result = unsafe { isl_multi_val_dump(mv) };
284        let err = isl_rs_ctx.last_error();
285        if err != Error::None_ {
286            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
287        }
288        Ok(isl_rs_result)
289    }
290
291    /// Wraps `isl_multi_val_factor_range`.
292    pub fn factor_range(self) -> Result<MultiVal, LibISLError> {
293        let multi = self;
294        let isl_rs_ctx = multi.get_ctx();
295        let mut multi = multi;
296        multi.do_not_free_on_drop();
297        let multi = multi.ptr;
298        let isl_rs_result = unsafe { isl_multi_val_factor_range(multi) };
299        let isl_rs_result = MultiVal { ptr: isl_rs_result,
300                                       should_free_on_drop: true };
301        let err = isl_rs_ctx.last_error();
302        if err != Error::None_ {
303            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
304        }
305        Ok(isl_rs_result)
306    }
307
308    /// Wraps `isl_multi_val_find_dim_by_id`.
309    pub fn find_dim_by_id(&self, type_: DimType, id: &Id) -> Result<i32, LibISLError> {
310        let multi = self;
311        let isl_rs_ctx = multi.get_ctx();
312        let multi = multi.ptr;
313        let type_ = type_.to_i32();
314        let id = id.ptr;
315        let isl_rs_result = unsafe { isl_multi_val_find_dim_by_id(multi, type_, id) };
316        let err = isl_rs_ctx.last_error();
317        if err != Error::None_ {
318            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
319        }
320        Ok(isl_rs_result)
321    }
322
323    /// Wraps `isl_multi_val_find_dim_by_name`.
324    pub fn find_dim_by_name(&self, type_: DimType, name: &str) -> Result<i32, LibISLError> {
325        let multi = self;
326        let isl_rs_ctx = multi.get_ctx();
327        let multi = multi.ptr;
328        let type_ = type_.to_i32();
329        let name = CString::new(name).unwrap();
330        let name = name.as_ptr();
331        let isl_rs_result = unsafe { isl_multi_val_find_dim_by_name(multi, type_, name) };
332        let err = isl_rs_ctx.last_error();
333        if err != Error::None_ {
334            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
335        }
336        Ok(isl_rs_result)
337    }
338
339    /// Wraps `isl_multi_val_flat_range_product`.
340    pub fn flat_range_product(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
341        let multi1 = self;
342        let isl_rs_ctx = multi1.get_ctx();
343        let mut multi1 = multi1;
344        multi1.do_not_free_on_drop();
345        let multi1 = multi1.ptr;
346        let mut multi2 = multi2;
347        multi2.do_not_free_on_drop();
348        let multi2 = multi2.ptr;
349        let isl_rs_result = unsafe { isl_multi_val_flat_range_product(multi1, multi2) };
350        let isl_rs_result = MultiVal { ptr: isl_rs_result,
351                                       should_free_on_drop: true };
352        let err = isl_rs_ctx.last_error();
353        if err != Error::None_ {
354            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
355        }
356        Ok(isl_rs_result)
357    }
358
359    /// Wraps `isl_multi_val_flatten_range`.
360    pub fn flatten_range(self) -> Result<MultiVal, LibISLError> {
361        let multi = self;
362        let isl_rs_ctx = multi.get_ctx();
363        let mut multi = multi;
364        multi.do_not_free_on_drop();
365        let multi = multi.ptr;
366        let isl_rs_result = unsafe { isl_multi_val_flatten_range(multi) };
367        let isl_rs_result = MultiVal { ptr: isl_rs_result,
368                                       should_free_on_drop: true };
369        let err = isl_rs_ctx.last_error();
370        if err != Error::None_ {
371            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
372        }
373        Ok(isl_rs_result)
374    }
375
376    /// Wraps `isl_multi_val_free`.
377    pub fn free(self) -> Result<MultiVal, LibISLError> {
378        let multi = self;
379        let isl_rs_ctx = multi.get_ctx();
380        let mut multi = multi;
381        multi.do_not_free_on_drop();
382        let multi = multi.ptr;
383        let isl_rs_result = unsafe { isl_multi_val_free(multi) };
384        let isl_rs_result = MultiVal { ptr: isl_rs_result,
385                                       should_free_on_drop: true };
386        let err = isl_rs_ctx.last_error();
387        if err != Error::None_ {
388            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
389        }
390        Ok(isl_rs_result)
391    }
392
393    /// Wraps `isl_multi_val_from_range`.
394    pub fn from_range(self) -> Result<MultiVal, LibISLError> {
395        let multi = self;
396        let isl_rs_ctx = multi.get_ctx();
397        let mut multi = multi;
398        multi.do_not_free_on_drop();
399        let multi = multi.ptr;
400        let isl_rs_result = unsafe { isl_multi_val_from_range(multi) };
401        let isl_rs_result = MultiVal { ptr: isl_rs_result,
402                                       should_free_on_drop: true };
403        let err = isl_rs_ctx.last_error();
404        if err != Error::None_ {
405            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
406        }
407        Ok(isl_rs_result)
408    }
409
410    /// Wraps `isl_multi_val_from_val_list`.
411    pub fn from_val_list(space: Space, list: ValList) -> Result<MultiVal, LibISLError> {
412        let isl_rs_ctx = space.get_ctx();
413        let mut space = space;
414        space.do_not_free_on_drop();
415        let space = space.ptr;
416        let mut list = list;
417        list.do_not_free_on_drop();
418        let list = list.ptr;
419        let isl_rs_result = unsafe { isl_multi_val_from_val_list(space, list) };
420        let isl_rs_result = MultiVal { ptr: isl_rs_result,
421                                       should_free_on_drop: true };
422        let err = isl_rs_ctx.last_error();
423        if err != Error::None_ {
424            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
425        }
426        Ok(isl_rs_result)
427    }
428
429    /// Wraps `isl_multi_val_get_at`.
430    pub fn get_at(&self, pos: i32) -> Result<Val, LibISLError> {
431        let multi = self;
432        let isl_rs_ctx = multi.get_ctx();
433        let multi = multi.ptr;
434        let isl_rs_result = unsafe { isl_multi_val_get_at(multi, pos) };
435        let isl_rs_result = Val { ptr: isl_rs_result,
436                                  should_free_on_drop: true };
437        let err = isl_rs_ctx.last_error();
438        if err != Error::None_ {
439            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
440        }
441        Ok(isl_rs_result)
442    }
443
444    /// Wraps `isl_multi_val_get_ctx`.
445    pub fn get_ctx(&self) -> Context {
446        let multi = self;
447        let multi = multi.ptr;
448        let isl_rs_result = unsafe { isl_multi_val_get_ctx(multi) };
449        let isl_rs_result = Context { ptr: isl_rs_result,
450                                      should_free_on_drop: false };
451        isl_rs_result
452    }
453
454    /// Wraps `isl_multi_val_get_dim_id`.
455    pub fn get_dim_id(&self, type_: DimType, pos: u32) -> Result<Id, LibISLError> {
456        let multi = self;
457        let isl_rs_ctx = multi.get_ctx();
458        let multi = multi.ptr;
459        let type_ = type_.to_i32();
460        let isl_rs_result = unsafe { isl_multi_val_get_dim_id(multi, type_, pos) };
461        let isl_rs_result = Id { ptr: isl_rs_result,
462                                 should_free_on_drop: true };
463        let err = isl_rs_ctx.last_error();
464        if err != Error::None_ {
465            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
466        }
467        Ok(isl_rs_result)
468    }
469
470    /// Wraps `isl_multi_val_get_domain_space`.
471    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
472        let multi = self;
473        let isl_rs_ctx = multi.get_ctx();
474        let multi = multi.ptr;
475        let isl_rs_result = unsafe { isl_multi_val_get_domain_space(multi) };
476        let isl_rs_result = Space { ptr: isl_rs_result,
477                                    should_free_on_drop: true };
478        let err = isl_rs_ctx.last_error();
479        if err != Error::None_ {
480            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
481        }
482        Ok(isl_rs_result)
483    }
484
485    /// Wraps `isl_multi_val_get_list`.
486    pub fn get_list(&self) -> Result<ValList, LibISLError> {
487        let multi = self;
488        let isl_rs_ctx = multi.get_ctx();
489        let multi = multi.ptr;
490        let isl_rs_result = unsafe { isl_multi_val_get_list(multi) };
491        let isl_rs_result = ValList { ptr: isl_rs_result,
492                                      should_free_on_drop: true };
493        let err = isl_rs_ctx.last_error();
494        if err != Error::None_ {
495            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
496        }
497        Ok(isl_rs_result)
498    }
499
500    /// Wraps `isl_multi_val_get_range_tuple_id`.
501    pub fn get_range_tuple_id(&self) -> Result<Id, LibISLError> {
502        let multi = self;
503        let isl_rs_ctx = multi.get_ctx();
504        let multi = multi.ptr;
505        let isl_rs_result = unsafe { isl_multi_val_get_range_tuple_id(multi) };
506        let isl_rs_result = Id { ptr: isl_rs_result,
507                                 should_free_on_drop: true };
508        let err = isl_rs_ctx.last_error();
509        if err != Error::None_ {
510            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
511        }
512        Ok(isl_rs_result)
513    }
514
515    /// Wraps `isl_multi_val_get_space`.
516    pub fn get_space(&self) -> Result<Space, LibISLError> {
517        let multi = self;
518        let isl_rs_ctx = multi.get_ctx();
519        let multi = multi.ptr;
520        let isl_rs_result = unsafe { isl_multi_val_get_space(multi) };
521        let isl_rs_result = Space { ptr: isl_rs_result,
522                                    should_free_on_drop: true };
523        let err = isl_rs_ctx.last_error();
524        if err != Error::None_ {
525            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
526        }
527        Ok(isl_rs_result)
528    }
529
530    /// Wraps `isl_multi_val_get_tuple_id`.
531    pub fn get_tuple_id(&self, type_: DimType) -> Result<Id, LibISLError> {
532        let multi = self;
533        let isl_rs_ctx = multi.get_ctx();
534        let multi = multi.ptr;
535        let type_ = type_.to_i32();
536        let isl_rs_result = unsafe { isl_multi_val_get_tuple_id(multi, type_) };
537        let isl_rs_result = Id { ptr: isl_rs_result,
538                                 should_free_on_drop: true };
539        let err = isl_rs_ctx.last_error();
540        if err != Error::None_ {
541            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
542        }
543        Ok(isl_rs_result)
544    }
545
546    /// Wraps `isl_multi_val_get_tuple_name`.
547    pub fn get_tuple_name(&self, type_: DimType) -> Result<&str, LibISLError> {
548        let multi = self;
549        let isl_rs_ctx = multi.get_ctx();
550        let multi = multi.ptr;
551        let type_ = type_.to_i32();
552        let isl_rs_result = unsafe { isl_multi_val_get_tuple_name(multi, type_) };
553        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
554        let isl_rs_result = isl_rs_result.to_str().unwrap();
555        let err = isl_rs_ctx.last_error();
556        if err != Error::None_ {
557            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
558        }
559        Ok(isl_rs_result)
560    }
561
562    /// Wraps `isl_multi_val_get_val`.
563    pub fn get_val(&self, pos: i32) -> Result<Val, LibISLError> {
564        let multi = self;
565        let isl_rs_ctx = multi.get_ctx();
566        let multi = multi.ptr;
567        let isl_rs_result = unsafe { isl_multi_val_get_val(multi, pos) };
568        let isl_rs_result = Val { ptr: isl_rs_result,
569                                  should_free_on_drop: true };
570        let err = isl_rs_ctx.last_error();
571        if err != Error::None_ {
572            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
573        }
574        Ok(isl_rs_result)
575    }
576
577    /// Wraps `isl_multi_val_has_range_tuple_id`.
578    pub fn has_range_tuple_id(&self) -> Result<bool, LibISLError> {
579        let multi = self;
580        let isl_rs_ctx = multi.get_ctx();
581        let multi = multi.ptr;
582        let isl_rs_result = unsafe { isl_multi_val_has_range_tuple_id(multi) };
583        let isl_rs_result = match isl_rs_result {
584            0 => false,
585            1 => true,
586            _ => panic!("Got isl_bool = -1"),
587        };
588        let err = isl_rs_ctx.last_error();
589        if err != Error::None_ {
590            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
591        }
592        Ok(isl_rs_result)
593    }
594
595    /// Wraps `isl_multi_val_has_tuple_id`.
596    pub fn has_tuple_id(&self, type_: DimType) -> Result<bool, LibISLError> {
597        let multi = self;
598        let isl_rs_ctx = multi.get_ctx();
599        let multi = multi.ptr;
600        let type_ = type_.to_i32();
601        let isl_rs_result = unsafe { isl_multi_val_has_tuple_id(multi, type_) };
602        let isl_rs_result = match isl_rs_result {
603            0 => false,
604            1 => true,
605            _ => panic!("Got isl_bool = -1"),
606        };
607        let err = isl_rs_ctx.last_error();
608        if err != Error::None_ {
609            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
610        }
611        Ok(isl_rs_result)
612    }
613
614    /// Wraps `isl_multi_val_insert_dims`.
615    pub fn insert_dims(self, type_: DimType, first: u32, n: u32) -> Result<MultiVal, LibISLError> {
616        let multi = self;
617        let isl_rs_ctx = multi.get_ctx();
618        let mut multi = multi;
619        multi.do_not_free_on_drop();
620        let multi = multi.ptr;
621        let type_ = type_.to_i32();
622        let isl_rs_result = unsafe { isl_multi_val_insert_dims(multi, type_, first, n) };
623        let isl_rs_result = MultiVal { ptr: isl_rs_result,
624                                       should_free_on_drop: true };
625        let err = isl_rs_ctx.last_error();
626        if err != Error::None_ {
627            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
628        }
629        Ok(isl_rs_result)
630    }
631
632    /// Wraps `isl_multi_val_involves_dims`.
633    pub fn involves_dims(&self, type_: DimType, first: u32, n: u32) -> Result<bool, LibISLError> {
634        let multi = self;
635        let isl_rs_ctx = multi.get_ctx();
636        let multi = multi.ptr;
637        let type_ = type_.to_i32();
638        let isl_rs_result = unsafe { isl_multi_val_involves_dims(multi, type_, first, n) };
639        let isl_rs_result = match isl_rs_result {
640            0 => false,
641            1 => true,
642            _ => panic!("Got isl_bool = -1"),
643        };
644        let err = isl_rs_ctx.last_error();
645        if err != Error::None_ {
646            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
647        }
648        Ok(isl_rs_result)
649    }
650
651    /// Wraps `isl_multi_val_involves_nan`.
652    pub fn involves_nan(&self) -> Result<bool, LibISLError> {
653        let multi = self;
654        let isl_rs_ctx = multi.get_ctx();
655        let multi = multi.ptr;
656        let isl_rs_result = unsafe { isl_multi_val_involves_nan(multi) };
657        let isl_rs_result = match isl_rs_result {
658            0 => false,
659            1 => true,
660            _ => panic!("Got isl_bool = -1"),
661        };
662        let err = isl_rs_ctx.last_error();
663        if err != Error::None_ {
664            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
665        }
666        Ok(isl_rs_result)
667    }
668
669    /// Wraps `isl_multi_val_is_zero`.
670    pub fn is_zero(&self) -> Result<bool, LibISLError> {
671        let mv = self;
672        let isl_rs_ctx = mv.get_ctx();
673        let mv = mv.ptr;
674        let isl_rs_result = unsafe { isl_multi_val_is_zero(mv) };
675        let isl_rs_result = match isl_rs_result {
676            0 => false,
677            1 => true,
678            _ => panic!("Got isl_bool = -1"),
679        };
680        let err = isl_rs_ctx.last_error();
681        if err != Error::None_ {
682            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
683        }
684        Ok(isl_rs_result)
685    }
686
687    /// Wraps `isl_multi_val_max`.
688    pub fn max(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
689        let multi1 = self;
690        let isl_rs_ctx = multi1.get_ctx();
691        let mut multi1 = multi1;
692        multi1.do_not_free_on_drop();
693        let multi1 = multi1.ptr;
694        let mut multi2 = multi2;
695        multi2.do_not_free_on_drop();
696        let multi2 = multi2.ptr;
697        let isl_rs_result = unsafe { isl_multi_val_max(multi1, multi2) };
698        let isl_rs_result = MultiVal { ptr: isl_rs_result,
699                                       should_free_on_drop: true };
700        let err = isl_rs_ctx.last_error();
701        if err != Error::None_ {
702            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
703        }
704        Ok(isl_rs_result)
705    }
706
707    /// Wraps `isl_multi_val_min`.
708    pub fn min(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
709        let multi1 = self;
710        let isl_rs_ctx = multi1.get_ctx();
711        let mut multi1 = multi1;
712        multi1.do_not_free_on_drop();
713        let multi1 = multi1.ptr;
714        let mut multi2 = multi2;
715        multi2.do_not_free_on_drop();
716        let multi2 = multi2.ptr;
717        let isl_rs_result = unsafe { isl_multi_val_min(multi1, multi2) };
718        let isl_rs_result = MultiVal { ptr: isl_rs_result,
719                                       should_free_on_drop: true };
720        let err = isl_rs_ctx.last_error();
721        if err != Error::None_ {
722            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
723        }
724        Ok(isl_rs_result)
725    }
726
727    /// Wraps `isl_multi_val_mod_multi_val`.
728    pub fn mod_multi_val(self, mv: MultiVal) -> Result<MultiVal, LibISLError> {
729        let multi = self;
730        let isl_rs_ctx = multi.get_ctx();
731        let mut multi = multi;
732        multi.do_not_free_on_drop();
733        let multi = multi.ptr;
734        let mut mv = mv;
735        mv.do_not_free_on_drop();
736        let mv = mv.ptr;
737        let isl_rs_result = unsafe { isl_multi_val_mod_multi_val(multi, mv) };
738        let isl_rs_result = MultiVal { ptr: isl_rs_result,
739                                       should_free_on_drop: true };
740        let err = isl_rs_ctx.last_error();
741        if err != Error::None_ {
742            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
743        }
744        Ok(isl_rs_result)
745    }
746
747    /// Wraps `isl_multi_val_mod_val`.
748    pub fn mod_val(self, v: Val) -> Result<MultiVal, LibISLError> {
749        let mv = self;
750        let isl_rs_ctx = mv.get_ctx();
751        let mut mv = mv;
752        mv.do_not_free_on_drop();
753        let mv = mv.ptr;
754        let mut v = v;
755        v.do_not_free_on_drop();
756        let v = v.ptr;
757        let isl_rs_result = unsafe { isl_multi_val_mod_val(mv, v) };
758        let isl_rs_result = MultiVal { ptr: isl_rs_result,
759                                       should_free_on_drop: true };
760        let err = isl_rs_ctx.last_error();
761        if err != Error::None_ {
762            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
763        }
764        Ok(isl_rs_result)
765    }
766
767    /// Wraps `isl_multi_val_neg`.
768    pub fn neg(self) -> Result<MultiVal, LibISLError> {
769        let multi = self;
770        let isl_rs_ctx = multi.get_ctx();
771        let mut multi = multi;
772        multi.do_not_free_on_drop();
773        let multi = multi.ptr;
774        let isl_rs_result = unsafe { isl_multi_val_neg(multi) };
775        let isl_rs_result = MultiVal { ptr: isl_rs_result,
776                                       should_free_on_drop: true };
777        let err = isl_rs_ctx.last_error();
778        if err != Error::None_ {
779            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
780        }
781        Ok(isl_rs_result)
782    }
783
784    /// Wraps `isl_multi_val_plain_is_equal`.
785    pub fn plain_is_equal(&self, multi2: &MultiVal) -> Result<bool, LibISLError> {
786        let multi1 = self;
787        let isl_rs_ctx = multi1.get_ctx();
788        let multi1 = multi1.ptr;
789        let multi2 = multi2.ptr;
790        let isl_rs_result = unsafe { isl_multi_val_plain_is_equal(multi1, multi2) };
791        let isl_rs_result = match isl_rs_result {
792            0 => false,
793            1 => true,
794            _ => panic!("Got isl_bool = -1"),
795        };
796        let err = isl_rs_ctx.last_error();
797        if err != Error::None_ {
798            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
799        }
800        Ok(isl_rs_result)
801    }
802
803    /// Wraps `isl_multi_val_product`.
804    pub fn product(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
805        let multi1 = self;
806        let isl_rs_ctx = multi1.get_ctx();
807        let mut multi1 = multi1;
808        multi1.do_not_free_on_drop();
809        let multi1 = multi1.ptr;
810        let mut multi2 = multi2;
811        multi2.do_not_free_on_drop();
812        let multi2 = multi2.ptr;
813        let isl_rs_result = unsafe { isl_multi_val_product(multi1, multi2) };
814        let isl_rs_result = MultiVal { ptr: isl_rs_result,
815                                       should_free_on_drop: true };
816        let err = isl_rs_ctx.last_error();
817        if err != Error::None_ {
818            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
819        }
820        Ok(isl_rs_result)
821    }
822
823    /// Wraps `isl_multi_val_project_domain_on_params`.
824    pub fn project_domain_on_params(self) -> Result<MultiVal, LibISLError> {
825        let multi = self;
826        let isl_rs_ctx = multi.get_ctx();
827        let mut multi = multi;
828        multi.do_not_free_on_drop();
829        let multi = multi.ptr;
830        let isl_rs_result = unsafe { isl_multi_val_project_domain_on_params(multi) };
831        let isl_rs_result = MultiVal { ptr: isl_rs_result,
832                                       should_free_on_drop: true };
833        let err = isl_rs_ctx.last_error();
834        if err != Error::None_ {
835            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
836        }
837        Ok(isl_rs_result)
838    }
839
840    /// Wraps `isl_multi_val_range_factor_domain`.
841    pub fn range_factor_domain(self) -> Result<MultiVal, LibISLError> {
842        let multi = self;
843        let isl_rs_ctx = multi.get_ctx();
844        let mut multi = multi;
845        multi.do_not_free_on_drop();
846        let multi = multi.ptr;
847        let isl_rs_result = unsafe { isl_multi_val_range_factor_domain(multi) };
848        let isl_rs_result = MultiVal { ptr: isl_rs_result,
849                                       should_free_on_drop: true };
850        let err = isl_rs_ctx.last_error();
851        if err != Error::None_ {
852            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
853        }
854        Ok(isl_rs_result)
855    }
856
857    /// Wraps `isl_multi_val_range_factor_range`.
858    pub fn range_factor_range(self) -> Result<MultiVal, LibISLError> {
859        let multi = self;
860        let isl_rs_ctx = multi.get_ctx();
861        let mut multi = multi;
862        multi.do_not_free_on_drop();
863        let multi = multi.ptr;
864        let isl_rs_result = unsafe { isl_multi_val_range_factor_range(multi) };
865        let isl_rs_result = MultiVal { ptr: isl_rs_result,
866                                       should_free_on_drop: true };
867        let err = isl_rs_ctx.last_error();
868        if err != Error::None_ {
869            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
870        }
871        Ok(isl_rs_result)
872    }
873
874    /// Wraps `isl_multi_val_range_is_wrapping`.
875    pub fn range_is_wrapping(&self) -> Result<bool, LibISLError> {
876        let multi = self;
877        let isl_rs_ctx = multi.get_ctx();
878        let multi = multi.ptr;
879        let isl_rs_result = unsafe { isl_multi_val_range_is_wrapping(multi) };
880        let isl_rs_result = match isl_rs_result {
881            0 => false,
882            1 => true,
883            _ => panic!("Got isl_bool = -1"),
884        };
885        let err = isl_rs_ctx.last_error();
886        if err != Error::None_ {
887            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
888        }
889        Ok(isl_rs_result)
890    }
891
892    /// Wraps `isl_multi_val_range_product`.
893    pub fn range_product(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
894        let multi1 = self;
895        let isl_rs_ctx = multi1.get_ctx();
896        let mut multi1 = multi1;
897        multi1.do_not_free_on_drop();
898        let multi1 = multi1.ptr;
899        let mut multi2 = multi2;
900        multi2.do_not_free_on_drop();
901        let multi2 = multi2.ptr;
902        let isl_rs_result = unsafe { isl_multi_val_range_product(multi1, multi2) };
903        let isl_rs_result = MultiVal { ptr: isl_rs_result,
904                                       should_free_on_drop: true };
905        let err = isl_rs_ctx.last_error();
906        if err != Error::None_ {
907            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
908        }
909        Ok(isl_rs_result)
910    }
911
912    /// Wraps `isl_multi_val_range_splice`.
913    pub fn range_splice(self, pos: u32, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
914        let multi1 = self;
915        let isl_rs_ctx = multi1.get_ctx();
916        let mut multi1 = multi1;
917        multi1.do_not_free_on_drop();
918        let multi1 = multi1.ptr;
919        let mut multi2 = multi2;
920        multi2.do_not_free_on_drop();
921        let multi2 = multi2.ptr;
922        let isl_rs_result = unsafe { isl_multi_val_range_splice(multi1, pos, multi2) };
923        let isl_rs_result = MultiVal { ptr: isl_rs_result,
924                                       should_free_on_drop: true };
925        let err = isl_rs_ctx.last_error();
926        if err != Error::None_ {
927            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
928        }
929        Ok(isl_rs_result)
930    }
931
932    /// Wraps `isl_multi_val_read_from_str`.
933    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<MultiVal, LibISLError> {
934        let isl_rs_ctx = Context { ptr: ctx.ptr,
935                                   should_free_on_drop: false };
936        let ctx = ctx.ptr;
937        let str_ = CString::new(str_).unwrap();
938        let str_ = str_.as_ptr();
939        let isl_rs_result = unsafe { isl_multi_val_read_from_str(ctx, str_) };
940        let isl_rs_result = MultiVal { ptr: isl_rs_result,
941                                       should_free_on_drop: true };
942        let err = isl_rs_ctx.last_error();
943        if err != Error::None_ {
944            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
945        }
946        Ok(isl_rs_result)
947    }
948
949    /// Wraps `isl_multi_val_reset_range_tuple_id`.
950    pub fn reset_range_tuple_id(self) -> Result<MultiVal, LibISLError> {
951        let multi = self;
952        let isl_rs_ctx = multi.get_ctx();
953        let mut multi = multi;
954        multi.do_not_free_on_drop();
955        let multi = multi.ptr;
956        let isl_rs_result = unsafe { isl_multi_val_reset_range_tuple_id(multi) };
957        let isl_rs_result = MultiVal { ptr: isl_rs_result,
958                                       should_free_on_drop: true };
959        let err = isl_rs_ctx.last_error();
960        if err != Error::None_ {
961            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
962        }
963        Ok(isl_rs_result)
964    }
965
966    /// Wraps `isl_multi_val_reset_tuple_id`.
967    pub fn reset_tuple_id(self, type_: DimType) -> Result<MultiVal, LibISLError> {
968        let multi = self;
969        let isl_rs_ctx = multi.get_ctx();
970        let mut multi = multi;
971        multi.do_not_free_on_drop();
972        let multi = multi.ptr;
973        let type_ = type_.to_i32();
974        let isl_rs_result = unsafe { isl_multi_val_reset_tuple_id(multi, type_) };
975        let isl_rs_result = MultiVal { ptr: isl_rs_result,
976                                       should_free_on_drop: true };
977        let err = isl_rs_ctx.last_error();
978        if err != Error::None_ {
979            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
980        }
981        Ok(isl_rs_result)
982    }
983
984    /// Wraps `isl_multi_val_reset_user`.
985    pub fn reset_user(self) -> Result<MultiVal, LibISLError> {
986        let multi = self;
987        let isl_rs_ctx = multi.get_ctx();
988        let mut multi = multi;
989        multi.do_not_free_on_drop();
990        let multi = multi.ptr;
991        let isl_rs_result = unsafe { isl_multi_val_reset_user(multi) };
992        let isl_rs_result = MultiVal { ptr: isl_rs_result,
993                                       should_free_on_drop: true };
994        let err = isl_rs_ctx.last_error();
995        if err != Error::None_ {
996            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
997        }
998        Ok(isl_rs_result)
999    }
1000
1001    /// Wraps `isl_multi_val_scale_down_multi_val`.
1002    pub fn scale_down_multi_val(self, mv: MultiVal) -> Result<MultiVal, LibISLError> {
1003        let multi = self;
1004        let isl_rs_ctx = multi.get_ctx();
1005        let mut multi = multi;
1006        multi.do_not_free_on_drop();
1007        let multi = multi.ptr;
1008        let mut mv = mv;
1009        mv.do_not_free_on_drop();
1010        let mv = mv.ptr;
1011        let isl_rs_result = unsafe { isl_multi_val_scale_down_multi_val(multi, mv) };
1012        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1013                                       should_free_on_drop: true };
1014        let err = isl_rs_ctx.last_error();
1015        if err != Error::None_ {
1016            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1017        }
1018        Ok(isl_rs_result)
1019    }
1020
1021    /// Wraps `isl_multi_val_scale_down_val`.
1022    pub fn scale_down_val(self, v: Val) -> Result<MultiVal, LibISLError> {
1023        let multi = self;
1024        let isl_rs_ctx = multi.get_ctx();
1025        let mut multi = multi;
1026        multi.do_not_free_on_drop();
1027        let multi = multi.ptr;
1028        let mut v = v;
1029        v.do_not_free_on_drop();
1030        let v = v.ptr;
1031        let isl_rs_result = unsafe { isl_multi_val_scale_down_val(multi, v) };
1032        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1033                                       should_free_on_drop: true };
1034        let err = isl_rs_ctx.last_error();
1035        if err != Error::None_ {
1036            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1037        }
1038        Ok(isl_rs_result)
1039    }
1040
1041    /// Wraps `isl_multi_val_scale_multi_val`.
1042    pub fn scale_multi_val(self, mv: MultiVal) -> Result<MultiVal, LibISLError> {
1043        let multi = self;
1044        let isl_rs_ctx = multi.get_ctx();
1045        let mut multi = multi;
1046        multi.do_not_free_on_drop();
1047        let multi = multi.ptr;
1048        let mut mv = mv;
1049        mv.do_not_free_on_drop();
1050        let mv = mv.ptr;
1051        let isl_rs_result = unsafe { isl_multi_val_scale_multi_val(multi, mv) };
1052        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1053                                       should_free_on_drop: true };
1054        let err = isl_rs_ctx.last_error();
1055        if err != Error::None_ {
1056            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1057        }
1058        Ok(isl_rs_result)
1059    }
1060
1061    /// Wraps `isl_multi_val_scale_val`.
1062    pub fn scale_val(self, v: Val) -> Result<MultiVal, LibISLError> {
1063        let multi = self;
1064        let isl_rs_ctx = multi.get_ctx();
1065        let mut multi = multi;
1066        multi.do_not_free_on_drop();
1067        let multi = multi.ptr;
1068        let mut v = v;
1069        v.do_not_free_on_drop();
1070        let v = v.ptr;
1071        let isl_rs_result = unsafe { isl_multi_val_scale_val(multi, v) };
1072        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1073                                       should_free_on_drop: true };
1074        let err = isl_rs_ctx.last_error();
1075        if err != Error::None_ {
1076            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1077        }
1078        Ok(isl_rs_result)
1079    }
1080
1081    /// Wraps `isl_multi_val_set_at`.
1082    pub fn set_at(self, pos: i32, el: Val) -> Result<MultiVal, LibISLError> {
1083        let multi = self;
1084        let isl_rs_ctx = multi.get_ctx();
1085        let mut multi = multi;
1086        multi.do_not_free_on_drop();
1087        let multi = multi.ptr;
1088        let mut el = el;
1089        el.do_not_free_on_drop();
1090        let el = el.ptr;
1091        let isl_rs_result = unsafe { isl_multi_val_set_at(multi, pos, el) };
1092        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1093                                       should_free_on_drop: true };
1094        let err = isl_rs_ctx.last_error();
1095        if err != Error::None_ {
1096            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1097        }
1098        Ok(isl_rs_result)
1099    }
1100
1101    /// Wraps `isl_multi_val_set_dim_id`.
1102    pub fn set_dim_id(self, type_: DimType, pos: u32, id: Id) -> Result<MultiVal, LibISLError> {
1103        let multi = self;
1104        let isl_rs_ctx = multi.get_ctx();
1105        let mut multi = multi;
1106        multi.do_not_free_on_drop();
1107        let multi = multi.ptr;
1108        let type_ = type_.to_i32();
1109        let mut id = id;
1110        id.do_not_free_on_drop();
1111        let id = id.ptr;
1112        let isl_rs_result = unsafe { isl_multi_val_set_dim_id(multi, type_, pos, id) };
1113        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1114                                       should_free_on_drop: true };
1115        let err = isl_rs_ctx.last_error();
1116        if err != Error::None_ {
1117            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1118        }
1119        Ok(isl_rs_result)
1120    }
1121
1122    /// Wraps `isl_multi_val_set_dim_name`.
1123    pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str) -> Result<MultiVal, LibISLError> {
1124        let multi = self;
1125        let isl_rs_ctx = multi.get_ctx();
1126        let mut multi = multi;
1127        multi.do_not_free_on_drop();
1128        let multi = multi.ptr;
1129        let type_ = type_.to_i32();
1130        let s = CString::new(s).unwrap();
1131        let s = s.as_ptr();
1132        let isl_rs_result = unsafe { isl_multi_val_set_dim_name(multi, type_, pos, s) };
1133        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1134                                       should_free_on_drop: true };
1135        let err = isl_rs_ctx.last_error();
1136        if err != Error::None_ {
1137            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1138        }
1139        Ok(isl_rs_result)
1140    }
1141
1142    /// Wraps `isl_multi_val_set_range_tuple_id`.
1143    pub fn set_range_tuple_id(self, id: Id) -> Result<MultiVal, LibISLError> {
1144        let multi = self;
1145        let isl_rs_ctx = multi.get_ctx();
1146        let mut multi = multi;
1147        multi.do_not_free_on_drop();
1148        let multi = multi.ptr;
1149        let mut id = id;
1150        id.do_not_free_on_drop();
1151        let id = id.ptr;
1152        let isl_rs_result = unsafe { isl_multi_val_set_range_tuple_id(multi, id) };
1153        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1154                                       should_free_on_drop: true };
1155        let err = isl_rs_ctx.last_error();
1156        if err != Error::None_ {
1157            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1158        }
1159        Ok(isl_rs_result)
1160    }
1161
1162    /// Wraps `isl_multi_val_set_tuple_id`.
1163    pub fn set_tuple_id(self, type_: DimType, id: Id) -> Result<MultiVal, LibISLError> {
1164        let multi = self;
1165        let isl_rs_ctx = multi.get_ctx();
1166        let mut multi = multi;
1167        multi.do_not_free_on_drop();
1168        let multi = multi.ptr;
1169        let type_ = type_.to_i32();
1170        let mut id = id;
1171        id.do_not_free_on_drop();
1172        let id = id.ptr;
1173        let isl_rs_result = unsafe { isl_multi_val_set_tuple_id(multi, type_, id) };
1174        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1175                                       should_free_on_drop: true };
1176        let err = isl_rs_ctx.last_error();
1177        if err != Error::None_ {
1178            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1179        }
1180        Ok(isl_rs_result)
1181    }
1182
1183    /// Wraps `isl_multi_val_set_tuple_name`.
1184    pub fn set_tuple_name(self, type_: DimType, s: &str) -> Result<MultiVal, LibISLError> {
1185        let multi = self;
1186        let isl_rs_ctx = multi.get_ctx();
1187        let mut multi = multi;
1188        multi.do_not_free_on_drop();
1189        let multi = multi.ptr;
1190        let type_ = type_.to_i32();
1191        let s = CString::new(s).unwrap();
1192        let s = s.as_ptr();
1193        let isl_rs_result = unsafe { isl_multi_val_set_tuple_name(multi, type_, s) };
1194        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1195                                       should_free_on_drop: true };
1196        let err = isl_rs_ctx.last_error();
1197        if err != Error::None_ {
1198            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1199        }
1200        Ok(isl_rs_result)
1201    }
1202
1203    /// Wraps `isl_multi_val_set_val`.
1204    pub fn set_val(self, pos: i32, el: Val) -> Result<MultiVal, LibISLError> {
1205        let multi = self;
1206        let isl_rs_ctx = multi.get_ctx();
1207        let mut multi = multi;
1208        multi.do_not_free_on_drop();
1209        let multi = multi.ptr;
1210        let mut el = el;
1211        el.do_not_free_on_drop();
1212        let el = el.ptr;
1213        let isl_rs_result = unsafe { isl_multi_val_set_val(multi, pos, el) };
1214        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1215                                       should_free_on_drop: true };
1216        let err = isl_rs_ctx.last_error();
1217        if err != Error::None_ {
1218            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1219        }
1220        Ok(isl_rs_result)
1221    }
1222
1223    /// Wraps `isl_multi_val_size`.
1224    pub fn size(&self) -> Result<i32, LibISLError> {
1225        let multi = self;
1226        let isl_rs_ctx = multi.get_ctx();
1227        let multi = multi.ptr;
1228        let isl_rs_result = unsafe { isl_multi_val_size(multi) };
1229        let err = isl_rs_ctx.last_error();
1230        if err != Error::None_ {
1231            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1232        }
1233        Ok(isl_rs_result)
1234    }
1235
1236    /// Wraps `isl_multi_val_splice`.
1237    pub fn splice(self, in_pos: u32, out_pos: u32, multi2: MultiVal)
1238                  -> Result<MultiVal, LibISLError> {
1239        let multi1 = self;
1240        let isl_rs_ctx = multi1.get_ctx();
1241        let mut multi1 = multi1;
1242        multi1.do_not_free_on_drop();
1243        let multi1 = multi1.ptr;
1244        let mut multi2 = multi2;
1245        multi2.do_not_free_on_drop();
1246        let multi2 = multi2.ptr;
1247        let isl_rs_result = unsafe { isl_multi_val_splice(multi1, in_pos, out_pos, multi2) };
1248        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1249                                       should_free_on_drop: true };
1250        let err = isl_rs_ctx.last_error();
1251        if err != Error::None_ {
1252            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1253        }
1254        Ok(isl_rs_result)
1255    }
1256
1257    /// Wraps `isl_multi_val_sub`.
1258    pub fn sub(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
1259        let multi1 = self;
1260        let isl_rs_ctx = multi1.get_ctx();
1261        let mut multi1 = multi1;
1262        multi1.do_not_free_on_drop();
1263        let multi1 = multi1.ptr;
1264        let mut multi2 = multi2;
1265        multi2.do_not_free_on_drop();
1266        let multi2 = multi2.ptr;
1267        let isl_rs_result = unsafe { isl_multi_val_sub(multi1, multi2) };
1268        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1269                                       should_free_on_drop: true };
1270        let err = isl_rs_ctx.last_error();
1271        if err != Error::None_ {
1272            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1273        }
1274        Ok(isl_rs_result)
1275    }
1276
1277    /// Wraps `isl_multi_val_to_str`.
1278    pub fn to_str(&self) -> Result<&str, LibISLError> {
1279        let mv = self;
1280        let isl_rs_ctx = mv.get_ctx();
1281        let mv = mv.ptr;
1282        let isl_rs_result = unsafe { isl_multi_val_to_str(mv) };
1283        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1284        let isl_rs_result = isl_rs_result.to_str().unwrap();
1285        let err = isl_rs_ctx.last_error();
1286        if err != Error::None_ {
1287            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1288        }
1289        Ok(isl_rs_result)
1290    }
1291
1292    /// Wraps `isl_multi_val_zero`.
1293    pub fn zero(space: Space) -> Result<MultiVal, LibISLError> {
1294        let isl_rs_ctx = space.get_ctx();
1295        let mut space = space;
1296        space.do_not_free_on_drop();
1297        let space = space.ptr;
1298        let isl_rs_result = unsafe { isl_multi_val_zero(space) };
1299        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1300                                       should_free_on_drop: true };
1301        let err = isl_rs_ctx.last_error();
1302        if err != Error::None_ {
1303            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1304        }
1305        Ok(isl_rs_result)
1306    }
1307
1308    /// Does not call isl_multi_val_free() on being dropped. (For internal use
1309    /// only.)
1310    pub fn do_not_free_on_drop(&mut self) {
1311        self.should_free_on_drop = false;
1312    }
1313}
1314
1315impl Drop for MultiVal {
1316    fn drop(&mut self) {
1317        if self.should_free_on_drop {
1318            unsafe {
1319                isl_multi_val_free(self.ptr);
1320            }
1321        }
1322    }
1323}
isl_rs/bindings/multi_val.rs

isl_rs/bindings/
multi_val.rs
