isl_rs/bindings/
constraint.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Aff, ConstraintList, Context, DimType, Error, LibISLError, LocalSpace, Space, Val};
5use libc::uintptr_t;
6use std::ffi::CStr;
7use std::os::raw::c_char;
8
9/// Wraps `isl_constraint`.
10pub struct Constraint {
11    pub ptr: uintptr_t,
12    pub should_free_on_drop: bool,
13}
14
15extern "C" {
16
17    fn isl_constraint_alloc_equality(ls: uintptr_t) -> uintptr_t;
18
19    fn isl_constraint_alloc_inequality(ls: uintptr_t) -> uintptr_t;
20
21    fn isl_constraint_cmp_last_non_zero(c1: uintptr_t, c2: uintptr_t) -> i32;
22
23    fn isl_constraint_copy(c: uintptr_t) -> uintptr_t;
24
25    fn isl_constraint_dim(constraint: uintptr_t, type_: i32) -> i32;
26
27    fn isl_constraint_dump(c: uintptr_t) -> ();
28
29    fn isl_constraint_free(c: uintptr_t) -> uintptr_t;
30
31    fn isl_constraint_get_aff(constraint: uintptr_t) -> uintptr_t;
32
33    fn isl_constraint_get_bound(constraint: uintptr_t, type_: i32, pos: i32) -> uintptr_t;
34
35    fn isl_constraint_get_coefficient_val(constraint: uintptr_t, type_: i32, pos: i32)
36                                          -> uintptr_t;
37
38    fn isl_constraint_get_constant_val(constraint: uintptr_t) -> uintptr_t;
39
40    fn isl_constraint_get_ctx(c: uintptr_t) -> uintptr_t;
41
42    fn isl_constraint_get_dim_name(constraint: uintptr_t, type_: i32, pos: u32) -> *const c_char;
43
44    fn isl_constraint_get_div(constraint: uintptr_t, pos: i32) -> uintptr_t;
45
46    fn isl_constraint_get_local_space(constraint: uintptr_t) -> uintptr_t;
47
48    fn isl_constraint_get_space(constraint: uintptr_t) -> uintptr_t;
49
50    fn isl_constraint_involves_dims(constraint: uintptr_t, type_: i32, first: u32, n: u32) -> i32;
51
52    fn isl_constraint_is_div_constraint(constraint: uintptr_t) -> i32;
53
54    fn isl_constraint_is_equal(constraint1: uintptr_t, constraint2: uintptr_t) -> i32;
55
56    fn isl_constraint_is_equality(constraint: uintptr_t) -> i32;
57
58    fn isl_constraint_is_lower_bound(constraint: uintptr_t, type_: i32, pos: u32) -> i32;
59
60    fn isl_constraint_is_upper_bound(constraint: uintptr_t, type_: i32, pos: u32) -> i32;
61
62    fn isl_constraint_negate(constraint: uintptr_t) -> uintptr_t;
63
64    fn isl_constraint_plain_cmp(c1: uintptr_t, c2: uintptr_t) -> i32;
65
66    fn isl_constraint_set_coefficient_si(constraint: uintptr_t, type_: i32, pos: i32, v: i32)
67                                         -> uintptr_t;
68
69    fn isl_constraint_set_coefficient_val(constraint: uintptr_t, type_: i32, pos: i32,
70                                          v: uintptr_t)
71                                          -> uintptr_t;
72
73    fn isl_constraint_set_constant_si(constraint: uintptr_t, v: i32) -> uintptr_t;
74
75    fn isl_constraint_set_constant_val(constraint: uintptr_t, v: uintptr_t) -> uintptr_t;
76
77    fn isl_constraint_to_list(el: uintptr_t) -> uintptr_t;
78
79}
80
81impl Constraint {
82    /// Wraps `isl_constraint_alloc_equality`.
83    pub fn alloc_equality(ls: LocalSpace) -> Result<Constraint, LibISLError> {
84        let isl_rs_ctx = ls.get_ctx();
85        let mut ls = ls;
86        ls.do_not_free_on_drop();
87        let ls = ls.ptr;
88        let isl_rs_result = unsafe { isl_constraint_alloc_equality(ls) };
89        let isl_rs_result = Constraint { ptr: isl_rs_result,
90                                         should_free_on_drop: true };
91        let err = isl_rs_ctx.last_error();
92        if err != Error::None_ {
93            let err_msg = isl_rs_ctx.last_error_msg();
94            isl_rs_ctx.reset_error();
95            return Err(LibISLError::new(err, err_msg));
96        }
97        Ok(isl_rs_result)
98    }
99
100    /// Wraps `isl_constraint_alloc_inequality`.
101    pub fn alloc_inequality(ls: LocalSpace) -> Result<Constraint, LibISLError> {
102        let isl_rs_ctx = ls.get_ctx();
103        let mut ls = ls;
104        ls.do_not_free_on_drop();
105        let ls = ls.ptr;
106        let isl_rs_result = unsafe { isl_constraint_alloc_inequality(ls) };
107        let isl_rs_result = Constraint { ptr: isl_rs_result,
108                                         should_free_on_drop: true };
109        let err = isl_rs_ctx.last_error();
110        if err != Error::None_ {
111            let err_msg = isl_rs_ctx.last_error_msg();
112            isl_rs_ctx.reset_error();
113            return Err(LibISLError::new(err, err_msg));
114        }
115        Ok(isl_rs_result)
116    }
117
118    /// Wraps `isl_constraint_cmp_last_non_zero`.
119    pub fn cmp_last_non_zero(&self, c2: &Constraint) -> Result<i32, LibISLError> {
120        let c1 = self;
121        let isl_rs_ctx = c1.get_ctx();
122        let c1 = c1.ptr;
123        let c2 = c2.ptr;
124        let isl_rs_result = unsafe { isl_constraint_cmp_last_non_zero(c1, c2) };
125        let err = isl_rs_ctx.last_error();
126        if err != Error::None_ {
127            let err_msg = isl_rs_ctx.last_error_msg();
128            isl_rs_ctx.reset_error();
129            return Err(LibISLError::new(err, err_msg));
130        }
131        Ok(isl_rs_result)
132    }
133
134    /// Wraps `isl_constraint_copy`.
135    pub fn copy(&self) -> Result<Constraint, LibISLError> {
136        let c = self;
137        let isl_rs_ctx = c.get_ctx();
138        let c = c.ptr;
139        let isl_rs_result = unsafe { isl_constraint_copy(c) };
140        let isl_rs_result = Constraint { ptr: isl_rs_result,
141                                         should_free_on_drop: true };
142        let err = isl_rs_ctx.last_error();
143        if err != Error::None_ {
144            let err_msg = isl_rs_ctx.last_error_msg();
145            isl_rs_ctx.reset_error();
146            return Err(LibISLError::new(err, err_msg));
147        }
148        Ok(isl_rs_result)
149    }
150
151    /// Wraps `isl_constraint_dim`.
152    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
153        let constraint = self;
154        let isl_rs_ctx = constraint.get_ctx();
155        let constraint = constraint.ptr;
156        let type_ = type_.to_i32();
157        let isl_rs_result = unsafe { isl_constraint_dim(constraint, type_) };
158        let err = isl_rs_ctx.last_error();
159        if err != Error::None_ {
160            let err_msg = isl_rs_ctx.last_error_msg();
161            isl_rs_ctx.reset_error();
162            return Err(LibISLError::new(err, err_msg));
163        }
164        Ok(isl_rs_result)
165    }
166
167    /// Wraps `isl_constraint_dump`.
168    pub fn dump(&self) -> Result<(), LibISLError> {
169        let c = self;
170        let isl_rs_ctx = c.get_ctx();
171        let c = c.ptr;
172        let isl_rs_result = unsafe { isl_constraint_dump(c) };
173        let err = isl_rs_ctx.last_error();
174        if err != Error::None_ {
175            let err_msg = isl_rs_ctx.last_error_msg();
176            isl_rs_ctx.reset_error();
177            return Err(LibISLError::new(err, err_msg));
178        }
179        Ok(isl_rs_result)
180    }
181
182    /// Wraps `isl_constraint_free`.
183    pub fn free(self) -> Result<Constraint, LibISLError> {
184        let c = self;
185        let isl_rs_ctx = c.get_ctx();
186        let mut c = c;
187        c.do_not_free_on_drop();
188        let c = c.ptr;
189        let isl_rs_result = unsafe { isl_constraint_free(c) };
190        let isl_rs_result = Constraint { ptr: isl_rs_result,
191                                         should_free_on_drop: true };
192        let err = isl_rs_ctx.last_error();
193        if err != Error::None_ {
194            let err_msg = isl_rs_ctx.last_error_msg();
195            isl_rs_ctx.reset_error();
196            return Err(LibISLError::new(err, err_msg));
197        }
198        Ok(isl_rs_result)
199    }
200
201    /// Wraps `isl_constraint_get_aff`.
202    pub fn get_aff(&self) -> Result<Aff, LibISLError> {
203        let constraint = self;
204        let isl_rs_ctx = constraint.get_ctx();
205        let constraint = constraint.ptr;
206        let isl_rs_result = unsafe { isl_constraint_get_aff(constraint) };
207        let isl_rs_result = Aff { ptr: isl_rs_result,
208                                  should_free_on_drop: true };
209        let err = isl_rs_ctx.last_error();
210        if err != Error::None_ {
211            let err_msg = isl_rs_ctx.last_error_msg();
212            isl_rs_ctx.reset_error();
213            return Err(LibISLError::new(err, err_msg));
214        }
215        Ok(isl_rs_result)
216    }
217
218    /// Wraps `isl_constraint_get_bound`.
219    pub fn get_bound(&self, type_: DimType, pos: i32) -> Result<Aff, LibISLError> {
220        let constraint = self;
221        let isl_rs_ctx = constraint.get_ctx();
222        let constraint = constraint.ptr;
223        let type_ = type_.to_i32();
224        let isl_rs_result = unsafe { isl_constraint_get_bound(constraint, type_, pos) };
225        let isl_rs_result = Aff { ptr: isl_rs_result,
226                                  should_free_on_drop: true };
227        let err = isl_rs_ctx.last_error();
228        if err != Error::None_ {
229            let err_msg = isl_rs_ctx.last_error_msg();
230            isl_rs_ctx.reset_error();
231            return Err(LibISLError::new(err, err_msg));
232        }
233        Ok(isl_rs_result)
234    }
235
236    /// Wraps `isl_constraint_get_coefficient_val`.
237    pub fn get_coefficient_val(&self, type_: DimType, pos: i32) -> Result<Val, LibISLError> {
238        let constraint = self;
239        let isl_rs_ctx = constraint.get_ctx();
240        let constraint = constraint.ptr;
241        let type_ = type_.to_i32();
242        let isl_rs_result = unsafe { isl_constraint_get_coefficient_val(constraint, type_, pos) };
243        let isl_rs_result = Val { ptr: isl_rs_result,
244                                  should_free_on_drop: true };
245        let err = isl_rs_ctx.last_error();
246        if err != Error::None_ {
247            let err_msg = isl_rs_ctx.last_error_msg();
248            isl_rs_ctx.reset_error();
249            return Err(LibISLError::new(err, err_msg));
250        }
251        Ok(isl_rs_result)
252    }
253
254    /// Wraps `isl_constraint_get_constant_val`.
255    pub fn get_constant_val(&self) -> Result<Val, LibISLError> {
256        let constraint = self;
257        let isl_rs_ctx = constraint.get_ctx();
258        let constraint = constraint.ptr;
259        let isl_rs_result = unsafe { isl_constraint_get_constant_val(constraint) };
260        let isl_rs_result = Val { ptr: isl_rs_result,
261                                  should_free_on_drop: true };
262        let err = isl_rs_ctx.last_error();
263        if err != Error::None_ {
264            let err_msg = isl_rs_ctx.last_error_msg();
265            isl_rs_ctx.reset_error();
266            return Err(LibISLError::new(err, err_msg));
267        }
268        Ok(isl_rs_result)
269    }
270
271    /// Wraps `isl_constraint_get_ctx`.
272    pub fn get_ctx(&self) -> Context {
273        let c = self;
274        let c = c.ptr;
275        let isl_rs_result = unsafe { isl_constraint_get_ctx(c) };
276        let isl_rs_result = Context { ptr: isl_rs_result,
277                                      should_free_on_drop: false };
278        isl_rs_result
279    }
280
281    /// Wraps `isl_constraint_get_dim_name`.
282    pub fn get_dim_name(&self, type_: DimType, pos: u32) -> Result<&str, LibISLError> {
283        let constraint = self;
284        let isl_rs_ctx = constraint.get_ctx();
285        let constraint = constraint.ptr;
286        let type_ = type_.to_i32();
287        let isl_rs_result = unsafe { isl_constraint_get_dim_name(constraint, type_, pos) };
288        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
289        let isl_rs_result = isl_rs_result.to_str().unwrap();
290        let err = isl_rs_ctx.last_error();
291        if err != Error::None_ {
292            let err_msg = isl_rs_ctx.last_error_msg();
293            isl_rs_ctx.reset_error();
294            return Err(LibISLError::new(err, err_msg));
295        }
296        Ok(isl_rs_result)
297    }
298
299    /// Wraps `isl_constraint_get_div`.
300    pub fn get_div(&self, pos: i32) -> Result<Aff, LibISLError> {
301        let constraint = self;
302        let isl_rs_ctx = constraint.get_ctx();
303        let constraint = constraint.ptr;
304        let isl_rs_result = unsafe { isl_constraint_get_div(constraint, pos) };
305        let isl_rs_result = Aff { ptr: isl_rs_result,
306                                  should_free_on_drop: true };
307        let err = isl_rs_ctx.last_error();
308        if err != Error::None_ {
309            let err_msg = isl_rs_ctx.last_error_msg();
310            isl_rs_ctx.reset_error();
311            return Err(LibISLError::new(err, err_msg));
312        }
313        Ok(isl_rs_result)
314    }
315
316    /// Wraps `isl_constraint_get_local_space`.
317    pub fn get_local_space(&self) -> Result<LocalSpace, LibISLError> {
318        let constraint = self;
319        let isl_rs_ctx = constraint.get_ctx();
320        let constraint = constraint.ptr;
321        let isl_rs_result = unsafe { isl_constraint_get_local_space(constraint) };
322        let isl_rs_result = LocalSpace { ptr: isl_rs_result,
323                                         should_free_on_drop: true };
324        let err = isl_rs_ctx.last_error();
325        if err != Error::None_ {
326            let err_msg = isl_rs_ctx.last_error_msg();
327            isl_rs_ctx.reset_error();
328            return Err(LibISLError::new(err, err_msg));
329        }
330        Ok(isl_rs_result)
331    }
332
333    /// Wraps `isl_constraint_get_space`.
334    pub fn get_space(&self) -> Result<Space, LibISLError> {
335        let constraint = self;
336        let isl_rs_ctx = constraint.get_ctx();
337        let constraint = constraint.ptr;
338        let isl_rs_result = unsafe { isl_constraint_get_space(constraint) };
339        let isl_rs_result = Space { ptr: isl_rs_result,
340                                    should_free_on_drop: true };
341        let err = isl_rs_ctx.last_error();
342        if err != Error::None_ {
343            let err_msg = isl_rs_ctx.last_error_msg();
344            isl_rs_ctx.reset_error();
345            return Err(LibISLError::new(err, err_msg));
346        }
347        Ok(isl_rs_result)
348    }
349
350    /// Wraps `isl_constraint_involves_dims`.
351    pub fn involves_dims(&self, type_: DimType, first: u32, n: u32) -> Result<bool, LibISLError> {
352        let constraint = self;
353        let isl_rs_ctx = constraint.get_ctx();
354        let constraint = constraint.ptr;
355        let type_ = type_.to_i32();
356        let isl_rs_result = unsafe { isl_constraint_involves_dims(constraint, type_, first, n) };
357        let isl_rs_result = match isl_rs_result {
358            0 => false,
359            1 => true,
360            _ => {
361                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
362            }
363        };
364        let err = isl_rs_ctx.last_error();
365        if err != Error::None_ {
366            let err_msg = isl_rs_ctx.last_error_msg();
367            isl_rs_ctx.reset_error();
368            return Err(LibISLError::new(err, err_msg));
369        }
370        Ok(isl_rs_result)
371    }
372
373    /// Wraps `isl_constraint_is_div_constraint`.
374    pub fn is_div_constraint(&self) -> Result<bool, LibISLError> {
375        let constraint = self;
376        let isl_rs_ctx = constraint.get_ctx();
377        let constraint = constraint.ptr;
378        let isl_rs_result = unsafe { isl_constraint_is_div_constraint(constraint) };
379        let isl_rs_result = match isl_rs_result {
380            0 => false,
381            1 => true,
382            _ => {
383                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
384            }
385        };
386        let err = isl_rs_ctx.last_error();
387        if err != Error::None_ {
388            let err_msg = isl_rs_ctx.last_error_msg();
389            isl_rs_ctx.reset_error();
390            return Err(LibISLError::new(err, err_msg));
391        }
392        Ok(isl_rs_result)
393    }
394
395    /// Wraps `isl_constraint_is_equal`.
396    pub fn is_equal(&self, constraint2: &Constraint) -> Result<i32, LibISLError> {
397        let constraint1 = self;
398        let isl_rs_ctx = constraint1.get_ctx();
399        let constraint1 = constraint1.ptr;
400        let constraint2 = constraint2.ptr;
401        let isl_rs_result = unsafe { isl_constraint_is_equal(constraint1, constraint2) };
402        let err = isl_rs_ctx.last_error();
403        if err != Error::None_ {
404            let err_msg = isl_rs_ctx.last_error_msg();
405            isl_rs_ctx.reset_error();
406            return Err(LibISLError::new(err, err_msg));
407        }
408        Ok(isl_rs_result)
409    }
410
411    /// Wraps `isl_constraint_is_equality`.
412    pub fn is_equality(&self) -> Result<bool, LibISLError> {
413        let constraint = self;
414        let isl_rs_ctx = constraint.get_ctx();
415        let constraint = constraint.ptr;
416        let isl_rs_result = unsafe { isl_constraint_is_equality(constraint) };
417        let isl_rs_result = match isl_rs_result {
418            0 => false,
419            1 => true,
420            _ => {
421                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
422            }
423        };
424        let err = isl_rs_ctx.last_error();
425        if err != Error::None_ {
426            let err_msg = isl_rs_ctx.last_error_msg();
427            isl_rs_ctx.reset_error();
428            return Err(LibISLError::new(err, err_msg));
429        }
430        Ok(isl_rs_result)
431    }
432
433    /// Wraps `isl_constraint_is_lower_bound`.
434    pub fn is_lower_bound(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
435        let constraint = self;
436        let isl_rs_ctx = constraint.get_ctx();
437        let constraint = constraint.ptr;
438        let type_ = type_.to_i32();
439        let isl_rs_result = unsafe { isl_constraint_is_lower_bound(constraint, type_, pos) };
440        let isl_rs_result = match isl_rs_result {
441            0 => false,
442            1 => true,
443            _ => {
444                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
445            }
446        };
447        let err = isl_rs_ctx.last_error();
448        if err != Error::None_ {
449            let err_msg = isl_rs_ctx.last_error_msg();
450            isl_rs_ctx.reset_error();
451            return Err(LibISLError::new(err, err_msg));
452        }
453        Ok(isl_rs_result)
454    }
455
456    /// Wraps `isl_constraint_is_upper_bound`.
457    pub fn is_upper_bound(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
458        let constraint = self;
459        let isl_rs_ctx = constraint.get_ctx();
460        let constraint = constraint.ptr;
461        let type_ = type_.to_i32();
462        let isl_rs_result = unsafe { isl_constraint_is_upper_bound(constraint, type_, pos) };
463        let isl_rs_result = match isl_rs_result {
464            0 => false,
465            1 => true,
466            _ => {
467                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
468            }
469        };
470        let err = isl_rs_ctx.last_error();
471        if err != Error::None_ {
472            let err_msg = isl_rs_ctx.last_error_msg();
473            isl_rs_ctx.reset_error();
474            return Err(LibISLError::new(err, err_msg));
475        }
476        Ok(isl_rs_result)
477    }
478
479    /// Wraps `isl_constraint_negate`.
480    pub fn negate(self) -> Result<Constraint, LibISLError> {
481        let constraint = self;
482        let isl_rs_ctx = constraint.get_ctx();
483        let mut constraint = constraint;
484        constraint.do_not_free_on_drop();
485        let constraint = constraint.ptr;
486        let isl_rs_result = unsafe { isl_constraint_negate(constraint) };
487        let isl_rs_result = Constraint { ptr: isl_rs_result,
488                                         should_free_on_drop: true };
489        let err = isl_rs_ctx.last_error();
490        if err != Error::None_ {
491            let err_msg = isl_rs_ctx.last_error_msg();
492            isl_rs_ctx.reset_error();
493            return Err(LibISLError::new(err, err_msg));
494        }
495        Ok(isl_rs_result)
496    }
497
498    /// Wraps `isl_constraint_plain_cmp`.
499    pub fn plain_cmp(&self, c2: &Constraint) -> Result<i32, LibISLError> {
500        let c1 = self;
501        let isl_rs_ctx = c1.get_ctx();
502        let c1 = c1.ptr;
503        let c2 = c2.ptr;
504        let isl_rs_result = unsafe { isl_constraint_plain_cmp(c1, c2) };
505        let err = isl_rs_ctx.last_error();
506        if err != Error::None_ {
507            let err_msg = isl_rs_ctx.last_error_msg();
508            isl_rs_ctx.reset_error();
509            return Err(LibISLError::new(err, err_msg));
510        }
511        Ok(isl_rs_result)
512    }
513
514    /// Wraps `isl_constraint_set_coefficient_si`.
515    pub fn set_coefficient_si(self, type_: DimType, pos: i32, v: i32)
516                              -> Result<Constraint, LibISLError> {
517        let constraint = self;
518        let isl_rs_ctx = constraint.get_ctx();
519        let mut constraint = constraint;
520        constraint.do_not_free_on_drop();
521        let constraint = constraint.ptr;
522        let type_ = type_.to_i32();
523        let isl_rs_result = unsafe { isl_constraint_set_coefficient_si(constraint, type_, pos, v) };
524        let isl_rs_result = Constraint { ptr: isl_rs_result,
525                                         should_free_on_drop: true };
526        let err = isl_rs_ctx.last_error();
527        if err != Error::None_ {
528            let err_msg = isl_rs_ctx.last_error_msg();
529            isl_rs_ctx.reset_error();
530            return Err(LibISLError::new(err, err_msg));
531        }
532        Ok(isl_rs_result)
533    }
534
535    /// Wraps `isl_constraint_set_coefficient_val`.
536    pub fn set_coefficient_val(self, type_: DimType, pos: i32, v: Val)
537                               -> Result<Constraint, LibISLError> {
538        let constraint = self;
539        let isl_rs_ctx = constraint.get_ctx();
540        let mut constraint = constraint;
541        constraint.do_not_free_on_drop();
542        let constraint = constraint.ptr;
543        let type_ = type_.to_i32();
544        let mut v = v;
545        v.do_not_free_on_drop();
546        let v = v.ptr;
547        let isl_rs_result =
548            unsafe { isl_constraint_set_coefficient_val(constraint, type_, pos, v) };
549        let isl_rs_result = Constraint { ptr: isl_rs_result,
550                                         should_free_on_drop: true };
551        let err = isl_rs_ctx.last_error();
552        if err != Error::None_ {
553            let err_msg = isl_rs_ctx.last_error_msg();
554            isl_rs_ctx.reset_error();
555            return Err(LibISLError::new(err, err_msg));
556        }
557        Ok(isl_rs_result)
558    }
559
560    /// Wraps `isl_constraint_set_constant_si`.
561    pub fn set_constant_si(self, v: i32) -> Result<Constraint, LibISLError> {
562        let constraint = self;
563        let isl_rs_ctx = constraint.get_ctx();
564        let mut constraint = constraint;
565        constraint.do_not_free_on_drop();
566        let constraint = constraint.ptr;
567        let isl_rs_result = unsafe { isl_constraint_set_constant_si(constraint, v) };
568        let isl_rs_result = Constraint { ptr: isl_rs_result,
569                                         should_free_on_drop: true };
570        let err = isl_rs_ctx.last_error();
571        if err != Error::None_ {
572            let err_msg = isl_rs_ctx.last_error_msg();
573            isl_rs_ctx.reset_error();
574            return Err(LibISLError::new(err, err_msg));
575        }
576        Ok(isl_rs_result)
577    }
578
579    /// Wraps `isl_constraint_set_constant_val`.
580    pub fn set_constant_val(self, v: Val) -> Result<Constraint, LibISLError> {
581        let constraint = self;
582        let isl_rs_ctx = constraint.get_ctx();
583        let mut constraint = constraint;
584        constraint.do_not_free_on_drop();
585        let constraint = constraint.ptr;
586        let mut v = v;
587        v.do_not_free_on_drop();
588        let v = v.ptr;
589        let isl_rs_result = unsafe { isl_constraint_set_constant_val(constraint, v) };
590        let isl_rs_result = Constraint { ptr: isl_rs_result,
591                                         should_free_on_drop: true };
592        let err = isl_rs_ctx.last_error();
593        if err != Error::None_ {
594            let err_msg = isl_rs_ctx.last_error_msg();
595            isl_rs_ctx.reset_error();
596            return Err(LibISLError::new(err, err_msg));
597        }
598        Ok(isl_rs_result)
599    }
600
601    /// Wraps `isl_constraint_to_list`.
602    pub fn to_list(self) -> Result<ConstraintList, LibISLError> {
603        let el = self;
604        let isl_rs_ctx = el.get_ctx();
605        let mut el = el;
606        el.do_not_free_on_drop();
607        let el = el.ptr;
608        let isl_rs_result = unsafe { isl_constraint_to_list(el) };
609        let isl_rs_result = ConstraintList { ptr: isl_rs_result,
610                                             should_free_on_drop: true };
611        let err = isl_rs_ctx.last_error();
612        if err != Error::None_ {
613            let err_msg = isl_rs_ctx.last_error_msg();
614            isl_rs_ctx.reset_error();
615            return Err(LibISLError::new(err, err_msg));
616        }
617        Ok(isl_rs_result)
618    }
619
620    /// Does not call isl_constraint_free() on being dropped. (For internal use
621    /// only.)
622    pub fn do_not_free_on_drop(&mut self) {
623        self.should_free_on_drop = false;
624    }
625}
626
627impl Drop for Constraint {
628    fn drop(&mut self) {
629        if self.should_free_on_drop {
630            unsafe {
631                isl_constraint_free(self.ptr);
632            }
633        }
634    }
635}
isl_rs/bindings/constraint.rs

isl_rs/bindings/
constraint.rs
