isl_rs/bindings/
pw_qpolynomial_fold.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{
5    Context, DimType, Error, Fold, Id, LibISLError, Point, PwQPolynomial, PwQPolynomialFoldList,
6    QPolynomialFold, Set, Space, UnionPwQPolynomialFold, Val,
7};
8use libc::uintptr_t;
9use std::ffi::CString;
10use std::os::raw::c_char;
11
12/// Wraps `isl_pw_qpolynomial_fold`.
13pub struct PwQPolynomialFold {
14    pub ptr: uintptr_t,
15    pub should_free_on_drop: bool,
16}
17
18extern "C" {
19
20    fn isl_pw_qpolynomial_fold_add(pwf1: uintptr_t, pwf2: uintptr_t) -> uintptr_t;
21
22    fn isl_pw_qpolynomial_fold_add_disjoint(pwf1: uintptr_t, pwf2: uintptr_t) -> uintptr_t;
23
24    fn isl_pw_qpolynomial_fold_alloc(type_: i32, set: uintptr_t, fold: uintptr_t) -> uintptr_t;
25
26    fn isl_pw_qpolynomial_fold_as_qpolynomial_fold(pwf: uintptr_t) -> uintptr_t;
27
28    fn isl_pw_qpolynomial_fold_coalesce(pwf: uintptr_t) -> uintptr_t;
29
30    fn isl_pw_qpolynomial_fold_copy(pwf: uintptr_t) -> uintptr_t;
31
32    fn isl_pw_qpolynomial_fold_dim(pwf: uintptr_t, type_: i32) -> i32;
33
34    fn isl_pw_qpolynomial_fold_domain(pwf: uintptr_t) -> uintptr_t;
35
36    fn isl_pw_qpolynomial_fold_drop_dims(pwf: uintptr_t, type_: i32, first: u32, n: u32)
37                                         -> uintptr_t;
38
39    fn isl_pw_qpolynomial_fold_drop_unused_params(pwf: uintptr_t) -> uintptr_t;
40
41    fn isl_pw_qpolynomial_fold_dump(pwf: uintptr_t) -> ();
42
43    fn isl_pw_qpolynomial_fold_eval(pwf: uintptr_t, pnt: uintptr_t) -> uintptr_t;
44
45    fn isl_pw_qpolynomial_fold_find_dim_by_name(pwf: uintptr_t, type_: i32, name: *const c_char)
46                                                -> i32;
47
48    fn isl_pw_qpolynomial_fold_fix_val(pwf: uintptr_t, type_: i32, n: u32, v: uintptr_t)
49                                       -> uintptr_t;
50
51    fn isl_pw_qpolynomial_fold_fold(pwf1: uintptr_t, pwf2: uintptr_t) -> uintptr_t;
52
53    fn isl_pw_qpolynomial_fold_free(pwf: uintptr_t) -> uintptr_t;
54
55    fn isl_pw_qpolynomial_fold_from_pw_qpolynomial(type_: i32, pwqp: uintptr_t) -> uintptr_t;
56
57    fn isl_pw_qpolynomial_fold_from_qpolynomial_fold(fold: uintptr_t) -> uintptr_t;
58
59    fn isl_pw_qpolynomial_fold_from_range(pwf: uintptr_t) -> uintptr_t;
60
61    fn isl_pw_qpolynomial_fold_get_ctx(pwf: uintptr_t) -> uintptr_t;
62
63    fn isl_pw_qpolynomial_fold_get_domain_space(pwf: uintptr_t) -> uintptr_t;
64
65    fn isl_pw_qpolynomial_fold_get_space(pwf: uintptr_t) -> uintptr_t;
66
67    fn isl_pw_qpolynomial_fold_get_type(pwf: uintptr_t) -> i32;
68
69    fn isl_pw_qpolynomial_fold_gist(pwf: uintptr_t, context: uintptr_t) -> uintptr_t;
70
71    fn isl_pw_qpolynomial_fold_gist_params(pwf: uintptr_t, context: uintptr_t) -> uintptr_t;
72
73    fn isl_pw_qpolynomial_fold_has_equal_space(pwf1: uintptr_t, pwf2: uintptr_t) -> i32;
74
75    fn isl_pw_qpolynomial_fold_intersect_domain(pwf: uintptr_t, set: uintptr_t) -> uintptr_t;
76
77    fn isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(pwf: uintptr_t, set: uintptr_t)
78                                                               -> uintptr_t;
79
80    fn isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(pwf: uintptr_t, set: uintptr_t)
81                                                              -> uintptr_t;
82
83    fn isl_pw_qpolynomial_fold_intersect_params(pwf: uintptr_t, set: uintptr_t) -> uintptr_t;
84
85    fn isl_pw_qpolynomial_fold_involves_nan(pwf: uintptr_t) -> i32;
86
87    fn isl_pw_qpolynomial_fold_involves_param_id(pwf: uintptr_t, id: uintptr_t) -> i32;
88
89    fn isl_pw_qpolynomial_fold_is_zero(pwf: uintptr_t) -> i32;
90
91    fn isl_pw_qpolynomial_fold_isa_qpolynomial_fold(pwf: uintptr_t) -> i32;
92
93    fn isl_pw_qpolynomial_fold_max(pwf: uintptr_t) -> uintptr_t;
94
95    fn isl_pw_qpolynomial_fold_min(pwf: uintptr_t) -> uintptr_t;
96
97    fn isl_pw_qpolynomial_fold_move_dims(pwf: uintptr_t, dst_type: i32, dst_pos: u32,
98                                         src_type: i32, src_pos: u32, n: u32)
99                                         -> uintptr_t;
100
101    fn isl_pw_qpolynomial_fold_n_piece(pwf: uintptr_t) -> i32;
102
103    fn isl_pw_qpolynomial_fold_plain_is_equal(pwf1: uintptr_t, pwf2: uintptr_t) -> i32;
104
105    fn isl_pw_qpolynomial_fold_project_domain_on_params(pwf: uintptr_t) -> uintptr_t;
106
107    fn isl_pw_qpolynomial_fold_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
108
109    fn isl_pw_qpolynomial_fold_reset_space(pwf: uintptr_t, space: uintptr_t) -> uintptr_t;
110
111    fn isl_pw_qpolynomial_fold_reset_user(pwf: uintptr_t) -> uintptr_t;
112
113    fn isl_pw_qpolynomial_fold_scale_down_val(pwf: uintptr_t, v: uintptr_t) -> uintptr_t;
114
115    fn isl_pw_qpolynomial_fold_scale_val(pwf: uintptr_t, v: uintptr_t) -> uintptr_t;
116
117    fn isl_pw_qpolynomial_fold_set_dim_name(pwf: uintptr_t, type_: i32, pos: u32, s: *const c_char)
118                                            -> uintptr_t;
119
120    fn isl_pw_qpolynomial_fold_size(pwf: uintptr_t) -> usize;
121
122    fn isl_pw_qpolynomial_fold_subtract_domain(pwf: uintptr_t, set: uintptr_t) -> uintptr_t;
123
124    fn isl_pw_qpolynomial_fold_to_list(el: uintptr_t) -> uintptr_t;
125
126    fn isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(pwf: uintptr_t) -> uintptr_t;
127
128    fn isl_pw_qpolynomial_fold_zero(space: uintptr_t, type_: i32) -> uintptr_t;
129
130}
131
132impl PwQPolynomialFold {
133    /// Wraps `isl_pw_qpolynomial_fold_add`.
134    pub fn add(self, pwf2: PwQPolynomialFold) -> Result<PwQPolynomialFold, LibISLError> {
135        let pwf1 = self;
136        let isl_rs_ctx = pwf1.get_ctx();
137        let mut pwf1 = pwf1;
138        pwf1.do_not_free_on_drop();
139        let pwf1 = pwf1.ptr;
140        let mut pwf2 = pwf2;
141        pwf2.do_not_free_on_drop();
142        let pwf2 = pwf2.ptr;
143        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_add(pwf1, pwf2) };
144        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
145                                                should_free_on_drop: true };
146        let err = isl_rs_ctx.last_error();
147        if err != Error::None_ {
148            let err_msg = isl_rs_ctx.last_error_msg();
149            isl_rs_ctx.reset_error();
150            return Err(LibISLError::new(err, err_msg));
151        }
152        Ok(isl_rs_result)
153    }
154
155    /// Wraps `isl_pw_qpolynomial_fold_add_disjoint`.
156    pub fn add_disjoint(self, pwf2: PwQPolynomialFold) -> Result<PwQPolynomialFold, LibISLError> {
157        let pwf1 = self;
158        let isl_rs_ctx = pwf1.get_ctx();
159        let mut pwf1 = pwf1;
160        pwf1.do_not_free_on_drop();
161        let pwf1 = pwf1.ptr;
162        let mut pwf2 = pwf2;
163        pwf2.do_not_free_on_drop();
164        let pwf2 = pwf2.ptr;
165        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_add_disjoint(pwf1, pwf2) };
166        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
167                                                should_free_on_drop: true };
168        let err = isl_rs_ctx.last_error();
169        if err != Error::None_ {
170            let err_msg = isl_rs_ctx.last_error_msg();
171            isl_rs_ctx.reset_error();
172            return Err(LibISLError::new(err, err_msg));
173        }
174        Ok(isl_rs_result)
175    }
176
177    /// Wraps `isl_pw_qpolynomial_fold_alloc`.
178    pub fn alloc(type_: Fold, set: Set, fold: QPolynomialFold)
179                 -> Result<PwQPolynomialFold, LibISLError> {
180        let isl_rs_ctx = set.get_ctx();
181        let type_ = type_.to_i32();
182        let mut set = set;
183        set.do_not_free_on_drop();
184        let set = set.ptr;
185        let mut fold = fold;
186        fold.do_not_free_on_drop();
187        let fold = fold.ptr;
188        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_alloc(type_, set, fold) };
189        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
190                                                should_free_on_drop: true };
191        let err = isl_rs_ctx.last_error();
192        if err != Error::None_ {
193            let err_msg = isl_rs_ctx.last_error_msg();
194            isl_rs_ctx.reset_error();
195            return Err(LibISLError::new(err, err_msg));
196        }
197        Ok(isl_rs_result)
198    }
199
200    /// Wraps `isl_pw_qpolynomial_fold_as_qpolynomial_fold`.
201    pub fn as_qpolynomial_fold(self) -> Result<QPolynomialFold, LibISLError> {
202        let pwf = self;
203        let isl_rs_ctx = pwf.get_ctx();
204        let mut pwf = pwf;
205        pwf.do_not_free_on_drop();
206        let pwf = pwf.ptr;
207        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_as_qpolynomial_fold(pwf) };
208        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
209                                              should_free_on_drop: true };
210        let err = isl_rs_ctx.last_error();
211        if err != Error::None_ {
212            let err_msg = isl_rs_ctx.last_error_msg();
213            isl_rs_ctx.reset_error();
214            return Err(LibISLError::new(err, err_msg));
215        }
216        Ok(isl_rs_result)
217    }
218
219    /// Wraps `isl_pw_qpolynomial_fold_coalesce`.
220    pub fn coalesce(self) -> Result<PwQPolynomialFold, LibISLError> {
221        let pwf = self;
222        let isl_rs_ctx = pwf.get_ctx();
223        let mut pwf = pwf;
224        pwf.do_not_free_on_drop();
225        let pwf = pwf.ptr;
226        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_coalesce(pwf) };
227        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
228                                                should_free_on_drop: true };
229        let err = isl_rs_ctx.last_error();
230        if err != Error::None_ {
231            let err_msg = isl_rs_ctx.last_error_msg();
232            isl_rs_ctx.reset_error();
233            return Err(LibISLError::new(err, err_msg));
234        }
235        Ok(isl_rs_result)
236    }
237
238    /// Wraps `isl_pw_qpolynomial_fold_copy`.
239    pub fn copy(&self) -> Result<PwQPolynomialFold, LibISLError> {
240        let pwf = self;
241        let isl_rs_ctx = pwf.get_ctx();
242        let pwf = pwf.ptr;
243        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_copy(pwf) };
244        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
245                                                should_free_on_drop: true };
246        let err = isl_rs_ctx.last_error();
247        if err != Error::None_ {
248            let err_msg = isl_rs_ctx.last_error_msg();
249            isl_rs_ctx.reset_error();
250            return Err(LibISLError::new(err, err_msg));
251        }
252        Ok(isl_rs_result)
253    }
254
255    /// Wraps `isl_pw_qpolynomial_fold_dim`.
256    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
257        let pwf = self;
258        let isl_rs_ctx = pwf.get_ctx();
259        let pwf = pwf.ptr;
260        let type_ = type_.to_i32();
261        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_dim(pwf, type_) };
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_pw_qpolynomial_fold_domain`.
272    pub fn domain(self) -> Result<Set, LibISLError> {
273        let pwf = self;
274        let isl_rs_ctx = pwf.get_ctx();
275        let mut pwf = pwf;
276        pwf.do_not_free_on_drop();
277        let pwf = pwf.ptr;
278        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_domain(pwf) };
279        let isl_rs_result = Set { ptr: isl_rs_result,
280                                  should_free_on_drop: true };
281        let err = isl_rs_ctx.last_error();
282        if err != Error::None_ {
283            let err_msg = isl_rs_ctx.last_error_msg();
284            isl_rs_ctx.reset_error();
285            return Err(LibISLError::new(err, err_msg));
286        }
287        Ok(isl_rs_result)
288    }
289
290    /// Wraps `isl_pw_qpolynomial_fold_drop_dims`.
291    pub fn drop_dims(self, type_: DimType, first: u32, n: u32)
292                     -> Result<PwQPolynomialFold, LibISLError> {
293        let pwf = self;
294        let isl_rs_ctx = pwf.get_ctx();
295        let mut pwf = pwf;
296        pwf.do_not_free_on_drop();
297        let pwf = pwf.ptr;
298        let type_ = type_.to_i32();
299        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_drop_dims(pwf, type_, first, n) };
300        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
301                                                should_free_on_drop: true };
302        let err = isl_rs_ctx.last_error();
303        if err != Error::None_ {
304            let err_msg = isl_rs_ctx.last_error_msg();
305            isl_rs_ctx.reset_error();
306            return Err(LibISLError::new(err, err_msg));
307        }
308        Ok(isl_rs_result)
309    }
310
311    /// Wraps `isl_pw_qpolynomial_fold_drop_unused_params`.
312    pub fn drop_unused_params(self) -> Result<PwQPolynomialFold, LibISLError> {
313        let pwf = self;
314        let isl_rs_ctx = pwf.get_ctx();
315        let mut pwf = pwf;
316        pwf.do_not_free_on_drop();
317        let pwf = pwf.ptr;
318        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_drop_unused_params(pwf) };
319        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
320                                                should_free_on_drop: true };
321        let err = isl_rs_ctx.last_error();
322        if err != Error::None_ {
323            let err_msg = isl_rs_ctx.last_error_msg();
324            isl_rs_ctx.reset_error();
325            return Err(LibISLError::new(err, err_msg));
326        }
327        Ok(isl_rs_result)
328    }
329
330    /// Wraps `isl_pw_qpolynomial_fold_dump`.
331    pub fn dump(&self) -> Result<(), LibISLError> {
332        let pwf = self;
333        let isl_rs_ctx = pwf.get_ctx();
334        let pwf = pwf.ptr;
335        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_dump(pwf) };
336        let err = isl_rs_ctx.last_error();
337        if err != Error::None_ {
338            let err_msg = isl_rs_ctx.last_error_msg();
339            isl_rs_ctx.reset_error();
340            return Err(LibISLError::new(err, err_msg));
341        }
342        Ok(isl_rs_result)
343    }
344
345    /// Wraps `isl_pw_qpolynomial_fold_eval`.
346    pub fn eval(self, pnt: Point) -> Result<Val, LibISLError> {
347        let pwf = self;
348        let isl_rs_ctx = pwf.get_ctx();
349        let mut pwf = pwf;
350        pwf.do_not_free_on_drop();
351        let pwf = pwf.ptr;
352        let mut pnt = pnt;
353        pnt.do_not_free_on_drop();
354        let pnt = pnt.ptr;
355        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_eval(pwf, pnt) };
356        let isl_rs_result = Val { ptr: isl_rs_result,
357                                  should_free_on_drop: true };
358        let err = isl_rs_ctx.last_error();
359        if err != Error::None_ {
360            let err_msg = isl_rs_ctx.last_error_msg();
361            isl_rs_ctx.reset_error();
362            return Err(LibISLError::new(err, err_msg));
363        }
364        Ok(isl_rs_result)
365    }
366
367    /// Wraps `isl_pw_qpolynomial_fold_find_dim_by_name`.
368    pub fn find_dim_by_name(&self, type_: DimType, name: &str) -> Result<i32, LibISLError> {
369        let pwf = self;
370        let isl_rs_ctx = pwf.get_ctx();
371        let pwf = pwf.ptr;
372        let type_ = type_.to_i32();
373        let name = CString::new(name).unwrap();
374        let name = name.as_ptr();
375        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_find_dim_by_name(pwf, type_, name) };
376        let err = isl_rs_ctx.last_error();
377        if err != Error::None_ {
378            let err_msg = isl_rs_ctx.last_error_msg();
379            isl_rs_ctx.reset_error();
380            return Err(LibISLError::new(err, err_msg));
381        }
382        Ok(isl_rs_result)
383    }
384
385    /// Wraps `isl_pw_qpolynomial_fold_fix_val`.
386    pub fn fix_val(self, type_: DimType, n: u32, v: Val) -> Result<PwQPolynomialFold, LibISLError> {
387        let pwf = self;
388        let isl_rs_ctx = pwf.get_ctx();
389        let mut pwf = pwf;
390        pwf.do_not_free_on_drop();
391        let pwf = pwf.ptr;
392        let type_ = type_.to_i32();
393        let mut v = v;
394        v.do_not_free_on_drop();
395        let v = v.ptr;
396        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_fix_val(pwf, type_, n, v) };
397        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
398                                                should_free_on_drop: true };
399        let err = isl_rs_ctx.last_error();
400        if err != Error::None_ {
401            let err_msg = isl_rs_ctx.last_error_msg();
402            isl_rs_ctx.reset_error();
403            return Err(LibISLError::new(err, err_msg));
404        }
405        Ok(isl_rs_result)
406    }
407
408    /// Wraps `isl_pw_qpolynomial_fold_fold`.
409    pub fn fold(self, pwf2: PwQPolynomialFold) -> Result<PwQPolynomialFold, LibISLError> {
410        let pwf1 = self;
411        let isl_rs_ctx = pwf1.get_ctx();
412        let mut pwf1 = pwf1;
413        pwf1.do_not_free_on_drop();
414        let pwf1 = pwf1.ptr;
415        let mut pwf2 = pwf2;
416        pwf2.do_not_free_on_drop();
417        let pwf2 = pwf2.ptr;
418        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_fold(pwf1, pwf2) };
419        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
420                                                should_free_on_drop: true };
421        let err = isl_rs_ctx.last_error();
422        if err != Error::None_ {
423            let err_msg = isl_rs_ctx.last_error_msg();
424            isl_rs_ctx.reset_error();
425            return Err(LibISLError::new(err, err_msg));
426        }
427        Ok(isl_rs_result)
428    }
429
430    /// Wraps `isl_pw_qpolynomial_fold_free`.
431    pub fn free(self) -> Result<PwQPolynomialFold, LibISLError> {
432        let pwf = self;
433        let isl_rs_ctx = pwf.get_ctx();
434        let mut pwf = pwf;
435        pwf.do_not_free_on_drop();
436        let pwf = pwf.ptr;
437        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_free(pwf) };
438        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
439                                                should_free_on_drop: true };
440        let err = isl_rs_ctx.last_error();
441        if err != Error::None_ {
442            let err_msg = isl_rs_ctx.last_error_msg();
443            isl_rs_ctx.reset_error();
444            return Err(LibISLError::new(err, err_msg));
445        }
446        Ok(isl_rs_result)
447    }
448
449    /// Wraps `isl_pw_qpolynomial_fold_from_pw_qpolynomial`.
450    pub fn from_pw_qpolynomial(type_: Fold, pwqp: PwQPolynomial)
451                               -> Result<PwQPolynomialFold, LibISLError> {
452        let isl_rs_ctx = pwqp.get_ctx();
453        let type_ = type_.to_i32();
454        let mut pwqp = pwqp;
455        pwqp.do_not_free_on_drop();
456        let pwqp = pwqp.ptr;
457        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_from_pw_qpolynomial(type_, pwqp) };
458        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
459                                                should_free_on_drop: true };
460        let err = isl_rs_ctx.last_error();
461        if err != Error::None_ {
462            let err_msg = isl_rs_ctx.last_error_msg();
463            isl_rs_ctx.reset_error();
464            return Err(LibISLError::new(err, err_msg));
465        }
466        Ok(isl_rs_result)
467    }
468
469    /// Wraps `isl_pw_qpolynomial_fold_from_qpolynomial_fold`.
470    pub fn from_qpolynomial_fold(fold: QPolynomialFold) -> Result<PwQPolynomialFold, LibISLError> {
471        let isl_rs_ctx = fold.get_ctx();
472        let mut fold = fold;
473        fold.do_not_free_on_drop();
474        let fold = fold.ptr;
475        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_from_qpolynomial_fold(fold) };
476        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
477                                                should_free_on_drop: true };
478        let err = isl_rs_ctx.last_error();
479        if err != Error::None_ {
480            let err_msg = isl_rs_ctx.last_error_msg();
481            isl_rs_ctx.reset_error();
482            return Err(LibISLError::new(err, err_msg));
483        }
484        Ok(isl_rs_result)
485    }
486
487    /// Wraps `isl_pw_qpolynomial_fold_from_range`.
488    pub fn from_range(self) -> Result<PwQPolynomialFold, LibISLError> {
489        let pwf = self;
490        let isl_rs_ctx = pwf.get_ctx();
491        let mut pwf = pwf;
492        pwf.do_not_free_on_drop();
493        let pwf = pwf.ptr;
494        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_from_range(pwf) };
495        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_get_ctx`.
507    pub fn get_ctx(&self) -> Context {
508        let pwf = self;
509        let pwf = pwf.ptr;
510        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_get_ctx(pwf) };
511        let isl_rs_result = Context { ptr: isl_rs_result,
512                                      should_free_on_drop: false };
513        isl_rs_result
514    }
515
516    /// Wraps `isl_pw_qpolynomial_fold_get_domain_space`.
517    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
518        let pwf = self;
519        let isl_rs_ctx = pwf.get_ctx();
520        let pwf = pwf.ptr;
521        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_get_domain_space(pwf) };
522        let isl_rs_result = Space { ptr: isl_rs_result,
523                                    should_free_on_drop: true };
524        let err = isl_rs_ctx.last_error();
525        if err != Error::None_ {
526            let err_msg = isl_rs_ctx.last_error_msg();
527            isl_rs_ctx.reset_error();
528            return Err(LibISLError::new(err, err_msg));
529        }
530        Ok(isl_rs_result)
531    }
532
533    /// Wraps `isl_pw_qpolynomial_fold_get_space`.
534    pub fn get_space(&self) -> Result<Space, LibISLError> {
535        let pwf = self;
536        let isl_rs_ctx = pwf.get_ctx();
537        let pwf = pwf.ptr;
538        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_get_space(pwf) };
539        let isl_rs_result = Space { ptr: isl_rs_result,
540                                    should_free_on_drop: true };
541        let err = isl_rs_ctx.last_error();
542        if err != Error::None_ {
543            let err_msg = isl_rs_ctx.last_error_msg();
544            isl_rs_ctx.reset_error();
545            return Err(LibISLError::new(err, err_msg));
546        }
547        Ok(isl_rs_result)
548    }
549
550    /// Wraps `isl_pw_qpolynomial_fold_get_type`.
551    pub fn get_type(&self) -> Result<Fold, LibISLError> {
552        let pwf = self;
553        let isl_rs_ctx = pwf.get_ctx();
554        let pwf = pwf.ptr;
555        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_get_type(pwf) };
556        let isl_rs_result = Fold::from_i32(isl_rs_result);
557        let err = isl_rs_ctx.last_error();
558        if err != Error::None_ {
559            let err_msg = isl_rs_ctx.last_error_msg();
560            isl_rs_ctx.reset_error();
561            return Err(LibISLError::new(err, err_msg));
562        }
563        Ok(isl_rs_result)
564    }
565
566    /// Wraps `isl_pw_qpolynomial_fold_gist`.
567    pub fn gist(self, context: Set) -> Result<PwQPolynomialFold, LibISLError> {
568        let pwf = self;
569        let isl_rs_ctx = pwf.get_ctx();
570        let mut pwf = pwf;
571        pwf.do_not_free_on_drop();
572        let pwf = pwf.ptr;
573        let mut context = context;
574        context.do_not_free_on_drop();
575        let context = context.ptr;
576        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_gist(pwf, context) };
577        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
578                                                should_free_on_drop: true };
579        let err = isl_rs_ctx.last_error();
580        if err != Error::None_ {
581            let err_msg = isl_rs_ctx.last_error_msg();
582            isl_rs_ctx.reset_error();
583            return Err(LibISLError::new(err, err_msg));
584        }
585        Ok(isl_rs_result)
586    }
587
588    /// Wraps `isl_pw_qpolynomial_fold_gist_params`.
589    pub fn gist_params(self, context: Set) -> Result<PwQPolynomialFold, LibISLError> {
590        let pwf = self;
591        let isl_rs_ctx = pwf.get_ctx();
592        let mut pwf = pwf;
593        pwf.do_not_free_on_drop();
594        let pwf = pwf.ptr;
595        let mut context = context;
596        context.do_not_free_on_drop();
597        let context = context.ptr;
598        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_gist_params(pwf, context) };
599        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
600                                                should_free_on_drop: true };
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_pw_qpolynomial_fold_has_equal_space`.
611    pub fn has_equal_space(&self, pwf2: &PwQPolynomialFold) -> Result<bool, LibISLError> {
612        let pwf1 = self;
613        let isl_rs_ctx = pwf1.get_ctx();
614        let pwf1 = pwf1.ptr;
615        let pwf2 = pwf2.ptr;
616        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_has_equal_space(pwf1, pwf2) };
617        let isl_rs_result = match isl_rs_result {
618            0 => false,
619            1 => true,
620            _ => {
621                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
622            }
623        };
624        let err = isl_rs_ctx.last_error();
625        if err != Error::None_ {
626            let err_msg = isl_rs_ctx.last_error_msg();
627            isl_rs_ctx.reset_error();
628            return Err(LibISLError::new(err, err_msg));
629        }
630        Ok(isl_rs_result)
631    }
632
633    /// Wraps `isl_pw_qpolynomial_fold_intersect_domain`.
634    pub fn intersect_domain(self, set: Set) -> Result<PwQPolynomialFold, LibISLError> {
635        let pwf = self;
636        let isl_rs_ctx = pwf.get_ctx();
637        let mut pwf = pwf;
638        pwf.do_not_free_on_drop();
639        let pwf = pwf.ptr;
640        let mut set = set;
641        set.do_not_free_on_drop();
642        let set = set.ptr;
643        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_intersect_domain(pwf, set) };
644        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
645                                                should_free_on_drop: true };
646        let err = isl_rs_ctx.last_error();
647        if err != Error::None_ {
648            let err_msg = isl_rs_ctx.last_error_msg();
649            isl_rs_ctx.reset_error();
650            return Err(LibISLError::new(err, err_msg));
651        }
652        Ok(isl_rs_result)
653    }
654
655    /// Wraps `isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain`.
656    pub fn intersect_domain_wrapped_domain(self, set: Set)
657                                           -> Result<PwQPolynomialFold, LibISLError> {
658        let pwf = self;
659        let isl_rs_ctx = pwf.get_ctx();
660        let mut pwf = pwf;
661        pwf.do_not_free_on_drop();
662        let pwf = pwf.ptr;
663        let mut set = set;
664        set.do_not_free_on_drop();
665        let set = set.ptr;
666        let isl_rs_result =
667            unsafe { isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(pwf, set) };
668        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
669                                                should_free_on_drop: true };
670        let err = isl_rs_ctx.last_error();
671        if err != Error::None_ {
672            let err_msg = isl_rs_ctx.last_error_msg();
673            isl_rs_ctx.reset_error();
674            return Err(LibISLError::new(err, err_msg));
675        }
676        Ok(isl_rs_result)
677    }
678
679    /// Wraps `isl_pw_qpolynomial_fold_intersect_domain_wrapped_range`.
680    pub fn intersect_domain_wrapped_range(self, set: Set)
681                                          -> Result<PwQPolynomialFold, LibISLError> {
682        let pwf = self;
683        let isl_rs_ctx = pwf.get_ctx();
684        let mut pwf = pwf;
685        pwf.do_not_free_on_drop();
686        let pwf = pwf.ptr;
687        let mut set = set;
688        set.do_not_free_on_drop();
689        let set = set.ptr;
690        let isl_rs_result =
691            unsafe { isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(pwf, set) };
692        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
693                                                should_free_on_drop: true };
694        let err = isl_rs_ctx.last_error();
695        if err != Error::None_ {
696            let err_msg = isl_rs_ctx.last_error_msg();
697            isl_rs_ctx.reset_error();
698            return Err(LibISLError::new(err, err_msg));
699        }
700        Ok(isl_rs_result)
701    }
702
703    /// Wraps `isl_pw_qpolynomial_fold_intersect_params`.
704    pub fn intersect_params(self, set: Set) -> Result<PwQPolynomialFold, LibISLError> {
705        let pwf = self;
706        let isl_rs_ctx = pwf.get_ctx();
707        let mut pwf = pwf;
708        pwf.do_not_free_on_drop();
709        let pwf = pwf.ptr;
710        let mut set = set;
711        set.do_not_free_on_drop();
712        let set = set.ptr;
713        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_intersect_params(pwf, set) };
714        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
715                                                should_free_on_drop: true };
716        let err = isl_rs_ctx.last_error();
717        if err != Error::None_ {
718            let err_msg = isl_rs_ctx.last_error_msg();
719            isl_rs_ctx.reset_error();
720            return Err(LibISLError::new(err, err_msg));
721        }
722        Ok(isl_rs_result)
723    }
724
725    /// Wraps `isl_pw_qpolynomial_fold_involves_nan`.
726    pub fn involves_nan(&self) -> Result<bool, LibISLError> {
727        let pwf = self;
728        let isl_rs_ctx = pwf.get_ctx();
729        let pwf = pwf.ptr;
730        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_involves_nan(pwf) };
731        let isl_rs_result = match isl_rs_result {
732            0 => false,
733            1 => true,
734            _ => {
735                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
736            }
737        };
738        let err = isl_rs_ctx.last_error();
739        if err != Error::None_ {
740            let err_msg = isl_rs_ctx.last_error_msg();
741            isl_rs_ctx.reset_error();
742            return Err(LibISLError::new(err, err_msg));
743        }
744        Ok(isl_rs_result)
745    }
746
747    /// Wraps `isl_pw_qpolynomial_fold_involves_param_id`.
748    pub fn involves_param_id(&self, id: &Id) -> Result<bool, LibISLError> {
749        let pwf = self;
750        let isl_rs_ctx = pwf.get_ctx();
751        let pwf = pwf.ptr;
752        let id = id.ptr;
753        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_involves_param_id(pwf, id) };
754        let isl_rs_result = match isl_rs_result {
755            0 => false,
756            1 => true,
757            _ => {
758                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
759            }
760        };
761        let err = isl_rs_ctx.last_error();
762        if err != Error::None_ {
763            let err_msg = isl_rs_ctx.last_error_msg();
764            isl_rs_ctx.reset_error();
765            return Err(LibISLError::new(err, err_msg));
766        }
767        Ok(isl_rs_result)
768    }
769
770    /// Wraps `isl_pw_qpolynomial_fold_is_zero`.
771    pub fn is_zero(&self) -> Result<bool, LibISLError> {
772        let pwf = self;
773        let isl_rs_ctx = pwf.get_ctx();
774        let pwf = pwf.ptr;
775        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_is_zero(pwf) };
776        let isl_rs_result = match isl_rs_result {
777            0 => false,
778            1 => true,
779            _ => {
780                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
781            }
782        };
783        let err = isl_rs_ctx.last_error();
784        if err != Error::None_ {
785            let err_msg = isl_rs_ctx.last_error_msg();
786            isl_rs_ctx.reset_error();
787            return Err(LibISLError::new(err, err_msg));
788        }
789        Ok(isl_rs_result)
790    }
791
792    /// Wraps `isl_pw_qpolynomial_fold_isa_qpolynomial_fold`.
793    pub fn isa_qpolynomial_fold(&self) -> Result<bool, LibISLError> {
794        let pwf = self;
795        let isl_rs_ctx = pwf.get_ctx();
796        let pwf = pwf.ptr;
797        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_isa_qpolynomial_fold(pwf) };
798        let isl_rs_result = match isl_rs_result {
799            0 => false,
800            1 => true,
801            _ => {
802                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
803            }
804        };
805        let err = isl_rs_ctx.last_error();
806        if err != Error::None_ {
807            let err_msg = isl_rs_ctx.last_error_msg();
808            isl_rs_ctx.reset_error();
809            return Err(LibISLError::new(err, err_msg));
810        }
811        Ok(isl_rs_result)
812    }
813
814    /// Wraps `isl_pw_qpolynomial_fold_max`.
815    pub fn max(self) -> Result<Val, LibISLError> {
816        let pwf = self;
817        let isl_rs_ctx = pwf.get_ctx();
818        let mut pwf = pwf;
819        pwf.do_not_free_on_drop();
820        let pwf = pwf.ptr;
821        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_max(pwf) };
822        let isl_rs_result = Val { ptr: isl_rs_result,
823                                  should_free_on_drop: true };
824        let err = isl_rs_ctx.last_error();
825        if err != Error::None_ {
826            let err_msg = isl_rs_ctx.last_error_msg();
827            isl_rs_ctx.reset_error();
828            return Err(LibISLError::new(err, err_msg));
829        }
830        Ok(isl_rs_result)
831    }
832
833    /// Wraps `isl_pw_qpolynomial_fold_min`.
834    pub fn min(self) -> Result<Val, LibISLError> {
835        let pwf = self;
836        let isl_rs_ctx = pwf.get_ctx();
837        let mut pwf = pwf;
838        pwf.do_not_free_on_drop();
839        let pwf = pwf.ptr;
840        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_min(pwf) };
841        let isl_rs_result = Val { ptr: isl_rs_result,
842                                  should_free_on_drop: true };
843        let err = isl_rs_ctx.last_error();
844        if err != Error::None_ {
845            let err_msg = isl_rs_ctx.last_error_msg();
846            isl_rs_ctx.reset_error();
847            return Err(LibISLError::new(err, err_msg));
848        }
849        Ok(isl_rs_result)
850    }
851
852    /// Wraps `isl_pw_qpolynomial_fold_move_dims`.
853    pub fn move_dims(self, dst_type: DimType, dst_pos: u32, src_type: DimType, src_pos: u32,
854                     n: u32)
855                     -> Result<PwQPolynomialFold, LibISLError> {
856        let pwf = self;
857        let isl_rs_ctx = pwf.get_ctx();
858        let mut pwf = pwf;
859        pwf.do_not_free_on_drop();
860        let pwf = pwf.ptr;
861        let dst_type = dst_type.to_i32();
862        let src_type = src_type.to_i32();
863        let isl_rs_result = unsafe {
864            isl_pw_qpolynomial_fold_move_dims(pwf, dst_type, dst_pos, src_type, src_pos, n)
865        };
866        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
867                                                should_free_on_drop: true };
868        let err = isl_rs_ctx.last_error();
869        if err != Error::None_ {
870            let err_msg = isl_rs_ctx.last_error_msg();
871            isl_rs_ctx.reset_error();
872            return Err(LibISLError::new(err, err_msg));
873        }
874        Ok(isl_rs_result)
875    }
876
877    /// Wraps `isl_pw_qpolynomial_fold_n_piece`.
878    pub fn n_piece(&self) -> Result<i32, LibISLError> {
879        let pwf = self;
880        let isl_rs_ctx = pwf.get_ctx();
881        let pwf = pwf.ptr;
882        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_n_piece(pwf) };
883        let err = isl_rs_ctx.last_error();
884        if err != Error::None_ {
885            let err_msg = isl_rs_ctx.last_error_msg();
886            isl_rs_ctx.reset_error();
887            return Err(LibISLError::new(err, err_msg));
888        }
889        Ok(isl_rs_result)
890    }
891
892    /// Wraps `isl_pw_qpolynomial_fold_plain_is_equal`.
893    pub fn plain_is_equal(&self, pwf2: &PwQPolynomialFold) -> Result<bool, LibISLError> {
894        let pwf1 = self;
895        let isl_rs_ctx = pwf1.get_ctx();
896        let pwf1 = pwf1.ptr;
897        let pwf2 = pwf2.ptr;
898        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_plain_is_equal(pwf1, pwf2) };
899        let isl_rs_result = match isl_rs_result {
900            0 => false,
901            1 => true,
902            _ => {
903                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
904            }
905        };
906        let err = isl_rs_ctx.last_error();
907        if err != Error::None_ {
908            let err_msg = isl_rs_ctx.last_error_msg();
909            isl_rs_ctx.reset_error();
910            return Err(LibISLError::new(err, err_msg));
911        }
912        Ok(isl_rs_result)
913    }
914
915    /// Wraps `isl_pw_qpolynomial_fold_project_domain_on_params`.
916    pub fn project_domain_on_params(self) -> Result<PwQPolynomialFold, LibISLError> {
917        let pwf = self;
918        let isl_rs_ctx = pwf.get_ctx();
919        let mut pwf = pwf;
920        pwf.do_not_free_on_drop();
921        let pwf = pwf.ptr;
922        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_project_domain_on_params(pwf) };
923        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
924                                                should_free_on_drop: true };
925        let err = isl_rs_ctx.last_error();
926        if err != Error::None_ {
927            let err_msg = isl_rs_ctx.last_error_msg();
928            isl_rs_ctx.reset_error();
929            return Err(LibISLError::new(err, err_msg));
930        }
931        Ok(isl_rs_result)
932    }
933
934    /// Wraps `isl_pw_qpolynomial_fold_read_from_str`.
935    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<PwQPolynomialFold, LibISLError> {
936        let isl_rs_ctx = Context { ptr: ctx.ptr,
937                                   should_free_on_drop: false };
938        let ctx = ctx.ptr;
939        let str_ = CString::new(str_).unwrap();
940        let str_ = str_.as_ptr();
941        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_read_from_str(ctx, str_) };
942        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
943                                                should_free_on_drop: true };
944        let err = isl_rs_ctx.last_error();
945        if err != Error::None_ {
946            let err_msg = isl_rs_ctx.last_error_msg();
947            isl_rs_ctx.reset_error();
948            return Err(LibISLError::new(err, err_msg));
949        }
950        Ok(isl_rs_result)
951    }
952
953    /// Wraps `isl_pw_qpolynomial_fold_reset_space`.
954    pub fn reset_space(self, space: Space) -> Result<PwQPolynomialFold, LibISLError> {
955        let pwf = self;
956        let isl_rs_ctx = pwf.get_ctx();
957        let mut pwf = pwf;
958        pwf.do_not_free_on_drop();
959        let pwf = pwf.ptr;
960        let mut space = space;
961        space.do_not_free_on_drop();
962        let space = space.ptr;
963        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_reset_space(pwf, space) };
964        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
965                                                should_free_on_drop: true };
966        let err = isl_rs_ctx.last_error();
967        if err != Error::None_ {
968            let err_msg = isl_rs_ctx.last_error_msg();
969            isl_rs_ctx.reset_error();
970            return Err(LibISLError::new(err, err_msg));
971        }
972        Ok(isl_rs_result)
973    }
974
975    /// Wraps `isl_pw_qpolynomial_fold_reset_user`.
976    pub fn reset_user(self) -> Result<PwQPolynomialFold, LibISLError> {
977        let pwf = self;
978        let isl_rs_ctx = pwf.get_ctx();
979        let mut pwf = pwf;
980        pwf.do_not_free_on_drop();
981        let pwf = pwf.ptr;
982        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_reset_user(pwf) };
983        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
984                                                should_free_on_drop: true };
985        let err = isl_rs_ctx.last_error();
986        if err != Error::None_ {
987            let err_msg = isl_rs_ctx.last_error_msg();
988            isl_rs_ctx.reset_error();
989            return Err(LibISLError::new(err, err_msg));
990        }
991        Ok(isl_rs_result)
992    }
993
994    /// Wraps `isl_pw_qpolynomial_fold_scale_down_val`.
995    pub fn scale_down_val(self, v: Val) -> Result<PwQPolynomialFold, LibISLError> {
996        let pwf = self;
997        let isl_rs_ctx = pwf.get_ctx();
998        let mut pwf = pwf;
999        pwf.do_not_free_on_drop();
1000        let pwf = pwf.ptr;
1001        let mut v = v;
1002        v.do_not_free_on_drop();
1003        let v = v.ptr;
1004        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_scale_down_val(pwf, v) };
1005        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
1006                                                should_free_on_drop: true };
1007        let err = isl_rs_ctx.last_error();
1008        if err != Error::None_ {
1009            let err_msg = isl_rs_ctx.last_error_msg();
1010            isl_rs_ctx.reset_error();
1011            return Err(LibISLError::new(err, err_msg));
1012        }
1013        Ok(isl_rs_result)
1014    }
1015
1016    /// Wraps `isl_pw_qpolynomial_fold_scale_val`.
1017    pub fn scale_val(self, v: Val) -> Result<PwQPolynomialFold, LibISLError> {
1018        let pwf = self;
1019        let isl_rs_ctx = pwf.get_ctx();
1020        let mut pwf = pwf;
1021        pwf.do_not_free_on_drop();
1022        let pwf = pwf.ptr;
1023        let mut v = v;
1024        v.do_not_free_on_drop();
1025        let v = v.ptr;
1026        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_scale_val(pwf, v) };
1027        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
1028                                                should_free_on_drop: true };
1029        let err = isl_rs_ctx.last_error();
1030        if err != Error::None_ {
1031            let err_msg = isl_rs_ctx.last_error_msg();
1032            isl_rs_ctx.reset_error();
1033            return Err(LibISLError::new(err, err_msg));
1034        }
1035        Ok(isl_rs_result)
1036    }
1037
1038    /// Wraps `isl_pw_qpolynomial_fold_set_dim_name`.
1039    pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str)
1040                        -> Result<PwQPolynomialFold, LibISLError> {
1041        let pwf = self;
1042        let isl_rs_ctx = pwf.get_ctx();
1043        let mut pwf = pwf;
1044        pwf.do_not_free_on_drop();
1045        let pwf = pwf.ptr;
1046        let type_ = type_.to_i32();
1047        let s = CString::new(s).unwrap();
1048        let s = s.as_ptr();
1049        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_set_dim_name(pwf, type_, pos, s) };
1050        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
1051                                                should_free_on_drop: true };
1052        let err = isl_rs_ctx.last_error();
1053        if err != Error::None_ {
1054            let err_msg = isl_rs_ctx.last_error_msg();
1055            isl_rs_ctx.reset_error();
1056            return Err(LibISLError::new(err, err_msg));
1057        }
1058        Ok(isl_rs_result)
1059    }
1060
1061    /// Wraps `isl_pw_qpolynomial_fold_size`.
1062    pub fn size(&self) -> Result<usize, LibISLError> {
1063        let pwf = self;
1064        let isl_rs_ctx = pwf.get_ctx();
1065        let pwf = pwf.ptr;
1066        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_size(pwf) };
1067        let err = isl_rs_ctx.last_error();
1068        if err != Error::None_ {
1069            let err_msg = isl_rs_ctx.last_error_msg();
1070            isl_rs_ctx.reset_error();
1071            return Err(LibISLError::new(err, err_msg));
1072        }
1073        Ok(isl_rs_result)
1074    }
1075
1076    /// Wraps `isl_pw_qpolynomial_fold_subtract_domain`.
1077    pub fn subtract_domain(self, set: Set) -> Result<PwQPolynomialFold, LibISLError> {
1078        let pwf = self;
1079        let isl_rs_ctx = pwf.get_ctx();
1080        let mut pwf = pwf;
1081        pwf.do_not_free_on_drop();
1082        let pwf = pwf.ptr;
1083        let mut set = set;
1084        set.do_not_free_on_drop();
1085        let set = set.ptr;
1086        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_subtract_domain(pwf, set) };
1087        let isl_rs_result = PwQPolynomialFold { ptr: isl_rs_result,
1088                                                should_free_on_drop: true };
1089        let err = isl_rs_ctx.last_error();
1090        if err != Error::None_ {
1091            let err_msg = isl_rs_ctx.last_error_msg();
1092            isl_rs_ctx.reset_error();
1093            return Err(LibISLError::new(err, err_msg));
1094        }
1095        Ok(isl_rs_result)
1096    }
1097
1098    /// Wraps `isl_pw_qpolynomial_fold_to_list`.
1099    pub fn to_list(self) -> Result<PwQPolynomialFoldList, LibISLError> {
1100        let el = self;
1101        let isl_rs_ctx = el.get_ctx();
1102        let mut el = el;
1103        el.do_not_free_on_drop();
1104        let el = el.ptr;
1105        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_to_list(el) };
1106        let isl_rs_result = PwQPolynomialFoldList { ptr: isl_rs_result,
1107                                                    should_free_on_drop: true };
1108        let err = isl_rs_ctx.last_error();
1109        if err != Error::None_ {
1110            let err_msg = isl_rs_ctx.last_error_msg();
1111            isl_rs_ctx.reset_error();
1112            return Err(LibISLError::new(err, err_msg));
1113        }
1114        Ok(isl_rs_result)
1115    }
1116
1117    /// Wraps `isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold`.
1118    pub fn to_union_pw_qpolynomial_fold(self) -> Result<UnionPwQPolynomialFold, LibISLError> {
1119        let pwf = self;
1120        let isl_rs_ctx = pwf.get_ctx();
1121        let mut pwf = pwf;
1122        pwf.do_not_free_on_drop();
1123        let pwf = pwf.ptr;
1124        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(pwf) };
1125        let isl_rs_result = UnionPwQPolynomialFold { ptr: isl_rs_result,
1126                                                     should_free_on_drop: true };
1127        let err = isl_rs_ctx.last_error();
1128        if err != Error::None_ {
1129            let err_msg = isl_rs_ctx.last_error_msg();
1130            isl_rs_ctx.reset_error();
1131            return Err(LibISLError::new(err, err_msg));
1132        }
1133        Ok(isl_rs_result)
1134    }
1135
1136    /// Wraps `isl_pw_qpolynomial_fold_zero`.
1137    pub fn zero(space: Space, type_: Fold) -> Result<PwQPolynomialFold, LibISLError> {
1138        let isl_rs_ctx = space.get_ctx();
1139        let mut space = space;
1140        space.do_not_free_on_drop();
1141        let space = space.ptr;
1142        let type_ = type_.to_i32();
1143        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_zero(space, type_) };
1144        let isl_rs_result = PwQPolynomialFold { 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    /// Does not call isl_pw_qpolynomial_fold_free() on being dropped. (For
1156    /// internal use only.)
1157    pub fn do_not_free_on_drop(&mut self) {
1158        self.should_free_on_drop = false;
1159    }
1160}
1161
1162impl Drop for PwQPolynomialFold {
1163    fn drop(&mut self) {
1164        if self.should_free_on_drop {
1165            unsafe {
1166                isl_pw_qpolynomial_fold_free(self.ptr);
1167            }
1168        }
1169    }
1170}
isl_rs/bindings/pw_qpolynomial_fold.rs

isl_rs/bindings/
pw_qpolynomial_fold.rs
