isl_rs/bindings/
qpolynomial_list.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Context, Error, LibISLError, QPolynomial};
5use libc::uintptr_t;
6use std::ffi::CStr;
7use std::os::raw::c_char;
8
9/// Wraps `isl_qpolynomial_list`.
10pub struct QPolynomialList {
11    pub ptr: uintptr_t,
12    pub should_free_on_drop: bool,
13}
14
15extern "C" {
16
17    fn isl_qpolynomial_list_add(list: uintptr_t, el: uintptr_t) -> uintptr_t;
18
19    fn isl_qpolynomial_list_alloc(ctx: uintptr_t, n: i32) -> uintptr_t;
20
21    fn isl_qpolynomial_list_clear(list: uintptr_t) -> uintptr_t;
22
23    fn isl_qpolynomial_list_concat(list1: uintptr_t, list2: uintptr_t) -> uintptr_t;
24
25    fn isl_qpolynomial_list_copy(list: uintptr_t) -> uintptr_t;
26
27    fn isl_qpolynomial_list_drop(list: uintptr_t, first: u32, n: u32) -> uintptr_t;
28
29    fn isl_qpolynomial_list_dump(list: uintptr_t) -> ();
30
31    fn isl_qpolynomial_list_free(list: uintptr_t) -> uintptr_t;
32
33    fn isl_qpolynomial_list_from_qpolynomial(el: uintptr_t) -> uintptr_t;
34
35    fn isl_qpolynomial_list_get_at(list: uintptr_t, index: i32) -> uintptr_t;
36
37    fn isl_qpolynomial_list_get_ctx(list: uintptr_t) -> uintptr_t;
38
39    fn isl_qpolynomial_list_get_qpolynomial(list: uintptr_t, index: i32) -> uintptr_t;
40
41    fn isl_qpolynomial_list_insert(list: uintptr_t, pos: u32, el: uintptr_t) -> uintptr_t;
42
43    fn isl_qpolynomial_list_n_qpolynomial(list: uintptr_t) -> i32;
44
45    fn isl_qpolynomial_list_reverse(list: uintptr_t) -> uintptr_t;
46
47    fn isl_qpolynomial_list_set_at(list: uintptr_t, index: i32, el: uintptr_t) -> uintptr_t;
48
49    fn isl_qpolynomial_list_set_qpolynomial(list: uintptr_t, index: i32, el: uintptr_t)
50                                            -> uintptr_t;
51
52    fn isl_qpolynomial_list_size(list: uintptr_t) -> i32;
53
54    fn isl_qpolynomial_list_swap(list: uintptr_t, pos1: u32, pos2: u32) -> uintptr_t;
55
56    fn isl_qpolynomial_list_to_str(list: uintptr_t) -> *const c_char;
57
58}
59
60impl QPolynomialList {
61    /// Wraps `isl_qpolynomial_list_add`.
62    pub fn add(self, el: QPolynomial) -> Result<QPolynomialList, LibISLError> {
63        let list = self;
64        let isl_rs_ctx = list.get_ctx();
65        let mut list = list;
66        list.do_not_free_on_drop();
67        let list = list.ptr;
68        let mut el = el;
69        el.do_not_free_on_drop();
70        let el = el.ptr;
71        let isl_rs_result = unsafe { isl_qpolynomial_list_add(list, el) };
72        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
73                                              should_free_on_drop: true };
74        let err = isl_rs_ctx.last_error();
75        if err != Error::None_ {
76            let err_msg = isl_rs_ctx.last_error_msg();
77            isl_rs_ctx.reset_error();
78            return Err(LibISLError::new(err, err_msg));
79        }
80        Ok(isl_rs_result)
81    }
82
83    /// Wraps `isl_qpolynomial_list_alloc`.
84    pub fn alloc(ctx: &Context, n: i32) -> Result<QPolynomialList, LibISLError> {
85        let isl_rs_ctx = Context { ptr: ctx.ptr,
86                                   should_free_on_drop: false };
87        let ctx = ctx.ptr;
88        let isl_rs_result = unsafe { isl_qpolynomial_list_alloc(ctx, n) };
89        let isl_rs_result = QPolynomialList { 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_qpolynomial_list_clear`.
101    pub fn clear(self) -> Result<QPolynomialList, LibISLError> {
102        let list = self;
103        let isl_rs_ctx = list.get_ctx();
104        let mut list = list;
105        list.do_not_free_on_drop();
106        let list = list.ptr;
107        let isl_rs_result = unsafe { isl_qpolynomial_list_clear(list) };
108        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
109                                              should_free_on_drop: true };
110        let err = isl_rs_ctx.last_error();
111        if err != Error::None_ {
112            let err_msg = isl_rs_ctx.last_error_msg();
113            isl_rs_ctx.reset_error();
114            return Err(LibISLError::new(err, err_msg));
115        }
116        Ok(isl_rs_result)
117    }
118
119    /// Wraps `isl_qpolynomial_list_concat`.
120    pub fn concat(self, list2: QPolynomialList) -> Result<QPolynomialList, LibISLError> {
121        let list1 = self;
122        let isl_rs_ctx = list1.get_ctx();
123        let mut list1 = list1;
124        list1.do_not_free_on_drop();
125        let list1 = list1.ptr;
126        let mut list2 = list2;
127        list2.do_not_free_on_drop();
128        let list2 = list2.ptr;
129        let isl_rs_result = unsafe { isl_qpolynomial_list_concat(list1, list2) };
130        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
131                                              should_free_on_drop: true };
132        let err = isl_rs_ctx.last_error();
133        if err != Error::None_ {
134            let err_msg = isl_rs_ctx.last_error_msg();
135            isl_rs_ctx.reset_error();
136            return Err(LibISLError::new(err, err_msg));
137        }
138        Ok(isl_rs_result)
139    }
140
141    /// Wraps `isl_qpolynomial_list_copy`.
142    pub fn copy(&self) -> Result<QPolynomialList, LibISLError> {
143        let list = self;
144        let isl_rs_ctx = list.get_ctx();
145        let list = list.ptr;
146        let isl_rs_result = unsafe { isl_qpolynomial_list_copy(list) };
147        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
148                                              should_free_on_drop: true };
149        let err = isl_rs_ctx.last_error();
150        if err != Error::None_ {
151            let err_msg = isl_rs_ctx.last_error_msg();
152            isl_rs_ctx.reset_error();
153            return Err(LibISLError::new(err, err_msg));
154        }
155        Ok(isl_rs_result)
156    }
157
158    /// Wraps `isl_qpolynomial_list_drop`.
159    pub fn drop(self, first: u32, n: u32) -> Result<QPolynomialList, LibISLError> {
160        let list = self;
161        let isl_rs_ctx = list.get_ctx();
162        let mut list = list;
163        list.do_not_free_on_drop();
164        let list = list.ptr;
165        let isl_rs_result = unsafe { isl_qpolynomial_list_drop(list, first, n) };
166        let isl_rs_result = QPolynomialList { 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_qpolynomial_list_dump`.
178    pub fn dump(&self) -> Result<(), LibISLError> {
179        let list = self;
180        let isl_rs_ctx = list.get_ctx();
181        let list = list.ptr;
182        let isl_rs_result = unsafe { isl_qpolynomial_list_dump(list) };
183        let err = isl_rs_ctx.last_error();
184        if err != Error::None_ {
185            let err_msg = isl_rs_ctx.last_error_msg();
186            isl_rs_ctx.reset_error();
187            return Err(LibISLError::new(err, err_msg));
188        }
189        Ok(isl_rs_result)
190    }
191
192    /// Wraps `isl_qpolynomial_list_free`.
193    pub fn free(self) -> Result<QPolynomialList, LibISLError> {
194        let list = self;
195        let isl_rs_ctx = list.get_ctx();
196        let mut list = list;
197        list.do_not_free_on_drop();
198        let list = list.ptr;
199        let isl_rs_result = unsafe { isl_qpolynomial_list_free(list) };
200        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
201                                              should_free_on_drop: true };
202        let err = isl_rs_ctx.last_error();
203        if err != Error::None_ {
204            let err_msg = isl_rs_ctx.last_error_msg();
205            isl_rs_ctx.reset_error();
206            return Err(LibISLError::new(err, err_msg));
207        }
208        Ok(isl_rs_result)
209    }
210
211    /// Wraps `isl_qpolynomial_list_from_qpolynomial`.
212    pub fn from_qpolynomial(el: QPolynomial) -> Result<QPolynomialList, LibISLError> {
213        let isl_rs_ctx = el.get_ctx();
214        let mut el = el;
215        el.do_not_free_on_drop();
216        let el = el.ptr;
217        let isl_rs_result = unsafe { isl_qpolynomial_list_from_qpolynomial(el) };
218        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
219                                              should_free_on_drop: true };
220        let err = isl_rs_ctx.last_error();
221        if err != Error::None_ {
222            let err_msg = isl_rs_ctx.last_error_msg();
223            isl_rs_ctx.reset_error();
224            return Err(LibISLError::new(err, err_msg));
225        }
226        Ok(isl_rs_result)
227    }
228
229    /// Wraps `isl_qpolynomial_list_get_at`.
230    pub fn get_at(&self, index: i32) -> Result<QPolynomial, LibISLError> {
231        let list = self;
232        let isl_rs_ctx = list.get_ctx();
233        let list = list.ptr;
234        let isl_rs_result = unsafe { isl_qpolynomial_list_get_at(list, index) };
235        let isl_rs_result = QPolynomial { ptr: isl_rs_result,
236                                          should_free_on_drop: true };
237        let err = isl_rs_ctx.last_error();
238        if err != Error::None_ {
239            let err_msg = isl_rs_ctx.last_error_msg();
240            isl_rs_ctx.reset_error();
241            return Err(LibISLError::new(err, err_msg));
242        }
243        Ok(isl_rs_result)
244    }
245
246    /// Wraps `isl_qpolynomial_list_get_ctx`.
247    pub fn get_ctx(&self) -> Context {
248        let list = self;
249        let list = list.ptr;
250        let isl_rs_result = unsafe { isl_qpolynomial_list_get_ctx(list) };
251        let isl_rs_result = Context { ptr: isl_rs_result,
252                                      should_free_on_drop: false };
253        isl_rs_result
254    }
255
256    /// Wraps `isl_qpolynomial_list_get_qpolynomial`.
257    pub fn get_qpolynomial(&self, index: i32) -> Result<QPolynomial, LibISLError> {
258        let list = self;
259        let isl_rs_ctx = list.get_ctx();
260        let list = list.ptr;
261        let isl_rs_result = unsafe { isl_qpolynomial_list_get_qpolynomial(list, index) };
262        let isl_rs_result = QPolynomial { 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_list_insert`.
274    pub fn insert(self, pos: u32, el: QPolynomial) -> Result<QPolynomialList, LibISLError> {
275        let list = self;
276        let isl_rs_ctx = list.get_ctx();
277        let mut list = list;
278        list.do_not_free_on_drop();
279        let list = list.ptr;
280        let mut el = el;
281        el.do_not_free_on_drop();
282        let el = el.ptr;
283        let isl_rs_result = unsafe { isl_qpolynomial_list_insert(list, pos, el) };
284        let isl_rs_result = QPolynomialList { 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_list_n_qpolynomial`.
296    pub fn n_qpolynomial(&self) -> Result<i32, LibISLError> {
297        let list = self;
298        let isl_rs_ctx = list.get_ctx();
299        let list = list.ptr;
300        let isl_rs_result = unsafe { isl_qpolynomial_list_n_qpolynomial(list) };
301        let err = isl_rs_ctx.last_error();
302        if err != Error::None_ {
303            let err_msg = isl_rs_ctx.last_error_msg();
304            isl_rs_ctx.reset_error();
305            return Err(LibISLError::new(err, err_msg));
306        }
307        Ok(isl_rs_result)
308    }
309
310    /// Wraps `isl_qpolynomial_list_reverse`.
311    pub fn reverse(self) -> Result<QPolynomialList, LibISLError> {
312        let list = self;
313        let isl_rs_ctx = list.get_ctx();
314        let mut list = list;
315        list.do_not_free_on_drop();
316        let list = list.ptr;
317        let isl_rs_result = unsafe { isl_qpolynomial_list_reverse(list) };
318        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
319                                              should_free_on_drop: true };
320        let err = isl_rs_ctx.last_error();
321        if err != Error::None_ {
322            let err_msg = isl_rs_ctx.last_error_msg();
323            isl_rs_ctx.reset_error();
324            return Err(LibISLError::new(err, err_msg));
325        }
326        Ok(isl_rs_result)
327    }
328
329    /// Wraps `isl_qpolynomial_list_set_at`.
330    pub fn set_at(self, index: i32, el: QPolynomial) -> Result<QPolynomialList, LibISLError> {
331        let list = self;
332        let isl_rs_ctx = list.get_ctx();
333        let mut list = list;
334        list.do_not_free_on_drop();
335        let list = list.ptr;
336        let mut el = el;
337        el.do_not_free_on_drop();
338        let el = el.ptr;
339        let isl_rs_result = unsafe { isl_qpolynomial_list_set_at(list, index, el) };
340        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
341                                              should_free_on_drop: true };
342        let err = isl_rs_ctx.last_error();
343        if err != Error::None_ {
344            let err_msg = isl_rs_ctx.last_error_msg();
345            isl_rs_ctx.reset_error();
346            return Err(LibISLError::new(err, err_msg));
347        }
348        Ok(isl_rs_result)
349    }
350
351    /// Wraps `isl_qpolynomial_list_set_qpolynomial`.
352    pub fn set_qpolynomial(self, index: i32, el: QPolynomial)
353                           -> Result<QPolynomialList, LibISLError> {
354        let list = self;
355        let isl_rs_ctx = list.get_ctx();
356        let mut list = list;
357        list.do_not_free_on_drop();
358        let list = list.ptr;
359        let mut el = el;
360        el.do_not_free_on_drop();
361        let el = el.ptr;
362        let isl_rs_result = unsafe { isl_qpolynomial_list_set_qpolynomial(list, index, el) };
363        let isl_rs_result = QPolynomialList { ptr: isl_rs_result,
364                                              should_free_on_drop: true };
365        let err = isl_rs_ctx.last_error();
366        if err != Error::None_ {
367            let err_msg = isl_rs_ctx.last_error_msg();
368            isl_rs_ctx.reset_error();
369            return Err(LibISLError::new(err, err_msg));
370        }
371        Ok(isl_rs_result)
372    }
373
374    /// Wraps `isl_qpolynomial_list_size`.
375    pub fn size(&self) -> Result<i32, LibISLError> {
376        let list = self;
377        let isl_rs_ctx = list.get_ctx();
378        let list = list.ptr;
379        let isl_rs_result = unsafe { isl_qpolynomial_list_size(list) };
380        let err = isl_rs_ctx.last_error();
381        if err != Error::None_ {
382            let err_msg = isl_rs_ctx.last_error_msg();
383            isl_rs_ctx.reset_error();
384            return Err(LibISLError::new(err, err_msg));
385        }
386        Ok(isl_rs_result)
387    }
388
389    /// Wraps `isl_qpolynomial_list_swap`.
390    pub fn swap(self, pos1: u32, pos2: u32) -> Result<QPolynomialList, LibISLError> {
391        let list = self;
392        let isl_rs_ctx = list.get_ctx();
393        let mut list = list;
394        list.do_not_free_on_drop();
395        let list = list.ptr;
396        let isl_rs_result = unsafe { isl_qpolynomial_list_swap(list, pos1, pos2) };
397        let isl_rs_result = QPolynomialList { 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_qpolynomial_list_to_str`.
409    pub fn to_str(&self) -> Result<&str, LibISLError> {
410        let list = self;
411        let isl_rs_ctx = list.get_ctx();
412        let list = list.ptr;
413        let isl_rs_result = unsafe { isl_qpolynomial_list_to_str(list) };
414        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
415        let isl_rs_result = isl_rs_result.to_str().unwrap();
416        let err = isl_rs_ctx.last_error();
417        if err != Error::None_ {
418            let err_msg = isl_rs_ctx.last_error_msg();
419            isl_rs_ctx.reset_error();
420            return Err(LibISLError::new(err, err_msg));
421        }
422        Ok(isl_rs_result)
423    }
424
425    /// Does not call isl_qpolynomial_list_free() on being dropped. (For
426    /// internal use only.)
427    pub fn do_not_free_on_drop(&mut self) {
428        self.should_free_on_drop = false;
429    }
430}
431
432impl Drop for QPolynomialList {
433    fn drop(&mut self) {
434        if self.should_free_on_drop {
435            unsafe {
436                isl_qpolynomial_list_free(self.ptr);
437            }
438        }
439    }
440}
isl_rs/bindings/qpolynomial_list.rs

isl_rs/bindings/
qpolynomial_list.rs
