isl_rs/bindings/
union_set.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{
5    BasicSet, BasicSetList, Context, DimType, Error, LibISLError, MultiAff, MultiUnionPwAff,
6    MultiVal, Point, PwMultiAff, Schedule, Set, SetList, Space, UnionMap, UnionPwMultiAff,
7    UnionSetList,
8};
9use libc::uintptr_t;
10use std::ffi::{CStr, CString};
11use std::os::raw::c_char;
12
13/// Wraps `isl_union_set`.
14pub struct UnionSet {
15    pub ptr: uintptr_t,
16    pub should_free_on_drop: bool,
17}
18
19extern "C" {
20
21    fn isl_union_set_add_set(uset: uintptr_t, set: uintptr_t) -> uintptr_t;
22
23    fn isl_union_set_affine_hull(uset: uintptr_t) -> uintptr_t;
24
25    fn isl_union_set_align_params(uset: uintptr_t, model: uintptr_t) -> uintptr_t;
26
27    fn isl_union_set_apply(uset: uintptr_t, umap: uintptr_t) -> uintptr_t;
28
29    fn isl_union_set_as_set(uset: uintptr_t) -> uintptr_t;
30
31    fn isl_union_set_coalesce(uset: uintptr_t) -> uintptr_t;
32
33    fn isl_union_set_coefficients(bset: uintptr_t) -> uintptr_t;
34
35    fn isl_union_set_compute_divs(uset: uintptr_t) -> uintptr_t;
36
37    fn isl_union_set_compute_schedule(domain: uintptr_t, validity: uintptr_t, proximity: uintptr_t)
38                                      -> uintptr_t;
39
40    fn isl_union_set_contains(uset: uintptr_t, space: uintptr_t) -> i32;
41
42    fn isl_union_set_copy(uset: uintptr_t) -> uintptr_t;
43
44    fn isl_union_set_detect_equalities(uset: uintptr_t) -> uintptr_t;
45
46    fn isl_union_set_dim(uset: uintptr_t, type_: i32) -> i32;
47
48    fn isl_union_set_drop_unused_params(uset: uintptr_t) -> uintptr_t;
49
50    fn isl_union_set_dump(uset: uintptr_t) -> ();
51
52    fn isl_union_set_empty(space: uintptr_t) -> uintptr_t;
53
54    fn isl_union_set_empty_ctx(ctx: uintptr_t) -> uintptr_t;
55
56    fn isl_union_set_empty_space(space: uintptr_t) -> uintptr_t;
57
58    fn isl_union_set_extract_set(uset: uintptr_t, space: uintptr_t) -> uintptr_t;
59
60    fn isl_union_set_free(uset: uintptr_t) -> uintptr_t;
61
62    fn isl_union_set_from_basic_set(bset: uintptr_t) -> uintptr_t;
63
64    fn isl_union_set_from_point(pnt: uintptr_t) -> uintptr_t;
65
66    fn isl_union_set_from_set(set: uintptr_t) -> uintptr_t;
67
68    fn isl_union_set_get_basic_set_list(uset: uintptr_t) -> uintptr_t;
69
70    fn isl_union_set_get_ctx(uset: uintptr_t) -> uintptr_t;
71
72    fn isl_union_set_get_hash(uset: uintptr_t) -> u32;
73
74    fn isl_union_set_get_set_list(uset: uintptr_t) -> uintptr_t;
75
76    fn isl_union_set_get_space(uset: uintptr_t) -> uintptr_t;
77
78    fn isl_union_set_gist(uset: uintptr_t, context: uintptr_t) -> uintptr_t;
79
80    fn isl_union_set_gist_params(uset: uintptr_t, set: uintptr_t) -> uintptr_t;
81
82    fn isl_union_set_identity(uset: uintptr_t) -> uintptr_t;
83
84    fn isl_union_set_identity_union_pw_multi_aff(uset: uintptr_t) -> uintptr_t;
85
86    fn isl_union_set_intersect(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;
87
88    fn isl_union_set_intersect_params(uset: uintptr_t, set: uintptr_t) -> uintptr_t;
89
90    fn isl_union_set_is_disjoint(uset1: uintptr_t, uset2: uintptr_t) -> i32;
91
92    fn isl_union_set_is_empty(uset: uintptr_t) -> i32;
93
94    fn isl_union_set_is_equal(uset1: uintptr_t, uset2: uintptr_t) -> i32;
95
96    fn isl_union_set_is_params(uset: uintptr_t) -> i32;
97
98    fn isl_union_set_is_strict_subset(uset1: uintptr_t, uset2: uintptr_t) -> i32;
99
100    fn isl_union_set_is_subset(uset1: uintptr_t, uset2: uintptr_t) -> i32;
101
102    fn isl_union_set_isa_set(uset: uintptr_t) -> i32;
103
104    fn isl_union_set_lex_ge_union_set(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;
105
106    fn isl_union_set_lex_gt_union_set(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;
107
108    fn isl_union_set_lex_le_union_set(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;
109
110    fn isl_union_set_lex_lt_union_set(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;
111
112    fn isl_union_set_lexmax(uset: uintptr_t) -> uintptr_t;
113
114    fn isl_union_set_lexmin(uset: uintptr_t) -> uintptr_t;
115
116    fn isl_union_set_lift(uset: uintptr_t) -> uintptr_t;
117
118    fn isl_union_set_min_multi_union_pw_aff(uset: uintptr_t, obj: uintptr_t) -> uintptr_t;
119
120    fn isl_union_set_n_set(uset: uintptr_t) -> i32;
121
122    fn isl_union_set_params(uset: uintptr_t) -> uintptr_t;
123
124    fn isl_union_set_plain_unshifted_simple_hull(uset: uintptr_t) -> uintptr_t;
125
126    fn isl_union_set_polyhedral_hull(uset: uintptr_t) -> uintptr_t;
127
128    fn isl_union_set_preimage_multi_aff(uset: uintptr_t, ma: uintptr_t) -> uintptr_t;
129
130    fn isl_union_set_preimage_pw_multi_aff(uset: uintptr_t, pma: uintptr_t) -> uintptr_t;
131
132    fn isl_union_set_preimage_union_pw_multi_aff(uset: uintptr_t, upma: uintptr_t) -> uintptr_t;
133
134    fn isl_union_set_product(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;
135
136    fn isl_union_set_project_out(uset: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;
137
138    fn isl_union_set_project_out_all_params(uset: uintptr_t) -> uintptr_t;
139
140    fn isl_union_set_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
141
142    fn isl_union_set_remove_divs(bset: uintptr_t) -> uintptr_t;
143
144    fn isl_union_set_remove_redundancies(uset: uintptr_t) -> uintptr_t;
145
146    fn isl_union_set_reset_user(uset: uintptr_t) -> uintptr_t;
147
148    fn isl_union_set_sample(uset: uintptr_t) -> uintptr_t;
149
150    fn isl_union_set_sample_point(uset: uintptr_t) -> uintptr_t;
151
152    fn isl_union_set_simple_hull(uset: uintptr_t) -> uintptr_t;
153
154    fn isl_union_set_solutions(bset: uintptr_t) -> uintptr_t;
155
156    fn isl_union_set_subtract(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;
157
158    fn isl_union_set_to_list(el: uintptr_t) -> uintptr_t;
159
160    fn isl_union_set_to_str(uset: uintptr_t) -> *const c_char;
161
162    fn isl_union_set_union(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;
163
164    fn isl_union_set_universe(uset: uintptr_t) -> uintptr_t;
165
166    fn isl_union_set_unwrap(uset: uintptr_t) -> uintptr_t;
167
168    fn isl_union_set_wrapped_domain_map(uset: uintptr_t) -> uintptr_t;
169
170}
171
172impl UnionSet {
173    /// Wraps `isl_union_set_add_set`.
174    pub fn add_set(self, set: Set) -> Result<UnionSet, LibISLError> {
175        let uset = self;
176        let isl_rs_ctx = uset.get_ctx();
177        let mut uset = uset;
178        uset.do_not_free_on_drop();
179        let uset = uset.ptr;
180        let mut set = set;
181        set.do_not_free_on_drop();
182        let set = set.ptr;
183        let isl_rs_result = unsafe { isl_union_set_add_set(uset, set) };
184        let isl_rs_result = UnionSet { ptr: isl_rs_result,
185                                       should_free_on_drop: true };
186        let err = isl_rs_ctx.last_error();
187        if err != Error::None_ {
188            let err_msg = isl_rs_ctx.last_error_msg();
189            isl_rs_ctx.reset_error();
190            return Err(LibISLError::new(err, err_msg));
191        }
192        Ok(isl_rs_result)
193    }
194
195    /// Wraps `isl_union_set_affine_hull`.
196    pub fn affine_hull(self) -> Result<UnionSet, LibISLError> {
197        let uset = self;
198        let isl_rs_ctx = uset.get_ctx();
199        let mut uset = uset;
200        uset.do_not_free_on_drop();
201        let uset = uset.ptr;
202        let isl_rs_result = unsafe { isl_union_set_affine_hull(uset) };
203        let isl_rs_result = UnionSet { ptr: isl_rs_result,
204                                       should_free_on_drop: true };
205        let err = isl_rs_ctx.last_error();
206        if err != Error::None_ {
207            let err_msg = isl_rs_ctx.last_error_msg();
208            isl_rs_ctx.reset_error();
209            return Err(LibISLError::new(err, err_msg));
210        }
211        Ok(isl_rs_result)
212    }
213
214    /// Wraps `isl_union_set_align_params`.
215    pub fn align_params(self, model: Space) -> Result<UnionSet, LibISLError> {
216        let uset = self;
217        let isl_rs_ctx = uset.get_ctx();
218        let mut uset = uset;
219        uset.do_not_free_on_drop();
220        let uset = uset.ptr;
221        let mut model = model;
222        model.do_not_free_on_drop();
223        let model = model.ptr;
224        let isl_rs_result = unsafe { isl_union_set_align_params(uset, model) };
225        let isl_rs_result = UnionSet { ptr: isl_rs_result,
226                                       should_free_on_drop: true };
227        let err = isl_rs_ctx.last_error();
228        if err != Error::None_ {
229            let err_msg = isl_rs_ctx.last_error_msg();
230            isl_rs_ctx.reset_error();
231            return Err(LibISLError::new(err, err_msg));
232        }
233        Ok(isl_rs_result)
234    }
235
236    /// Wraps `isl_union_set_apply`.
237    pub fn apply(self, umap: UnionMap) -> Result<UnionSet, LibISLError> {
238        let uset = self;
239        let isl_rs_ctx = uset.get_ctx();
240        let mut uset = uset;
241        uset.do_not_free_on_drop();
242        let uset = uset.ptr;
243        let mut umap = umap;
244        umap.do_not_free_on_drop();
245        let umap = umap.ptr;
246        let isl_rs_result = unsafe { isl_union_set_apply(uset, umap) };
247        let isl_rs_result = UnionSet { ptr: isl_rs_result,
248                                       should_free_on_drop: true };
249        let err = isl_rs_ctx.last_error();
250        if err != Error::None_ {
251            let err_msg = isl_rs_ctx.last_error_msg();
252            isl_rs_ctx.reset_error();
253            return Err(LibISLError::new(err, err_msg));
254        }
255        Ok(isl_rs_result)
256    }
257
258    /// Wraps `isl_union_set_as_set`.
259    pub fn as_set(self) -> Result<Set, LibISLError> {
260        let uset = self;
261        let isl_rs_ctx = uset.get_ctx();
262        let mut uset = uset;
263        uset.do_not_free_on_drop();
264        let uset = uset.ptr;
265        let isl_rs_result = unsafe { isl_union_set_as_set(uset) };
266        let isl_rs_result = Set { ptr: isl_rs_result,
267                                  should_free_on_drop: true };
268        let err = isl_rs_ctx.last_error();
269        if err != Error::None_ {
270            let err_msg = isl_rs_ctx.last_error_msg();
271            isl_rs_ctx.reset_error();
272            return Err(LibISLError::new(err, err_msg));
273        }
274        Ok(isl_rs_result)
275    }
276
277    /// Wraps `isl_union_set_coalesce`.
278    pub fn coalesce(self) -> Result<UnionSet, LibISLError> {
279        let uset = self;
280        let isl_rs_ctx = uset.get_ctx();
281        let mut uset = uset;
282        uset.do_not_free_on_drop();
283        let uset = uset.ptr;
284        let isl_rs_result = unsafe { isl_union_set_coalesce(uset) };
285        let isl_rs_result = UnionSet { ptr: isl_rs_result,
286                                       should_free_on_drop: true };
287        let err = isl_rs_ctx.last_error();
288        if err != Error::None_ {
289            let err_msg = isl_rs_ctx.last_error_msg();
290            isl_rs_ctx.reset_error();
291            return Err(LibISLError::new(err, err_msg));
292        }
293        Ok(isl_rs_result)
294    }
295
296    /// Wraps `isl_union_set_coefficients`.
297    pub fn coefficients(self) -> Result<UnionSet, LibISLError> {
298        let bset = self;
299        let isl_rs_ctx = bset.get_ctx();
300        let mut bset = bset;
301        bset.do_not_free_on_drop();
302        let bset = bset.ptr;
303        let isl_rs_result = unsafe { isl_union_set_coefficients(bset) };
304        let isl_rs_result = UnionSet { ptr: isl_rs_result,
305                                       should_free_on_drop: true };
306        let err = isl_rs_ctx.last_error();
307        if err != Error::None_ {
308            let err_msg = isl_rs_ctx.last_error_msg();
309            isl_rs_ctx.reset_error();
310            return Err(LibISLError::new(err, err_msg));
311        }
312        Ok(isl_rs_result)
313    }
314
315    /// Wraps `isl_union_set_compute_divs`.
316    pub fn compute_divs(self) -> Result<UnionSet, LibISLError> {
317        let uset = self;
318        let isl_rs_ctx = uset.get_ctx();
319        let mut uset = uset;
320        uset.do_not_free_on_drop();
321        let uset = uset.ptr;
322        let isl_rs_result = unsafe { isl_union_set_compute_divs(uset) };
323        let isl_rs_result = UnionSet { ptr: isl_rs_result,
324                                       should_free_on_drop: true };
325        let err = isl_rs_ctx.last_error();
326        if err != Error::None_ {
327            let err_msg = isl_rs_ctx.last_error_msg();
328            isl_rs_ctx.reset_error();
329            return Err(LibISLError::new(err, err_msg));
330        }
331        Ok(isl_rs_result)
332    }
333
334    /// Wraps `isl_union_set_compute_schedule`.
335    pub fn compute_schedule(self, validity: UnionMap, proximity: UnionMap)
336                            -> Result<Schedule, LibISLError> {
337        let domain = self;
338        let isl_rs_ctx = domain.get_ctx();
339        let mut domain = domain;
340        domain.do_not_free_on_drop();
341        let domain = domain.ptr;
342        let mut validity = validity;
343        validity.do_not_free_on_drop();
344        let validity = validity.ptr;
345        let mut proximity = proximity;
346        proximity.do_not_free_on_drop();
347        let proximity = proximity.ptr;
348        let isl_rs_result = unsafe { isl_union_set_compute_schedule(domain, validity, proximity) };
349        let isl_rs_result = Schedule { ptr: isl_rs_result,
350                                       should_free_on_drop: true };
351        let err = isl_rs_ctx.last_error();
352        if err != Error::None_ {
353            let err_msg = isl_rs_ctx.last_error_msg();
354            isl_rs_ctx.reset_error();
355            return Err(LibISLError::new(err, err_msg));
356        }
357        Ok(isl_rs_result)
358    }
359
360    /// Wraps `isl_union_set_contains`.
361    pub fn contains(&self, space: &Space) -> Result<bool, LibISLError> {
362        let uset = self;
363        let isl_rs_ctx = uset.get_ctx();
364        let uset = uset.ptr;
365        let space = space.ptr;
366        let isl_rs_result = unsafe { isl_union_set_contains(uset, space) };
367        let isl_rs_result = match isl_rs_result {
368            0 => false,
369            1 => true,
370            _ => {
371                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
372            }
373        };
374        let err = isl_rs_ctx.last_error();
375        if err != Error::None_ {
376            let err_msg = isl_rs_ctx.last_error_msg();
377            isl_rs_ctx.reset_error();
378            return Err(LibISLError::new(err, err_msg));
379        }
380        Ok(isl_rs_result)
381    }
382
383    /// Wraps `isl_union_set_copy`.
384    pub fn copy(&self) -> Result<UnionSet, LibISLError> {
385        let uset = self;
386        let isl_rs_ctx = uset.get_ctx();
387        let uset = uset.ptr;
388        let isl_rs_result = unsafe { isl_union_set_copy(uset) };
389        let isl_rs_result = UnionSet { ptr: isl_rs_result,
390                                       should_free_on_drop: true };
391        let err = isl_rs_ctx.last_error();
392        if err != Error::None_ {
393            let err_msg = isl_rs_ctx.last_error_msg();
394            isl_rs_ctx.reset_error();
395            return Err(LibISLError::new(err, err_msg));
396        }
397        Ok(isl_rs_result)
398    }
399
400    /// Wraps `isl_union_set_detect_equalities`.
401    pub fn detect_equalities(self) -> Result<UnionSet, LibISLError> {
402        let uset = self;
403        let isl_rs_ctx = uset.get_ctx();
404        let mut uset = uset;
405        uset.do_not_free_on_drop();
406        let uset = uset.ptr;
407        let isl_rs_result = unsafe { isl_union_set_detect_equalities(uset) };
408        let isl_rs_result = UnionSet { ptr: isl_rs_result,
409                                       should_free_on_drop: true };
410        let err = isl_rs_ctx.last_error();
411        if err != Error::None_ {
412            let err_msg = isl_rs_ctx.last_error_msg();
413            isl_rs_ctx.reset_error();
414            return Err(LibISLError::new(err, err_msg));
415        }
416        Ok(isl_rs_result)
417    }
418
419    /// Wraps `isl_union_set_dim`.
420    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
421        let uset = self;
422        let isl_rs_ctx = uset.get_ctx();
423        let uset = uset.ptr;
424        let type_ = type_.to_i32();
425        let isl_rs_result = unsafe { isl_union_set_dim(uset, type_) };
426        let err = isl_rs_ctx.last_error();
427        if err != Error::None_ {
428            let err_msg = isl_rs_ctx.last_error_msg();
429            isl_rs_ctx.reset_error();
430            return Err(LibISLError::new(err, err_msg));
431        }
432        Ok(isl_rs_result)
433    }
434
435    /// Wraps `isl_union_set_drop_unused_params`.
436    pub fn drop_unused_params(self) -> Result<UnionSet, LibISLError> {
437        let uset = self;
438        let isl_rs_ctx = uset.get_ctx();
439        let mut uset = uset;
440        uset.do_not_free_on_drop();
441        let uset = uset.ptr;
442        let isl_rs_result = unsafe { isl_union_set_drop_unused_params(uset) };
443        let isl_rs_result = UnionSet { ptr: isl_rs_result,
444                                       should_free_on_drop: true };
445        let err = isl_rs_ctx.last_error();
446        if err != Error::None_ {
447            let err_msg = isl_rs_ctx.last_error_msg();
448            isl_rs_ctx.reset_error();
449            return Err(LibISLError::new(err, err_msg));
450        }
451        Ok(isl_rs_result)
452    }
453
454    /// Wraps `isl_union_set_dump`.
455    pub fn dump(&self) -> Result<(), LibISLError> {
456        let uset = self;
457        let isl_rs_ctx = uset.get_ctx();
458        let uset = uset.ptr;
459        let isl_rs_result = unsafe { isl_union_set_dump(uset) };
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_union_set_empty`.
470    pub fn empty(space: Space) -> Result<UnionSet, LibISLError> {
471        let isl_rs_ctx = space.get_ctx();
472        let mut space = space;
473        space.do_not_free_on_drop();
474        let space = space.ptr;
475        let isl_rs_result = unsafe { isl_union_set_empty(space) };
476        let isl_rs_result = UnionSet { 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_union_set_empty_ctx`.
488    pub fn empty_ctx(ctx: &Context) -> Result<UnionSet, LibISLError> {
489        let isl_rs_ctx = Context { ptr: ctx.ptr,
490                                   should_free_on_drop: false };
491        let ctx = ctx.ptr;
492        let isl_rs_result = unsafe { isl_union_set_empty_ctx(ctx) };
493        let isl_rs_result = UnionSet { ptr: isl_rs_result,
494                                       should_free_on_drop: true };
495        let err = isl_rs_ctx.last_error();
496        if err != Error::None_ {
497            let err_msg = isl_rs_ctx.last_error_msg();
498            isl_rs_ctx.reset_error();
499            return Err(LibISLError::new(err, err_msg));
500        }
501        Ok(isl_rs_result)
502    }
503
504    /// Wraps `isl_union_set_empty_space`.
505    pub fn empty_space(space: Space) -> Result<UnionSet, LibISLError> {
506        let isl_rs_ctx = space.get_ctx();
507        let mut space = space;
508        space.do_not_free_on_drop();
509        let space = space.ptr;
510        let isl_rs_result = unsafe { isl_union_set_empty_space(space) };
511        let isl_rs_result = UnionSet { ptr: isl_rs_result,
512                                       should_free_on_drop: true };
513        let err = isl_rs_ctx.last_error();
514        if err != Error::None_ {
515            let err_msg = isl_rs_ctx.last_error_msg();
516            isl_rs_ctx.reset_error();
517            return Err(LibISLError::new(err, err_msg));
518        }
519        Ok(isl_rs_result)
520    }
521
522    /// Wraps `isl_union_set_extract_set`.
523    pub fn extract_set(&self, space: Space) -> Result<Set, LibISLError> {
524        let uset = self;
525        let isl_rs_ctx = uset.get_ctx();
526        let uset = uset.ptr;
527        let mut space = space;
528        space.do_not_free_on_drop();
529        let space = space.ptr;
530        let isl_rs_result = unsafe { isl_union_set_extract_set(uset, space) };
531        let isl_rs_result = Set { ptr: isl_rs_result,
532                                  should_free_on_drop: true };
533        let err = isl_rs_ctx.last_error();
534        if err != Error::None_ {
535            let err_msg = isl_rs_ctx.last_error_msg();
536            isl_rs_ctx.reset_error();
537            return Err(LibISLError::new(err, err_msg));
538        }
539        Ok(isl_rs_result)
540    }
541
542    /// Wraps `isl_union_set_free`.
543    pub fn free(self) -> Result<UnionSet, LibISLError> {
544        let uset = self;
545        let isl_rs_ctx = uset.get_ctx();
546        let mut uset = uset;
547        uset.do_not_free_on_drop();
548        let uset = uset.ptr;
549        let isl_rs_result = unsafe { isl_union_set_free(uset) };
550        let isl_rs_result = UnionSet { ptr: isl_rs_result,
551                                       should_free_on_drop: true };
552        let err = isl_rs_ctx.last_error();
553        if err != Error::None_ {
554            let err_msg = isl_rs_ctx.last_error_msg();
555            isl_rs_ctx.reset_error();
556            return Err(LibISLError::new(err, err_msg));
557        }
558        Ok(isl_rs_result)
559    }
560
561    /// Wraps `isl_union_set_from_basic_set`.
562    pub fn from_basic_set(bset: BasicSet) -> Result<UnionSet, LibISLError> {
563        let isl_rs_ctx = bset.get_ctx();
564        let mut bset = bset;
565        bset.do_not_free_on_drop();
566        let bset = bset.ptr;
567        let isl_rs_result = unsafe { isl_union_set_from_basic_set(bset) };
568        let isl_rs_result = UnionSet { ptr: isl_rs_result,
569                                       should_free_on_drop: true };
570        let err = isl_rs_ctx.last_error();
571        if err != Error::None_ {
572            let err_msg = isl_rs_ctx.last_error_msg();
573            isl_rs_ctx.reset_error();
574            return Err(LibISLError::new(err, err_msg));
575        }
576        Ok(isl_rs_result)
577    }
578
579    /// Wraps `isl_union_set_from_point`.
580    pub fn from_point(pnt: Point) -> Result<UnionSet, LibISLError> {
581        let isl_rs_ctx = pnt.get_ctx();
582        let mut pnt = pnt;
583        pnt.do_not_free_on_drop();
584        let pnt = pnt.ptr;
585        let isl_rs_result = unsafe { isl_union_set_from_point(pnt) };
586        let isl_rs_result = UnionSet { ptr: isl_rs_result,
587                                       should_free_on_drop: true };
588        let err = isl_rs_ctx.last_error();
589        if err != Error::None_ {
590            let err_msg = isl_rs_ctx.last_error_msg();
591            isl_rs_ctx.reset_error();
592            return Err(LibISLError::new(err, err_msg));
593        }
594        Ok(isl_rs_result)
595    }
596
597    /// Wraps `isl_union_set_from_set`.
598    pub fn from_set(set: Set) -> Result<UnionSet, LibISLError> {
599        let isl_rs_ctx = set.get_ctx();
600        let mut set = set;
601        set.do_not_free_on_drop();
602        let set = set.ptr;
603        let isl_rs_result = unsafe { isl_union_set_from_set(set) };
604        let isl_rs_result = UnionSet { ptr: isl_rs_result,
605                                       should_free_on_drop: true };
606        let err = isl_rs_ctx.last_error();
607        if err != Error::None_ {
608            let err_msg = isl_rs_ctx.last_error_msg();
609            isl_rs_ctx.reset_error();
610            return Err(LibISLError::new(err, err_msg));
611        }
612        Ok(isl_rs_result)
613    }
614
615    /// Wraps `isl_union_set_get_basic_set_list`.
616    pub fn get_basic_set_list(&self) -> Result<BasicSetList, LibISLError> {
617        let uset = self;
618        let isl_rs_ctx = uset.get_ctx();
619        let uset = uset.ptr;
620        let isl_rs_result = unsafe { isl_union_set_get_basic_set_list(uset) };
621        let isl_rs_result = BasicSetList { ptr: isl_rs_result,
622                                           should_free_on_drop: true };
623        let err = isl_rs_ctx.last_error();
624        if err != Error::None_ {
625            let err_msg = isl_rs_ctx.last_error_msg();
626            isl_rs_ctx.reset_error();
627            return Err(LibISLError::new(err, err_msg));
628        }
629        Ok(isl_rs_result)
630    }
631
632    /// Wraps `isl_union_set_get_ctx`.
633    pub fn get_ctx(&self) -> Context {
634        let uset = self;
635        let uset = uset.ptr;
636        let isl_rs_result = unsafe { isl_union_set_get_ctx(uset) };
637        let isl_rs_result = Context { ptr: isl_rs_result,
638                                      should_free_on_drop: false };
639        isl_rs_result
640    }
641
642    /// Wraps `isl_union_set_get_hash`.
643    pub fn get_hash(&self) -> Result<u32, LibISLError> {
644        let uset = self;
645        let isl_rs_ctx = uset.get_ctx();
646        let uset = uset.ptr;
647        let isl_rs_result = unsafe { isl_union_set_get_hash(uset) };
648        let err = isl_rs_ctx.last_error();
649        if err != Error::None_ {
650            let err_msg = isl_rs_ctx.last_error_msg();
651            isl_rs_ctx.reset_error();
652            return Err(LibISLError::new(err, err_msg));
653        }
654        Ok(isl_rs_result)
655    }
656
657    /// Wraps `isl_union_set_get_set_list`.
658    pub fn get_set_list(&self) -> Result<SetList, LibISLError> {
659        let uset = self;
660        let isl_rs_ctx = uset.get_ctx();
661        let uset = uset.ptr;
662        let isl_rs_result = unsafe { isl_union_set_get_set_list(uset) };
663        let isl_rs_result = SetList { ptr: isl_rs_result,
664                                      should_free_on_drop: true };
665        let err = isl_rs_ctx.last_error();
666        if err != Error::None_ {
667            let err_msg = isl_rs_ctx.last_error_msg();
668            isl_rs_ctx.reset_error();
669            return Err(LibISLError::new(err, err_msg));
670        }
671        Ok(isl_rs_result)
672    }
673
674    /// Wraps `isl_union_set_get_space`.
675    pub fn get_space(&self) -> Result<Space, LibISLError> {
676        let uset = self;
677        let isl_rs_ctx = uset.get_ctx();
678        let uset = uset.ptr;
679        let isl_rs_result = unsafe { isl_union_set_get_space(uset) };
680        let isl_rs_result = Space { ptr: isl_rs_result,
681                                    should_free_on_drop: true };
682        let err = isl_rs_ctx.last_error();
683        if err != Error::None_ {
684            let err_msg = isl_rs_ctx.last_error_msg();
685            isl_rs_ctx.reset_error();
686            return Err(LibISLError::new(err, err_msg));
687        }
688        Ok(isl_rs_result)
689    }
690
691    /// Wraps `isl_union_set_gist`.
692    pub fn gist(self, context: UnionSet) -> Result<UnionSet, LibISLError> {
693        let uset = self;
694        let isl_rs_ctx = uset.get_ctx();
695        let mut uset = uset;
696        uset.do_not_free_on_drop();
697        let uset = uset.ptr;
698        let mut context = context;
699        context.do_not_free_on_drop();
700        let context = context.ptr;
701        let isl_rs_result = unsafe { isl_union_set_gist(uset, context) };
702        let isl_rs_result = UnionSet { ptr: isl_rs_result,
703                                       should_free_on_drop: true };
704        let err = isl_rs_ctx.last_error();
705        if err != Error::None_ {
706            let err_msg = isl_rs_ctx.last_error_msg();
707            isl_rs_ctx.reset_error();
708            return Err(LibISLError::new(err, err_msg));
709        }
710        Ok(isl_rs_result)
711    }
712
713    /// Wraps `isl_union_set_gist_params`.
714    pub fn gist_params(self, set: Set) -> Result<UnionSet, LibISLError> {
715        let uset = self;
716        let isl_rs_ctx = uset.get_ctx();
717        let mut uset = uset;
718        uset.do_not_free_on_drop();
719        let uset = uset.ptr;
720        let mut set = set;
721        set.do_not_free_on_drop();
722        let set = set.ptr;
723        let isl_rs_result = unsafe { isl_union_set_gist_params(uset, set) };
724        let isl_rs_result = UnionSet { ptr: isl_rs_result,
725                                       should_free_on_drop: true };
726        let err = isl_rs_ctx.last_error();
727        if err != Error::None_ {
728            let err_msg = isl_rs_ctx.last_error_msg();
729            isl_rs_ctx.reset_error();
730            return Err(LibISLError::new(err, err_msg));
731        }
732        Ok(isl_rs_result)
733    }
734
735    /// Wraps `isl_union_set_identity`.
736    pub fn identity(self) -> Result<UnionMap, LibISLError> {
737        let uset = self;
738        let isl_rs_ctx = uset.get_ctx();
739        let mut uset = uset;
740        uset.do_not_free_on_drop();
741        let uset = uset.ptr;
742        let isl_rs_result = unsafe { isl_union_set_identity(uset) };
743        let isl_rs_result = UnionMap { ptr: isl_rs_result,
744                                       should_free_on_drop: true };
745        let err = isl_rs_ctx.last_error();
746        if err != Error::None_ {
747            let err_msg = isl_rs_ctx.last_error_msg();
748            isl_rs_ctx.reset_error();
749            return Err(LibISLError::new(err, err_msg));
750        }
751        Ok(isl_rs_result)
752    }
753
754    /// Wraps `isl_union_set_identity_union_pw_multi_aff`.
755    pub fn identity_union_pw_multi_aff(self) -> Result<UnionPwMultiAff, LibISLError> {
756        let uset = self;
757        let isl_rs_ctx = uset.get_ctx();
758        let mut uset = uset;
759        uset.do_not_free_on_drop();
760        let uset = uset.ptr;
761        let isl_rs_result = unsafe { isl_union_set_identity_union_pw_multi_aff(uset) };
762        let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
763                                              should_free_on_drop: true };
764        let err = isl_rs_ctx.last_error();
765        if err != Error::None_ {
766            let err_msg = isl_rs_ctx.last_error_msg();
767            isl_rs_ctx.reset_error();
768            return Err(LibISLError::new(err, err_msg));
769        }
770        Ok(isl_rs_result)
771    }
772
773    /// Wraps `isl_union_set_intersect`.
774    pub fn intersect(self, uset2: UnionSet) -> Result<UnionSet, LibISLError> {
775        let uset1 = self;
776        let isl_rs_ctx = uset1.get_ctx();
777        let mut uset1 = uset1;
778        uset1.do_not_free_on_drop();
779        let uset1 = uset1.ptr;
780        let mut uset2 = uset2;
781        uset2.do_not_free_on_drop();
782        let uset2 = uset2.ptr;
783        let isl_rs_result = unsafe { isl_union_set_intersect(uset1, uset2) };
784        let isl_rs_result = UnionSet { ptr: isl_rs_result,
785                                       should_free_on_drop: true };
786        let err = isl_rs_ctx.last_error();
787        if err != Error::None_ {
788            let err_msg = isl_rs_ctx.last_error_msg();
789            isl_rs_ctx.reset_error();
790            return Err(LibISLError::new(err, err_msg));
791        }
792        Ok(isl_rs_result)
793    }
794
795    /// Wraps `isl_union_set_intersect_params`.
796    pub fn intersect_params(self, set: Set) -> Result<UnionSet, LibISLError> {
797        let uset = self;
798        let isl_rs_ctx = uset.get_ctx();
799        let mut uset = uset;
800        uset.do_not_free_on_drop();
801        let uset = uset.ptr;
802        let mut set = set;
803        set.do_not_free_on_drop();
804        let set = set.ptr;
805        let isl_rs_result = unsafe { isl_union_set_intersect_params(uset, set) };
806        let isl_rs_result = UnionSet { ptr: isl_rs_result,
807                                       should_free_on_drop: true };
808        let err = isl_rs_ctx.last_error();
809        if err != Error::None_ {
810            let err_msg = isl_rs_ctx.last_error_msg();
811            isl_rs_ctx.reset_error();
812            return Err(LibISLError::new(err, err_msg));
813        }
814        Ok(isl_rs_result)
815    }
816
817    /// Wraps `isl_union_set_is_disjoint`.
818    pub fn is_disjoint(&self, uset2: &UnionSet) -> Result<bool, LibISLError> {
819        let uset1 = self;
820        let isl_rs_ctx = uset1.get_ctx();
821        let uset1 = uset1.ptr;
822        let uset2 = uset2.ptr;
823        let isl_rs_result = unsafe { isl_union_set_is_disjoint(uset1, uset2) };
824        let isl_rs_result = match isl_rs_result {
825            0 => false,
826            1 => true,
827            _ => {
828                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
829            }
830        };
831        let err = isl_rs_ctx.last_error();
832        if err != Error::None_ {
833            let err_msg = isl_rs_ctx.last_error_msg();
834            isl_rs_ctx.reset_error();
835            return Err(LibISLError::new(err, err_msg));
836        }
837        Ok(isl_rs_result)
838    }
839
840    /// Wraps `isl_union_set_is_empty`.
841    pub fn is_empty(&self) -> Result<bool, LibISLError> {
842        let uset = self;
843        let isl_rs_ctx = uset.get_ctx();
844        let uset = uset.ptr;
845        let isl_rs_result = unsafe { isl_union_set_is_empty(uset) };
846        let isl_rs_result = match isl_rs_result {
847            0 => false,
848            1 => true,
849            _ => {
850                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
851            }
852        };
853        let err = isl_rs_ctx.last_error();
854        if err != Error::None_ {
855            let err_msg = isl_rs_ctx.last_error_msg();
856            isl_rs_ctx.reset_error();
857            return Err(LibISLError::new(err, err_msg));
858        }
859        Ok(isl_rs_result)
860    }
861
862    /// Wraps `isl_union_set_is_equal`.
863    pub fn is_equal(&self, uset2: &UnionSet) -> Result<bool, LibISLError> {
864        let uset1 = self;
865        let isl_rs_ctx = uset1.get_ctx();
866        let uset1 = uset1.ptr;
867        let uset2 = uset2.ptr;
868        let isl_rs_result = unsafe { isl_union_set_is_equal(uset1, uset2) };
869        let isl_rs_result = match isl_rs_result {
870            0 => false,
871            1 => true,
872            _ => {
873                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
874            }
875        };
876        let err = isl_rs_ctx.last_error();
877        if err != Error::None_ {
878            let err_msg = isl_rs_ctx.last_error_msg();
879            isl_rs_ctx.reset_error();
880            return Err(LibISLError::new(err, err_msg));
881        }
882        Ok(isl_rs_result)
883    }
884
885    /// Wraps `isl_union_set_is_params`.
886    pub fn is_params(&self) -> Result<bool, LibISLError> {
887        let uset = self;
888        let isl_rs_ctx = uset.get_ctx();
889        let uset = uset.ptr;
890        let isl_rs_result = unsafe { isl_union_set_is_params(uset) };
891        let isl_rs_result = match isl_rs_result {
892            0 => false,
893            1 => true,
894            _ => {
895                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
896            }
897        };
898        let err = isl_rs_ctx.last_error();
899        if err != Error::None_ {
900            let err_msg = isl_rs_ctx.last_error_msg();
901            isl_rs_ctx.reset_error();
902            return Err(LibISLError::new(err, err_msg));
903        }
904        Ok(isl_rs_result)
905    }
906
907    /// Wraps `isl_union_set_is_strict_subset`.
908    pub fn is_strict_subset(&self, uset2: &UnionSet) -> Result<bool, LibISLError> {
909        let uset1 = self;
910        let isl_rs_ctx = uset1.get_ctx();
911        let uset1 = uset1.ptr;
912        let uset2 = uset2.ptr;
913        let isl_rs_result = unsafe { isl_union_set_is_strict_subset(uset1, uset2) };
914        let isl_rs_result = match isl_rs_result {
915            0 => false,
916            1 => true,
917            _ => {
918                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
919            }
920        };
921        let err = isl_rs_ctx.last_error();
922        if err != Error::None_ {
923            let err_msg = isl_rs_ctx.last_error_msg();
924            isl_rs_ctx.reset_error();
925            return Err(LibISLError::new(err, err_msg));
926        }
927        Ok(isl_rs_result)
928    }
929
930    /// Wraps `isl_union_set_is_subset`.
931    pub fn is_subset(&self, uset2: &UnionSet) -> Result<bool, LibISLError> {
932        let uset1 = self;
933        let isl_rs_ctx = uset1.get_ctx();
934        let uset1 = uset1.ptr;
935        let uset2 = uset2.ptr;
936        let isl_rs_result = unsafe { isl_union_set_is_subset(uset1, uset2) };
937        let isl_rs_result = match isl_rs_result {
938            0 => false,
939            1 => true,
940            _ => {
941                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
942            }
943        };
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_union_set_isa_set`.
954    pub fn isa_set(&self) -> Result<bool, LibISLError> {
955        let uset = self;
956        let isl_rs_ctx = uset.get_ctx();
957        let uset = uset.ptr;
958        let isl_rs_result = unsafe { isl_union_set_isa_set(uset) };
959        let isl_rs_result = match isl_rs_result {
960            0 => false,
961            1 => true,
962            _ => {
963                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
964            }
965        };
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_union_set_lex_ge_union_set`.
976    pub fn lex_ge_union_set(self, uset2: UnionSet) -> Result<UnionMap, LibISLError> {
977        let uset1 = self;
978        let isl_rs_ctx = uset1.get_ctx();
979        let mut uset1 = uset1;
980        uset1.do_not_free_on_drop();
981        let uset1 = uset1.ptr;
982        let mut uset2 = uset2;
983        uset2.do_not_free_on_drop();
984        let uset2 = uset2.ptr;
985        let isl_rs_result = unsafe { isl_union_set_lex_ge_union_set(uset1, uset2) };
986        let isl_rs_result = UnionMap { ptr: isl_rs_result,
987                                       should_free_on_drop: true };
988        let err = isl_rs_ctx.last_error();
989        if err != Error::None_ {
990            let err_msg = isl_rs_ctx.last_error_msg();
991            isl_rs_ctx.reset_error();
992            return Err(LibISLError::new(err, err_msg));
993        }
994        Ok(isl_rs_result)
995    }
996
997    /// Wraps `isl_union_set_lex_gt_union_set`.
998    pub fn lex_gt_union_set(self, uset2: UnionSet) -> Result<UnionMap, LibISLError> {
999        let uset1 = self;
1000        let isl_rs_ctx = uset1.get_ctx();
1001        let mut uset1 = uset1;
1002        uset1.do_not_free_on_drop();
1003        let uset1 = uset1.ptr;
1004        let mut uset2 = uset2;
1005        uset2.do_not_free_on_drop();
1006        let uset2 = uset2.ptr;
1007        let isl_rs_result = unsafe { isl_union_set_lex_gt_union_set(uset1, uset2) };
1008        let isl_rs_result = UnionMap { ptr: isl_rs_result,
1009                                       should_free_on_drop: true };
1010        let err = isl_rs_ctx.last_error();
1011        if err != Error::None_ {
1012            let err_msg = isl_rs_ctx.last_error_msg();
1013            isl_rs_ctx.reset_error();
1014            return Err(LibISLError::new(err, err_msg));
1015        }
1016        Ok(isl_rs_result)
1017    }
1018
1019    /// Wraps `isl_union_set_lex_le_union_set`.
1020    pub fn lex_le_union_set(self, uset2: UnionSet) -> Result<UnionMap, LibISLError> {
1021        let uset1 = self;
1022        let isl_rs_ctx = uset1.get_ctx();
1023        let mut uset1 = uset1;
1024        uset1.do_not_free_on_drop();
1025        let uset1 = uset1.ptr;
1026        let mut uset2 = uset2;
1027        uset2.do_not_free_on_drop();
1028        let uset2 = uset2.ptr;
1029        let isl_rs_result = unsafe { isl_union_set_lex_le_union_set(uset1, uset2) };
1030        let isl_rs_result = UnionMap { ptr: isl_rs_result,
1031                                       should_free_on_drop: true };
1032        let err = isl_rs_ctx.last_error();
1033        if err != Error::None_ {
1034            let err_msg = isl_rs_ctx.last_error_msg();
1035            isl_rs_ctx.reset_error();
1036            return Err(LibISLError::new(err, err_msg));
1037        }
1038        Ok(isl_rs_result)
1039    }
1040
1041    /// Wraps `isl_union_set_lex_lt_union_set`.
1042    pub fn lex_lt_union_set(self, uset2: UnionSet) -> Result<UnionMap, LibISLError> {
1043        let uset1 = self;
1044        let isl_rs_ctx = uset1.get_ctx();
1045        let mut uset1 = uset1;
1046        uset1.do_not_free_on_drop();
1047        let uset1 = uset1.ptr;
1048        let mut uset2 = uset2;
1049        uset2.do_not_free_on_drop();
1050        let uset2 = uset2.ptr;
1051        let isl_rs_result = unsafe { isl_union_set_lex_lt_union_set(uset1, uset2) };
1052        let isl_rs_result = UnionMap { ptr: isl_rs_result,
1053                                       should_free_on_drop: true };
1054        let err = isl_rs_ctx.last_error();
1055        if err != Error::None_ {
1056            let err_msg = isl_rs_ctx.last_error_msg();
1057            isl_rs_ctx.reset_error();
1058            return Err(LibISLError::new(err, err_msg));
1059        }
1060        Ok(isl_rs_result)
1061    }
1062
1063    /// Wraps `isl_union_set_lexmax`.
1064    pub fn lexmax(self) -> Result<UnionSet, LibISLError> {
1065        let uset = self;
1066        let isl_rs_ctx = uset.get_ctx();
1067        let mut uset = uset;
1068        uset.do_not_free_on_drop();
1069        let uset = uset.ptr;
1070        let isl_rs_result = unsafe { isl_union_set_lexmax(uset) };
1071        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1072                                       should_free_on_drop: true };
1073        let err = isl_rs_ctx.last_error();
1074        if err != Error::None_ {
1075            let err_msg = isl_rs_ctx.last_error_msg();
1076            isl_rs_ctx.reset_error();
1077            return Err(LibISLError::new(err, err_msg));
1078        }
1079        Ok(isl_rs_result)
1080    }
1081
1082    /// Wraps `isl_union_set_lexmin`.
1083    pub fn lexmin(self) -> Result<UnionSet, LibISLError> {
1084        let uset = self;
1085        let isl_rs_ctx = uset.get_ctx();
1086        let mut uset = uset;
1087        uset.do_not_free_on_drop();
1088        let uset = uset.ptr;
1089        let isl_rs_result = unsafe { isl_union_set_lexmin(uset) };
1090        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1091                                       should_free_on_drop: true };
1092        let err = isl_rs_ctx.last_error();
1093        if err != Error::None_ {
1094            let err_msg = isl_rs_ctx.last_error_msg();
1095            isl_rs_ctx.reset_error();
1096            return Err(LibISLError::new(err, err_msg));
1097        }
1098        Ok(isl_rs_result)
1099    }
1100
1101    /// Wraps `isl_union_set_lift`.
1102    pub fn lift(self) -> Result<UnionSet, LibISLError> {
1103        let uset = self;
1104        let isl_rs_ctx = uset.get_ctx();
1105        let mut uset = uset;
1106        uset.do_not_free_on_drop();
1107        let uset = uset.ptr;
1108        let isl_rs_result = unsafe { isl_union_set_lift(uset) };
1109        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1110                                       should_free_on_drop: true };
1111        let err = isl_rs_ctx.last_error();
1112        if err != Error::None_ {
1113            let err_msg = isl_rs_ctx.last_error_msg();
1114            isl_rs_ctx.reset_error();
1115            return Err(LibISLError::new(err, err_msg));
1116        }
1117        Ok(isl_rs_result)
1118    }
1119
1120    /// Wraps `isl_union_set_min_multi_union_pw_aff`.
1121    pub fn min_multi_union_pw_aff(&self, obj: &MultiUnionPwAff) -> Result<MultiVal, LibISLError> {
1122        let uset = self;
1123        let isl_rs_ctx = uset.get_ctx();
1124        let uset = uset.ptr;
1125        let obj = obj.ptr;
1126        let isl_rs_result = unsafe { isl_union_set_min_multi_union_pw_aff(uset, obj) };
1127        let isl_rs_result = MultiVal { ptr: isl_rs_result,
1128                                       should_free_on_drop: true };
1129        let err = isl_rs_ctx.last_error();
1130        if err != Error::None_ {
1131            let err_msg = isl_rs_ctx.last_error_msg();
1132            isl_rs_ctx.reset_error();
1133            return Err(LibISLError::new(err, err_msg));
1134        }
1135        Ok(isl_rs_result)
1136    }
1137
1138    /// Wraps `isl_union_set_n_set`.
1139    pub fn n_set(&self) -> Result<i32, LibISLError> {
1140        let uset = self;
1141        let isl_rs_ctx = uset.get_ctx();
1142        let uset = uset.ptr;
1143        let isl_rs_result = unsafe { isl_union_set_n_set(uset) };
1144        let err = isl_rs_ctx.last_error();
1145        if err != Error::None_ {
1146            let err_msg = isl_rs_ctx.last_error_msg();
1147            isl_rs_ctx.reset_error();
1148            return Err(LibISLError::new(err, err_msg));
1149        }
1150        Ok(isl_rs_result)
1151    }
1152
1153    /// Wraps `isl_union_set_params`.
1154    pub fn params(self) -> Result<Set, LibISLError> {
1155        let uset = self;
1156        let isl_rs_ctx = uset.get_ctx();
1157        let mut uset = uset;
1158        uset.do_not_free_on_drop();
1159        let uset = uset.ptr;
1160        let isl_rs_result = unsafe { isl_union_set_params(uset) };
1161        let isl_rs_result = Set { ptr: isl_rs_result,
1162                                  should_free_on_drop: true };
1163        let err = isl_rs_ctx.last_error();
1164        if err != Error::None_ {
1165            let err_msg = isl_rs_ctx.last_error_msg();
1166            isl_rs_ctx.reset_error();
1167            return Err(LibISLError::new(err, err_msg));
1168        }
1169        Ok(isl_rs_result)
1170    }
1171
1172    /// Wraps `isl_union_set_plain_unshifted_simple_hull`.
1173    pub fn plain_unshifted_simple_hull(self) -> Result<UnionSet, LibISLError> {
1174        let uset = self;
1175        let isl_rs_ctx = uset.get_ctx();
1176        let mut uset = uset;
1177        uset.do_not_free_on_drop();
1178        let uset = uset.ptr;
1179        let isl_rs_result = unsafe { isl_union_set_plain_unshifted_simple_hull(uset) };
1180        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1181                                       should_free_on_drop: true };
1182        let err = isl_rs_ctx.last_error();
1183        if err != Error::None_ {
1184            let err_msg = isl_rs_ctx.last_error_msg();
1185            isl_rs_ctx.reset_error();
1186            return Err(LibISLError::new(err, err_msg));
1187        }
1188        Ok(isl_rs_result)
1189    }
1190
1191    /// Wraps `isl_union_set_polyhedral_hull`.
1192    pub fn polyhedral_hull(self) -> Result<UnionSet, LibISLError> {
1193        let uset = self;
1194        let isl_rs_ctx = uset.get_ctx();
1195        let mut uset = uset;
1196        uset.do_not_free_on_drop();
1197        let uset = uset.ptr;
1198        let isl_rs_result = unsafe { isl_union_set_polyhedral_hull(uset) };
1199        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1200                                       should_free_on_drop: true };
1201        let err = isl_rs_ctx.last_error();
1202        if err != Error::None_ {
1203            let err_msg = isl_rs_ctx.last_error_msg();
1204            isl_rs_ctx.reset_error();
1205            return Err(LibISLError::new(err, err_msg));
1206        }
1207        Ok(isl_rs_result)
1208    }
1209
1210    /// Wraps `isl_union_set_preimage_multi_aff`.
1211    pub fn preimage_multi_aff(self, ma: MultiAff) -> Result<UnionSet, LibISLError> {
1212        let uset = self;
1213        let isl_rs_ctx = uset.get_ctx();
1214        let mut uset = uset;
1215        uset.do_not_free_on_drop();
1216        let uset = uset.ptr;
1217        let mut ma = ma;
1218        ma.do_not_free_on_drop();
1219        let ma = ma.ptr;
1220        let isl_rs_result = unsafe { isl_union_set_preimage_multi_aff(uset, ma) };
1221        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1222                                       should_free_on_drop: true };
1223        let err = isl_rs_ctx.last_error();
1224        if err != Error::None_ {
1225            let err_msg = isl_rs_ctx.last_error_msg();
1226            isl_rs_ctx.reset_error();
1227            return Err(LibISLError::new(err, err_msg));
1228        }
1229        Ok(isl_rs_result)
1230    }
1231
1232    /// Wraps `isl_union_set_preimage_pw_multi_aff`.
1233    pub fn preimage_pw_multi_aff(self, pma: PwMultiAff) -> Result<UnionSet, LibISLError> {
1234        let uset = self;
1235        let isl_rs_ctx = uset.get_ctx();
1236        let mut uset = uset;
1237        uset.do_not_free_on_drop();
1238        let uset = uset.ptr;
1239        let mut pma = pma;
1240        pma.do_not_free_on_drop();
1241        let pma = pma.ptr;
1242        let isl_rs_result = unsafe { isl_union_set_preimage_pw_multi_aff(uset, pma) };
1243        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1244                                       should_free_on_drop: true };
1245        let err = isl_rs_ctx.last_error();
1246        if err != Error::None_ {
1247            let err_msg = isl_rs_ctx.last_error_msg();
1248            isl_rs_ctx.reset_error();
1249            return Err(LibISLError::new(err, err_msg));
1250        }
1251        Ok(isl_rs_result)
1252    }
1253
1254    /// Wraps `isl_union_set_preimage_union_pw_multi_aff`.
1255    pub fn preimage_union_pw_multi_aff(self, upma: UnionPwMultiAff)
1256                                       -> Result<UnionSet, LibISLError> {
1257        let uset = self;
1258        let isl_rs_ctx = uset.get_ctx();
1259        let mut uset = uset;
1260        uset.do_not_free_on_drop();
1261        let uset = uset.ptr;
1262        let mut upma = upma;
1263        upma.do_not_free_on_drop();
1264        let upma = upma.ptr;
1265        let isl_rs_result = unsafe { isl_union_set_preimage_union_pw_multi_aff(uset, upma) };
1266        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1267                                       should_free_on_drop: true };
1268        let err = isl_rs_ctx.last_error();
1269        if err != Error::None_ {
1270            let err_msg = isl_rs_ctx.last_error_msg();
1271            isl_rs_ctx.reset_error();
1272            return Err(LibISLError::new(err, err_msg));
1273        }
1274        Ok(isl_rs_result)
1275    }
1276
1277    /// Wraps `isl_union_set_product`.
1278    pub fn product(self, uset2: UnionSet) -> Result<UnionSet, LibISLError> {
1279        let uset1 = self;
1280        let isl_rs_ctx = uset1.get_ctx();
1281        let mut uset1 = uset1;
1282        uset1.do_not_free_on_drop();
1283        let uset1 = uset1.ptr;
1284        let mut uset2 = uset2;
1285        uset2.do_not_free_on_drop();
1286        let uset2 = uset2.ptr;
1287        let isl_rs_result = unsafe { isl_union_set_product(uset1, uset2) };
1288        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1289                                       should_free_on_drop: true };
1290        let err = isl_rs_ctx.last_error();
1291        if err != Error::None_ {
1292            let err_msg = isl_rs_ctx.last_error_msg();
1293            isl_rs_ctx.reset_error();
1294            return Err(LibISLError::new(err, err_msg));
1295        }
1296        Ok(isl_rs_result)
1297    }
1298
1299    /// Wraps `isl_union_set_project_out`.
1300    pub fn project_out(self, type_: DimType, first: u32, n: u32) -> Result<UnionSet, LibISLError> {
1301        let uset = self;
1302        let isl_rs_ctx = uset.get_ctx();
1303        let mut uset = uset;
1304        uset.do_not_free_on_drop();
1305        let uset = uset.ptr;
1306        let type_ = type_.to_i32();
1307        let isl_rs_result = unsafe { isl_union_set_project_out(uset, type_, first, n) };
1308        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1309                                       should_free_on_drop: true };
1310        let err = isl_rs_ctx.last_error();
1311        if err != Error::None_ {
1312            let err_msg = isl_rs_ctx.last_error_msg();
1313            isl_rs_ctx.reset_error();
1314            return Err(LibISLError::new(err, err_msg));
1315        }
1316        Ok(isl_rs_result)
1317    }
1318
1319    /// Wraps `isl_union_set_project_out_all_params`.
1320    pub fn project_out_all_params(self) -> Result<UnionSet, LibISLError> {
1321        let uset = self;
1322        let isl_rs_ctx = uset.get_ctx();
1323        let mut uset = uset;
1324        uset.do_not_free_on_drop();
1325        let uset = uset.ptr;
1326        let isl_rs_result = unsafe { isl_union_set_project_out_all_params(uset) };
1327        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1328                                       should_free_on_drop: true };
1329        let err = isl_rs_ctx.last_error();
1330        if err != Error::None_ {
1331            let err_msg = isl_rs_ctx.last_error_msg();
1332            isl_rs_ctx.reset_error();
1333            return Err(LibISLError::new(err, err_msg));
1334        }
1335        Ok(isl_rs_result)
1336    }
1337
1338    /// Wraps `isl_union_set_read_from_str`.
1339    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<UnionSet, LibISLError> {
1340        let isl_rs_ctx = Context { ptr: ctx.ptr,
1341                                   should_free_on_drop: false };
1342        let ctx = ctx.ptr;
1343        let str_ = CString::new(str_).unwrap();
1344        let str_ = str_.as_ptr();
1345        let isl_rs_result = unsafe { isl_union_set_read_from_str(ctx, str_) };
1346        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1347                                       should_free_on_drop: true };
1348        let err = isl_rs_ctx.last_error();
1349        if err != Error::None_ {
1350            let err_msg = isl_rs_ctx.last_error_msg();
1351            isl_rs_ctx.reset_error();
1352            return Err(LibISLError::new(err, err_msg));
1353        }
1354        Ok(isl_rs_result)
1355    }
1356
1357    /// Wraps `isl_union_set_remove_divs`.
1358    pub fn remove_divs(self) -> Result<UnionSet, LibISLError> {
1359        let bset = self;
1360        let isl_rs_ctx = bset.get_ctx();
1361        let mut bset = bset;
1362        bset.do_not_free_on_drop();
1363        let bset = bset.ptr;
1364        let isl_rs_result = unsafe { isl_union_set_remove_divs(bset) };
1365        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1366                                       should_free_on_drop: true };
1367        let err = isl_rs_ctx.last_error();
1368        if err != Error::None_ {
1369            let err_msg = isl_rs_ctx.last_error_msg();
1370            isl_rs_ctx.reset_error();
1371            return Err(LibISLError::new(err, err_msg));
1372        }
1373        Ok(isl_rs_result)
1374    }
1375
1376    /// Wraps `isl_union_set_remove_redundancies`.
1377    pub fn remove_redundancies(self) -> Result<UnionSet, LibISLError> {
1378        let uset = self;
1379        let isl_rs_ctx = uset.get_ctx();
1380        let mut uset = uset;
1381        uset.do_not_free_on_drop();
1382        let uset = uset.ptr;
1383        let isl_rs_result = unsafe { isl_union_set_remove_redundancies(uset) };
1384        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1385                                       should_free_on_drop: true };
1386        let err = isl_rs_ctx.last_error();
1387        if err != Error::None_ {
1388            let err_msg = isl_rs_ctx.last_error_msg();
1389            isl_rs_ctx.reset_error();
1390            return Err(LibISLError::new(err, err_msg));
1391        }
1392        Ok(isl_rs_result)
1393    }
1394
1395    /// Wraps `isl_union_set_reset_user`.
1396    pub fn reset_user(self) -> Result<UnionSet, LibISLError> {
1397        let uset = self;
1398        let isl_rs_ctx = uset.get_ctx();
1399        let mut uset = uset;
1400        uset.do_not_free_on_drop();
1401        let uset = uset.ptr;
1402        let isl_rs_result = unsafe { isl_union_set_reset_user(uset) };
1403        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1404                                       should_free_on_drop: true };
1405        let err = isl_rs_ctx.last_error();
1406        if err != Error::None_ {
1407            let err_msg = isl_rs_ctx.last_error_msg();
1408            isl_rs_ctx.reset_error();
1409            return Err(LibISLError::new(err, err_msg));
1410        }
1411        Ok(isl_rs_result)
1412    }
1413
1414    /// Wraps `isl_union_set_sample`.
1415    pub fn sample(self) -> Result<BasicSet, LibISLError> {
1416        let uset = self;
1417        let isl_rs_ctx = uset.get_ctx();
1418        let mut uset = uset;
1419        uset.do_not_free_on_drop();
1420        let uset = uset.ptr;
1421        let isl_rs_result = unsafe { isl_union_set_sample(uset) };
1422        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1423                                       should_free_on_drop: true };
1424        let err = isl_rs_ctx.last_error();
1425        if err != Error::None_ {
1426            let err_msg = isl_rs_ctx.last_error_msg();
1427            isl_rs_ctx.reset_error();
1428            return Err(LibISLError::new(err, err_msg));
1429        }
1430        Ok(isl_rs_result)
1431    }
1432
1433    /// Wraps `isl_union_set_sample_point`.
1434    pub fn sample_point(self) -> Result<Point, LibISLError> {
1435        let uset = self;
1436        let isl_rs_ctx = uset.get_ctx();
1437        let mut uset = uset;
1438        uset.do_not_free_on_drop();
1439        let uset = uset.ptr;
1440        let isl_rs_result = unsafe { isl_union_set_sample_point(uset) };
1441        let isl_rs_result = Point { ptr: isl_rs_result,
1442                                    should_free_on_drop: true };
1443        let err = isl_rs_ctx.last_error();
1444        if err != Error::None_ {
1445            let err_msg = isl_rs_ctx.last_error_msg();
1446            isl_rs_ctx.reset_error();
1447            return Err(LibISLError::new(err, err_msg));
1448        }
1449        Ok(isl_rs_result)
1450    }
1451
1452    /// Wraps `isl_union_set_simple_hull`.
1453    pub fn simple_hull(self) -> Result<UnionSet, LibISLError> {
1454        let uset = self;
1455        let isl_rs_ctx = uset.get_ctx();
1456        let mut uset = uset;
1457        uset.do_not_free_on_drop();
1458        let uset = uset.ptr;
1459        let isl_rs_result = unsafe { isl_union_set_simple_hull(uset) };
1460        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1461                                       should_free_on_drop: true };
1462        let err = isl_rs_ctx.last_error();
1463        if err != Error::None_ {
1464            let err_msg = isl_rs_ctx.last_error_msg();
1465            isl_rs_ctx.reset_error();
1466            return Err(LibISLError::new(err, err_msg));
1467        }
1468        Ok(isl_rs_result)
1469    }
1470
1471    /// Wraps `isl_union_set_solutions`.
1472    pub fn solutions(self) -> Result<UnionSet, LibISLError> {
1473        let bset = self;
1474        let isl_rs_ctx = bset.get_ctx();
1475        let mut bset = bset;
1476        bset.do_not_free_on_drop();
1477        let bset = bset.ptr;
1478        let isl_rs_result = unsafe { isl_union_set_solutions(bset) };
1479        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1480                                       should_free_on_drop: true };
1481        let err = isl_rs_ctx.last_error();
1482        if err != Error::None_ {
1483            let err_msg = isl_rs_ctx.last_error_msg();
1484            isl_rs_ctx.reset_error();
1485            return Err(LibISLError::new(err, err_msg));
1486        }
1487        Ok(isl_rs_result)
1488    }
1489
1490    /// Wraps `isl_union_set_subtract`.
1491    pub fn subtract(self, uset2: UnionSet) -> Result<UnionSet, LibISLError> {
1492        let uset1 = self;
1493        let isl_rs_ctx = uset1.get_ctx();
1494        let mut uset1 = uset1;
1495        uset1.do_not_free_on_drop();
1496        let uset1 = uset1.ptr;
1497        let mut uset2 = uset2;
1498        uset2.do_not_free_on_drop();
1499        let uset2 = uset2.ptr;
1500        let isl_rs_result = unsafe { isl_union_set_subtract(uset1, uset2) };
1501        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1502                                       should_free_on_drop: true };
1503        let err = isl_rs_ctx.last_error();
1504        if err != Error::None_ {
1505            let err_msg = isl_rs_ctx.last_error_msg();
1506            isl_rs_ctx.reset_error();
1507            return Err(LibISLError::new(err, err_msg));
1508        }
1509        Ok(isl_rs_result)
1510    }
1511
1512    /// Wraps `isl_union_set_to_list`.
1513    pub fn to_list(self) -> Result<UnionSetList, LibISLError> {
1514        let el = self;
1515        let isl_rs_ctx = el.get_ctx();
1516        let mut el = el;
1517        el.do_not_free_on_drop();
1518        let el = el.ptr;
1519        let isl_rs_result = unsafe { isl_union_set_to_list(el) };
1520        let isl_rs_result = UnionSetList { ptr: isl_rs_result,
1521                                           should_free_on_drop: true };
1522        let err = isl_rs_ctx.last_error();
1523        if err != Error::None_ {
1524            let err_msg = isl_rs_ctx.last_error_msg();
1525            isl_rs_ctx.reset_error();
1526            return Err(LibISLError::new(err, err_msg));
1527        }
1528        Ok(isl_rs_result)
1529    }
1530
1531    /// Wraps `isl_union_set_to_str`.
1532    pub fn to_str(&self) -> Result<&str, LibISLError> {
1533        let uset = self;
1534        let isl_rs_ctx = uset.get_ctx();
1535        let uset = uset.ptr;
1536        let isl_rs_result = unsafe { isl_union_set_to_str(uset) };
1537        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1538        let isl_rs_result = isl_rs_result.to_str().unwrap();
1539        let err = isl_rs_ctx.last_error();
1540        if err != Error::None_ {
1541            let err_msg = isl_rs_ctx.last_error_msg();
1542            isl_rs_ctx.reset_error();
1543            return Err(LibISLError::new(err, err_msg));
1544        }
1545        Ok(isl_rs_result)
1546    }
1547
1548    /// Wraps `isl_union_set_union`.
1549    pub fn union(self, uset2: UnionSet) -> Result<UnionSet, LibISLError> {
1550        let uset1 = self;
1551        let isl_rs_ctx = uset1.get_ctx();
1552        let mut uset1 = uset1;
1553        uset1.do_not_free_on_drop();
1554        let uset1 = uset1.ptr;
1555        let mut uset2 = uset2;
1556        uset2.do_not_free_on_drop();
1557        let uset2 = uset2.ptr;
1558        let isl_rs_result = unsafe { isl_union_set_union(uset1, uset2) };
1559        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1560                                       should_free_on_drop: true };
1561        let err = isl_rs_ctx.last_error();
1562        if err != Error::None_ {
1563            let err_msg = isl_rs_ctx.last_error_msg();
1564            isl_rs_ctx.reset_error();
1565            return Err(LibISLError::new(err, err_msg));
1566        }
1567        Ok(isl_rs_result)
1568    }
1569
1570    /// Wraps `isl_union_set_universe`.
1571    pub fn universe(self) -> Result<UnionSet, LibISLError> {
1572        let uset = self;
1573        let isl_rs_ctx = uset.get_ctx();
1574        let mut uset = uset;
1575        uset.do_not_free_on_drop();
1576        let uset = uset.ptr;
1577        let isl_rs_result = unsafe { isl_union_set_universe(uset) };
1578        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1579                                       should_free_on_drop: true };
1580        let err = isl_rs_ctx.last_error();
1581        if err != Error::None_ {
1582            let err_msg = isl_rs_ctx.last_error_msg();
1583            isl_rs_ctx.reset_error();
1584            return Err(LibISLError::new(err, err_msg));
1585        }
1586        Ok(isl_rs_result)
1587    }
1588
1589    /// Wraps `isl_union_set_unwrap`.
1590    pub fn unwrap(self) -> Result<UnionMap, LibISLError> {
1591        let uset = self;
1592        let isl_rs_ctx = uset.get_ctx();
1593        let mut uset = uset;
1594        uset.do_not_free_on_drop();
1595        let uset = uset.ptr;
1596        let isl_rs_result = unsafe { isl_union_set_unwrap(uset) };
1597        let isl_rs_result = UnionMap { ptr: isl_rs_result,
1598                                       should_free_on_drop: true };
1599        let err = isl_rs_ctx.last_error();
1600        if err != Error::None_ {
1601            let err_msg = isl_rs_ctx.last_error_msg();
1602            isl_rs_ctx.reset_error();
1603            return Err(LibISLError::new(err, err_msg));
1604        }
1605        Ok(isl_rs_result)
1606    }
1607
1608    /// Wraps `isl_union_set_wrapped_domain_map`.
1609    pub fn wrapped_domain_map(self) -> Result<UnionMap, LibISLError> {
1610        let uset = self;
1611        let isl_rs_ctx = uset.get_ctx();
1612        let mut uset = uset;
1613        uset.do_not_free_on_drop();
1614        let uset = uset.ptr;
1615        let isl_rs_result = unsafe { isl_union_set_wrapped_domain_map(uset) };
1616        let isl_rs_result = UnionMap { ptr: isl_rs_result,
1617                                       should_free_on_drop: true };
1618        let err = isl_rs_ctx.last_error();
1619        if err != Error::None_ {
1620            let err_msg = isl_rs_ctx.last_error_msg();
1621            isl_rs_ctx.reset_error();
1622            return Err(LibISLError::new(err, err_msg));
1623        }
1624        Ok(isl_rs_result)
1625    }
1626
1627    /// Does not call isl_union_set_free() on being dropped. (For internal use
1628    /// only.)
1629    pub fn do_not_free_on_drop(&mut self) {
1630        self.should_free_on_drop = false;
1631    }
1632}
1633
1634impl Drop for UnionSet {
1635    fn drop(&mut self) {
1636        if self.should_free_on_drop {
1637            unsafe {
1638                isl_union_set_free(self.ptr);
1639            }
1640        }
1641    }
1642}
isl_rs/bindings/union_set.rs

isl_rs/bindings/
union_set.rs
