isl_rs/bindings/
val.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Context, Error, LibISLError, ValList};
5use libc::uintptr_t;
6use std::ffi::{CStr, CString};
7use std::os::raw::c_char;
8
9/// Wraps `isl_val`.
10pub struct Val {
11    pub ptr: uintptr_t,
12    pub should_free_on_drop: bool,
13}
14
15extern "C" {
16
17    fn isl_val_2exp(v: uintptr_t) -> uintptr_t;
18
19    fn isl_val_abs(v: uintptr_t) -> uintptr_t;
20
21    fn isl_val_abs_eq(v1: uintptr_t, v2: uintptr_t) -> i32;
22
23    fn isl_val_add(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
24
25    fn isl_val_add_ui(v1: uintptr_t, v2: u64) -> uintptr_t;
26
27    fn isl_val_ceil(v: uintptr_t) -> uintptr_t;
28
29    fn isl_val_cmp_si(v: uintptr_t, i: i64) -> i32;
30
31    fn isl_val_copy(v: uintptr_t) -> uintptr_t;
32
33    fn isl_val_div(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
34
35    fn isl_val_div_ui(v1: uintptr_t, v2: u64) -> uintptr_t;
36
37    fn isl_val_dump(v: uintptr_t) -> ();
38
39    fn isl_val_eq(v1: uintptr_t, v2: uintptr_t) -> i32;
40
41    fn isl_val_eq_si(v: uintptr_t, i: i64) -> i32;
42
43    fn isl_val_floor(v: uintptr_t) -> uintptr_t;
44
45    fn isl_val_free(v: uintptr_t) -> uintptr_t;
46
47    fn isl_val_gcd(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
48
49    fn isl_val_ge(v1: uintptr_t, v2: uintptr_t) -> i32;
50
51    fn isl_val_get_ctx(val: uintptr_t) -> uintptr_t;
52
53    fn isl_val_get_d(v: uintptr_t) -> f64;
54
55    fn isl_val_get_den_si(v: uintptr_t) -> i64;
56
57    fn isl_val_get_den_val(v: uintptr_t) -> uintptr_t;
58
59    fn isl_val_get_hash(val: uintptr_t) -> u32;
60
61    fn isl_val_get_num_si(v: uintptr_t) -> i64;
62
63    fn isl_val_gt(v1: uintptr_t, v2: uintptr_t) -> i32;
64
65    fn isl_val_gt_si(v: uintptr_t, i: i64) -> i32;
66
67    fn isl_val_infty(ctx: uintptr_t) -> uintptr_t;
68
69    fn isl_val_int_from_si(ctx: uintptr_t, i: i64) -> uintptr_t;
70
71    fn isl_val_int_from_ui(ctx: uintptr_t, u: u64) -> uintptr_t;
72
73    fn isl_val_inv(v: uintptr_t) -> uintptr_t;
74
75    fn isl_val_is_divisible_by(v1: uintptr_t, v2: uintptr_t) -> i32;
76
77    fn isl_val_is_infty(v: uintptr_t) -> i32;
78
79    fn isl_val_is_int(v: uintptr_t) -> i32;
80
81    fn isl_val_is_nan(v: uintptr_t) -> i32;
82
83    fn isl_val_is_neg(v: uintptr_t) -> i32;
84
85    fn isl_val_is_neginfty(v: uintptr_t) -> i32;
86
87    fn isl_val_is_negone(v: uintptr_t) -> i32;
88
89    fn isl_val_is_nonneg(v: uintptr_t) -> i32;
90
91    fn isl_val_is_nonpos(v: uintptr_t) -> i32;
92
93    fn isl_val_is_one(v: uintptr_t) -> i32;
94
95    fn isl_val_is_pos(v: uintptr_t) -> i32;
96
97    fn isl_val_is_rat(v: uintptr_t) -> i32;
98
99    fn isl_val_is_zero(v: uintptr_t) -> i32;
100
101    fn isl_val_le(v1: uintptr_t, v2: uintptr_t) -> i32;
102
103    fn isl_val_lt(v1: uintptr_t, v2: uintptr_t) -> i32;
104
105    fn isl_val_max(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
106
107    fn isl_val_min(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
108
109    fn isl_val_mod(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
110
111    fn isl_val_mul(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
112
113    fn isl_val_mul_ui(v1: uintptr_t, v2: u64) -> uintptr_t;
114
115    fn isl_val_n_abs_num_chunks(v: uintptr_t, size: usize) -> i32;
116
117    fn isl_val_nan(ctx: uintptr_t) -> uintptr_t;
118
119    fn isl_val_ne(v1: uintptr_t, v2: uintptr_t) -> i32;
120
121    fn isl_val_neg(v: uintptr_t) -> uintptr_t;
122
123    fn isl_val_neginfty(ctx: uintptr_t) -> uintptr_t;
124
125    fn isl_val_negone(ctx: uintptr_t) -> uintptr_t;
126
127    fn isl_val_one(ctx: uintptr_t) -> uintptr_t;
128
129    fn isl_val_pow2(v: uintptr_t) -> uintptr_t;
130
131    fn isl_val_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
132
133    fn isl_val_set_si(v: uintptr_t, i: i64) -> uintptr_t;
134
135    fn isl_val_sgn(v: uintptr_t) -> i32;
136
137    fn isl_val_sub(v1: uintptr_t, v2: uintptr_t) -> uintptr_t;
138
139    fn isl_val_sub_ui(v1: uintptr_t, v2: u64) -> uintptr_t;
140
141    fn isl_val_to_list(el: uintptr_t) -> uintptr_t;
142
143    fn isl_val_to_str(v: uintptr_t) -> *const c_char;
144
145    fn isl_val_trunc(v: uintptr_t) -> uintptr_t;
146
147    fn isl_val_zero(ctx: uintptr_t) -> uintptr_t;
148
149}
150
151impl Val {
152    /// Wraps `isl_val_2exp`.
153    pub fn to_exp(self) -> Result<Val, LibISLError> {
154        let v = self;
155        let isl_rs_ctx = v.get_ctx();
156        let mut v = v;
157        v.do_not_free_on_drop();
158        let v = v.ptr;
159        let isl_rs_result = unsafe { isl_val_2exp(v) };
160        let isl_rs_result = Val { ptr: isl_rs_result,
161                                  should_free_on_drop: true };
162        let err = isl_rs_ctx.last_error();
163        if err != Error::None_ {
164            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
165        }
166        Ok(isl_rs_result)
167    }
168
169    /// Wraps `isl_val_abs`.
170    pub fn abs(self) -> Result<Val, LibISLError> {
171        let v = self;
172        let isl_rs_ctx = v.get_ctx();
173        let mut v = v;
174        v.do_not_free_on_drop();
175        let v = v.ptr;
176        let isl_rs_result = unsafe { isl_val_abs(v) };
177        let isl_rs_result = Val { ptr: isl_rs_result,
178                                  should_free_on_drop: true };
179        let err = isl_rs_ctx.last_error();
180        if err != Error::None_ {
181            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
182        }
183        Ok(isl_rs_result)
184    }
185
186    /// Wraps `isl_val_abs_eq`.
187    pub fn abs_eq(&self, v2: &Val) -> Result<bool, LibISLError> {
188        let v1 = self;
189        let isl_rs_ctx = v1.get_ctx();
190        let v1 = v1.ptr;
191        let v2 = v2.ptr;
192        let isl_rs_result = unsafe { isl_val_abs_eq(v1, v2) };
193        let isl_rs_result = match isl_rs_result {
194            0 => false,
195            1 => true,
196            _ => panic!("Got isl_bool = -1"),
197        };
198        let err = isl_rs_ctx.last_error();
199        if err != Error::None_ {
200            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
201        }
202        Ok(isl_rs_result)
203    }
204
205    /// Wraps `isl_val_add`.
206    pub fn add(self, v2: Val) -> Result<Val, LibISLError> {
207        let v1 = self;
208        let isl_rs_ctx = v1.get_ctx();
209        let mut v1 = v1;
210        v1.do_not_free_on_drop();
211        let v1 = v1.ptr;
212        let mut v2 = v2;
213        v2.do_not_free_on_drop();
214        let v2 = v2.ptr;
215        let isl_rs_result = unsafe { isl_val_add(v1, v2) };
216        let isl_rs_result = Val { ptr: isl_rs_result,
217                                  should_free_on_drop: true };
218        let err = isl_rs_ctx.last_error();
219        if err != Error::None_ {
220            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
221        }
222        Ok(isl_rs_result)
223    }
224
225    /// Wraps `isl_val_add_ui`.
226    pub fn add_ui(self, v2: u64) -> Result<Val, LibISLError> {
227        let v1 = self;
228        let isl_rs_ctx = v1.get_ctx();
229        let mut v1 = v1;
230        v1.do_not_free_on_drop();
231        let v1 = v1.ptr;
232        let isl_rs_result = unsafe { isl_val_add_ui(v1, v2) };
233        let isl_rs_result = Val { ptr: isl_rs_result,
234                                  should_free_on_drop: true };
235        let err = isl_rs_ctx.last_error();
236        if err != Error::None_ {
237            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
238        }
239        Ok(isl_rs_result)
240    }
241
242    /// Wraps `isl_val_ceil`.
243    pub fn ceil(self) -> Result<Val, LibISLError> {
244        let v = self;
245        let isl_rs_ctx = v.get_ctx();
246        let mut v = v;
247        v.do_not_free_on_drop();
248        let v = v.ptr;
249        let isl_rs_result = unsafe { isl_val_ceil(v) };
250        let isl_rs_result = Val { ptr: isl_rs_result,
251                                  should_free_on_drop: true };
252        let err = isl_rs_ctx.last_error();
253        if err != Error::None_ {
254            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
255        }
256        Ok(isl_rs_result)
257    }
258
259    /// Wraps `isl_val_cmp_si`.
260    pub fn cmp_si(&self, i: i64) -> Result<i32, LibISLError> {
261        let v = self;
262        let isl_rs_ctx = v.get_ctx();
263        let v = v.ptr;
264        let isl_rs_result = unsafe { isl_val_cmp_si(v, i) };
265        let err = isl_rs_ctx.last_error();
266        if err != Error::None_ {
267            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
268        }
269        Ok(isl_rs_result)
270    }
271
272    /// Wraps `isl_val_copy`.
273    pub fn copy(&self) -> Result<Val, LibISLError> {
274        let v = self;
275        let isl_rs_ctx = v.get_ctx();
276        let v = v.ptr;
277        let isl_rs_result = unsafe { isl_val_copy(v) };
278        let isl_rs_result = Val { ptr: isl_rs_result,
279                                  should_free_on_drop: true };
280        let err = isl_rs_ctx.last_error();
281        if err != Error::None_ {
282            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
283        }
284        Ok(isl_rs_result)
285    }
286
287    /// Wraps `isl_val_div`.
288    pub fn div(self, v2: Val) -> Result<Val, LibISLError> {
289        let v1 = self;
290        let isl_rs_ctx = v1.get_ctx();
291        let mut v1 = v1;
292        v1.do_not_free_on_drop();
293        let v1 = v1.ptr;
294        let mut v2 = v2;
295        v2.do_not_free_on_drop();
296        let v2 = v2.ptr;
297        let isl_rs_result = unsafe { isl_val_div(v1, v2) };
298        let isl_rs_result = Val { ptr: isl_rs_result,
299                                  should_free_on_drop: true };
300        let err = isl_rs_ctx.last_error();
301        if err != Error::None_ {
302            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
303        }
304        Ok(isl_rs_result)
305    }
306
307    /// Wraps `isl_val_div_ui`.
308    pub fn div_ui(self, v2: u64) -> Result<Val, LibISLError> {
309        let v1 = self;
310        let isl_rs_ctx = v1.get_ctx();
311        let mut v1 = v1;
312        v1.do_not_free_on_drop();
313        let v1 = v1.ptr;
314        let isl_rs_result = unsafe { isl_val_div_ui(v1, v2) };
315        let isl_rs_result = Val { ptr: isl_rs_result,
316                                  should_free_on_drop: true };
317        let err = isl_rs_ctx.last_error();
318        if err != Error::None_ {
319            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
320        }
321        Ok(isl_rs_result)
322    }
323
324    /// Wraps `isl_val_dump`.
325    pub fn dump(&self) -> Result<(), LibISLError> {
326        let v = self;
327        let isl_rs_ctx = v.get_ctx();
328        let v = v.ptr;
329        let isl_rs_result = unsafe { isl_val_dump(v) };
330        let err = isl_rs_ctx.last_error();
331        if err != Error::None_ {
332            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
333        }
334        Ok(isl_rs_result)
335    }
336
337    /// Wraps `isl_val_eq`.
338    pub fn eq(&self, v2: &Val) -> Result<bool, LibISLError> {
339        let v1 = self;
340        let isl_rs_ctx = v1.get_ctx();
341        let v1 = v1.ptr;
342        let v2 = v2.ptr;
343        let isl_rs_result = unsafe { isl_val_eq(v1, v2) };
344        let isl_rs_result = match isl_rs_result {
345            0 => false,
346            1 => true,
347            _ => panic!("Got isl_bool = -1"),
348        };
349        let err = isl_rs_ctx.last_error();
350        if err != Error::None_ {
351            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
352        }
353        Ok(isl_rs_result)
354    }
355
356    /// Wraps `isl_val_eq_si`.
357    pub fn eq_si(&self, i: i64) -> Result<bool, LibISLError> {
358        let v = self;
359        let isl_rs_ctx = v.get_ctx();
360        let v = v.ptr;
361        let isl_rs_result = unsafe { isl_val_eq_si(v, i) };
362        let isl_rs_result = match isl_rs_result {
363            0 => false,
364            1 => true,
365            _ => panic!("Got isl_bool = -1"),
366        };
367        let err = isl_rs_ctx.last_error();
368        if err != Error::None_ {
369            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
370        }
371        Ok(isl_rs_result)
372    }
373
374    /// Wraps `isl_val_floor`.
375    pub fn floor(self) -> Result<Val, LibISLError> {
376        let v = self;
377        let isl_rs_ctx = v.get_ctx();
378        let mut v = v;
379        v.do_not_free_on_drop();
380        let v = v.ptr;
381        let isl_rs_result = unsafe { isl_val_floor(v) };
382        let isl_rs_result = Val { ptr: isl_rs_result,
383                                  should_free_on_drop: true };
384        let err = isl_rs_ctx.last_error();
385        if err != Error::None_ {
386            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
387        }
388        Ok(isl_rs_result)
389    }
390
391    /// Wraps `isl_val_free`.
392    pub fn free(self) -> Result<Val, LibISLError> {
393        let v = self;
394        let isl_rs_ctx = v.get_ctx();
395        let mut v = v;
396        v.do_not_free_on_drop();
397        let v = v.ptr;
398        let isl_rs_result = unsafe { isl_val_free(v) };
399        let isl_rs_result = Val { ptr: isl_rs_result,
400                                  should_free_on_drop: true };
401        let err = isl_rs_ctx.last_error();
402        if err != Error::None_ {
403            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
404        }
405        Ok(isl_rs_result)
406    }
407
408    /// Wraps `isl_val_gcd`.
409    pub fn gcd(self, v2: Val) -> Result<Val, LibISLError> {
410        let v1 = self;
411        let isl_rs_ctx = v1.get_ctx();
412        let mut v1 = v1;
413        v1.do_not_free_on_drop();
414        let v1 = v1.ptr;
415        let mut v2 = v2;
416        v2.do_not_free_on_drop();
417        let v2 = v2.ptr;
418        let isl_rs_result = unsafe { isl_val_gcd(v1, v2) };
419        let isl_rs_result = Val { ptr: isl_rs_result,
420                                  should_free_on_drop: true };
421        let err = isl_rs_ctx.last_error();
422        if err != Error::None_ {
423            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
424        }
425        Ok(isl_rs_result)
426    }
427
428    /// Wraps `isl_val_ge`.
429    pub fn ge(&self, v2: &Val) -> Result<bool, LibISLError> {
430        let v1 = self;
431        let isl_rs_ctx = v1.get_ctx();
432        let v1 = v1.ptr;
433        let v2 = v2.ptr;
434        let isl_rs_result = unsafe { isl_val_ge(v1, v2) };
435        let isl_rs_result = match isl_rs_result {
436            0 => false,
437            1 => true,
438            _ => panic!("Got isl_bool = -1"),
439        };
440        let err = isl_rs_ctx.last_error();
441        if err != Error::None_ {
442            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
443        }
444        Ok(isl_rs_result)
445    }
446
447    /// Wraps `isl_val_get_ctx`.
448    pub fn get_ctx(&self) -> Context {
449        let val = self;
450        let val = val.ptr;
451        let isl_rs_result = unsafe { isl_val_get_ctx(val) };
452        let isl_rs_result = Context { ptr: isl_rs_result,
453                                      should_free_on_drop: false };
454        isl_rs_result
455    }
456
457    /// Wraps `isl_val_get_d`.
458    pub fn get_d(&self) -> Result<f64, LibISLError> {
459        let v = self;
460        let isl_rs_ctx = v.get_ctx();
461        let v = v.ptr;
462        let isl_rs_result = unsafe { isl_val_get_d(v) };
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_val_get_den_si`.
471    pub fn get_den_si(&self) -> Result<i64, LibISLError> {
472        let v = self;
473        let isl_rs_ctx = v.get_ctx();
474        let v = v.ptr;
475        let isl_rs_result = unsafe { isl_val_get_den_si(v) };
476        let err = isl_rs_ctx.last_error();
477        if err != Error::None_ {
478            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
479        }
480        Ok(isl_rs_result)
481    }
482
483    /// Wraps `isl_val_get_den_val`.
484    pub fn get_den_val(&self) -> Result<Val, LibISLError> {
485        let v = self;
486        let isl_rs_ctx = v.get_ctx();
487        let v = v.ptr;
488        let isl_rs_result = unsafe { isl_val_get_den_val(v) };
489        let isl_rs_result = Val { ptr: isl_rs_result,
490                                  should_free_on_drop: true };
491        let err = isl_rs_ctx.last_error();
492        if err != Error::None_ {
493            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
494        }
495        Ok(isl_rs_result)
496    }
497
498    /// Wraps `isl_val_get_hash`.
499    pub fn get_hash(&self) -> Result<u32, LibISLError> {
500        let val = self;
501        let isl_rs_ctx = val.get_ctx();
502        let val = val.ptr;
503        let isl_rs_result = unsafe { isl_val_get_hash(val) };
504        let err = isl_rs_ctx.last_error();
505        if err != Error::None_ {
506            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
507        }
508        Ok(isl_rs_result)
509    }
510
511    /// Wraps `isl_val_get_num_si`.
512    pub fn get_num_si(&self) -> Result<i64, LibISLError> {
513        let v = self;
514        let isl_rs_ctx = v.get_ctx();
515        let v = v.ptr;
516        let isl_rs_result = unsafe { isl_val_get_num_si(v) };
517        let err = isl_rs_ctx.last_error();
518        if err != Error::None_ {
519            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
520        }
521        Ok(isl_rs_result)
522    }
523
524    /// Wraps `isl_val_gt`.
525    pub fn gt(&self, v2: &Val) -> Result<bool, LibISLError> {
526        let v1 = self;
527        let isl_rs_ctx = v1.get_ctx();
528        let v1 = v1.ptr;
529        let v2 = v2.ptr;
530        let isl_rs_result = unsafe { isl_val_gt(v1, v2) };
531        let isl_rs_result = match isl_rs_result {
532            0 => false,
533            1 => true,
534            _ => panic!("Got isl_bool = -1"),
535        };
536        let err = isl_rs_ctx.last_error();
537        if err != Error::None_ {
538            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
539        }
540        Ok(isl_rs_result)
541    }
542
543    /// Wraps `isl_val_gt_si`.
544    pub fn gt_si(&self, i: i64) -> Result<bool, LibISLError> {
545        let v = self;
546        let isl_rs_ctx = v.get_ctx();
547        let v = v.ptr;
548        let isl_rs_result = unsafe { isl_val_gt_si(v, i) };
549        let isl_rs_result = match isl_rs_result {
550            0 => false,
551            1 => true,
552            _ => panic!("Got isl_bool = -1"),
553        };
554        let err = isl_rs_ctx.last_error();
555        if err != Error::None_ {
556            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
557        }
558        Ok(isl_rs_result)
559    }
560
561    /// Wraps `isl_val_infty`.
562    pub fn infty(ctx: &Context) -> Result<Val, LibISLError> {
563        let isl_rs_ctx = Context { ptr: ctx.ptr,
564                                   should_free_on_drop: false };
565        let ctx = ctx.ptr;
566        let isl_rs_result = unsafe { isl_val_infty(ctx) };
567        let isl_rs_result = Val { ptr: isl_rs_result,
568                                  should_free_on_drop: true };
569        let err = isl_rs_ctx.last_error();
570        if err != Error::None_ {
571            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
572        }
573        Ok(isl_rs_result)
574    }
575
576    /// Wraps `isl_val_int_from_si`.
577    pub fn int_from_si(ctx: &Context, i: i64) -> Result<Val, LibISLError> {
578        let isl_rs_ctx = Context { ptr: ctx.ptr,
579                                   should_free_on_drop: false };
580        let ctx = ctx.ptr;
581        let isl_rs_result = unsafe { isl_val_int_from_si(ctx, i) };
582        let isl_rs_result = Val { ptr: isl_rs_result,
583                                  should_free_on_drop: true };
584        let err = isl_rs_ctx.last_error();
585        if err != Error::None_ {
586            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
587        }
588        Ok(isl_rs_result)
589    }
590
591    /// Wraps `isl_val_int_from_ui`.
592    pub fn int_from_ui(ctx: &Context, u: u64) -> Result<Val, LibISLError> {
593        let isl_rs_ctx = Context { ptr: ctx.ptr,
594                                   should_free_on_drop: false };
595        let ctx = ctx.ptr;
596        let isl_rs_result = unsafe { isl_val_int_from_ui(ctx, u) };
597        let isl_rs_result = Val { ptr: isl_rs_result,
598                                  should_free_on_drop: true };
599        let err = isl_rs_ctx.last_error();
600        if err != Error::None_ {
601            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
602        }
603        Ok(isl_rs_result)
604    }
605
606    /// Wraps `isl_val_inv`.
607    pub fn inv(self) -> Result<Val, LibISLError> {
608        let v = self;
609        let isl_rs_ctx = v.get_ctx();
610        let mut v = v;
611        v.do_not_free_on_drop();
612        let v = v.ptr;
613        let isl_rs_result = unsafe { isl_val_inv(v) };
614        let isl_rs_result = Val { ptr: isl_rs_result,
615                                  should_free_on_drop: true };
616        let err = isl_rs_ctx.last_error();
617        if err != Error::None_ {
618            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
619        }
620        Ok(isl_rs_result)
621    }
622
623    /// Wraps `isl_val_is_divisible_by`.
624    pub fn is_divisible_by(&self, v2: &Val) -> Result<bool, LibISLError> {
625        let v1 = self;
626        let isl_rs_ctx = v1.get_ctx();
627        let v1 = v1.ptr;
628        let v2 = v2.ptr;
629        let isl_rs_result = unsafe { isl_val_is_divisible_by(v1, v2) };
630        let isl_rs_result = match isl_rs_result {
631            0 => false,
632            1 => true,
633            _ => panic!("Got isl_bool = -1"),
634        };
635        let err = isl_rs_ctx.last_error();
636        if err != Error::None_ {
637            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
638        }
639        Ok(isl_rs_result)
640    }
641
642    /// Wraps `isl_val_is_infty`.
643    pub fn is_infty(&self) -> Result<bool, LibISLError> {
644        let v = self;
645        let isl_rs_ctx = v.get_ctx();
646        let v = v.ptr;
647        let isl_rs_result = unsafe { isl_val_is_infty(v) };
648        let isl_rs_result = match isl_rs_result {
649            0 => false,
650            1 => true,
651            _ => panic!("Got isl_bool = -1"),
652        };
653        let err = isl_rs_ctx.last_error();
654        if err != Error::None_ {
655            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
656        }
657        Ok(isl_rs_result)
658    }
659
660    /// Wraps `isl_val_is_int`.
661    pub fn is_int(&self) -> Result<bool, LibISLError> {
662        let v = self;
663        let isl_rs_ctx = v.get_ctx();
664        let v = v.ptr;
665        let isl_rs_result = unsafe { isl_val_is_int(v) };
666        let isl_rs_result = match isl_rs_result {
667            0 => false,
668            1 => true,
669            _ => panic!("Got isl_bool = -1"),
670        };
671        let err = isl_rs_ctx.last_error();
672        if err != Error::None_ {
673            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
674        }
675        Ok(isl_rs_result)
676    }
677
678    /// Wraps `isl_val_is_nan`.
679    pub fn is_nan(&self) -> Result<bool, LibISLError> {
680        let v = self;
681        let isl_rs_ctx = v.get_ctx();
682        let v = v.ptr;
683        let isl_rs_result = unsafe { isl_val_is_nan(v) };
684        let isl_rs_result = match isl_rs_result {
685            0 => false,
686            1 => true,
687            _ => panic!("Got isl_bool = -1"),
688        };
689        let err = isl_rs_ctx.last_error();
690        if err != Error::None_ {
691            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
692        }
693        Ok(isl_rs_result)
694    }
695
696    /// Wraps `isl_val_is_neg`.
697    pub fn is_neg(&self) -> Result<bool, LibISLError> {
698        let v = self;
699        let isl_rs_ctx = v.get_ctx();
700        let v = v.ptr;
701        let isl_rs_result = unsafe { isl_val_is_neg(v) };
702        let isl_rs_result = match isl_rs_result {
703            0 => false,
704            1 => true,
705            _ => panic!("Got isl_bool = -1"),
706        };
707        let err = isl_rs_ctx.last_error();
708        if err != Error::None_ {
709            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
710        }
711        Ok(isl_rs_result)
712    }
713
714    /// Wraps `isl_val_is_neginfty`.
715    pub fn is_neginfty(&self) -> Result<bool, LibISLError> {
716        let v = self;
717        let isl_rs_ctx = v.get_ctx();
718        let v = v.ptr;
719        let isl_rs_result = unsafe { isl_val_is_neginfty(v) };
720        let isl_rs_result = match isl_rs_result {
721            0 => false,
722            1 => true,
723            _ => panic!("Got isl_bool = -1"),
724        };
725        let err = isl_rs_ctx.last_error();
726        if err != Error::None_ {
727            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
728        }
729        Ok(isl_rs_result)
730    }
731
732    /// Wraps `isl_val_is_negone`.
733    pub fn is_negone(&self) -> Result<bool, LibISLError> {
734        let v = self;
735        let isl_rs_ctx = v.get_ctx();
736        let v = v.ptr;
737        let isl_rs_result = unsafe { isl_val_is_negone(v) };
738        let isl_rs_result = match isl_rs_result {
739            0 => false,
740            1 => true,
741            _ => panic!("Got isl_bool = -1"),
742        };
743        let err = isl_rs_ctx.last_error();
744        if err != Error::None_ {
745            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
746        }
747        Ok(isl_rs_result)
748    }
749
750    /// Wraps `isl_val_is_nonneg`.
751    pub fn is_nonneg(&self) -> Result<bool, LibISLError> {
752        let v = self;
753        let isl_rs_ctx = v.get_ctx();
754        let v = v.ptr;
755        let isl_rs_result = unsafe { isl_val_is_nonneg(v) };
756        let isl_rs_result = match isl_rs_result {
757            0 => false,
758            1 => true,
759            _ => panic!("Got isl_bool = -1"),
760        };
761        let err = isl_rs_ctx.last_error();
762        if err != Error::None_ {
763            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
764        }
765        Ok(isl_rs_result)
766    }
767
768    /// Wraps `isl_val_is_nonpos`.
769    pub fn is_nonpos(&self) -> Result<bool, LibISLError> {
770        let v = self;
771        let isl_rs_ctx = v.get_ctx();
772        let v = v.ptr;
773        let isl_rs_result = unsafe { isl_val_is_nonpos(v) };
774        let isl_rs_result = match isl_rs_result {
775            0 => false,
776            1 => true,
777            _ => panic!("Got isl_bool = -1"),
778        };
779        let err = isl_rs_ctx.last_error();
780        if err != Error::None_ {
781            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
782        }
783        Ok(isl_rs_result)
784    }
785
786    /// Wraps `isl_val_is_one`.
787    pub fn is_one(&self) -> Result<bool, LibISLError> {
788        let v = self;
789        let isl_rs_ctx = v.get_ctx();
790        let v = v.ptr;
791        let isl_rs_result = unsafe { isl_val_is_one(v) };
792        let isl_rs_result = match isl_rs_result {
793            0 => false,
794            1 => true,
795            _ => panic!("Got isl_bool = -1"),
796        };
797        let err = isl_rs_ctx.last_error();
798        if err != Error::None_ {
799            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
800        }
801        Ok(isl_rs_result)
802    }
803
804    /// Wraps `isl_val_is_pos`.
805    pub fn is_pos(&self) -> Result<bool, LibISLError> {
806        let v = self;
807        let isl_rs_ctx = v.get_ctx();
808        let v = v.ptr;
809        let isl_rs_result = unsafe { isl_val_is_pos(v) };
810        let isl_rs_result = match isl_rs_result {
811            0 => false,
812            1 => true,
813            _ => panic!("Got isl_bool = -1"),
814        };
815        let err = isl_rs_ctx.last_error();
816        if err != Error::None_ {
817            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
818        }
819        Ok(isl_rs_result)
820    }
821
822    /// Wraps `isl_val_is_rat`.
823    pub fn is_rat(&self) -> Result<bool, LibISLError> {
824        let v = self;
825        let isl_rs_ctx = v.get_ctx();
826        let v = v.ptr;
827        let isl_rs_result = unsafe { isl_val_is_rat(v) };
828        let isl_rs_result = match isl_rs_result {
829            0 => false,
830            1 => true,
831            _ => panic!("Got isl_bool = -1"),
832        };
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_val_is_zero`.
841    pub fn is_zero(&self) -> Result<bool, LibISLError> {
842        let v = self;
843        let isl_rs_ctx = v.get_ctx();
844        let v = v.ptr;
845        let isl_rs_result = unsafe { isl_val_is_zero(v) };
846        let isl_rs_result = match isl_rs_result {
847            0 => false,
848            1 => true,
849            _ => panic!("Got isl_bool = -1"),
850        };
851        let err = isl_rs_ctx.last_error();
852        if err != Error::None_ {
853            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
854        }
855        Ok(isl_rs_result)
856    }
857
858    /// Wraps `isl_val_le`.
859    pub fn le(&self, v2: &Val) -> Result<bool, LibISLError> {
860        let v1 = self;
861        let isl_rs_ctx = v1.get_ctx();
862        let v1 = v1.ptr;
863        let v2 = v2.ptr;
864        let isl_rs_result = unsafe { isl_val_le(v1, v2) };
865        let isl_rs_result = match isl_rs_result {
866            0 => false,
867            1 => true,
868            _ => panic!("Got isl_bool = -1"),
869        };
870        let err = isl_rs_ctx.last_error();
871        if err != Error::None_ {
872            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
873        }
874        Ok(isl_rs_result)
875    }
876
877    /// Wraps `isl_val_lt`.
878    pub fn lt(&self, v2: &Val) -> Result<bool, LibISLError> {
879        let v1 = self;
880        let isl_rs_ctx = v1.get_ctx();
881        let v1 = v1.ptr;
882        let v2 = v2.ptr;
883        let isl_rs_result = unsafe { isl_val_lt(v1, v2) };
884        let isl_rs_result = match isl_rs_result {
885            0 => false,
886            1 => true,
887            _ => panic!("Got isl_bool = -1"),
888        };
889        let err = isl_rs_ctx.last_error();
890        if err != Error::None_ {
891            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
892        }
893        Ok(isl_rs_result)
894    }
895
896    /// Wraps `isl_val_max`.
897    pub fn max(self, v2: Val) -> Result<Val, LibISLError> {
898        let v1 = self;
899        let isl_rs_ctx = v1.get_ctx();
900        let mut v1 = v1;
901        v1.do_not_free_on_drop();
902        let v1 = v1.ptr;
903        let mut v2 = v2;
904        v2.do_not_free_on_drop();
905        let v2 = v2.ptr;
906        let isl_rs_result = unsafe { isl_val_max(v1, v2) };
907        let isl_rs_result = Val { ptr: isl_rs_result,
908                                  should_free_on_drop: true };
909        let err = isl_rs_ctx.last_error();
910        if err != Error::None_ {
911            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
912        }
913        Ok(isl_rs_result)
914    }
915
916    /// Wraps `isl_val_min`.
917    pub fn min(self, v2: Val) -> Result<Val, LibISLError> {
918        let v1 = self;
919        let isl_rs_ctx = v1.get_ctx();
920        let mut v1 = v1;
921        v1.do_not_free_on_drop();
922        let v1 = v1.ptr;
923        let mut v2 = v2;
924        v2.do_not_free_on_drop();
925        let v2 = v2.ptr;
926        let isl_rs_result = unsafe { isl_val_min(v1, v2) };
927        let isl_rs_result = Val { ptr: isl_rs_result,
928                                  should_free_on_drop: true };
929        let err = isl_rs_ctx.last_error();
930        if err != Error::None_ {
931            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
932        }
933        Ok(isl_rs_result)
934    }
935
936    /// Wraps `isl_val_mod`.
937    pub fn mod_(self, v2: Val) -> Result<Val, LibISLError> {
938        let v1 = self;
939        let isl_rs_ctx = v1.get_ctx();
940        let mut v1 = v1;
941        v1.do_not_free_on_drop();
942        let v1 = v1.ptr;
943        let mut v2 = v2;
944        v2.do_not_free_on_drop();
945        let v2 = v2.ptr;
946        let isl_rs_result = unsafe { isl_val_mod(v1, v2) };
947        let isl_rs_result = Val { ptr: isl_rs_result,
948                                  should_free_on_drop: true };
949        let err = isl_rs_ctx.last_error();
950        if err != Error::None_ {
951            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
952        }
953        Ok(isl_rs_result)
954    }
955
956    /// Wraps `isl_val_mul`.
957    pub fn mul(self, v2: Val) -> Result<Val, LibISLError> {
958        let v1 = self;
959        let isl_rs_ctx = v1.get_ctx();
960        let mut v1 = v1;
961        v1.do_not_free_on_drop();
962        let v1 = v1.ptr;
963        let mut v2 = v2;
964        v2.do_not_free_on_drop();
965        let v2 = v2.ptr;
966        let isl_rs_result = unsafe { isl_val_mul(v1, v2) };
967        let isl_rs_result = Val { ptr: isl_rs_result,
968                                  should_free_on_drop: true };
969        let err = isl_rs_ctx.last_error();
970        if err != Error::None_ {
971            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
972        }
973        Ok(isl_rs_result)
974    }
975
976    /// Wraps `isl_val_mul_ui`.
977    pub fn mul_ui(self, v2: u64) -> Result<Val, LibISLError> {
978        let v1 = self;
979        let isl_rs_ctx = v1.get_ctx();
980        let mut v1 = v1;
981        v1.do_not_free_on_drop();
982        let v1 = v1.ptr;
983        let isl_rs_result = unsafe { isl_val_mul_ui(v1, v2) };
984        let isl_rs_result = Val { ptr: isl_rs_result,
985                                  should_free_on_drop: true };
986        let err = isl_rs_ctx.last_error();
987        if err != Error::None_ {
988            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
989        }
990        Ok(isl_rs_result)
991    }
992
993    /// Wraps `isl_val_n_abs_num_chunks`.
994    pub fn n_abs_num_chunks(&self, size: usize) -> Result<i32, LibISLError> {
995        let v = self;
996        let isl_rs_ctx = v.get_ctx();
997        let v = v.ptr;
998        let isl_rs_result = unsafe { isl_val_n_abs_num_chunks(v, size) };
999        let err = isl_rs_ctx.last_error();
1000        if err != Error::None_ {
1001            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1002        }
1003        Ok(isl_rs_result)
1004    }
1005
1006    /// Wraps `isl_val_nan`.
1007    pub fn nan(ctx: &Context) -> Result<Val, LibISLError> {
1008        let isl_rs_ctx = Context { ptr: ctx.ptr,
1009                                   should_free_on_drop: false };
1010        let ctx = ctx.ptr;
1011        let isl_rs_result = unsafe { isl_val_nan(ctx) };
1012        let isl_rs_result = Val { 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_val_ne`.
1022    pub fn ne(&self, v2: &Val) -> Result<bool, LibISLError> {
1023        let v1 = self;
1024        let isl_rs_ctx = v1.get_ctx();
1025        let v1 = v1.ptr;
1026        let v2 = v2.ptr;
1027        let isl_rs_result = unsafe { isl_val_ne(v1, v2) };
1028        let isl_rs_result = match isl_rs_result {
1029            0 => false,
1030            1 => true,
1031            _ => panic!("Got isl_bool = -1"),
1032        };
1033        let err = isl_rs_ctx.last_error();
1034        if err != Error::None_ {
1035            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1036        }
1037        Ok(isl_rs_result)
1038    }
1039
1040    /// Wraps `isl_val_neg`.
1041    pub fn neg(self) -> Result<Val, LibISLError> {
1042        let v = self;
1043        let isl_rs_ctx = v.get_ctx();
1044        let mut v = v;
1045        v.do_not_free_on_drop();
1046        let v = v.ptr;
1047        let isl_rs_result = unsafe { isl_val_neg(v) };
1048        let isl_rs_result = Val { ptr: isl_rs_result,
1049                                  should_free_on_drop: true };
1050        let err = isl_rs_ctx.last_error();
1051        if err != Error::None_ {
1052            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1053        }
1054        Ok(isl_rs_result)
1055    }
1056
1057    /// Wraps `isl_val_neginfty`.
1058    pub fn neginfty(ctx: &Context) -> Result<Val, LibISLError> {
1059        let isl_rs_ctx = Context { ptr: ctx.ptr,
1060                                   should_free_on_drop: false };
1061        let ctx = ctx.ptr;
1062        let isl_rs_result = unsafe { isl_val_neginfty(ctx) };
1063        let isl_rs_result = Val { ptr: isl_rs_result,
1064                                  should_free_on_drop: true };
1065        let err = isl_rs_ctx.last_error();
1066        if err != Error::None_ {
1067            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1068        }
1069        Ok(isl_rs_result)
1070    }
1071
1072    /// Wraps `isl_val_negone`.
1073    pub fn negone(ctx: &Context) -> Result<Val, LibISLError> {
1074        let isl_rs_ctx = Context { ptr: ctx.ptr,
1075                                   should_free_on_drop: false };
1076        let ctx = ctx.ptr;
1077        let isl_rs_result = unsafe { isl_val_negone(ctx) };
1078        let isl_rs_result = Val { ptr: isl_rs_result,
1079                                  should_free_on_drop: true };
1080        let err = isl_rs_ctx.last_error();
1081        if err != Error::None_ {
1082            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1083        }
1084        Ok(isl_rs_result)
1085    }
1086
1087    /// Wraps `isl_val_one`.
1088    pub fn one(ctx: &Context) -> Result<Val, LibISLError> {
1089        let isl_rs_ctx = Context { ptr: ctx.ptr,
1090                                   should_free_on_drop: false };
1091        let ctx = ctx.ptr;
1092        let isl_rs_result = unsafe { isl_val_one(ctx) };
1093        let isl_rs_result = Val { ptr: isl_rs_result,
1094                                  should_free_on_drop: true };
1095        let err = isl_rs_ctx.last_error();
1096        if err != Error::None_ {
1097            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1098        }
1099        Ok(isl_rs_result)
1100    }
1101
1102    /// Wraps `isl_val_pow2`.
1103    pub fn pow2(self) -> Result<Val, LibISLError> {
1104        let v = self;
1105        let isl_rs_ctx = v.get_ctx();
1106        let mut v = v;
1107        v.do_not_free_on_drop();
1108        let v = v.ptr;
1109        let isl_rs_result = unsafe { isl_val_pow2(v) };
1110        let isl_rs_result = Val { ptr: isl_rs_result,
1111                                  should_free_on_drop: true };
1112        let err = isl_rs_ctx.last_error();
1113        if err != Error::None_ {
1114            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1115        }
1116        Ok(isl_rs_result)
1117    }
1118
1119    /// Wraps `isl_val_read_from_str`.
1120    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<Val, LibISLError> {
1121        let isl_rs_ctx = Context { ptr: ctx.ptr,
1122                                   should_free_on_drop: false };
1123        let ctx = ctx.ptr;
1124        let str_ = CString::new(str_).unwrap();
1125        let str_ = str_.as_ptr();
1126        let isl_rs_result = unsafe { isl_val_read_from_str(ctx, str_) };
1127        let isl_rs_result = Val { ptr: isl_rs_result,
1128                                  should_free_on_drop: true };
1129        let err = isl_rs_ctx.last_error();
1130        if err != Error::None_ {
1131            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1132        }
1133        Ok(isl_rs_result)
1134    }
1135
1136    /// Wraps `isl_val_set_si`.
1137    pub fn set_si(self, i: i64) -> Result<Val, LibISLError> {
1138        let v = self;
1139        let isl_rs_ctx = v.get_ctx();
1140        let mut v = v;
1141        v.do_not_free_on_drop();
1142        let v = v.ptr;
1143        let isl_rs_result = unsafe { isl_val_set_si(v, i) };
1144        let isl_rs_result = Val { ptr: isl_rs_result,
1145                                  should_free_on_drop: true };
1146        let err = isl_rs_ctx.last_error();
1147        if err != Error::None_ {
1148            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1149        }
1150        Ok(isl_rs_result)
1151    }
1152
1153    /// Wraps `isl_val_sgn`.
1154    pub fn sgn(&self) -> Result<i32, LibISLError> {
1155        let v = self;
1156        let isl_rs_ctx = v.get_ctx();
1157        let v = v.ptr;
1158        let isl_rs_result = unsafe { isl_val_sgn(v) };
1159        let err = isl_rs_ctx.last_error();
1160        if err != Error::None_ {
1161            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1162        }
1163        Ok(isl_rs_result)
1164    }
1165
1166    /// Wraps `isl_val_sub`.
1167    pub fn sub(self, v2: Val) -> Result<Val, LibISLError> {
1168        let v1 = self;
1169        let isl_rs_ctx = v1.get_ctx();
1170        let mut v1 = v1;
1171        v1.do_not_free_on_drop();
1172        let v1 = v1.ptr;
1173        let mut v2 = v2;
1174        v2.do_not_free_on_drop();
1175        let v2 = v2.ptr;
1176        let isl_rs_result = unsafe { isl_val_sub(v1, v2) };
1177        let isl_rs_result = Val { ptr: isl_rs_result,
1178                                  should_free_on_drop: true };
1179        let err = isl_rs_ctx.last_error();
1180        if err != Error::None_ {
1181            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1182        }
1183        Ok(isl_rs_result)
1184    }
1185
1186    /// Wraps `isl_val_sub_ui`.
1187    pub fn sub_ui(self, v2: u64) -> Result<Val, LibISLError> {
1188        let v1 = self;
1189        let isl_rs_ctx = v1.get_ctx();
1190        let mut v1 = v1;
1191        v1.do_not_free_on_drop();
1192        let v1 = v1.ptr;
1193        let isl_rs_result = unsafe { isl_val_sub_ui(v1, v2) };
1194        let isl_rs_result = Val { 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_val_to_list`.
1204    pub fn to_list(self) -> Result<ValList, LibISLError> {
1205        let el = self;
1206        let isl_rs_ctx = el.get_ctx();
1207        let mut el = el;
1208        el.do_not_free_on_drop();
1209        let el = el.ptr;
1210        let isl_rs_result = unsafe { isl_val_to_list(el) };
1211        let isl_rs_result = ValList { ptr: isl_rs_result,
1212                                      should_free_on_drop: true };
1213        let err = isl_rs_ctx.last_error();
1214        if err != Error::None_ {
1215            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1216        }
1217        Ok(isl_rs_result)
1218    }
1219
1220    /// Wraps `isl_val_to_str`.
1221    pub fn to_str(&self) -> Result<&str, LibISLError> {
1222        let v = self;
1223        let isl_rs_ctx = v.get_ctx();
1224        let v = v.ptr;
1225        let isl_rs_result = unsafe { isl_val_to_str(v) };
1226        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1227        let isl_rs_result = isl_rs_result.to_str().unwrap();
1228        let err = isl_rs_ctx.last_error();
1229        if err != Error::None_ {
1230            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1231        }
1232        Ok(isl_rs_result)
1233    }
1234
1235    /// Wraps `isl_val_trunc`.
1236    pub fn trunc(self) -> Result<Val, LibISLError> {
1237        let v = self;
1238        let isl_rs_ctx = v.get_ctx();
1239        let mut v = v;
1240        v.do_not_free_on_drop();
1241        let v = v.ptr;
1242        let isl_rs_result = unsafe { isl_val_trunc(v) };
1243        let isl_rs_result = Val { ptr: isl_rs_result,
1244                                  should_free_on_drop: true };
1245        let err = isl_rs_ctx.last_error();
1246        if err != Error::None_ {
1247            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1248        }
1249        Ok(isl_rs_result)
1250    }
1251
1252    /// Wraps `isl_val_zero`.
1253    pub fn zero(ctx: &Context) -> Result<Val, LibISLError> {
1254        let isl_rs_ctx = Context { ptr: ctx.ptr,
1255                                   should_free_on_drop: false };
1256        let ctx = ctx.ptr;
1257        let isl_rs_result = unsafe { isl_val_zero(ctx) };
1258        let isl_rs_result = Val { ptr: isl_rs_result,
1259                                  should_free_on_drop: true };
1260        let err = isl_rs_ctx.last_error();
1261        if err != Error::None_ {
1262            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1263        }
1264        Ok(isl_rs_result)
1265    }
1266
1267    /// Does not call isl_val_free() on being dropped. (For internal use only.)
1268    pub fn do_not_free_on_drop(&mut self) {
1269        self.should_free_on_drop = false;
1270    }
1271}
1272
1273impl Drop for Val {
1274    fn drop(&mut self) {
1275        if self.should_free_on_drop {
1276            unsafe {
1277                isl_val_free(self.ptr);
1278            }
1279        }
1280    }
1281}
isl_rs/bindings/val.rs

isl_rs/bindings/
val.rs
