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            let err_msg = isl_rs_ctx.last_error_msg();
169            isl_rs_ctx.reset_error();
170            return Err(LibISLError::new(err, err_msg));
171        }
172        Ok(isl_rs_result)
173    }
174
175    /// Wraps `isl_multi_val_add_dims`.
176    pub fn add_dims(self, type_: DimType, n: u32) -> Result<MultiVal, LibISLError> {
177        let multi = self;
178        let isl_rs_ctx = multi.get_ctx();
179        let mut multi = multi;
180        multi.do_not_free_on_drop();
181        let multi = multi.ptr;
182        let type_ = type_.to_i32();
183        let isl_rs_result = unsafe { isl_multi_val_add_dims(multi, type_, n) };
184        let isl_rs_result = MultiVal { ptr: isl_rs_result,
185                                       should_free_on_drop: true };
186        let err = isl_rs_ctx.last_error();
187        if err != Error::None_ {
188            let err_msg = isl_rs_ctx.last_error_msg();
189            isl_rs_ctx.reset_error();
190            return Err(LibISLError::new(err, err_msg));
191        }
192        Ok(isl_rs_result)
193    }
194
195    /// Wraps `isl_multi_val_add_val`.
196    pub fn add_val(self, v: Val) -> Result<MultiVal, LibISLError> {
197        let mv = self;
198        let isl_rs_ctx = mv.get_ctx();
199        let mut mv = mv;
200        mv.do_not_free_on_drop();
201        let mv = mv.ptr;
202        let mut v = v;
203        v.do_not_free_on_drop();
204        let v = v.ptr;
205        let isl_rs_result = unsafe { isl_multi_val_add_val(mv, v) };
206        let isl_rs_result = MultiVal { ptr: isl_rs_result,
207                                       should_free_on_drop: true };
208        let err = isl_rs_ctx.last_error();
209        if err != Error::None_ {
210            let err_msg = isl_rs_ctx.last_error_msg();
211            isl_rs_ctx.reset_error();
212            return Err(LibISLError::new(err, err_msg));
213        }
214        Ok(isl_rs_result)
215    }
216
217    /// Wraps `isl_multi_val_align_params`.
218    pub fn align_params(self, model: Space) -> Result<MultiVal, LibISLError> {
219        let multi = self;
220        let isl_rs_ctx = multi.get_ctx();
221        let mut multi = multi;
222        multi.do_not_free_on_drop();
223        let multi = multi.ptr;
224        let mut model = model;
225        model.do_not_free_on_drop();
226        let model = model.ptr;
227        let isl_rs_result = unsafe { isl_multi_val_align_params(multi, model) };
228        let isl_rs_result = MultiVal { ptr: isl_rs_result,
229                                       should_free_on_drop: true };
230        let err = isl_rs_ctx.last_error();
231        if err != Error::None_ {
232            let err_msg = isl_rs_ctx.last_error_msg();
233            isl_rs_ctx.reset_error();
234            return Err(LibISLError::new(err, err_msg));
235        }
236        Ok(isl_rs_result)
237    }
238
239    /// Wraps `isl_multi_val_copy`.
240    pub fn copy(&self) -> Result<MultiVal, LibISLError> {
241        let multi = self;
242        let isl_rs_ctx = multi.get_ctx();
243        let multi = multi.ptr;
244        let isl_rs_result = unsafe { isl_multi_val_copy(multi) };
245        let isl_rs_result = MultiVal { ptr: isl_rs_result,
246                                       should_free_on_drop: true };
247        let err = isl_rs_ctx.last_error();
248        if err != Error::None_ {
249            let err_msg = isl_rs_ctx.last_error_msg();
250            isl_rs_ctx.reset_error();
251            return Err(LibISLError::new(err, err_msg));
252        }
253        Ok(isl_rs_result)
254    }
255
256    /// Wraps `isl_multi_val_dim`.
257    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
258        let multi = self;
259        let isl_rs_ctx = multi.get_ctx();
260        let multi = multi.ptr;
261        let type_ = type_.to_i32();
262        let isl_rs_result = unsafe { isl_multi_val_dim(multi, type_) };
263        let err = isl_rs_ctx.last_error();
264        if err != Error::None_ {
265            let err_msg = isl_rs_ctx.last_error_msg();
266            isl_rs_ctx.reset_error();
267            return Err(LibISLError::new(err, err_msg));
268        }
269        Ok(isl_rs_result)
270    }
271
272    /// Wraps `isl_multi_val_drop_dims`.
273    pub fn drop_dims(self, type_: DimType, first: u32, n: u32) -> Result<MultiVal, LibISLError> {
274        let multi = self;
275        let isl_rs_ctx = multi.get_ctx();
276        let mut multi = multi;
277        multi.do_not_free_on_drop();
278        let multi = multi.ptr;
279        let type_ = type_.to_i32();
280        let isl_rs_result = unsafe { isl_multi_val_drop_dims(multi, type_, first, n) };
281        let isl_rs_result = MultiVal { ptr: isl_rs_result,
282                                       should_free_on_drop: true };
283        let err = isl_rs_ctx.last_error();
284        if err != Error::None_ {
285            let err_msg = isl_rs_ctx.last_error_msg();
286            isl_rs_ctx.reset_error();
287            return Err(LibISLError::new(err, err_msg));
288        }
289        Ok(isl_rs_result)
290    }
291
292    /// Wraps `isl_multi_val_dump`.
293    pub fn dump(&self) -> Result<(), LibISLError> {
294        let mv = self;
295        let isl_rs_ctx = mv.get_ctx();
296        let mv = mv.ptr;
297        let isl_rs_result = unsafe { isl_multi_val_dump(mv) };
298        let err = isl_rs_ctx.last_error();
299        if err != Error::None_ {
300            let err_msg = isl_rs_ctx.last_error_msg();
301            isl_rs_ctx.reset_error();
302            return Err(LibISLError::new(err, err_msg));
303        }
304        Ok(isl_rs_result)
305    }
306
307    /// Wraps `isl_multi_val_factor_range`.
308    pub fn factor_range(self) -> Result<MultiVal, LibISLError> {
309        let multi = self;
310        let isl_rs_ctx = multi.get_ctx();
311        let mut multi = multi;
312        multi.do_not_free_on_drop();
313        let multi = multi.ptr;
314        let isl_rs_result = unsafe { isl_multi_val_factor_range(multi) };
315        let isl_rs_result = MultiVal { ptr: isl_rs_result,
316                                       should_free_on_drop: true };
317        let err = isl_rs_ctx.last_error();
318        if err != Error::None_ {
319            let err_msg = isl_rs_ctx.last_error_msg();
320            isl_rs_ctx.reset_error();
321            return Err(LibISLError::new(err, err_msg));
322        }
323        Ok(isl_rs_result)
324    }
325
326    /// Wraps `isl_multi_val_find_dim_by_id`.
327    pub fn find_dim_by_id(&self, type_: DimType, id: &Id) -> Result<i32, LibISLError> {
328        let multi = self;
329        let isl_rs_ctx = multi.get_ctx();
330        let multi = multi.ptr;
331        let type_ = type_.to_i32();
332        let id = id.ptr;
333        let isl_rs_result = unsafe { isl_multi_val_find_dim_by_id(multi, type_, id) };
334        let err = isl_rs_ctx.last_error();
335        if err != Error::None_ {
336            let err_msg = isl_rs_ctx.last_error_msg();
337            isl_rs_ctx.reset_error();
338            return Err(LibISLError::new(err, err_msg));
339        }
340        Ok(isl_rs_result)
341    }
342
343    /// Wraps `isl_multi_val_find_dim_by_name`.
344    pub fn find_dim_by_name(&self, type_: DimType, name: &str) -> Result<i32, LibISLError> {
345        let multi = self;
346        let isl_rs_ctx = multi.get_ctx();
347        let multi = multi.ptr;
348        let type_ = type_.to_i32();
349        let name = CString::new(name).unwrap();
350        let name = name.as_ptr();
351        let isl_rs_result = unsafe { isl_multi_val_find_dim_by_name(multi, type_, name) };
352        let err = isl_rs_ctx.last_error();
353        if err != Error::None_ {
354            let err_msg = isl_rs_ctx.last_error_msg();
355            isl_rs_ctx.reset_error();
356            return Err(LibISLError::new(err, err_msg));
357        }
358        Ok(isl_rs_result)
359    }
360
361    /// Wraps `isl_multi_val_flat_range_product`.
362    pub fn flat_range_product(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
363        let multi1 = self;
364        let isl_rs_ctx = multi1.get_ctx();
365        let mut multi1 = multi1;
366        multi1.do_not_free_on_drop();
367        let multi1 = multi1.ptr;
368        let mut multi2 = multi2;
369        multi2.do_not_free_on_drop();
370        let multi2 = multi2.ptr;
371        let isl_rs_result = unsafe { isl_multi_val_flat_range_product(multi1, multi2) };
372        let isl_rs_result = MultiVal { ptr: isl_rs_result,
373                                       should_free_on_drop: true };
374        let err = isl_rs_ctx.last_error();
375        if err != Error::None_ {
376            let err_msg = isl_rs_ctx.last_error_msg();
377            isl_rs_ctx.reset_error();
378            return Err(LibISLError::new(err, err_msg));
379        }
380        Ok(isl_rs_result)
381    }
382
383    /// Wraps `isl_multi_val_flatten_range`.
384    pub fn flatten_range(self) -> Result<MultiVal, LibISLError> {
385        let multi = self;
386        let isl_rs_ctx = multi.get_ctx();
387        let mut multi = multi;
388        multi.do_not_free_on_drop();
389        let multi = multi.ptr;
390        let isl_rs_result = unsafe { isl_multi_val_flatten_range(multi) };
391        let isl_rs_result = MultiVal { ptr: isl_rs_result,
392                                       should_free_on_drop: true };
393        let err = isl_rs_ctx.last_error();
394        if err != Error::None_ {
395            let err_msg = isl_rs_ctx.last_error_msg();
396            isl_rs_ctx.reset_error();
397            return Err(LibISLError::new(err, err_msg));
398        }
399        Ok(isl_rs_result)
400    }
401
402    /// Wraps `isl_multi_val_free`.
403    pub fn free(self) -> Result<MultiVal, LibISLError> {
404        let multi = self;
405        let isl_rs_ctx = multi.get_ctx();
406        let mut multi = multi;
407        multi.do_not_free_on_drop();
408        let multi = multi.ptr;
409        let isl_rs_result = unsafe { isl_multi_val_free(multi) };
410        let isl_rs_result = MultiVal { ptr: isl_rs_result,
411                                       should_free_on_drop: true };
412        let err = isl_rs_ctx.last_error();
413        if err != Error::None_ {
414            let err_msg = isl_rs_ctx.last_error_msg();
415            isl_rs_ctx.reset_error();
416            return Err(LibISLError::new(err, err_msg));
417        }
418        Ok(isl_rs_result)
419    }
420
421    /// Wraps `isl_multi_val_from_range`.
422    pub fn from_range(self) -> Result<MultiVal, LibISLError> {
423        let multi = self;
424        let isl_rs_ctx = multi.get_ctx();
425        let mut multi = multi;
426        multi.do_not_free_on_drop();
427        let multi = multi.ptr;
428        let isl_rs_result = unsafe { isl_multi_val_from_range(multi) };
429        let isl_rs_result = MultiVal { ptr: isl_rs_result,
430                                       should_free_on_drop: true };
431        let err = isl_rs_ctx.last_error();
432        if err != Error::None_ {
433            let err_msg = isl_rs_ctx.last_error_msg();
434            isl_rs_ctx.reset_error();
435            return Err(LibISLError::new(err, err_msg));
436        }
437        Ok(isl_rs_result)
438    }
439
440    /// Wraps `isl_multi_val_from_val_list`.
441    pub fn from_val_list(space: Space, list: ValList) -> Result<MultiVal, LibISLError> {
442        let isl_rs_ctx = space.get_ctx();
443        let mut space = space;
444        space.do_not_free_on_drop();
445        let space = space.ptr;
446        let mut list = list;
447        list.do_not_free_on_drop();
448        let list = list.ptr;
449        let isl_rs_result = unsafe { isl_multi_val_from_val_list(space, list) };
450        let isl_rs_result = MultiVal { ptr: isl_rs_result,
451                                       should_free_on_drop: true };
452        let err = isl_rs_ctx.last_error();
453        if err != Error::None_ {
454            let err_msg = isl_rs_ctx.last_error_msg();
455            isl_rs_ctx.reset_error();
456            return Err(LibISLError::new(err, err_msg));
457        }
458        Ok(isl_rs_result)
459    }
460
461    /// Wraps `isl_multi_val_get_at`.
462    pub fn get_at(&self, pos: i32) -> Result<Val, LibISLError> {
463        let multi = self;
464        let isl_rs_ctx = multi.get_ctx();
465        let multi = multi.ptr;
466        let isl_rs_result = unsafe { isl_multi_val_get_at(multi, pos) };
467        let isl_rs_result = Val { ptr: isl_rs_result,
468                                  should_free_on_drop: true };
469        let err = isl_rs_ctx.last_error();
470        if err != Error::None_ {
471            let err_msg = isl_rs_ctx.last_error_msg();
472            isl_rs_ctx.reset_error();
473            return Err(LibISLError::new(err, err_msg));
474        }
475        Ok(isl_rs_result)
476    }
477
478    /// Wraps `isl_multi_val_get_ctx`.
479    pub fn get_ctx(&self) -> Context {
480        let multi = self;
481        let multi = multi.ptr;
482        let isl_rs_result = unsafe { isl_multi_val_get_ctx(multi) };
483        let isl_rs_result = Context { ptr: isl_rs_result,
484                                      should_free_on_drop: false };
485        isl_rs_result
486    }
487
488    /// Wraps `isl_multi_val_get_dim_id`.
489    pub fn get_dim_id(&self, type_: DimType, pos: u32) -> Result<Id, LibISLError> {
490        let multi = self;
491        let isl_rs_ctx = multi.get_ctx();
492        let multi = multi.ptr;
493        let type_ = type_.to_i32();
494        let isl_rs_result = unsafe { isl_multi_val_get_dim_id(multi, type_, pos) };
495        let isl_rs_result = Id { ptr: isl_rs_result,
496                                 should_free_on_drop: true };
497        let err = isl_rs_ctx.last_error();
498        if err != Error::None_ {
499            let err_msg = isl_rs_ctx.last_error_msg();
500            isl_rs_ctx.reset_error();
501            return Err(LibISLError::new(err, err_msg));
502        }
503        Ok(isl_rs_result)
504    }
505
506    /// Wraps `isl_multi_val_get_domain_space`.
507    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
508        let multi = self;
509        let isl_rs_ctx = multi.get_ctx();
510        let multi = multi.ptr;
511        let isl_rs_result = unsafe { isl_multi_val_get_domain_space(multi) };
512        let isl_rs_result = Space { ptr: isl_rs_result,
513                                    should_free_on_drop: true };
514        let err = isl_rs_ctx.last_error();
515        if err != Error::None_ {
516            let err_msg = isl_rs_ctx.last_error_msg();
517            isl_rs_ctx.reset_error();
518            return Err(LibISLError::new(err, err_msg));
519        }
520        Ok(isl_rs_result)
521    }
522
523    /// Wraps `isl_multi_val_get_list`.
524    pub fn get_list(&self) -> Result<ValList, LibISLError> {
525        let multi = self;
526        let isl_rs_ctx = multi.get_ctx();
527        let multi = multi.ptr;
528        let isl_rs_result = unsafe { isl_multi_val_get_list(multi) };
529        let isl_rs_result = ValList { ptr: isl_rs_result,
530                                      should_free_on_drop: true };
531        let err = isl_rs_ctx.last_error();
532        if err != Error::None_ {
533            let err_msg = isl_rs_ctx.last_error_msg();
534            isl_rs_ctx.reset_error();
535            return Err(LibISLError::new(err, err_msg));
536        }
537        Ok(isl_rs_result)
538    }
539
540    /// Wraps `isl_multi_val_get_range_tuple_id`.
541    pub fn get_range_tuple_id(&self) -> Result<Id, LibISLError> {
542        let multi = self;
543        let isl_rs_ctx = multi.get_ctx();
544        let multi = multi.ptr;
545        let isl_rs_result = unsafe { isl_multi_val_get_range_tuple_id(multi) };
546        let isl_rs_result = Id { ptr: isl_rs_result,
547                                 should_free_on_drop: true };
548        let err = isl_rs_ctx.last_error();
549        if err != Error::None_ {
550            let err_msg = isl_rs_ctx.last_error_msg();
551            isl_rs_ctx.reset_error();
552            return Err(LibISLError::new(err, err_msg));
553        }
554        Ok(isl_rs_result)
555    }
556
557    /// Wraps `isl_multi_val_get_space`.
558    pub fn get_space(&self) -> Result<Space, LibISLError> {
559        let multi = self;
560        let isl_rs_ctx = multi.get_ctx();
561        let multi = multi.ptr;
562        let isl_rs_result = unsafe { isl_multi_val_get_space(multi) };
563        let isl_rs_result = Space { ptr: isl_rs_result,
564                                    should_free_on_drop: true };
565        let err = isl_rs_ctx.last_error();
566        if err != Error::None_ {
567            let err_msg = isl_rs_ctx.last_error_msg();
568            isl_rs_ctx.reset_error();
569            return Err(LibISLError::new(err, err_msg));
570        }
571        Ok(isl_rs_result)
572    }
573
574    /// Wraps `isl_multi_val_get_tuple_id`.
575    pub fn get_tuple_id(&self, type_: DimType) -> Result<Id, LibISLError> {
576        let multi = self;
577        let isl_rs_ctx = multi.get_ctx();
578        let multi = multi.ptr;
579        let type_ = type_.to_i32();
580        let isl_rs_result = unsafe { isl_multi_val_get_tuple_id(multi, type_) };
581        let isl_rs_result = Id { ptr: isl_rs_result,
582                                 should_free_on_drop: true };
583        let err = isl_rs_ctx.last_error();
584        if err != Error::None_ {
585            let err_msg = isl_rs_ctx.last_error_msg();
586            isl_rs_ctx.reset_error();
587            return Err(LibISLError::new(err, err_msg));
588        }
589        Ok(isl_rs_result)
590    }
591
592    /// Wraps `isl_multi_val_get_tuple_name`.
593    pub fn get_tuple_name(&self, type_: DimType) -> Result<&str, LibISLError> {
594        let multi = self;
595        let isl_rs_ctx = multi.get_ctx();
596        let multi = multi.ptr;
597        let type_ = type_.to_i32();
598        let isl_rs_result = unsafe { isl_multi_val_get_tuple_name(multi, type_) };
599        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
600        let isl_rs_result = isl_rs_result.to_str().unwrap();
601        let err = isl_rs_ctx.last_error();
602        if err != Error::None_ {
603            let err_msg = isl_rs_ctx.last_error_msg();
604            isl_rs_ctx.reset_error();
605            return Err(LibISLError::new(err, err_msg));
606        }
607        Ok(isl_rs_result)
608    }
609
610    /// Wraps `isl_multi_val_get_val`.
611    pub fn get_val(&self, pos: i32) -> Result<Val, LibISLError> {
612        let multi = self;
613        let isl_rs_ctx = multi.get_ctx();
614        let multi = multi.ptr;
615        let isl_rs_result = unsafe { isl_multi_val_get_val(multi, pos) };
616        let isl_rs_result = Val { ptr: isl_rs_result,
617                                  should_free_on_drop: true };
618        let err = isl_rs_ctx.last_error();
619        if err != Error::None_ {
620            let err_msg = isl_rs_ctx.last_error_msg();
621            isl_rs_ctx.reset_error();
622            return Err(LibISLError::new(err, err_msg));
623        }
624        Ok(isl_rs_result)
625    }
626
627    /// Wraps `isl_multi_val_has_range_tuple_id`.
628    pub fn has_range_tuple_id(&self) -> Result<bool, LibISLError> {
629        let multi = self;
630        let isl_rs_ctx = multi.get_ctx();
631        let multi = multi.ptr;
632        let isl_rs_result = unsafe { isl_multi_val_has_range_tuple_id(multi) };
633        let isl_rs_result = match isl_rs_result {
634            0 => false,
635            1 => true,
636            _ => {
637                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
638            }
639        };
640        let err = isl_rs_ctx.last_error();
641        if err != Error::None_ {
642            let err_msg = isl_rs_ctx.last_error_msg();
643            isl_rs_ctx.reset_error();
644            return Err(LibISLError::new(err, err_msg));
645        }
646        Ok(isl_rs_result)
647    }
648
649    /// Wraps `isl_multi_val_has_tuple_id`.
650    pub fn has_tuple_id(&self, type_: DimType) -> Result<bool, LibISLError> {
651        let multi = self;
652        let isl_rs_ctx = multi.get_ctx();
653        let multi = multi.ptr;
654        let type_ = type_.to_i32();
655        let isl_rs_result = unsafe { isl_multi_val_has_tuple_id(multi, type_) };
656        let isl_rs_result = match isl_rs_result {
657            0 => false,
658            1 => true,
659            _ => {
660                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
661            }
662        };
663        let err = isl_rs_ctx.last_error();
664        if err != Error::None_ {
665            let err_msg = isl_rs_ctx.last_error_msg();
666            isl_rs_ctx.reset_error();
667            return Err(LibISLError::new(err, err_msg));
668        }
669        Ok(isl_rs_result)
670    }
671
672    /// Wraps `isl_multi_val_insert_dims`.
673    pub fn insert_dims(self, type_: DimType, first: u32, n: u32) -> Result<MultiVal, LibISLError> {
674        let multi = self;
675        let isl_rs_ctx = multi.get_ctx();
676        let mut multi = multi;
677        multi.do_not_free_on_drop();
678        let multi = multi.ptr;
679        let type_ = type_.to_i32();
680        let isl_rs_result = unsafe { isl_multi_val_insert_dims(multi, type_, first, n) };
681        let isl_rs_result = MultiVal { ptr: isl_rs_result,
682                                       should_free_on_drop: true };
683        let err = isl_rs_ctx.last_error();
684        if err != Error::None_ {
685            let err_msg = isl_rs_ctx.last_error_msg();
686            isl_rs_ctx.reset_error();
687            return Err(LibISLError::new(err, err_msg));
688        }
689        Ok(isl_rs_result)
690    }
691
692    /// Wraps `isl_multi_val_involves_dims`.
693    pub fn involves_dims(&self, type_: DimType, first: u32, n: u32) -> Result<bool, LibISLError> {
694        let multi = self;
695        let isl_rs_ctx = multi.get_ctx();
696        let multi = multi.ptr;
697        let type_ = type_.to_i32();
698        let isl_rs_result = unsafe { isl_multi_val_involves_dims(multi, type_, first, n) };
699        let isl_rs_result = match isl_rs_result {
700            0 => false,
701            1 => true,
702            _ => {
703                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
704            }
705        };
706        let err = isl_rs_ctx.last_error();
707        if err != Error::None_ {
708            let err_msg = isl_rs_ctx.last_error_msg();
709            isl_rs_ctx.reset_error();
710            return Err(LibISLError::new(err, err_msg));
711        }
712        Ok(isl_rs_result)
713    }
714
715    /// Wraps `isl_multi_val_involves_nan`.
716    pub fn involves_nan(&self) -> Result<bool, LibISLError> {
717        let multi = self;
718        let isl_rs_ctx = multi.get_ctx();
719        let multi = multi.ptr;
720        let isl_rs_result = unsafe { isl_multi_val_involves_nan(multi) };
721        let isl_rs_result = match isl_rs_result {
722            0 => false,
723            1 => true,
724            _ => {
725                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
726            }
727        };
728        let err = isl_rs_ctx.last_error();
729        if err != Error::None_ {
730            let err_msg = isl_rs_ctx.last_error_msg();
731            isl_rs_ctx.reset_error();
732            return Err(LibISLError::new(err, err_msg));
733        }
734        Ok(isl_rs_result)
735    }
736
737    /// Wraps `isl_multi_val_is_zero`.
738    pub fn is_zero(&self) -> Result<bool, LibISLError> {
739        let mv = self;
740        let isl_rs_ctx = mv.get_ctx();
741        let mv = mv.ptr;
742        let isl_rs_result = unsafe { isl_multi_val_is_zero(mv) };
743        let isl_rs_result = match isl_rs_result {
744            0 => false,
745            1 => true,
746            _ => {
747                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
748            }
749        };
750        let err = isl_rs_ctx.last_error();
751        if err != Error::None_ {
752            let err_msg = isl_rs_ctx.last_error_msg();
753            isl_rs_ctx.reset_error();
754            return Err(LibISLError::new(err, err_msg));
755        }
756        Ok(isl_rs_result)
757    }
758
759    /// Wraps `isl_multi_val_max`.
760    pub fn max(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
761        let multi1 = self;
762        let isl_rs_ctx = multi1.get_ctx();
763        let mut multi1 = multi1;
764        multi1.do_not_free_on_drop();
765        let multi1 = multi1.ptr;
766        let mut multi2 = multi2;
767        multi2.do_not_free_on_drop();
768        let multi2 = multi2.ptr;
769        let isl_rs_result = unsafe { isl_multi_val_max(multi1, multi2) };
770        let isl_rs_result = MultiVal { ptr: isl_rs_result,
771                                       should_free_on_drop: true };
772        let err = isl_rs_ctx.last_error();
773        if err != Error::None_ {
774            let err_msg = isl_rs_ctx.last_error_msg();
775            isl_rs_ctx.reset_error();
776            return Err(LibISLError::new(err, err_msg));
777        }
778        Ok(isl_rs_result)
779    }
780
781    /// Wraps `isl_multi_val_min`.
782    pub fn min(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
783        let multi1 = self;
784        let isl_rs_ctx = multi1.get_ctx();
785        let mut multi1 = multi1;
786        multi1.do_not_free_on_drop();
787        let multi1 = multi1.ptr;
788        let mut multi2 = multi2;
789        multi2.do_not_free_on_drop();
790        let multi2 = multi2.ptr;
791        let isl_rs_result = unsafe { isl_multi_val_min(multi1, multi2) };
792        let isl_rs_result = MultiVal { ptr: isl_rs_result,
793                                       should_free_on_drop: true };
794        let err = isl_rs_ctx.last_error();
795        if err != Error::None_ {
796            let err_msg = isl_rs_ctx.last_error_msg();
797            isl_rs_ctx.reset_error();
798            return Err(LibISLError::new(err, err_msg));
799        }
800        Ok(isl_rs_result)
801    }
802
803    /// Wraps `isl_multi_val_mod_multi_val`.
804    pub fn mod_multi_val(self, mv: MultiVal) -> Result<MultiVal, LibISLError> {
805        let multi = self;
806        let isl_rs_ctx = multi.get_ctx();
807        let mut multi = multi;
808        multi.do_not_free_on_drop();
809        let multi = multi.ptr;
810        let mut mv = mv;
811        mv.do_not_free_on_drop();
812        let mv = mv.ptr;
813        let isl_rs_result = unsafe { isl_multi_val_mod_multi_val(multi, mv) };
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            let err_msg = isl_rs_ctx.last_error_msg();
819            isl_rs_ctx.reset_error();
820            return Err(LibISLError::new(err, err_msg));
821        }
822        Ok(isl_rs_result)
823    }
824
825    /// Wraps `isl_multi_val_mod_val`.
826    pub fn mod_val(self, v: Val) -> Result<MultiVal, LibISLError> {
827        let mv = self;
828        let isl_rs_ctx = mv.get_ctx();
829        let mut mv = mv;
830        mv.do_not_free_on_drop();
831        let mv = mv.ptr;
832        let mut v = v;
833        v.do_not_free_on_drop();
834        let v = v.ptr;
835        let isl_rs_result = unsafe { isl_multi_val_mod_val(mv, v) };
836        let isl_rs_result = MultiVal { ptr: isl_rs_result,
837                                       should_free_on_drop: true };
838        let err = isl_rs_ctx.last_error();
839        if err != Error::None_ {
840            let err_msg = isl_rs_ctx.last_error_msg();
841            isl_rs_ctx.reset_error();
842            return Err(LibISLError::new(err, err_msg));
843        }
844        Ok(isl_rs_result)
845    }
846
847    /// Wraps `isl_multi_val_neg`.
848    pub fn neg(self) -> Result<MultiVal, LibISLError> {
849        let multi = self;
850        let isl_rs_ctx = multi.get_ctx();
851        let mut multi = multi;
852        multi.do_not_free_on_drop();
853        let multi = multi.ptr;
854        let isl_rs_result = unsafe { isl_multi_val_neg(multi) };
855        let isl_rs_result = MultiVal { ptr: isl_rs_result,
856                                       should_free_on_drop: true };
857        let err = isl_rs_ctx.last_error();
858        if err != Error::None_ {
859            let err_msg = isl_rs_ctx.last_error_msg();
860            isl_rs_ctx.reset_error();
861            return Err(LibISLError::new(err, err_msg));
862        }
863        Ok(isl_rs_result)
864    }
865
866    /// Wraps `isl_multi_val_plain_is_equal`.
867    pub fn plain_is_equal(&self, multi2: &MultiVal) -> Result<bool, LibISLError> {
868        let multi1 = self;
869        let isl_rs_ctx = multi1.get_ctx();
870        let multi1 = multi1.ptr;
871        let multi2 = multi2.ptr;
872        let isl_rs_result = unsafe { isl_multi_val_plain_is_equal(multi1, multi2) };
873        let isl_rs_result = match isl_rs_result {
874            0 => false,
875            1 => true,
876            _ => {
877                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
878            }
879        };
880        let err = isl_rs_ctx.last_error();
881        if err != Error::None_ {
882            let err_msg = isl_rs_ctx.last_error_msg();
883            isl_rs_ctx.reset_error();
884            return Err(LibISLError::new(err, err_msg));
885        }
886        Ok(isl_rs_result)
887    }
888
889    /// Wraps `isl_multi_val_product`.
890    pub fn product(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
891        let multi1 = self;
892        let isl_rs_ctx = multi1.get_ctx();
893        let mut multi1 = multi1;
894        multi1.do_not_free_on_drop();
895        let multi1 = multi1.ptr;
896        let mut multi2 = multi2;
897        multi2.do_not_free_on_drop();
898        let multi2 = multi2.ptr;
899        let isl_rs_result = unsafe { isl_multi_val_product(multi1, multi2) };
900        let isl_rs_result = MultiVal { ptr: isl_rs_result,
901                                       should_free_on_drop: true };
902        let err = isl_rs_ctx.last_error();
903        if err != Error::None_ {
904            let err_msg = isl_rs_ctx.last_error_msg();
905            isl_rs_ctx.reset_error();
906            return Err(LibISLError::new(err, err_msg));
907        }
908        Ok(isl_rs_result)
909    }
910
911    /// Wraps `isl_multi_val_project_domain_on_params`.
912    pub fn project_domain_on_params(self) -> Result<MultiVal, LibISLError> {
913        let multi = self;
914        let isl_rs_ctx = multi.get_ctx();
915        let mut multi = multi;
916        multi.do_not_free_on_drop();
917        let multi = multi.ptr;
918        let isl_rs_result = unsafe { isl_multi_val_project_domain_on_params(multi) };
919        let isl_rs_result = MultiVal { ptr: isl_rs_result,
920                                       should_free_on_drop: true };
921        let err = isl_rs_ctx.last_error();
922        if err != Error::None_ {
923            let err_msg = isl_rs_ctx.last_error_msg();
924            isl_rs_ctx.reset_error();
925            return Err(LibISLError::new(err, err_msg));
926        }
927        Ok(isl_rs_result)
928    }
929
930    /// Wraps `isl_multi_val_range_factor_domain`.
931    pub fn range_factor_domain(self) -> Result<MultiVal, LibISLError> {
932        let multi = self;
933        let isl_rs_ctx = multi.get_ctx();
934        let mut multi = multi;
935        multi.do_not_free_on_drop();
936        let multi = multi.ptr;
937        let isl_rs_result = unsafe { isl_multi_val_range_factor_domain(multi) };
938        let isl_rs_result = MultiVal { ptr: isl_rs_result,
939                                       should_free_on_drop: true };
940        let err = isl_rs_ctx.last_error();
941        if err != Error::None_ {
942            let err_msg = isl_rs_ctx.last_error_msg();
943            isl_rs_ctx.reset_error();
944            return Err(LibISLError::new(err, err_msg));
945        }
946        Ok(isl_rs_result)
947    }
948
949    /// Wraps `isl_multi_val_range_factor_range`.
950    pub fn range_factor_range(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_range_factor_range(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            let err_msg = isl_rs_ctx.last_error_msg();
962            isl_rs_ctx.reset_error();
963            return Err(LibISLError::new(err, err_msg));
964        }
965        Ok(isl_rs_result)
966    }
967
968    /// Wraps `isl_multi_val_range_is_wrapping`.
969    pub fn range_is_wrapping(&self) -> Result<bool, LibISLError> {
970        let multi = self;
971        let isl_rs_ctx = multi.get_ctx();
972        let multi = multi.ptr;
973        let isl_rs_result = unsafe { isl_multi_val_range_is_wrapping(multi) };
974        let isl_rs_result = match isl_rs_result {
975            0 => false,
976            1 => true,
977            _ => {
978                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
979            }
980        };
981        let err = isl_rs_ctx.last_error();
982        if err != Error::None_ {
983            let err_msg = isl_rs_ctx.last_error_msg();
984            isl_rs_ctx.reset_error();
985            return Err(LibISLError::new(err, err_msg));
986        }
987        Ok(isl_rs_result)
988    }
989
990    /// Wraps `isl_multi_val_range_product`.
991    pub fn range_product(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
992        let multi1 = self;
993        let isl_rs_ctx = multi1.get_ctx();
994        let mut multi1 = multi1;
995        multi1.do_not_free_on_drop();
996        let multi1 = multi1.ptr;
997        let mut multi2 = multi2;
998        multi2.do_not_free_on_drop();
999        let multi2 = multi2.ptr;
1000        let isl_rs_result = unsafe { isl_multi_val_range_product(multi1, multi2) };
1001        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1002                                       should_free_on_drop: true };
1003        let err = isl_rs_ctx.last_error();
1004        if err != Error::None_ {
1005            let err_msg = isl_rs_ctx.last_error_msg();
1006            isl_rs_ctx.reset_error();
1007            return Err(LibISLError::new(err, err_msg));
1008        }
1009        Ok(isl_rs_result)
1010    }
1011
1012    /// Wraps `isl_multi_val_range_splice`.
1013    pub fn range_splice(self, pos: u32, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
1014        let multi1 = self;
1015        let isl_rs_ctx = multi1.get_ctx();
1016        let mut multi1 = multi1;
1017        multi1.do_not_free_on_drop();
1018        let multi1 = multi1.ptr;
1019        let mut multi2 = multi2;
1020        multi2.do_not_free_on_drop();
1021        let multi2 = multi2.ptr;
1022        let isl_rs_result = unsafe { isl_multi_val_range_splice(multi1, pos, multi2) };
1023        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1024                                       should_free_on_drop: true };
1025        let err = isl_rs_ctx.last_error();
1026        if err != Error::None_ {
1027            let err_msg = isl_rs_ctx.last_error_msg();
1028            isl_rs_ctx.reset_error();
1029            return Err(LibISLError::new(err, err_msg));
1030        }
1031        Ok(isl_rs_result)
1032    }
1033
1034    /// Wraps `isl_multi_val_read_from_str`.
1035    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<MultiVal, LibISLError> {
1036        let isl_rs_ctx = Context { ptr: ctx.ptr,
1037                                   should_free_on_drop: false };
1038        let ctx = ctx.ptr;
1039        let str_ = CString::new(str_).unwrap();
1040        let str_ = str_.as_ptr();
1041        let isl_rs_result = unsafe { isl_multi_val_read_from_str(ctx, str_) };
1042        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1043                                       should_free_on_drop: true };
1044        let err = isl_rs_ctx.last_error();
1045        if err != Error::None_ {
1046            let err_msg = isl_rs_ctx.last_error_msg();
1047            isl_rs_ctx.reset_error();
1048            return Err(LibISLError::new(err, err_msg));
1049        }
1050        Ok(isl_rs_result)
1051    }
1052
1053    /// Wraps `isl_multi_val_reset_range_tuple_id`.
1054    pub fn reset_range_tuple_id(self) -> Result<MultiVal, LibISLError> {
1055        let multi = self;
1056        let isl_rs_ctx = multi.get_ctx();
1057        let mut multi = multi;
1058        multi.do_not_free_on_drop();
1059        let multi = multi.ptr;
1060        let isl_rs_result = unsafe { isl_multi_val_reset_range_tuple_id(multi) };
1061        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1062                                       should_free_on_drop: true };
1063        let err = isl_rs_ctx.last_error();
1064        if err != Error::None_ {
1065            let err_msg = isl_rs_ctx.last_error_msg();
1066            isl_rs_ctx.reset_error();
1067            return Err(LibISLError::new(err, err_msg));
1068        }
1069        Ok(isl_rs_result)
1070    }
1071
1072    /// Wraps `isl_multi_val_reset_tuple_id`.
1073    pub fn reset_tuple_id(self, type_: DimType) -> Result<MultiVal, LibISLError> {
1074        let multi = self;
1075        let isl_rs_ctx = multi.get_ctx();
1076        let mut multi = multi;
1077        multi.do_not_free_on_drop();
1078        let multi = multi.ptr;
1079        let type_ = type_.to_i32();
1080        let isl_rs_result = unsafe { isl_multi_val_reset_tuple_id(multi, type_) };
1081        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1082                                       should_free_on_drop: true };
1083        let err = isl_rs_ctx.last_error();
1084        if err != Error::None_ {
1085            let err_msg = isl_rs_ctx.last_error_msg();
1086            isl_rs_ctx.reset_error();
1087            return Err(LibISLError::new(err, err_msg));
1088        }
1089        Ok(isl_rs_result)
1090    }
1091
1092    /// Wraps `isl_multi_val_reset_user`.
1093    pub fn reset_user(self) -> Result<MultiVal, LibISLError> {
1094        let multi = self;
1095        let isl_rs_ctx = multi.get_ctx();
1096        let mut multi = multi;
1097        multi.do_not_free_on_drop();
1098        let multi = multi.ptr;
1099        let isl_rs_result = unsafe { isl_multi_val_reset_user(multi) };
1100        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1101                                       should_free_on_drop: true };
1102        let err = isl_rs_ctx.last_error();
1103        if err != Error::None_ {
1104            let err_msg = isl_rs_ctx.last_error_msg();
1105            isl_rs_ctx.reset_error();
1106            return Err(LibISLError::new(err, err_msg));
1107        }
1108        Ok(isl_rs_result)
1109    }
1110
1111    /// Wraps `isl_multi_val_scale_down_multi_val`.
1112    pub fn scale_down_multi_val(self, mv: MultiVal) -> Result<MultiVal, LibISLError> {
1113        let multi = self;
1114        let isl_rs_ctx = multi.get_ctx();
1115        let mut multi = multi;
1116        multi.do_not_free_on_drop();
1117        let multi = multi.ptr;
1118        let mut mv = mv;
1119        mv.do_not_free_on_drop();
1120        let mv = mv.ptr;
1121        let isl_rs_result = unsafe { isl_multi_val_scale_down_multi_val(multi, mv) };
1122        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1123                                       should_free_on_drop: true };
1124        let err = isl_rs_ctx.last_error();
1125        if err != Error::None_ {
1126            let err_msg = isl_rs_ctx.last_error_msg();
1127            isl_rs_ctx.reset_error();
1128            return Err(LibISLError::new(err, err_msg));
1129        }
1130        Ok(isl_rs_result)
1131    }
1132
1133    /// Wraps `isl_multi_val_scale_down_val`.
1134    pub fn scale_down_val(self, v: Val) -> Result<MultiVal, LibISLError> {
1135        let multi = self;
1136        let isl_rs_ctx = multi.get_ctx();
1137        let mut multi = multi;
1138        multi.do_not_free_on_drop();
1139        let multi = multi.ptr;
1140        let mut v = v;
1141        v.do_not_free_on_drop();
1142        let v = v.ptr;
1143        let isl_rs_result = unsafe { isl_multi_val_scale_down_val(multi, v) };
1144        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1145                                       should_free_on_drop: true };
1146        let err = isl_rs_ctx.last_error();
1147        if err != Error::None_ {
1148            let err_msg = isl_rs_ctx.last_error_msg();
1149            isl_rs_ctx.reset_error();
1150            return Err(LibISLError::new(err, err_msg));
1151        }
1152        Ok(isl_rs_result)
1153    }
1154
1155    /// Wraps `isl_multi_val_scale_multi_val`.
1156    pub fn scale_multi_val(self, mv: MultiVal) -> Result<MultiVal, LibISLError> {
1157        let multi = self;
1158        let isl_rs_ctx = multi.get_ctx();
1159        let mut multi = multi;
1160        multi.do_not_free_on_drop();
1161        let multi = multi.ptr;
1162        let mut mv = mv;
1163        mv.do_not_free_on_drop();
1164        let mv = mv.ptr;
1165        let isl_rs_result = unsafe { isl_multi_val_scale_multi_val(multi, mv) };
1166        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1167                                       should_free_on_drop: true };
1168        let err = isl_rs_ctx.last_error();
1169        if err != Error::None_ {
1170            let err_msg = isl_rs_ctx.last_error_msg();
1171            isl_rs_ctx.reset_error();
1172            return Err(LibISLError::new(err, err_msg));
1173        }
1174        Ok(isl_rs_result)
1175    }
1176
1177    /// Wraps `isl_multi_val_scale_val`.
1178    pub fn scale_val(self, v: Val) -> Result<MultiVal, LibISLError> {
1179        let multi = self;
1180        let isl_rs_ctx = multi.get_ctx();
1181        let mut multi = multi;
1182        multi.do_not_free_on_drop();
1183        let multi = multi.ptr;
1184        let mut v = v;
1185        v.do_not_free_on_drop();
1186        let v = v.ptr;
1187        let isl_rs_result = unsafe { isl_multi_val_scale_val(multi, v) };
1188        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1189                                       should_free_on_drop: true };
1190        let err = isl_rs_ctx.last_error();
1191        if err != Error::None_ {
1192            let err_msg = isl_rs_ctx.last_error_msg();
1193            isl_rs_ctx.reset_error();
1194            return Err(LibISLError::new(err, err_msg));
1195        }
1196        Ok(isl_rs_result)
1197    }
1198
1199    /// Wraps `isl_multi_val_set_at`.
1200    pub fn set_at(self, pos: i32, el: Val) -> Result<MultiVal, LibISLError> {
1201        let multi = self;
1202        let isl_rs_ctx = multi.get_ctx();
1203        let mut multi = multi;
1204        multi.do_not_free_on_drop();
1205        let multi = multi.ptr;
1206        let mut el = el;
1207        el.do_not_free_on_drop();
1208        let el = el.ptr;
1209        let isl_rs_result = unsafe { isl_multi_val_set_at(multi, pos, el) };
1210        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1211                                       should_free_on_drop: true };
1212        let err = isl_rs_ctx.last_error();
1213        if err != Error::None_ {
1214            let err_msg = isl_rs_ctx.last_error_msg();
1215            isl_rs_ctx.reset_error();
1216            return Err(LibISLError::new(err, err_msg));
1217        }
1218        Ok(isl_rs_result)
1219    }
1220
1221    /// Wraps `isl_multi_val_set_dim_id`.
1222    pub fn set_dim_id(self, type_: DimType, pos: u32, id: Id) -> Result<MultiVal, LibISLError> {
1223        let multi = self;
1224        let isl_rs_ctx = multi.get_ctx();
1225        let mut multi = multi;
1226        multi.do_not_free_on_drop();
1227        let multi = multi.ptr;
1228        let type_ = type_.to_i32();
1229        let mut id = id;
1230        id.do_not_free_on_drop();
1231        let id = id.ptr;
1232        let isl_rs_result = unsafe { isl_multi_val_set_dim_id(multi, type_, pos, id) };
1233        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1234                                       should_free_on_drop: true };
1235        let err = isl_rs_ctx.last_error();
1236        if err != Error::None_ {
1237            let err_msg = isl_rs_ctx.last_error_msg();
1238            isl_rs_ctx.reset_error();
1239            return Err(LibISLError::new(err, err_msg));
1240        }
1241        Ok(isl_rs_result)
1242    }
1243
1244    /// Wraps `isl_multi_val_set_dim_name`.
1245    pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str) -> Result<MultiVal, LibISLError> {
1246        let multi = self;
1247        let isl_rs_ctx = multi.get_ctx();
1248        let mut multi = multi;
1249        multi.do_not_free_on_drop();
1250        let multi = multi.ptr;
1251        let type_ = type_.to_i32();
1252        let s = CString::new(s).unwrap();
1253        let s = s.as_ptr();
1254        let isl_rs_result = unsafe { isl_multi_val_set_dim_name(multi, type_, pos, s) };
1255        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1256                                       should_free_on_drop: true };
1257        let err = isl_rs_ctx.last_error();
1258        if err != Error::None_ {
1259            let err_msg = isl_rs_ctx.last_error_msg();
1260            isl_rs_ctx.reset_error();
1261            return Err(LibISLError::new(err, err_msg));
1262        }
1263        Ok(isl_rs_result)
1264    }
1265
1266    /// Wraps `isl_multi_val_set_range_tuple_id`.
1267    pub fn set_range_tuple_id(self, id: Id) -> Result<MultiVal, LibISLError> {
1268        let multi = self;
1269        let isl_rs_ctx = multi.get_ctx();
1270        let mut multi = multi;
1271        multi.do_not_free_on_drop();
1272        let multi = multi.ptr;
1273        let mut id = id;
1274        id.do_not_free_on_drop();
1275        let id = id.ptr;
1276        let isl_rs_result = unsafe { isl_multi_val_set_range_tuple_id(multi, id) };
1277        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1278                                       should_free_on_drop: true };
1279        let err = isl_rs_ctx.last_error();
1280        if err != Error::None_ {
1281            let err_msg = isl_rs_ctx.last_error_msg();
1282            isl_rs_ctx.reset_error();
1283            return Err(LibISLError::new(err, err_msg));
1284        }
1285        Ok(isl_rs_result)
1286    }
1287
1288    /// Wraps `isl_multi_val_set_tuple_id`.
1289    pub fn set_tuple_id(self, type_: DimType, id: Id) -> Result<MultiVal, LibISLError> {
1290        let multi = self;
1291        let isl_rs_ctx = multi.get_ctx();
1292        let mut multi = multi;
1293        multi.do_not_free_on_drop();
1294        let multi = multi.ptr;
1295        let type_ = type_.to_i32();
1296        let mut id = id;
1297        id.do_not_free_on_drop();
1298        let id = id.ptr;
1299        let isl_rs_result = unsafe { isl_multi_val_set_tuple_id(multi, type_, id) };
1300        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1301                                       should_free_on_drop: true };
1302        let err = isl_rs_ctx.last_error();
1303        if err != Error::None_ {
1304            let err_msg = isl_rs_ctx.last_error_msg();
1305            isl_rs_ctx.reset_error();
1306            return Err(LibISLError::new(err, err_msg));
1307        }
1308        Ok(isl_rs_result)
1309    }
1310
1311    /// Wraps `isl_multi_val_set_tuple_name`.
1312    pub fn set_tuple_name(self, type_: DimType, s: &str) -> Result<MultiVal, LibISLError> {
1313        let multi = self;
1314        let isl_rs_ctx = multi.get_ctx();
1315        let mut multi = multi;
1316        multi.do_not_free_on_drop();
1317        let multi = multi.ptr;
1318        let type_ = type_.to_i32();
1319        let s = CString::new(s).unwrap();
1320        let s = s.as_ptr();
1321        let isl_rs_result = unsafe { isl_multi_val_set_tuple_name(multi, type_, s) };
1322        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1323                                       should_free_on_drop: true };
1324        let err = isl_rs_ctx.last_error();
1325        if err != Error::None_ {
1326            let err_msg = isl_rs_ctx.last_error_msg();
1327            isl_rs_ctx.reset_error();
1328            return Err(LibISLError::new(err, err_msg));
1329        }
1330        Ok(isl_rs_result)
1331    }
1332
1333    /// Wraps `isl_multi_val_set_val`.
1334    pub fn set_val(self, pos: i32, el: Val) -> Result<MultiVal, LibISLError> {
1335        let multi = self;
1336        let isl_rs_ctx = multi.get_ctx();
1337        let mut multi = multi;
1338        multi.do_not_free_on_drop();
1339        let multi = multi.ptr;
1340        let mut el = el;
1341        el.do_not_free_on_drop();
1342        let el = el.ptr;
1343        let isl_rs_result = unsafe { isl_multi_val_set_val(multi, pos, el) };
1344        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1345                                       should_free_on_drop: true };
1346        let err = isl_rs_ctx.last_error();
1347        if err != Error::None_ {
1348            let err_msg = isl_rs_ctx.last_error_msg();
1349            isl_rs_ctx.reset_error();
1350            return Err(LibISLError::new(err, err_msg));
1351        }
1352        Ok(isl_rs_result)
1353    }
1354
1355    /// Wraps `isl_multi_val_size`.
1356    pub fn size(&self) -> Result<i32, LibISLError> {
1357        let multi = self;
1358        let isl_rs_ctx = multi.get_ctx();
1359        let multi = multi.ptr;
1360        let isl_rs_result = unsafe { isl_multi_val_size(multi) };
1361        let err = isl_rs_ctx.last_error();
1362        if err != Error::None_ {
1363            let err_msg = isl_rs_ctx.last_error_msg();
1364            isl_rs_ctx.reset_error();
1365            return Err(LibISLError::new(err, err_msg));
1366        }
1367        Ok(isl_rs_result)
1368    }
1369
1370    /// Wraps `isl_multi_val_splice`.
1371    pub fn splice(self, in_pos: u32, out_pos: u32, multi2: MultiVal)
1372                  -> Result<MultiVal, LibISLError> {
1373        let multi1 = self;
1374        let isl_rs_ctx = multi1.get_ctx();
1375        let mut multi1 = multi1;
1376        multi1.do_not_free_on_drop();
1377        let multi1 = multi1.ptr;
1378        let mut multi2 = multi2;
1379        multi2.do_not_free_on_drop();
1380        let multi2 = multi2.ptr;
1381        let isl_rs_result = unsafe { isl_multi_val_splice(multi1, in_pos, out_pos, multi2) };
1382        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1383                                       should_free_on_drop: true };
1384        let err = isl_rs_ctx.last_error();
1385        if err != Error::None_ {
1386            let err_msg = isl_rs_ctx.last_error_msg();
1387            isl_rs_ctx.reset_error();
1388            return Err(LibISLError::new(err, err_msg));
1389        }
1390        Ok(isl_rs_result)
1391    }
1392
1393    /// Wraps `isl_multi_val_sub`.
1394    pub fn sub(self, multi2: MultiVal) -> Result<MultiVal, LibISLError> {
1395        let multi1 = self;
1396        let isl_rs_ctx = multi1.get_ctx();
1397        let mut multi1 = multi1;
1398        multi1.do_not_free_on_drop();
1399        let multi1 = multi1.ptr;
1400        let mut multi2 = multi2;
1401        multi2.do_not_free_on_drop();
1402        let multi2 = multi2.ptr;
1403        let isl_rs_result = unsafe { isl_multi_val_sub(multi1, multi2) };
1404        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1405                                       should_free_on_drop: true };
1406        let err = isl_rs_ctx.last_error();
1407        if err != Error::None_ {
1408            let err_msg = isl_rs_ctx.last_error_msg();
1409            isl_rs_ctx.reset_error();
1410            return Err(LibISLError::new(err, err_msg));
1411        }
1412        Ok(isl_rs_result)
1413    }
1414
1415    /// Wraps `isl_multi_val_to_str`.
1416    pub fn to_str(&self) -> Result<&str, LibISLError> {
1417        let mv = self;
1418        let isl_rs_ctx = mv.get_ctx();
1419        let mv = mv.ptr;
1420        let isl_rs_result = unsafe { isl_multi_val_to_str(mv) };
1421        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1422        let isl_rs_result = isl_rs_result.to_str().unwrap();
1423        let err = isl_rs_ctx.last_error();
1424        if err != Error::None_ {
1425            let err_msg = isl_rs_ctx.last_error_msg();
1426            isl_rs_ctx.reset_error();
1427            return Err(LibISLError::new(err, err_msg));
1428        }
1429        Ok(isl_rs_result)
1430    }
1431
1432    /// Wraps `isl_multi_val_zero`.
1433    pub fn zero(space: Space) -> Result<MultiVal, LibISLError> {
1434        let isl_rs_ctx = space.get_ctx();
1435        let mut space = space;
1436        space.do_not_free_on_drop();
1437        let space = space.ptr;
1438        let isl_rs_result = unsafe { isl_multi_val_zero(space) };
1439        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1440                                       should_free_on_drop: true };
1441        let err = isl_rs_ctx.last_error();
1442        if err != Error::None_ {
1443            let err_msg = isl_rs_ctx.last_error_msg();
1444            isl_rs_ctx.reset_error();
1445            return Err(LibISLError::new(err, err_msg));
1446        }
1447        Ok(isl_rs_result)
1448    }
1449
1450    /// Does not call isl_multi_val_free() on being dropped. (For internal use
1451    /// only.)
1452    pub fn do_not_free_on_drop(&mut self) {
1453        self.should_free_on_drop = false;
1454    }
1455}
1456
1457impl Drop for MultiVal {
1458    fn drop(&mut self) {
1459        if self.should_free_on_drop {
1460            unsafe {
1461                isl_multi_val_free(self.ptr);
1462            }
1463        }
1464    }
1465}
isl_rs/bindings/multi_val.rs

isl_rs/bindings/
multi_val.rs
