isl_rs/bindings/
qpolynomial_fold.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Context, DimType, Error, Fold, LibISLError, Point, QPolynomial, Set, Space, Val};
5use libc::uintptr_t;
6
7/// Wraps `isl_qpolynomial_fold`.
8pub struct QPolynomialFold {
9    pub ptr: uintptr_t,
10    pub should_free_on_drop: bool,
11}
12
13extern "C" {
14
15    fn isl_qpolynomial_fold_alloc(type_: i32, qp: uintptr_t) -> uintptr_t;
16
17    fn isl_qpolynomial_fold_copy(fold: uintptr_t) -> uintptr_t;
18
19    fn isl_qpolynomial_fold_dump(fold: uintptr_t) -> ();
20
21    fn isl_qpolynomial_fold_empty(type_: i32, space: uintptr_t) -> uintptr_t;
22
23    fn isl_qpolynomial_fold_eval(fold: uintptr_t, pnt: uintptr_t) -> uintptr_t;
24
25    fn isl_qpolynomial_fold_fold(fold1: uintptr_t, fold2: uintptr_t) -> uintptr_t;
26
27    fn isl_qpolynomial_fold_free(fold: uintptr_t) -> uintptr_t;
28
29    fn isl_qpolynomial_fold_get_ctx(fold: uintptr_t) -> uintptr_t;
30
31    fn isl_qpolynomial_fold_get_domain_space(fold: uintptr_t) -> uintptr_t;
32
33    fn isl_qpolynomial_fold_get_space(fold: uintptr_t) -> uintptr_t;
34
35    fn isl_qpolynomial_fold_get_type(fold: uintptr_t) -> i32;
36
37    fn isl_qpolynomial_fold_gist(fold: uintptr_t, context: uintptr_t) -> uintptr_t;
38
39    fn isl_qpolynomial_fold_gist_params(fold: uintptr_t, context: uintptr_t) -> uintptr_t;
40
41    fn isl_qpolynomial_fold_is_empty(fold: uintptr_t) -> i32;
42
43    fn isl_qpolynomial_fold_is_nan(fold: uintptr_t) -> i32;
44
45    fn isl_qpolynomial_fold_move_dims(fold: uintptr_t, dst_type: i32, dst_pos: u32, src_type: i32,
46                                      src_pos: u32, n: u32)
47                                      -> uintptr_t;
48
49    fn isl_qpolynomial_fold_plain_is_equal(fold1: uintptr_t, fold2: uintptr_t) -> i32;
50
51    fn isl_qpolynomial_fold_scale_down_val(fold: uintptr_t, v: uintptr_t) -> uintptr_t;
52
53    fn isl_qpolynomial_fold_scale_val(fold: uintptr_t, v: uintptr_t) -> uintptr_t;
54
55}
56
57impl QPolynomialFold {
58    /// Wraps `isl_qpolynomial_fold_alloc`.
59    pub fn alloc(type_: Fold, qp: QPolynomial) -> Result<QPolynomialFold, LibISLError> {
60        let isl_rs_ctx = qp.get_ctx();
61        let type_ = type_.to_i32();
62        let mut qp = qp;
63        qp.do_not_free_on_drop();
64        let qp = qp.ptr;
65        let isl_rs_result = unsafe { isl_qpolynomial_fold_alloc(type_, qp) };
66        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
67                                              should_free_on_drop: true };
68        let err = isl_rs_ctx.last_error();
69        if err != Error::None_ {
70            let err_msg = isl_rs_ctx.last_error_msg();
71            isl_rs_ctx.reset_error();
72            return Err(LibISLError::new(err, err_msg));
73        }
74        Ok(isl_rs_result)
75    }
76
77    /// Wraps `isl_qpolynomial_fold_copy`.
78    pub fn copy(&self) -> Result<QPolynomialFold, LibISLError> {
79        let fold = self;
80        let isl_rs_ctx = fold.get_ctx();
81        let fold = fold.ptr;
82        let isl_rs_result = unsafe { isl_qpolynomial_fold_copy(fold) };
83        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
84                                              should_free_on_drop: true };
85        let err = isl_rs_ctx.last_error();
86        if err != Error::None_ {
87            let err_msg = isl_rs_ctx.last_error_msg();
88            isl_rs_ctx.reset_error();
89            return Err(LibISLError::new(err, err_msg));
90        }
91        Ok(isl_rs_result)
92    }
93
94    /// Wraps `isl_qpolynomial_fold_dump`.
95    pub fn dump(&self) -> Result<(), LibISLError> {
96        let fold = self;
97        let isl_rs_ctx = fold.get_ctx();
98        let fold = fold.ptr;
99        let isl_rs_result = unsafe { isl_qpolynomial_fold_dump(fold) };
100        let err = isl_rs_ctx.last_error();
101        if err != Error::None_ {
102            let err_msg = isl_rs_ctx.last_error_msg();
103            isl_rs_ctx.reset_error();
104            return Err(LibISLError::new(err, err_msg));
105        }
106        Ok(isl_rs_result)
107    }
108
109    /// Wraps `isl_qpolynomial_fold_empty`.
110    pub fn empty(type_: Fold, space: Space) -> Result<QPolynomialFold, LibISLError> {
111        let isl_rs_ctx = space.get_ctx();
112        let type_ = type_.to_i32();
113        let mut space = space;
114        space.do_not_free_on_drop();
115        let space = space.ptr;
116        let isl_rs_result = unsafe { isl_qpolynomial_fold_empty(type_, space) };
117        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
118                                              should_free_on_drop: true };
119        let err = isl_rs_ctx.last_error();
120        if err != Error::None_ {
121            let err_msg = isl_rs_ctx.last_error_msg();
122            isl_rs_ctx.reset_error();
123            return Err(LibISLError::new(err, err_msg));
124        }
125        Ok(isl_rs_result)
126    }
127
128    /// Wraps `isl_qpolynomial_fold_eval`.
129    pub fn eval(self, pnt: Point) -> Result<Val, LibISLError> {
130        let fold = self;
131        let isl_rs_ctx = fold.get_ctx();
132        let mut fold = fold;
133        fold.do_not_free_on_drop();
134        let fold = fold.ptr;
135        let mut pnt = pnt;
136        pnt.do_not_free_on_drop();
137        let pnt = pnt.ptr;
138        let isl_rs_result = unsafe { isl_qpolynomial_fold_eval(fold, pnt) };
139        let isl_rs_result = Val { ptr: isl_rs_result,
140                                  should_free_on_drop: true };
141        let err = isl_rs_ctx.last_error();
142        if err != Error::None_ {
143            let err_msg = isl_rs_ctx.last_error_msg();
144            isl_rs_ctx.reset_error();
145            return Err(LibISLError::new(err, err_msg));
146        }
147        Ok(isl_rs_result)
148    }
149
150    /// Wraps `isl_qpolynomial_fold_fold`.
151    pub fn fold(self, fold2: QPolynomialFold) -> Result<QPolynomialFold, LibISLError> {
152        let fold1 = self;
153        let isl_rs_ctx = fold1.get_ctx();
154        let mut fold1 = fold1;
155        fold1.do_not_free_on_drop();
156        let fold1 = fold1.ptr;
157        let mut fold2 = fold2;
158        fold2.do_not_free_on_drop();
159        let fold2 = fold2.ptr;
160        let isl_rs_result = unsafe { isl_qpolynomial_fold_fold(fold1, fold2) };
161        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
162                                              should_free_on_drop: true };
163        let err = isl_rs_ctx.last_error();
164        if err != Error::None_ {
165            let err_msg = isl_rs_ctx.last_error_msg();
166            isl_rs_ctx.reset_error();
167            return Err(LibISLError::new(err, err_msg));
168        }
169        Ok(isl_rs_result)
170    }
171
172    /// Wraps `isl_qpolynomial_fold_free`.
173    pub fn free(self) -> Result<QPolynomialFold, LibISLError> {
174        let fold = self;
175        let isl_rs_ctx = fold.get_ctx();
176        let mut fold = fold;
177        fold.do_not_free_on_drop();
178        let fold = fold.ptr;
179        let isl_rs_result = unsafe { isl_qpolynomial_fold_free(fold) };
180        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
181                                              should_free_on_drop: true };
182        let err = isl_rs_ctx.last_error();
183        if err != Error::None_ {
184            let err_msg = isl_rs_ctx.last_error_msg();
185            isl_rs_ctx.reset_error();
186            return Err(LibISLError::new(err, err_msg));
187        }
188        Ok(isl_rs_result)
189    }
190
191    /// Wraps `isl_qpolynomial_fold_get_ctx`.
192    pub fn get_ctx(&self) -> Context {
193        let fold = self;
194        let fold = fold.ptr;
195        let isl_rs_result = unsafe { isl_qpolynomial_fold_get_ctx(fold) };
196        let isl_rs_result = Context { ptr: isl_rs_result,
197                                      should_free_on_drop: false };
198        isl_rs_result
199    }
200
201    /// Wraps `isl_qpolynomial_fold_get_domain_space`.
202    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
203        let fold = self;
204        let isl_rs_ctx = fold.get_ctx();
205        let fold = fold.ptr;
206        let isl_rs_result = unsafe { isl_qpolynomial_fold_get_domain_space(fold) };
207        let isl_rs_result = Space { 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_qpolynomial_fold_get_space`.
219    pub fn get_space(&self) -> Result<Space, LibISLError> {
220        let fold = self;
221        let isl_rs_ctx = fold.get_ctx();
222        let fold = fold.ptr;
223        let isl_rs_result = unsafe { isl_qpolynomial_fold_get_space(fold) };
224        let isl_rs_result = Space { ptr: isl_rs_result,
225                                    should_free_on_drop: true };
226        let err = isl_rs_ctx.last_error();
227        if err != Error::None_ {
228            let err_msg = isl_rs_ctx.last_error_msg();
229            isl_rs_ctx.reset_error();
230            return Err(LibISLError::new(err, err_msg));
231        }
232        Ok(isl_rs_result)
233    }
234
235    /// Wraps `isl_qpolynomial_fold_get_type`.
236    pub fn get_type(&self) -> Result<Fold, LibISLError> {
237        let fold = self;
238        let isl_rs_ctx = fold.get_ctx();
239        let fold = fold.ptr;
240        let isl_rs_result = unsafe { isl_qpolynomial_fold_get_type(fold) };
241        let isl_rs_result = Fold::from_i32(isl_rs_result);
242        let err = isl_rs_ctx.last_error();
243        if err != Error::None_ {
244            let err_msg = isl_rs_ctx.last_error_msg();
245            isl_rs_ctx.reset_error();
246            return Err(LibISLError::new(err, err_msg));
247        }
248        Ok(isl_rs_result)
249    }
250
251    /// Wraps `isl_qpolynomial_fold_gist`.
252    pub fn gist(self, context: Set) -> Result<QPolynomialFold, LibISLError> {
253        let fold = self;
254        let isl_rs_ctx = fold.get_ctx();
255        let mut fold = fold;
256        fold.do_not_free_on_drop();
257        let fold = fold.ptr;
258        let mut context = context;
259        context.do_not_free_on_drop();
260        let context = context.ptr;
261        let isl_rs_result = unsafe { isl_qpolynomial_fold_gist(fold, context) };
262        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
263                                              should_free_on_drop: true };
264        let err = isl_rs_ctx.last_error();
265        if err != Error::None_ {
266            let err_msg = isl_rs_ctx.last_error_msg();
267            isl_rs_ctx.reset_error();
268            return Err(LibISLError::new(err, err_msg));
269        }
270        Ok(isl_rs_result)
271    }
272
273    /// Wraps `isl_qpolynomial_fold_gist_params`.
274    pub fn gist_params(self, context: Set) -> Result<QPolynomialFold, LibISLError> {
275        let fold = self;
276        let isl_rs_ctx = fold.get_ctx();
277        let mut fold = fold;
278        fold.do_not_free_on_drop();
279        let fold = fold.ptr;
280        let mut context = context;
281        context.do_not_free_on_drop();
282        let context = context.ptr;
283        let isl_rs_result = unsafe { isl_qpolynomial_fold_gist_params(fold, context) };
284        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
285                                              should_free_on_drop: true };
286        let err = isl_rs_ctx.last_error();
287        if err != Error::None_ {
288            let err_msg = isl_rs_ctx.last_error_msg();
289            isl_rs_ctx.reset_error();
290            return Err(LibISLError::new(err, err_msg));
291        }
292        Ok(isl_rs_result)
293    }
294
295    /// Wraps `isl_qpolynomial_fold_is_empty`.
296    pub fn is_empty(&self) -> Result<bool, LibISLError> {
297        let fold = self;
298        let isl_rs_ctx = fold.get_ctx();
299        let fold = fold.ptr;
300        let isl_rs_result = unsafe { isl_qpolynomial_fold_is_empty(fold) };
301        let isl_rs_result = match isl_rs_result {
302            0 => false,
303            1 => true,
304            _ => {
305                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
306            }
307        };
308        let err = isl_rs_ctx.last_error();
309        if err != Error::None_ {
310            let err_msg = isl_rs_ctx.last_error_msg();
311            isl_rs_ctx.reset_error();
312            return Err(LibISLError::new(err, err_msg));
313        }
314        Ok(isl_rs_result)
315    }
316
317    /// Wraps `isl_qpolynomial_fold_is_nan`.
318    pub fn is_nan(&self) -> Result<bool, LibISLError> {
319        let fold = self;
320        let isl_rs_ctx = fold.get_ctx();
321        let fold = fold.ptr;
322        let isl_rs_result = unsafe { isl_qpolynomial_fold_is_nan(fold) };
323        let isl_rs_result = match isl_rs_result {
324            0 => false,
325            1 => true,
326            _ => {
327                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
328            }
329        };
330        let err = isl_rs_ctx.last_error();
331        if err != Error::None_ {
332            let err_msg = isl_rs_ctx.last_error_msg();
333            isl_rs_ctx.reset_error();
334            return Err(LibISLError::new(err, err_msg));
335        }
336        Ok(isl_rs_result)
337    }
338
339    /// Wraps `isl_qpolynomial_fold_move_dims`.
340    pub fn move_dims(self, dst_type: DimType, dst_pos: u32, src_type: DimType, src_pos: u32,
341                     n: u32)
342                     -> Result<QPolynomialFold, LibISLError> {
343        let fold = self;
344        let isl_rs_ctx = fold.get_ctx();
345        let mut fold = fold;
346        fold.do_not_free_on_drop();
347        let fold = fold.ptr;
348        let dst_type = dst_type.to_i32();
349        let src_type = src_type.to_i32();
350        let isl_rs_result = unsafe {
351            isl_qpolynomial_fold_move_dims(fold, dst_type, dst_pos, src_type, src_pos, n)
352        };
353        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
354                                              should_free_on_drop: true };
355        let err = isl_rs_ctx.last_error();
356        if err != Error::None_ {
357            let err_msg = isl_rs_ctx.last_error_msg();
358            isl_rs_ctx.reset_error();
359            return Err(LibISLError::new(err, err_msg));
360        }
361        Ok(isl_rs_result)
362    }
363
364    /// Wraps `isl_qpolynomial_fold_plain_is_equal`.
365    pub fn plain_is_equal(&self, fold2: &QPolynomialFold) -> Result<bool, LibISLError> {
366        let fold1 = self;
367        let isl_rs_ctx = fold1.get_ctx();
368        let fold1 = fold1.ptr;
369        let fold2 = fold2.ptr;
370        let isl_rs_result = unsafe { isl_qpolynomial_fold_plain_is_equal(fold1, fold2) };
371        let isl_rs_result = match isl_rs_result {
372            0 => false,
373            1 => true,
374            _ => {
375                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
376            }
377        };
378        let err = isl_rs_ctx.last_error();
379        if err != Error::None_ {
380            let err_msg = isl_rs_ctx.last_error_msg();
381            isl_rs_ctx.reset_error();
382            return Err(LibISLError::new(err, err_msg));
383        }
384        Ok(isl_rs_result)
385    }
386
387    /// Wraps `isl_qpolynomial_fold_scale_down_val`.
388    pub fn scale_down_val(self, v: Val) -> Result<QPolynomialFold, LibISLError> {
389        let fold = self;
390        let isl_rs_ctx = fold.get_ctx();
391        let mut fold = fold;
392        fold.do_not_free_on_drop();
393        let fold = fold.ptr;
394        let mut v = v;
395        v.do_not_free_on_drop();
396        let v = v.ptr;
397        let isl_rs_result = unsafe { isl_qpolynomial_fold_scale_down_val(fold, v) };
398        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
399                                              should_free_on_drop: true };
400        let err = isl_rs_ctx.last_error();
401        if err != Error::None_ {
402            let err_msg = isl_rs_ctx.last_error_msg();
403            isl_rs_ctx.reset_error();
404            return Err(LibISLError::new(err, err_msg));
405        }
406        Ok(isl_rs_result)
407    }
408
409    /// Wraps `isl_qpolynomial_fold_scale_val`.
410    pub fn scale_val(self, v: Val) -> Result<QPolynomialFold, LibISLError> {
411        let fold = self;
412        let isl_rs_ctx = fold.get_ctx();
413        let mut fold = fold;
414        fold.do_not_free_on_drop();
415        let fold = fold.ptr;
416        let mut v = v;
417        v.do_not_free_on_drop();
418        let v = v.ptr;
419        let isl_rs_result = unsafe { isl_qpolynomial_fold_scale_val(fold, v) };
420        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
421                                              should_free_on_drop: true };
422        let err = isl_rs_ctx.last_error();
423        if err != Error::None_ {
424            let err_msg = isl_rs_ctx.last_error_msg();
425            isl_rs_ctx.reset_error();
426            return Err(LibISLError::new(err, err_msg));
427        }
428        Ok(isl_rs_result)
429    }
430
431    /// Does not call isl_qpolynomial_fold_free() on being dropped. (For
432    /// internal use only.)
433    pub fn do_not_free_on_drop(&mut self) {
434        self.should_free_on_drop = false;
435    }
436}
437
438impl Drop for QPolynomialFold {
439    fn drop(&mut self) {
440        if self.should_free_on_drop {
441            unsafe {
442                isl_qpolynomial_fold_free(self.ptr);
443            }
444        }
445    }
446}
isl_rs/bindings/qpolynomial_fold.rs

isl_rs/bindings/
qpolynomial_fold.rs
