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            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
71        }
72        Ok(isl_rs_result)
73    }
74
75    /// Wraps `isl_qpolynomial_fold_copy`.
76    pub fn copy(&self) -> Result<QPolynomialFold, LibISLError> {
77        let fold = self;
78        let isl_rs_ctx = fold.get_ctx();
79        let fold = fold.ptr;
80        let isl_rs_result = unsafe { isl_qpolynomial_fold_copy(fold) };
81        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
82                                              should_free_on_drop: true };
83        let err = isl_rs_ctx.last_error();
84        if err != Error::None_ {
85            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
86        }
87        Ok(isl_rs_result)
88    }
89
90    /// Wraps `isl_qpolynomial_fold_dump`.
91    pub fn dump(&self) -> Result<(), LibISLError> {
92        let fold = self;
93        let isl_rs_ctx = fold.get_ctx();
94        let fold = fold.ptr;
95        let isl_rs_result = unsafe { isl_qpolynomial_fold_dump(fold) };
96        let err = isl_rs_ctx.last_error();
97        if err != Error::None_ {
98            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
99        }
100        Ok(isl_rs_result)
101    }
102
103    /// Wraps `isl_qpolynomial_fold_empty`.
104    pub fn empty(type_: Fold, space: Space) -> Result<QPolynomialFold, LibISLError> {
105        let isl_rs_ctx = space.get_ctx();
106        let type_ = type_.to_i32();
107        let mut space = space;
108        space.do_not_free_on_drop();
109        let space = space.ptr;
110        let isl_rs_result = unsafe { isl_qpolynomial_fold_empty(type_, space) };
111        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
112                                              should_free_on_drop: true };
113        let err = isl_rs_ctx.last_error();
114        if err != Error::None_ {
115            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
116        }
117        Ok(isl_rs_result)
118    }
119
120    /// Wraps `isl_qpolynomial_fold_eval`.
121    pub fn eval(self, pnt: Point) -> Result<Val, LibISLError> {
122        let fold = self;
123        let isl_rs_ctx = fold.get_ctx();
124        let mut fold = fold;
125        fold.do_not_free_on_drop();
126        let fold = fold.ptr;
127        let mut pnt = pnt;
128        pnt.do_not_free_on_drop();
129        let pnt = pnt.ptr;
130        let isl_rs_result = unsafe { isl_qpolynomial_fold_eval(fold, pnt) };
131        let isl_rs_result = Val { ptr: isl_rs_result,
132                                  should_free_on_drop: true };
133        let err = isl_rs_ctx.last_error();
134        if err != Error::None_ {
135            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
136        }
137        Ok(isl_rs_result)
138    }
139
140    /// Wraps `isl_qpolynomial_fold_fold`.
141    pub fn fold(self, fold2: QPolynomialFold) -> Result<QPolynomialFold, LibISLError> {
142        let fold1 = self;
143        let isl_rs_ctx = fold1.get_ctx();
144        let mut fold1 = fold1;
145        fold1.do_not_free_on_drop();
146        let fold1 = fold1.ptr;
147        let mut fold2 = fold2;
148        fold2.do_not_free_on_drop();
149        let fold2 = fold2.ptr;
150        let isl_rs_result = unsafe { isl_qpolynomial_fold_fold(fold1, fold2) };
151        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
152                                              should_free_on_drop: true };
153        let err = isl_rs_ctx.last_error();
154        if err != Error::None_ {
155            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
156        }
157        Ok(isl_rs_result)
158    }
159
160    /// Wraps `isl_qpolynomial_fold_free`.
161    pub fn free(self) -> Result<QPolynomialFold, LibISLError> {
162        let fold = self;
163        let isl_rs_ctx = fold.get_ctx();
164        let mut fold = fold;
165        fold.do_not_free_on_drop();
166        let fold = fold.ptr;
167        let isl_rs_result = unsafe { isl_qpolynomial_fold_free(fold) };
168        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
169                                              should_free_on_drop: true };
170        let err = isl_rs_ctx.last_error();
171        if err != Error::None_ {
172            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
173        }
174        Ok(isl_rs_result)
175    }
176
177    /// Wraps `isl_qpolynomial_fold_get_ctx`.
178    pub fn get_ctx(&self) -> Context {
179        let fold = self;
180        let fold = fold.ptr;
181        let isl_rs_result = unsafe { isl_qpolynomial_fold_get_ctx(fold) };
182        let isl_rs_result = Context { ptr: isl_rs_result,
183                                      should_free_on_drop: false };
184        isl_rs_result
185    }
186
187    /// Wraps `isl_qpolynomial_fold_get_domain_space`.
188    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
189        let fold = self;
190        let isl_rs_ctx = fold.get_ctx();
191        let fold = fold.ptr;
192        let isl_rs_result = unsafe { isl_qpolynomial_fold_get_domain_space(fold) };
193        let isl_rs_result = Space { ptr: isl_rs_result,
194                                    should_free_on_drop: true };
195        let err = isl_rs_ctx.last_error();
196        if err != Error::None_ {
197            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
198        }
199        Ok(isl_rs_result)
200    }
201
202    /// Wraps `isl_qpolynomial_fold_get_space`.
203    pub fn get_space(&self) -> Result<Space, LibISLError> {
204        let fold = self;
205        let isl_rs_ctx = fold.get_ctx();
206        let fold = fold.ptr;
207        let isl_rs_result = unsafe { isl_qpolynomial_fold_get_space(fold) };
208        let isl_rs_result = Space { ptr: isl_rs_result,
209                                    should_free_on_drop: true };
210        let err = isl_rs_ctx.last_error();
211        if err != Error::None_ {
212            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
213        }
214        Ok(isl_rs_result)
215    }
216
217    /// Wraps `isl_qpolynomial_fold_get_type`.
218    pub fn get_type(&self) -> Result<Fold, LibISLError> {
219        let fold = self;
220        let isl_rs_ctx = fold.get_ctx();
221        let fold = fold.ptr;
222        let isl_rs_result = unsafe { isl_qpolynomial_fold_get_type(fold) };
223        let isl_rs_result = Fold::from_i32(isl_rs_result);
224        let err = isl_rs_ctx.last_error();
225        if err != Error::None_ {
226            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
227        }
228        Ok(isl_rs_result)
229    }
230
231    /// Wraps `isl_qpolynomial_fold_gist`.
232    pub fn gist(self, context: Set) -> Result<QPolynomialFold, LibISLError> {
233        let fold = self;
234        let isl_rs_ctx = fold.get_ctx();
235        let mut fold = fold;
236        fold.do_not_free_on_drop();
237        let fold = fold.ptr;
238        let mut context = context;
239        context.do_not_free_on_drop();
240        let context = context.ptr;
241        let isl_rs_result = unsafe { isl_qpolynomial_fold_gist(fold, context) };
242        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
243                                              should_free_on_drop: true };
244        let err = isl_rs_ctx.last_error();
245        if err != Error::None_ {
246            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
247        }
248        Ok(isl_rs_result)
249    }
250
251    /// Wraps `isl_qpolynomial_fold_gist_params`.
252    pub fn gist_params(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_params(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            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
267        }
268        Ok(isl_rs_result)
269    }
270
271    /// Wraps `isl_qpolynomial_fold_is_empty`.
272    pub fn is_empty(&self) -> Result<bool, LibISLError> {
273        let fold = self;
274        let isl_rs_ctx = fold.get_ctx();
275        let fold = fold.ptr;
276        let isl_rs_result = unsafe { isl_qpolynomial_fold_is_empty(fold) };
277        let isl_rs_result = match isl_rs_result {
278            0 => false,
279            1 => true,
280            _ => panic!("Got isl_bool = -1"),
281        };
282        let err = isl_rs_ctx.last_error();
283        if err != Error::None_ {
284            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
285        }
286        Ok(isl_rs_result)
287    }
288
289    /// Wraps `isl_qpolynomial_fold_is_nan`.
290    pub fn is_nan(&self) -> Result<bool, LibISLError> {
291        let fold = self;
292        let isl_rs_ctx = fold.get_ctx();
293        let fold = fold.ptr;
294        let isl_rs_result = unsafe { isl_qpolynomial_fold_is_nan(fold) };
295        let isl_rs_result = match isl_rs_result {
296            0 => false,
297            1 => true,
298            _ => panic!("Got isl_bool = -1"),
299        };
300        let err = isl_rs_ctx.last_error();
301        if err != Error::None_ {
302            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
303        }
304        Ok(isl_rs_result)
305    }
306
307    /// Wraps `isl_qpolynomial_fold_move_dims`.
308    pub fn move_dims(self, dst_type: DimType, dst_pos: u32, src_type: DimType, src_pos: u32,
309                     n: u32)
310                     -> Result<QPolynomialFold, LibISLError> {
311        let fold = self;
312        let isl_rs_ctx = fold.get_ctx();
313        let mut fold = fold;
314        fold.do_not_free_on_drop();
315        let fold = fold.ptr;
316        let dst_type = dst_type.to_i32();
317        let src_type = src_type.to_i32();
318        let isl_rs_result = unsafe {
319            isl_qpolynomial_fold_move_dims(fold, dst_type, dst_pos, src_type, src_pos, n)
320        };
321        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
322                                              should_free_on_drop: true };
323        let err = isl_rs_ctx.last_error();
324        if err != Error::None_ {
325            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
326        }
327        Ok(isl_rs_result)
328    }
329
330    /// Wraps `isl_qpolynomial_fold_plain_is_equal`.
331    pub fn plain_is_equal(&self, fold2: &QPolynomialFold) -> Result<bool, LibISLError> {
332        let fold1 = self;
333        let isl_rs_ctx = fold1.get_ctx();
334        let fold1 = fold1.ptr;
335        let fold2 = fold2.ptr;
336        let isl_rs_result = unsafe { isl_qpolynomial_fold_plain_is_equal(fold1, fold2) };
337        let isl_rs_result = match isl_rs_result {
338            0 => false,
339            1 => true,
340            _ => panic!("Got isl_bool = -1"),
341        };
342        let err = isl_rs_ctx.last_error();
343        if err != Error::None_ {
344            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
345        }
346        Ok(isl_rs_result)
347    }
348
349    /// Wraps `isl_qpolynomial_fold_scale_down_val`.
350    pub fn scale_down_val(self, v: Val) -> Result<QPolynomialFold, LibISLError> {
351        let fold = self;
352        let isl_rs_ctx = fold.get_ctx();
353        let mut fold = fold;
354        fold.do_not_free_on_drop();
355        let fold = fold.ptr;
356        let mut v = v;
357        v.do_not_free_on_drop();
358        let v = v.ptr;
359        let isl_rs_result = unsafe { isl_qpolynomial_fold_scale_down_val(fold, v) };
360        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
361                                              should_free_on_drop: true };
362        let err = isl_rs_ctx.last_error();
363        if err != Error::None_ {
364            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
365        }
366        Ok(isl_rs_result)
367    }
368
369    /// Wraps `isl_qpolynomial_fold_scale_val`.
370    pub fn scale_val(self, v: Val) -> Result<QPolynomialFold, LibISLError> {
371        let fold = self;
372        let isl_rs_ctx = fold.get_ctx();
373        let mut fold = fold;
374        fold.do_not_free_on_drop();
375        let fold = fold.ptr;
376        let mut v = v;
377        v.do_not_free_on_drop();
378        let v = v.ptr;
379        let isl_rs_result = unsafe { isl_qpolynomial_fold_scale_val(fold, v) };
380        let isl_rs_result = QPolynomialFold { ptr: isl_rs_result,
381                                              should_free_on_drop: true };
382        let err = isl_rs_ctx.last_error();
383        if err != Error::None_ {
384            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
385        }
386        Ok(isl_rs_result)
387    }
388
389    /// Does not call isl_qpolynomial_fold_free() on being dropped. (For
390    /// internal use only.)
391    pub fn do_not_free_on_drop(&mut self) {
392        self.should_free_on_drop = false;
393    }
394}
395
396impl Drop for QPolynomialFold {
397    fn drop(&mut self) {
398        if self.should_free_on_drop {
399            unsafe {
400                isl_qpolynomial_fold_free(self.ptr);
401            }
402        }
403    }
404}
isl_rs/bindings/qpolynomial_fold.rs

isl_rs/bindings/
qpolynomial_fold.rs
