isl_rs/bindings/
basic_set.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{
5    Aff, BasicMap, BasicSetList, Constraint, ConstraintList, Context, DimType, Error, Id,
6    LibISLError, LocalSpace, Mat, MultiAff, Point, Set, Space, Val, Vertices,
7};
8use libc::uintptr_t;
9use std::ffi::{CStr, CString};
10use std::os::raw::c_char;
11
12/// Wraps `isl_basic_set`.
13pub struct BasicSet {
14    pub ptr: uintptr_t,
15    pub should_free_on_drop: bool,
16}
17
18extern "C" {
19
20    fn isl_basic_set_add_constraint(bset: uintptr_t, constraint: uintptr_t) -> uintptr_t;
21
22    fn isl_basic_set_add_dims(bset: uintptr_t, type_: i32, n: u32) -> uintptr_t;
23
24    fn isl_basic_set_affine_hull(bset: uintptr_t) -> uintptr_t;
25
26    fn isl_basic_set_align_params(bset: uintptr_t, model: uintptr_t) -> uintptr_t;
27
28    fn isl_basic_set_apply(bset: uintptr_t, bmap: uintptr_t) -> uintptr_t;
29
30    fn isl_basic_set_box_from_points(pnt1: uintptr_t, pnt2: uintptr_t) -> uintptr_t;
31
32    fn isl_basic_set_coefficients(bset: uintptr_t) -> uintptr_t;
33
34    fn isl_basic_set_compare_at(bset1: uintptr_t, bset2: uintptr_t, pos: i32) -> i32;
35
36    fn isl_basic_set_compute_divs(bset: uintptr_t) -> uintptr_t;
37
38    fn isl_basic_set_compute_vertices(bset: uintptr_t) -> uintptr_t;
39
40    fn isl_basic_set_copy(bset: uintptr_t) -> uintptr_t;
41
42    fn isl_basic_set_detect_equalities(bset: uintptr_t) -> uintptr_t;
43
44    fn isl_basic_set_dim(bset: uintptr_t, type_: i32) -> i32;
45
46    fn isl_basic_set_dim_max_val(bset: uintptr_t, pos: i32) -> uintptr_t;
47
48    fn isl_basic_set_drop_constraints_involving_dims(bset: uintptr_t, type_: i32, first: u32,
49                                                     n: u32)
50                                                     -> uintptr_t;
51
52    fn isl_basic_set_drop_constraints_not_involving_dims(bset: uintptr_t, type_: i32, first: u32,
53                                                         n: u32)
54                                                         -> uintptr_t;
55
56    fn isl_basic_set_drop_unused_params(bset: uintptr_t) -> uintptr_t;
57
58    fn isl_basic_set_dump(bset: uintptr_t) -> ();
59
60    fn isl_basic_set_eliminate(bset: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;
61
62    fn isl_basic_set_empty(space: uintptr_t) -> uintptr_t;
63
64    fn isl_basic_set_equalities_matrix(bset: uintptr_t, c1: i32, c2: i32, c3: i32, c4: i32)
65                                       -> uintptr_t;
66
67    fn isl_basic_set_fix_si(bset: uintptr_t, type_: i32, pos: u32, value: i32) -> uintptr_t;
68
69    fn isl_basic_set_fix_val(bset: uintptr_t, type_: i32, pos: u32, v: uintptr_t) -> uintptr_t;
70
71    fn isl_basic_set_flat_product(bset1: uintptr_t, bset2: uintptr_t) -> uintptr_t;
72
73    fn isl_basic_set_flatten(bset: uintptr_t) -> uintptr_t;
74
75    fn isl_basic_set_free(bset: uintptr_t) -> uintptr_t;
76
77    fn isl_basic_set_from_constraint(constraint: uintptr_t) -> uintptr_t;
78
79    fn isl_basic_set_from_constraint_matrices(space: uintptr_t, eq: uintptr_t, ineq: uintptr_t,
80                                              c1: i32, c2: i32, c3: i32, c4: i32)
81                                              -> uintptr_t;
82
83    fn isl_basic_set_from_multi_aff(ma: uintptr_t) -> uintptr_t;
84
85    fn isl_basic_set_from_params(bset: uintptr_t) -> uintptr_t;
86
87    fn isl_basic_set_from_point(pnt: uintptr_t) -> uintptr_t;
88
89    fn isl_basic_set_get_constraint_list(bset: uintptr_t) -> uintptr_t;
90
91    fn isl_basic_set_get_ctx(bset: uintptr_t) -> uintptr_t;
92
93    fn isl_basic_set_get_dim_id(bset: uintptr_t, type_: i32, pos: u32) -> uintptr_t;
94
95    fn isl_basic_set_get_dim_name(bset: uintptr_t, type_: i32, pos: u32) -> *const c_char;
96
97    fn isl_basic_set_get_div(bset: uintptr_t, pos: i32) -> uintptr_t;
98
99    fn isl_basic_set_get_local_space(bset: uintptr_t) -> uintptr_t;
100
101    fn isl_basic_set_get_space(bset: uintptr_t) -> uintptr_t;
102
103    fn isl_basic_set_get_tuple_name(bset: uintptr_t) -> *const c_char;
104
105    fn isl_basic_set_gist(bset: uintptr_t, context: uintptr_t) -> uintptr_t;
106
107    fn isl_basic_set_inequalities_matrix(bset: uintptr_t, c1: i32, c2: i32, c3: i32, c4: i32)
108                                         -> uintptr_t;
109
110    fn isl_basic_set_insert_dims(bset: uintptr_t, type_: i32, pos: u32, n: u32) -> uintptr_t;
111
112    fn isl_basic_set_intersect(bset1: uintptr_t, bset2: uintptr_t) -> uintptr_t;
113
114    fn isl_basic_set_intersect_params(bset1: uintptr_t, bset2: uintptr_t) -> uintptr_t;
115
116    fn isl_basic_set_involves_dims(bset: uintptr_t, type_: i32, first: u32, n: u32) -> i32;
117
118    fn isl_basic_set_is_bounded(bset: uintptr_t) -> i32;
119
120    fn isl_basic_set_is_disjoint(bset1: uintptr_t, bset2: uintptr_t) -> i32;
121
122    fn isl_basic_set_is_empty(bset: uintptr_t) -> i32;
123
124    fn isl_basic_set_is_equal(bset1: uintptr_t, bset2: uintptr_t) -> i32;
125
126    fn isl_basic_set_is_rational(bset: uintptr_t) -> i32;
127
128    fn isl_basic_set_is_subset(bset1: uintptr_t, bset2: uintptr_t) -> i32;
129
130    fn isl_basic_set_is_universe(bset: uintptr_t) -> i32;
131
132    fn isl_basic_set_is_wrapping(bset: uintptr_t) -> i32;
133
134    fn isl_basic_set_lexmax(bset: uintptr_t) -> uintptr_t;
135
136    fn isl_basic_set_lexmin(bset: uintptr_t) -> uintptr_t;
137
138    fn isl_basic_set_lift(bset: uintptr_t) -> uintptr_t;
139
140    fn isl_basic_set_lower_bound_val(bset: uintptr_t, type_: i32, pos: u32, value: uintptr_t)
141                                     -> uintptr_t;
142
143    fn isl_basic_set_max_lp_val(bset: uintptr_t, obj: uintptr_t) -> uintptr_t;
144
145    fn isl_basic_set_max_val(bset: uintptr_t, obj: uintptr_t) -> uintptr_t;
146
147    fn isl_basic_set_min_lp_val(bset: uintptr_t, obj: uintptr_t) -> uintptr_t;
148
149    fn isl_basic_set_move_dims(bset: uintptr_t, dst_type: i32, dst_pos: u32, src_type: i32,
150                               src_pos: u32, n: u32)
151                               -> uintptr_t;
152
153    fn isl_basic_set_n_constraint(bset: uintptr_t) -> i32;
154
155    fn isl_basic_set_n_dim(bset: uintptr_t) -> i32;
156
157    fn isl_basic_set_n_param(bset: uintptr_t) -> i32;
158
159    fn isl_basic_set_nat_universe(space: uintptr_t) -> uintptr_t;
160
161    fn isl_basic_set_neg(bset: uintptr_t) -> uintptr_t;
162
163    fn isl_basic_set_params(bset: uintptr_t) -> uintptr_t;
164
165    fn isl_basic_set_plain_is_empty(bset: uintptr_t) -> i32;
166
167    fn isl_basic_set_plain_is_equal(bset1: uintptr_t, bset2: uintptr_t) -> i32;
168
169    fn isl_basic_set_plain_is_universe(bset: uintptr_t) -> i32;
170
171    fn isl_basic_set_positive_orthant(space: uintptr_t) -> uintptr_t;
172
173    fn isl_basic_set_preimage_multi_aff(bset: uintptr_t, ma: uintptr_t) -> uintptr_t;
174
175    fn isl_basic_set_project_out(bset: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;
176
177    fn isl_basic_set_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
178
179    fn isl_basic_set_reduced_basis(bset: uintptr_t) -> uintptr_t;
180
181    fn isl_basic_set_remove_dims(bset: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;
182
183    fn isl_basic_set_remove_divs(bset: uintptr_t) -> uintptr_t;
184
185    fn isl_basic_set_remove_divs_involving_dims(bset: uintptr_t, type_: i32, first: u32, n: u32)
186                                                -> uintptr_t;
187
188    fn isl_basic_set_remove_redundancies(bset: uintptr_t) -> uintptr_t;
189
190    fn isl_basic_set_remove_unknown_divs(bset: uintptr_t) -> uintptr_t;
191
192    fn isl_basic_set_sample(bset: uintptr_t) -> uintptr_t;
193
194    fn isl_basic_set_sample_point(bset: uintptr_t) -> uintptr_t;
195
196    fn isl_basic_set_set_dim_name(bset: uintptr_t, type_: i32, pos: u32, s: *const c_char)
197                                  -> uintptr_t;
198
199    fn isl_basic_set_set_tuple_id(bset: uintptr_t, id: uintptr_t) -> uintptr_t;
200
201    fn isl_basic_set_set_tuple_name(set: uintptr_t, s: *const c_char) -> uintptr_t;
202
203    fn isl_basic_set_solutions(bset: uintptr_t) -> uintptr_t;
204
205    fn isl_basic_set_to_list(el: uintptr_t) -> uintptr_t;
206
207    fn isl_basic_set_to_set(bset: uintptr_t) -> uintptr_t;
208
209    fn isl_basic_set_to_str(bset: uintptr_t) -> *const c_char;
210
211    fn isl_basic_set_total_dim(bset: uintptr_t) -> i32;
212
213    fn isl_basic_set_union(bset1: uintptr_t, bset2: uintptr_t) -> uintptr_t;
214
215    fn isl_basic_set_universe(space: uintptr_t) -> uintptr_t;
216
217    fn isl_basic_set_unwrap(bset: uintptr_t) -> uintptr_t;
218
219    fn isl_basic_set_upper_bound_val(bset: uintptr_t, type_: i32, pos: u32, value: uintptr_t)
220                                     -> uintptr_t;
221
222}
223
224impl BasicSet {
225    /// Wraps `isl_basic_set_add_constraint`.
226    pub fn add_constraint(self, constraint: Constraint) -> Result<BasicSet, LibISLError> {
227        let bset = self;
228        let isl_rs_ctx = bset.get_ctx();
229        let mut bset = bset;
230        bset.do_not_free_on_drop();
231        let bset = bset.ptr;
232        let mut constraint = constraint;
233        constraint.do_not_free_on_drop();
234        let constraint = constraint.ptr;
235        let isl_rs_result = unsafe { isl_basic_set_add_constraint(bset, constraint) };
236        let isl_rs_result = BasicSet { ptr: isl_rs_result,
237                                       should_free_on_drop: true };
238        let err = isl_rs_ctx.last_error();
239        if err != Error::None_ {
240            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
241        }
242        Ok(isl_rs_result)
243    }
244
245    /// Wraps `isl_basic_set_add_dims`.
246    pub fn add_dims(self, type_: DimType, n: u32) -> Result<BasicSet, LibISLError> {
247        let bset = self;
248        let isl_rs_ctx = bset.get_ctx();
249        let mut bset = bset;
250        bset.do_not_free_on_drop();
251        let bset = bset.ptr;
252        let type_ = type_.to_i32();
253        let isl_rs_result = unsafe { isl_basic_set_add_dims(bset, type_, n) };
254        let isl_rs_result = BasicSet { ptr: isl_rs_result,
255                                       should_free_on_drop: true };
256        let err = isl_rs_ctx.last_error();
257        if err != Error::None_ {
258            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
259        }
260        Ok(isl_rs_result)
261    }
262
263    /// Wraps `isl_basic_set_affine_hull`.
264    pub fn affine_hull(self) -> Result<BasicSet, LibISLError> {
265        let bset = self;
266        let isl_rs_ctx = bset.get_ctx();
267        let mut bset = bset;
268        bset.do_not_free_on_drop();
269        let bset = bset.ptr;
270        let isl_rs_result = unsafe { isl_basic_set_affine_hull(bset) };
271        let isl_rs_result = BasicSet { ptr: isl_rs_result,
272                                       should_free_on_drop: true };
273        let err = isl_rs_ctx.last_error();
274        if err != Error::None_ {
275            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
276        }
277        Ok(isl_rs_result)
278    }
279
280    /// Wraps `isl_basic_set_align_params`.
281    pub fn align_params(self, model: Space) -> Result<BasicSet, LibISLError> {
282        let bset = self;
283        let isl_rs_ctx = bset.get_ctx();
284        let mut bset = bset;
285        bset.do_not_free_on_drop();
286        let bset = bset.ptr;
287        let mut model = model;
288        model.do_not_free_on_drop();
289        let model = model.ptr;
290        let isl_rs_result = unsafe { isl_basic_set_align_params(bset, model) };
291        let isl_rs_result = BasicSet { ptr: isl_rs_result,
292                                       should_free_on_drop: true };
293        let err = isl_rs_ctx.last_error();
294        if err != Error::None_ {
295            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
296        }
297        Ok(isl_rs_result)
298    }
299
300    /// Wraps `isl_basic_set_apply`.
301    pub fn apply(self, bmap: BasicMap) -> Result<BasicSet, LibISLError> {
302        let bset = self;
303        let isl_rs_ctx = bset.get_ctx();
304        let mut bset = bset;
305        bset.do_not_free_on_drop();
306        let bset = bset.ptr;
307        let mut bmap = bmap;
308        bmap.do_not_free_on_drop();
309        let bmap = bmap.ptr;
310        let isl_rs_result = unsafe { isl_basic_set_apply(bset, bmap) };
311        let isl_rs_result = BasicSet { ptr: isl_rs_result,
312                                       should_free_on_drop: true };
313        let err = isl_rs_ctx.last_error();
314        if err != Error::None_ {
315            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
316        }
317        Ok(isl_rs_result)
318    }
319
320    /// Wraps `isl_basic_set_box_from_points`.
321    pub fn box_from_points(pnt1: Point, pnt2: Point) -> Result<BasicSet, LibISLError> {
322        let isl_rs_ctx = pnt1.get_ctx();
323        let mut pnt1 = pnt1;
324        pnt1.do_not_free_on_drop();
325        let pnt1 = pnt1.ptr;
326        let mut pnt2 = pnt2;
327        pnt2.do_not_free_on_drop();
328        let pnt2 = pnt2.ptr;
329        let isl_rs_result = unsafe { isl_basic_set_box_from_points(pnt1, pnt2) };
330        let isl_rs_result = BasicSet { ptr: isl_rs_result,
331                                       should_free_on_drop: true };
332        let err = isl_rs_ctx.last_error();
333        if err != Error::None_ {
334            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
335        }
336        Ok(isl_rs_result)
337    }
338
339    /// Wraps `isl_basic_set_coefficients`.
340    pub fn coefficients(self) -> Result<BasicSet, LibISLError> {
341        let bset = self;
342        let isl_rs_ctx = bset.get_ctx();
343        let mut bset = bset;
344        bset.do_not_free_on_drop();
345        let bset = bset.ptr;
346        let isl_rs_result = unsafe { isl_basic_set_coefficients(bset) };
347        let isl_rs_result = BasicSet { ptr: isl_rs_result,
348                                       should_free_on_drop: true };
349        let err = isl_rs_ctx.last_error();
350        if err != Error::None_ {
351            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
352        }
353        Ok(isl_rs_result)
354    }
355
356    /// Wraps `isl_basic_set_compare_at`.
357    pub fn compare_at(&self, bset2: &BasicSet, pos: i32) -> Result<i32, LibISLError> {
358        let bset1 = self;
359        let isl_rs_ctx = bset1.get_ctx();
360        let bset1 = bset1.ptr;
361        let bset2 = bset2.ptr;
362        let isl_rs_result = unsafe { isl_basic_set_compare_at(bset1, bset2, pos) };
363        let err = isl_rs_ctx.last_error();
364        if err != Error::None_ {
365            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
366        }
367        Ok(isl_rs_result)
368    }
369
370    /// Wraps `isl_basic_set_compute_divs`.
371    pub fn compute_divs(self) -> Result<Set, LibISLError> {
372        let bset = self;
373        let isl_rs_ctx = bset.get_ctx();
374        let mut bset = bset;
375        bset.do_not_free_on_drop();
376        let bset = bset.ptr;
377        let isl_rs_result = unsafe { isl_basic_set_compute_divs(bset) };
378        let isl_rs_result = Set { ptr: isl_rs_result,
379                                  should_free_on_drop: true };
380        let err = isl_rs_ctx.last_error();
381        if err != Error::None_ {
382            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
383        }
384        Ok(isl_rs_result)
385    }
386
387    /// Wraps `isl_basic_set_compute_vertices`.
388    pub fn compute_vertices(&self) -> Result<Vertices, LibISLError> {
389        let bset = self;
390        let isl_rs_ctx = bset.get_ctx();
391        let bset = bset.ptr;
392        let isl_rs_result = unsafe { isl_basic_set_compute_vertices(bset) };
393        let isl_rs_result = Vertices { ptr: isl_rs_result,
394                                       should_free_on_drop: true };
395        let err = isl_rs_ctx.last_error();
396        if err != Error::None_ {
397            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
398        }
399        Ok(isl_rs_result)
400    }
401
402    /// Wraps `isl_basic_set_copy`.
403    pub fn copy(&self) -> Result<BasicSet, LibISLError> {
404        let bset = self;
405        let isl_rs_ctx = bset.get_ctx();
406        let bset = bset.ptr;
407        let isl_rs_result = unsafe { isl_basic_set_copy(bset) };
408        let isl_rs_result = BasicSet { ptr: isl_rs_result,
409                                       should_free_on_drop: true };
410        let err = isl_rs_ctx.last_error();
411        if err != Error::None_ {
412            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
413        }
414        Ok(isl_rs_result)
415    }
416
417    /// Wraps `isl_basic_set_detect_equalities`.
418    pub fn detect_equalities(self) -> Result<BasicSet, LibISLError> {
419        let bset = self;
420        let isl_rs_ctx = bset.get_ctx();
421        let mut bset = bset;
422        bset.do_not_free_on_drop();
423        let bset = bset.ptr;
424        let isl_rs_result = unsafe { isl_basic_set_detect_equalities(bset) };
425        let isl_rs_result = BasicSet { ptr: isl_rs_result,
426                                       should_free_on_drop: true };
427        let err = isl_rs_ctx.last_error();
428        if err != Error::None_ {
429            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
430        }
431        Ok(isl_rs_result)
432    }
433
434    /// Wraps `isl_basic_set_dim`.
435    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
436        let bset = self;
437        let isl_rs_ctx = bset.get_ctx();
438        let bset = bset.ptr;
439        let type_ = type_.to_i32();
440        let isl_rs_result = unsafe { isl_basic_set_dim(bset, type_) };
441        let err = isl_rs_ctx.last_error();
442        if err != Error::None_ {
443            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
444        }
445        Ok(isl_rs_result)
446    }
447
448    /// Wraps `isl_basic_set_dim_max_val`.
449    pub fn dim_max_val(self, pos: i32) -> Result<Val, LibISLError> {
450        let bset = self;
451        let isl_rs_ctx = bset.get_ctx();
452        let mut bset = bset;
453        bset.do_not_free_on_drop();
454        let bset = bset.ptr;
455        let isl_rs_result = unsafe { isl_basic_set_dim_max_val(bset, pos) };
456        let isl_rs_result = Val { ptr: isl_rs_result,
457                                  should_free_on_drop: true };
458        let err = isl_rs_ctx.last_error();
459        if err != Error::None_ {
460            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
461        }
462        Ok(isl_rs_result)
463    }
464
465    /// Wraps `isl_basic_set_drop_constraints_involving_dims`.
466    pub fn drop_constraints_involving_dims(self, type_: DimType, first: u32, n: u32)
467                                           -> Result<BasicSet, LibISLError> {
468        let bset = self;
469        let isl_rs_ctx = bset.get_ctx();
470        let mut bset = bset;
471        bset.do_not_free_on_drop();
472        let bset = bset.ptr;
473        let type_ = type_.to_i32();
474        let isl_rs_result =
475            unsafe { isl_basic_set_drop_constraints_involving_dims(bset, type_, first, n) };
476        let isl_rs_result = BasicSet { ptr: isl_rs_result,
477                                       should_free_on_drop: true };
478        let err = isl_rs_ctx.last_error();
479        if err != Error::None_ {
480            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
481        }
482        Ok(isl_rs_result)
483    }
484
485    /// Wraps `isl_basic_set_drop_constraints_not_involving_dims`.
486    pub fn drop_constraints_not_involving_dims(self, type_: DimType, first: u32, n: u32)
487                                               -> Result<BasicSet, LibISLError> {
488        let bset = self;
489        let isl_rs_ctx = bset.get_ctx();
490        let mut bset = bset;
491        bset.do_not_free_on_drop();
492        let bset = bset.ptr;
493        let type_ = type_.to_i32();
494        let isl_rs_result =
495            unsafe { isl_basic_set_drop_constraints_not_involving_dims(bset, type_, first, n) };
496        let isl_rs_result = BasicSet { ptr: isl_rs_result,
497                                       should_free_on_drop: true };
498        let err = isl_rs_ctx.last_error();
499        if err != Error::None_ {
500            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
501        }
502        Ok(isl_rs_result)
503    }
504
505    /// Wraps `isl_basic_set_drop_unused_params`.
506    pub fn drop_unused_params(self) -> Result<BasicSet, LibISLError> {
507        let bset = self;
508        let isl_rs_ctx = bset.get_ctx();
509        let mut bset = bset;
510        bset.do_not_free_on_drop();
511        let bset = bset.ptr;
512        let isl_rs_result = unsafe { isl_basic_set_drop_unused_params(bset) };
513        let isl_rs_result = BasicSet { ptr: isl_rs_result,
514                                       should_free_on_drop: true };
515        let err = isl_rs_ctx.last_error();
516        if err != Error::None_ {
517            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
518        }
519        Ok(isl_rs_result)
520    }
521
522    /// Wraps `isl_basic_set_dump`.
523    pub fn dump(&self) -> Result<(), LibISLError> {
524        let bset = self;
525        let isl_rs_ctx = bset.get_ctx();
526        let bset = bset.ptr;
527        let isl_rs_result = unsafe { isl_basic_set_dump(bset) };
528        let err = isl_rs_ctx.last_error();
529        if err != Error::None_ {
530            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
531        }
532        Ok(isl_rs_result)
533    }
534
535    /// Wraps `isl_basic_set_eliminate`.
536    pub fn eliminate(self, type_: DimType, first: u32, n: u32) -> Result<BasicSet, LibISLError> {
537        let bset = self;
538        let isl_rs_ctx = bset.get_ctx();
539        let mut bset = bset;
540        bset.do_not_free_on_drop();
541        let bset = bset.ptr;
542        let type_ = type_.to_i32();
543        let isl_rs_result = unsafe { isl_basic_set_eliminate(bset, type_, first, n) };
544        let isl_rs_result = BasicSet { ptr: isl_rs_result,
545                                       should_free_on_drop: true };
546        let err = isl_rs_ctx.last_error();
547        if err != Error::None_ {
548            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
549        }
550        Ok(isl_rs_result)
551    }
552
553    /// Wraps `isl_basic_set_empty`.
554    pub fn empty(space: Space) -> Result<BasicSet, LibISLError> {
555        let isl_rs_ctx = space.get_ctx();
556        let mut space = space;
557        space.do_not_free_on_drop();
558        let space = space.ptr;
559        let isl_rs_result = unsafe { isl_basic_set_empty(space) };
560        let isl_rs_result = BasicSet { ptr: isl_rs_result,
561                                       should_free_on_drop: true };
562        let err = isl_rs_ctx.last_error();
563        if err != Error::None_ {
564            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
565        }
566        Ok(isl_rs_result)
567    }
568
569    /// Wraps `isl_basic_set_equalities_matrix`.
570    pub fn equalities_matrix(&self, c1: DimType, c2: DimType, c3: DimType, c4: DimType)
571                             -> Result<Mat, LibISLError> {
572        let bset = self;
573        let isl_rs_ctx = bset.get_ctx();
574        let bset = bset.ptr;
575        let c1 = c1.to_i32();
576        let c2 = c2.to_i32();
577        let c3 = c3.to_i32();
578        let c4 = c4.to_i32();
579        let isl_rs_result = unsafe { isl_basic_set_equalities_matrix(bset, c1, c2, c3, c4) };
580        let isl_rs_result = Mat { ptr: isl_rs_result,
581                                  should_free_on_drop: true };
582        let err = isl_rs_ctx.last_error();
583        if err != Error::None_ {
584            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
585        }
586        Ok(isl_rs_result)
587    }
588
589    /// Wraps `isl_basic_set_fix_si`.
590    pub fn fix_si(self, type_: DimType, pos: u32, value: i32) -> Result<BasicSet, LibISLError> {
591        let bset = self;
592        let isl_rs_ctx = bset.get_ctx();
593        let mut bset = bset;
594        bset.do_not_free_on_drop();
595        let bset = bset.ptr;
596        let type_ = type_.to_i32();
597        let isl_rs_result = unsafe { isl_basic_set_fix_si(bset, type_, pos, value) };
598        let isl_rs_result = BasicSet { ptr: isl_rs_result,
599                                       should_free_on_drop: true };
600        let err = isl_rs_ctx.last_error();
601        if err != Error::None_ {
602            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
603        }
604        Ok(isl_rs_result)
605    }
606
607    /// Wraps `isl_basic_set_fix_val`.
608    pub fn fix_val(self, type_: DimType, pos: u32, v: Val) -> Result<BasicSet, LibISLError> {
609        let bset = self;
610        let isl_rs_ctx = bset.get_ctx();
611        let mut bset = bset;
612        bset.do_not_free_on_drop();
613        let bset = bset.ptr;
614        let type_ = type_.to_i32();
615        let mut v = v;
616        v.do_not_free_on_drop();
617        let v = v.ptr;
618        let isl_rs_result = unsafe { isl_basic_set_fix_val(bset, type_, pos, v) };
619        let isl_rs_result = BasicSet { ptr: isl_rs_result,
620                                       should_free_on_drop: true };
621        let err = isl_rs_ctx.last_error();
622        if err != Error::None_ {
623            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
624        }
625        Ok(isl_rs_result)
626    }
627
628    /// Wraps `isl_basic_set_flat_product`.
629    pub fn flat_product(self, bset2: BasicSet) -> Result<BasicSet, LibISLError> {
630        let bset1 = self;
631        let isl_rs_ctx = bset1.get_ctx();
632        let mut bset1 = bset1;
633        bset1.do_not_free_on_drop();
634        let bset1 = bset1.ptr;
635        let mut bset2 = bset2;
636        bset2.do_not_free_on_drop();
637        let bset2 = bset2.ptr;
638        let isl_rs_result = unsafe { isl_basic_set_flat_product(bset1, bset2) };
639        let isl_rs_result = BasicSet { ptr: isl_rs_result,
640                                       should_free_on_drop: true };
641        let err = isl_rs_ctx.last_error();
642        if err != Error::None_ {
643            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
644        }
645        Ok(isl_rs_result)
646    }
647
648    /// Wraps `isl_basic_set_flatten`.
649    pub fn flatten(self) -> Result<BasicSet, LibISLError> {
650        let bset = self;
651        let isl_rs_ctx = bset.get_ctx();
652        let mut bset = bset;
653        bset.do_not_free_on_drop();
654        let bset = bset.ptr;
655        let isl_rs_result = unsafe { isl_basic_set_flatten(bset) };
656        let isl_rs_result = BasicSet { ptr: isl_rs_result,
657                                       should_free_on_drop: true };
658        let err = isl_rs_ctx.last_error();
659        if err != Error::None_ {
660            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
661        }
662        Ok(isl_rs_result)
663    }
664
665    /// Wraps `isl_basic_set_free`.
666    pub fn free(self) -> Result<BasicSet, LibISLError> {
667        let bset = self;
668        let isl_rs_ctx = bset.get_ctx();
669        let mut bset = bset;
670        bset.do_not_free_on_drop();
671        let bset = bset.ptr;
672        let isl_rs_result = unsafe { isl_basic_set_free(bset) };
673        let isl_rs_result = BasicSet { ptr: isl_rs_result,
674                                       should_free_on_drop: true };
675        let err = isl_rs_ctx.last_error();
676        if err != Error::None_ {
677            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
678        }
679        Ok(isl_rs_result)
680    }
681
682    /// Wraps `isl_basic_set_from_constraint`.
683    pub fn from_constraint(constraint: Constraint) -> Result<BasicSet, LibISLError> {
684        let isl_rs_ctx = constraint.get_ctx();
685        let mut constraint = constraint;
686        constraint.do_not_free_on_drop();
687        let constraint = constraint.ptr;
688        let isl_rs_result = unsafe { isl_basic_set_from_constraint(constraint) };
689        let isl_rs_result = BasicSet { ptr: isl_rs_result,
690                                       should_free_on_drop: true };
691        let err = isl_rs_ctx.last_error();
692        if err != Error::None_ {
693            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
694        }
695        Ok(isl_rs_result)
696    }
697
698    /// Wraps `isl_basic_set_from_constraint_matrices`.
699    pub fn from_constraint_matrices(space: Space, eq: Mat, ineq: Mat, c1: DimType, c2: DimType,
700                                    c3: DimType, c4: DimType)
701                                    -> Result<BasicSet, LibISLError> {
702        let isl_rs_ctx = space.get_ctx();
703        let mut space = space;
704        space.do_not_free_on_drop();
705        let space = space.ptr;
706        let mut eq = eq;
707        eq.do_not_free_on_drop();
708        let eq = eq.ptr;
709        let mut ineq = ineq;
710        ineq.do_not_free_on_drop();
711        let ineq = ineq.ptr;
712        let c1 = c1.to_i32();
713        let c2 = c2.to_i32();
714        let c3 = c3.to_i32();
715        let c4 = c4.to_i32();
716        let isl_rs_result =
717            unsafe { isl_basic_set_from_constraint_matrices(space, eq, ineq, c1, c2, c3, c4) };
718        let isl_rs_result = BasicSet { ptr: isl_rs_result,
719                                       should_free_on_drop: true };
720        let err = isl_rs_ctx.last_error();
721        if err != Error::None_ {
722            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
723        }
724        Ok(isl_rs_result)
725    }
726
727    /// Wraps `isl_basic_set_from_multi_aff`.
728    pub fn from_multi_aff(ma: MultiAff) -> Result<BasicSet, LibISLError> {
729        let isl_rs_ctx = ma.get_ctx();
730        let mut ma = ma;
731        ma.do_not_free_on_drop();
732        let ma = ma.ptr;
733        let isl_rs_result = unsafe { isl_basic_set_from_multi_aff(ma) };
734        let isl_rs_result = BasicSet { ptr: isl_rs_result,
735                                       should_free_on_drop: true };
736        let err = isl_rs_ctx.last_error();
737        if err != Error::None_ {
738            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
739        }
740        Ok(isl_rs_result)
741    }
742
743    /// Wraps `isl_basic_set_from_params`.
744    pub fn from_params(self) -> Result<BasicSet, LibISLError> {
745        let bset = self;
746        let isl_rs_ctx = bset.get_ctx();
747        let mut bset = bset;
748        bset.do_not_free_on_drop();
749        let bset = bset.ptr;
750        let isl_rs_result = unsafe { isl_basic_set_from_params(bset) };
751        let isl_rs_result = BasicSet { ptr: isl_rs_result,
752                                       should_free_on_drop: true };
753        let err = isl_rs_ctx.last_error();
754        if err != Error::None_ {
755            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
756        }
757        Ok(isl_rs_result)
758    }
759
760    /// Wraps `isl_basic_set_from_point`.
761    pub fn from_point(pnt: Point) -> Result<BasicSet, LibISLError> {
762        let isl_rs_ctx = pnt.get_ctx();
763        let mut pnt = pnt;
764        pnt.do_not_free_on_drop();
765        let pnt = pnt.ptr;
766        let isl_rs_result = unsafe { isl_basic_set_from_point(pnt) };
767        let isl_rs_result = BasicSet { ptr: isl_rs_result,
768                                       should_free_on_drop: true };
769        let err = isl_rs_ctx.last_error();
770        if err != Error::None_ {
771            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
772        }
773        Ok(isl_rs_result)
774    }
775
776    /// Wraps `isl_basic_set_get_constraint_list`.
777    pub fn get_constraint_list(&self) -> Result<ConstraintList, LibISLError> {
778        let bset = self;
779        let isl_rs_ctx = bset.get_ctx();
780        let bset = bset.ptr;
781        let isl_rs_result = unsafe { isl_basic_set_get_constraint_list(bset) };
782        let isl_rs_result = ConstraintList { ptr: isl_rs_result,
783                                             should_free_on_drop: true };
784        let err = isl_rs_ctx.last_error();
785        if err != Error::None_ {
786            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
787        }
788        Ok(isl_rs_result)
789    }
790
791    /// Wraps `isl_basic_set_get_ctx`.
792    pub fn get_ctx(&self) -> Context {
793        let bset = self;
794        let bset = bset.ptr;
795        let isl_rs_result = unsafe { isl_basic_set_get_ctx(bset) };
796        let isl_rs_result = Context { ptr: isl_rs_result,
797                                      should_free_on_drop: false };
798        isl_rs_result
799    }
800
801    /// Wraps `isl_basic_set_get_dim_id`.
802    pub fn get_dim_id(&self, type_: DimType, pos: u32) -> Result<Id, LibISLError> {
803        let bset = self;
804        let isl_rs_ctx = bset.get_ctx();
805        let bset = bset.ptr;
806        let type_ = type_.to_i32();
807        let isl_rs_result = unsafe { isl_basic_set_get_dim_id(bset, type_, pos) };
808        let isl_rs_result = Id { ptr: isl_rs_result,
809                                 should_free_on_drop: true };
810        let err = isl_rs_ctx.last_error();
811        if err != Error::None_ {
812            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
813        }
814        Ok(isl_rs_result)
815    }
816
817    /// Wraps `isl_basic_set_get_dim_name`.
818    pub fn get_dim_name(&self, type_: DimType, pos: u32) -> Result<&str, LibISLError> {
819        let bset = self;
820        let isl_rs_ctx = bset.get_ctx();
821        let bset = bset.ptr;
822        let type_ = type_.to_i32();
823        let isl_rs_result = unsafe { isl_basic_set_get_dim_name(bset, type_, pos) };
824        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
825        let isl_rs_result = isl_rs_result.to_str().unwrap();
826        let err = isl_rs_ctx.last_error();
827        if err != Error::None_ {
828            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
829        }
830        Ok(isl_rs_result)
831    }
832
833    /// Wraps `isl_basic_set_get_div`.
834    pub fn get_div(&self, pos: i32) -> Result<Aff, LibISLError> {
835        let bset = self;
836        let isl_rs_ctx = bset.get_ctx();
837        let bset = bset.ptr;
838        let isl_rs_result = unsafe { isl_basic_set_get_div(bset, pos) };
839        let isl_rs_result = Aff { ptr: isl_rs_result,
840                                  should_free_on_drop: true };
841        let err = isl_rs_ctx.last_error();
842        if err != Error::None_ {
843            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
844        }
845        Ok(isl_rs_result)
846    }
847
848    /// Wraps `isl_basic_set_get_local_space`.
849    pub fn get_local_space(&self) -> Result<LocalSpace, LibISLError> {
850        let bset = self;
851        let isl_rs_ctx = bset.get_ctx();
852        let bset = bset.ptr;
853        let isl_rs_result = unsafe { isl_basic_set_get_local_space(bset) };
854        let isl_rs_result = LocalSpace { ptr: isl_rs_result,
855                                         should_free_on_drop: true };
856        let err = isl_rs_ctx.last_error();
857        if err != Error::None_ {
858            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
859        }
860        Ok(isl_rs_result)
861    }
862
863    /// Wraps `isl_basic_set_get_space`.
864    pub fn get_space(&self) -> Result<Space, LibISLError> {
865        let bset = self;
866        let isl_rs_ctx = bset.get_ctx();
867        let bset = bset.ptr;
868        let isl_rs_result = unsafe { isl_basic_set_get_space(bset) };
869        let isl_rs_result = Space { ptr: isl_rs_result,
870                                    should_free_on_drop: true };
871        let err = isl_rs_ctx.last_error();
872        if err != Error::None_ {
873            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
874        }
875        Ok(isl_rs_result)
876    }
877
878    /// Wraps `isl_basic_set_get_tuple_name`.
879    pub fn get_tuple_name(&self) -> Result<&str, LibISLError> {
880        let bset = self;
881        let isl_rs_ctx = bset.get_ctx();
882        let bset = bset.ptr;
883        let isl_rs_result = unsafe { isl_basic_set_get_tuple_name(bset) };
884        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
885        let isl_rs_result = isl_rs_result.to_str().unwrap();
886        let err = isl_rs_ctx.last_error();
887        if err != Error::None_ {
888            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
889        }
890        Ok(isl_rs_result)
891    }
892
893    /// Wraps `isl_basic_set_gist`.
894    pub fn gist(self, context: BasicSet) -> Result<BasicSet, LibISLError> {
895        let bset = self;
896        let isl_rs_ctx = bset.get_ctx();
897        let mut bset = bset;
898        bset.do_not_free_on_drop();
899        let bset = bset.ptr;
900        let mut context = context;
901        context.do_not_free_on_drop();
902        let context = context.ptr;
903        let isl_rs_result = unsafe { isl_basic_set_gist(bset, context) };
904        let isl_rs_result = BasicSet { ptr: isl_rs_result,
905                                       should_free_on_drop: true };
906        let err = isl_rs_ctx.last_error();
907        if err != Error::None_ {
908            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
909        }
910        Ok(isl_rs_result)
911    }
912
913    /// Wraps `isl_basic_set_inequalities_matrix`.
914    pub fn inequalities_matrix(&self, c1: DimType, c2: DimType, c3: DimType, c4: DimType)
915                               -> Result<Mat, LibISLError> {
916        let bset = self;
917        let isl_rs_ctx = bset.get_ctx();
918        let bset = bset.ptr;
919        let c1 = c1.to_i32();
920        let c2 = c2.to_i32();
921        let c3 = c3.to_i32();
922        let c4 = c4.to_i32();
923        let isl_rs_result = unsafe { isl_basic_set_inequalities_matrix(bset, c1, c2, c3, c4) };
924        let isl_rs_result = Mat { ptr: isl_rs_result,
925                                  should_free_on_drop: true };
926        let err = isl_rs_ctx.last_error();
927        if err != Error::None_ {
928            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
929        }
930        Ok(isl_rs_result)
931    }
932
933    /// Wraps `isl_basic_set_insert_dims`.
934    pub fn insert_dims(self, type_: DimType, pos: u32, n: u32) -> Result<BasicSet, LibISLError> {
935        let bset = self;
936        let isl_rs_ctx = bset.get_ctx();
937        let mut bset = bset;
938        bset.do_not_free_on_drop();
939        let bset = bset.ptr;
940        let type_ = type_.to_i32();
941        let isl_rs_result = unsafe { isl_basic_set_insert_dims(bset, type_, pos, n) };
942        let isl_rs_result = BasicSet { ptr: isl_rs_result,
943                                       should_free_on_drop: true };
944        let err = isl_rs_ctx.last_error();
945        if err != Error::None_ {
946            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
947        }
948        Ok(isl_rs_result)
949    }
950
951    /// Wraps `isl_basic_set_intersect`.
952    pub fn intersect(self, bset2: BasicSet) -> Result<BasicSet, LibISLError> {
953        let bset1 = self;
954        let isl_rs_ctx = bset1.get_ctx();
955        let mut bset1 = bset1;
956        bset1.do_not_free_on_drop();
957        let bset1 = bset1.ptr;
958        let mut bset2 = bset2;
959        bset2.do_not_free_on_drop();
960        let bset2 = bset2.ptr;
961        let isl_rs_result = unsafe { isl_basic_set_intersect(bset1, bset2) };
962        let isl_rs_result = BasicSet { ptr: isl_rs_result,
963                                       should_free_on_drop: true };
964        let err = isl_rs_ctx.last_error();
965        if err != Error::None_ {
966            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
967        }
968        Ok(isl_rs_result)
969    }
970
971    /// Wraps `isl_basic_set_intersect_params`.
972    pub fn intersect_params(self, bset2: BasicSet) -> Result<BasicSet, LibISLError> {
973        let bset1 = self;
974        let isl_rs_ctx = bset1.get_ctx();
975        let mut bset1 = bset1;
976        bset1.do_not_free_on_drop();
977        let bset1 = bset1.ptr;
978        let mut bset2 = bset2;
979        bset2.do_not_free_on_drop();
980        let bset2 = bset2.ptr;
981        let isl_rs_result = unsafe { isl_basic_set_intersect_params(bset1, bset2) };
982        let isl_rs_result = BasicSet { ptr: isl_rs_result,
983                                       should_free_on_drop: true };
984        let err = isl_rs_ctx.last_error();
985        if err != Error::None_ {
986            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
987        }
988        Ok(isl_rs_result)
989    }
990
991    /// Wraps `isl_basic_set_involves_dims`.
992    pub fn involves_dims(&self, type_: DimType, first: u32, n: u32) -> Result<bool, LibISLError> {
993        let bset = self;
994        let isl_rs_ctx = bset.get_ctx();
995        let bset = bset.ptr;
996        let type_ = type_.to_i32();
997        let isl_rs_result = unsafe { isl_basic_set_involves_dims(bset, type_, first, n) };
998        let isl_rs_result = match isl_rs_result {
999            0 => false,
1000            1 => true,
1001            _ => panic!("Got isl_bool = -1"),
1002        };
1003        let err = isl_rs_ctx.last_error();
1004        if err != Error::None_ {
1005            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1006        }
1007        Ok(isl_rs_result)
1008    }
1009
1010    /// Wraps `isl_basic_set_is_bounded`.
1011    pub fn is_bounded(&self) -> Result<bool, LibISLError> {
1012        let bset = self;
1013        let isl_rs_ctx = bset.get_ctx();
1014        let bset = bset.ptr;
1015        let isl_rs_result = unsafe { isl_basic_set_is_bounded(bset) };
1016        let isl_rs_result = match isl_rs_result {
1017            0 => false,
1018            1 => true,
1019            _ => panic!("Got isl_bool = -1"),
1020        };
1021        let err = isl_rs_ctx.last_error();
1022        if err != Error::None_ {
1023            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1024        }
1025        Ok(isl_rs_result)
1026    }
1027
1028    /// Wraps `isl_basic_set_is_disjoint`.
1029    pub fn is_disjoint(&self, bset2: &BasicSet) -> Result<bool, LibISLError> {
1030        let bset1 = self;
1031        let isl_rs_ctx = bset1.get_ctx();
1032        let bset1 = bset1.ptr;
1033        let bset2 = bset2.ptr;
1034        let isl_rs_result = unsafe { isl_basic_set_is_disjoint(bset1, bset2) };
1035        let isl_rs_result = match isl_rs_result {
1036            0 => false,
1037            1 => true,
1038            _ => panic!("Got isl_bool = -1"),
1039        };
1040        let err = isl_rs_ctx.last_error();
1041        if err != Error::None_ {
1042            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1043        }
1044        Ok(isl_rs_result)
1045    }
1046
1047    /// Wraps `isl_basic_set_is_empty`.
1048    pub fn is_empty(&self) -> Result<bool, LibISLError> {
1049        let bset = self;
1050        let isl_rs_ctx = bset.get_ctx();
1051        let bset = bset.ptr;
1052        let isl_rs_result = unsafe { isl_basic_set_is_empty(bset) };
1053        let isl_rs_result = match isl_rs_result {
1054            0 => false,
1055            1 => true,
1056            _ => panic!("Got isl_bool = -1"),
1057        };
1058        let err = isl_rs_ctx.last_error();
1059        if err != Error::None_ {
1060            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1061        }
1062        Ok(isl_rs_result)
1063    }
1064
1065    /// Wraps `isl_basic_set_is_equal`.
1066    pub fn is_equal(&self, bset2: &BasicSet) -> Result<bool, LibISLError> {
1067        let bset1 = self;
1068        let isl_rs_ctx = bset1.get_ctx();
1069        let bset1 = bset1.ptr;
1070        let bset2 = bset2.ptr;
1071        let isl_rs_result = unsafe { isl_basic_set_is_equal(bset1, bset2) };
1072        let isl_rs_result = match isl_rs_result {
1073            0 => false,
1074            1 => true,
1075            _ => panic!("Got isl_bool = -1"),
1076        };
1077        let err = isl_rs_ctx.last_error();
1078        if err != Error::None_ {
1079            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1080        }
1081        Ok(isl_rs_result)
1082    }
1083
1084    /// Wraps `isl_basic_set_is_rational`.
1085    pub fn is_rational(&self) -> Result<i32, LibISLError> {
1086        let bset = self;
1087        let isl_rs_ctx = bset.get_ctx();
1088        let bset = bset.ptr;
1089        let isl_rs_result = unsafe { isl_basic_set_is_rational(bset) };
1090        let err = isl_rs_ctx.last_error();
1091        if err != Error::None_ {
1092            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1093        }
1094        Ok(isl_rs_result)
1095    }
1096
1097    /// Wraps `isl_basic_set_is_subset`.
1098    pub fn is_subset(&self, bset2: &BasicSet) -> Result<bool, LibISLError> {
1099        let bset1 = self;
1100        let isl_rs_ctx = bset1.get_ctx();
1101        let bset1 = bset1.ptr;
1102        let bset2 = bset2.ptr;
1103        let isl_rs_result = unsafe { isl_basic_set_is_subset(bset1, bset2) };
1104        let isl_rs_result = match isl_rs_result {
1105            0 => false,
1106            1 => true,
1107            _ => panic!("Got isl_bool = -1"),
1108        };
1109        let err = isl_rs_ctx.last_error();
1110        if err != Error::None_ {
1111            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1112        }
1113        Ok(isl_rs_result)
1114    }
1115
1116    /// Wraps `isl_basic_set_is_universe`.
1117    pub fn is_universe(&self) -> Result<bool, LibISLError> {
1118        let bset = self;
1119        let isl_rs_ctx = bset.get_ctx();
1120        let bset = bset.ptr;
1121        let isl_rs_result = unsafe { isl_basic_set_is_universe(bset) };
1122        let isl_rs_result = match isl_rs_result {
1123            0 => false,
1124            1 => true,
1125            _ => panic!("Got isl_bool = -1"),
1126        };
1127        let err = isl_rs_ctx.last_error();
1128        if err != Error::None_ {
1129            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1130        }
1131        Ok(isl_rs_result)
1132    }
1133
1134    /// Wraps `isl_basic_set_is_wrapping`.
1135    pub fn is_wrapping(&self) -> Result<bool, LibISLError> {
1136        let bset = self;
1137        let isl_rs_ctx = bset.get_ctx();
1138        let bset = bset.ptr;
1139        let isl_rs_result = unsafe { isl_basic_set_is_wrapping(bset) };
1140        let isl_rs_result = match isl_rs_result {
1141            0 => false,
1142            1 => true,
1143            _ => panic!("Got isl_bool = -1"),
1144        };
1145        let err = isl_rs_ctx.last_error();
1146        if err != Error::None_ {
1147            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1148        }
1149        Ok(isl_rs_result)
1150    }
1151
1152    /// Wraps `isl_basic_set_lexmax`.
1153    pub fn lexmax(self) -> Result<Set, LibISLError> {
1154        let bset = self;
1155        let isl_rs_ctx = bset.get_ctx();
1156        let mut bset = bset;
1157        bset.do_not_free_on_drop();
1158        let bset = bset.ptr;
1159        let isl_rs_result = unsafe { isl_basic_set_lexmax(bset) };
1160        let isl_rs_result = Set { ptr: isl_rs_result,
1161                                  should_free_on_drop: true };
1162        let err = isl_rs_ctx.last_error();
1163        if err != Error::None_ {
1164            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1165        }
1166        Ok(isl_rs_result)
1167    }
1168
1169    /// Wraps `isl_basic_set_lexmin`.
1170    pub fn lexmin(self) -> Result<Set, LibISLError> {
1171        let bset = self;
1172        let isl_rs_ctx = bset.get_ctx();
1173        let mut bset = bset;
1174        bset.do_not_free_on_drop();
1175        let bset = bset.ptr;
1176        let isl_rs_result = unsafe { isl_basic_set_lexmin(bset) };
1177        let isl_rs_result = Set { ptr: isl_rs_result,
1178                                  should_free_on_drop: true };
1179        let err = isl_rs_ctx.last_error();
1180        if err != Error::None_ {
1181            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1182        }
1183        Ok(isl_rs_result)
1184    }
1185
1186    /// Wraps `isl_basic_set_lift`.
1187    pub fn lift(self) -> Result<BasicSet, LibISLError> {
1188        let bset = self;
1189        let isl_rs_ctx = bset.get_ctx();
1190        let mut bset = bset;
1191        bset.do_not_free_on_drop();
1192        let bset = bset.ptr;
1193        let isl_rs_result = unsafe { isl_basic_set_lift(bset) };
1194        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1195                                       should_free_on_drop: true };
1196        let err = isl_rs_ctx.last_error();
1197        if err != Error::None_ {
1198            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1199        }
1200        Ok(isl_rs_result)
1201    }
1202
1203    /// Wraps `isl_basic_set_lower_bound_val`.
1204    pub fn lower_bound_val(self, type_: DimType, pos: u32, value: Val)
1205                           -> Result<BasicSet, LibISLError> {
1206        let bset = self;
1207        let isl_rs_ctx = bset.get_ctx();
1208        let mut bset = bset;
1209        bset.do_not_free_on_drop();
1210        let bset = bset.ptr;
1211        let type_ = type_.to_i32();
1212        let mut value = value;
1213        value.do_not_free_on_drop();
1214        let value = value.ptr;
1215        let isl_rs_result = unsafe { isl_basic_set_lower_bound_val(bset, type_, pos, value) };
1216        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1217                                       should_free_on_drop: true };
1218        let err = isl_rs_ctx.last_error();
1219        if err != Error::None_ {
1220            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1221        }
1222        Ok(isl_rs_result)
1223    }
1224
1225    /// Wraps `isl_basic_set_max_lp_val`.
1226    pub fn max_lp_val(&self, obj: &Aff) -> Result<Val, LibISLError> {
1227        let bset = self;
1228        let isl_rs_ctx = bset.get_ctx();
1229        let bset = bset.ptr;
1230        let obj = obj.ptr;
1231        let isl_rs_result = unsafe { isl_basic_set_max_lp_val(bset, obj) };
1232        let isl_rs_result = Val { ptr: isl_rs_result,
1233                                  should_free_on_drop: true };
1234        let err = isl_rs_ctx.last_error();
1235        if err != Error::None_ {
1236            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1237        }
1238        Ok(isl_rs_result)
1239    }
1240
1241    /// Wraps `isl_basic_set_max_val`.
1242    pub fn max_val(&self, obj: &Aff) -> Result<Val, LibISLError> {
1243        let bset = self;
1244        let isl_rs_ctx = bset.get_ctx();
1245        let bset = bset.ptr;
1246        let obj = obj.ptr;
1247        let isl_rs_result = unsafe { isl_basic_set_max_val(bset, obj) };
1248        let isl_rs_result = Val { ptr: isl_rs_result,
1249                                  should_free_on_drop: true };
1250        let err = isl_rs_ctx.last_error();
1251        if err != Error::None_ {
1252            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1253        }
1254        Ok(isl_rs_result)
1255    }
1256
1257    /// Wraps `isl_basic_set_min_lp_val`.
1258    pub fn min_lp_val(&self, obj: &Aff) -> Result<Val, LibISLError> {
1259        let bset = self;
1260        let isl_rs_ctx = bset.get_ctx();
1261        let bset = bset.ptr;
1262        let obj = obj.ptr;
1263        let isl_rs_result = unsafe { isl_basic_set_min_lp_val(bset, obj) };
1264        let isl_rs_result = Val { ptr: isl_rs_result,
1265                                  should_free_on_drop: true };
1266        let err = isl_rs_ctx.last_error();
1267        if err != Error::None_ {
1268            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1269        }
1270        Ok(isl_rs_result)
1271    }
1272
1273    /// Wraps `isl_basic_set_move_dims`.
1274    pub fn move_dims(self, dst_type: DimType, dst_pos: u32, src_type: DimType, src_pos: u32,
1275                     n: u32)
1276                     -> Result<BasicSet, LibISLError> {
1277        let bset = self;
1278        let isl_rs_ctx = bset.get_ctx();
1279        let mut bset = bset;
1280        bset.do_not_free_on_drop();
1281        let bset = bset.ptr;
1282        let dst_type = dst_type.to_i32();
1283        let src_type = src_type.to_i32();
1284        let isl_rs_result =
1285            unsafe { isl_basic_set_move_dims(bset, dst_type, dst_pos, src_type, src_pos, n) };
1286        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1287                                       should_free_on_drop: true };
1288        let err = isl_rs_ctx.last_error();
1289        if err != Error::None_ {
1290            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1291        }
1292        Ok(isl_rs_result)
1293    }
1294
1295    /// Wraps `isl_basic_set_n_constraint`.
1296    pub fn n_constraint(&self) -> Result<i32, LibISLError> {
1297        let bset = self;
1298        let isl_rs_ctx = bset.get_ctx();
1299        let bset = bset.ptr;
1300        let isl_rs_result = unsafe { isl_basic_set_n_constraint(bset) };
1301        let err = isl_rs_ctx.last_error();
1302        if err != Error::None_ {
1303            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1304        }
1305        Ok(isl_rs_result)
1306    }
1307
1308    /// Wraps `isl_basic_set_n_dim`.
1309    pub fn n_dim(&self) -> Result<i32, LibISLError> {
1310        let bset = self;
1311        let isl_rs_ctx = bset.get_ctx();
1312        let bset = bset.ptr;
1313        let isl_rs_result = unsafe { isl_basic_set_n_dim(bset) };
1314        let err = isl_rs_ctx.last_error();
1315        if err != Error::None_ {
1316            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1317        }
1318        Ok(isl_rs_result)
1319    }
1320
1321    /// Wraps `isl_basic_set_n_param`.
1322    pub fn n_param(&self) -> Result<i32, LibISLError> {
1323        let bset = self;
1324        let isl_rs_ctx = bset.get_ctx();
1325        let bset = bset.ptr;
1326        let isl_rs_result = unsafe { isl_basic_set_n_param(bset) };
1327        let err = isl_rs_ctx.last_error();
1328        if err != Error::None_ {
1329            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1330        }
1331        Ok(isl_rs_result)
1332    }
1333
1334    /// Wraps `isl_basic_set_nat_universe`.
1335    pub fn nat_universe(space: Space) -> Result<BasicSet, LibISLError> {
1336        let isl_rs_ctx = space.get_ctx();
1337        let mut space = space;
1338        space.do_not_free_on_drop();
1339        let space = space.ptr;
1340        let isl_rs_result = unsafe { isl_basic_set_nat_universe(space) };
1341        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1342                                       should_free_on_drop: true };
1343        let err = isl_rs_ctx.last_error();
1344        if err != Error::None_ {
1345            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1346        }
1347        Ok(isl_rs_result)
1348    }
1349
1350    /// Wraps `isl_basic_set_neg`.
1351    pub fn neg(self) -> Result<BasicSet, LibISLError> {
1352        let bset = self;
1353        let isl_rs_ctx = bset.get_ctx();
1354        let mut bset = bset;
1355        bset.do_not_free_on_drop();
1356        let bset = bset.ptr;
1357        let isl_rs_result = unsafe { isl_basic_set_neg(bset) };
1358        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1359                                       should_free_on_drop: true };
1360        let err = isl_rs_ctx.last_error();
1361        if err != Error::None_ {
1362            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1363        }
1364        Ok(isl_rs_result)
1365    }
1366
1367    /// Wraps `isl_basic_set_params`.
1368    pub fn params(self) -> Result<BasicSet, LibISLError> {
1369        let bset = self;
1370        let isl_rs_ctx = bset.get_ctx();
1371        let mut bset = bset;
1372        bset.do_not_free_on_drop();
1373        let bset = bset.ptr;
1374        let isl_rs_result = unsafe { isl_basic_set_params(bset) };
1375        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1376                                       should_free_on_drop: true };
1377        let err = isl_rs_ctx.last_error();
1378        if err != Error::None_ {
1379            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1380        }
1381        Ok(isl_rs_result)
1382    }
1383
1384    /// Wraps `isl_basic_set_plain_is_empty`.
1385    pub fn plain_is_empty(&self) -> Result<bool, LibISLError> {
1386        let bset = self;
1387        let isl_rs_ctx = bset.get_ctx();
1388        let bset = bset.ptr;
1389        let isl_rs_result = unsafe { isl_basic_set_plain_is_empty(bset) };
1390        let isl_rs_result = match isl_rs_result {
1391            0 => false,
1392            1 => true,
1393            _ => panic!("Got isl_bool = -1"),
1394        };
1395        let err = isl_rs_ctx.last_error();
1396        if err != Error::None_ {
1397            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1398        }
1399        Ok(isl_rs_result)
1400    }
1401
1402    /// Wraps `isl_basic_set_plain_is_equal`.
1403    pub fn plain_is_equal(&self, bset2: &BasicSet) -> Result<bool, LibISLError> {
1404        let bset1 = self;
1405        let isl_rs_ctx = bset1.get_ctx();
1406        let bset1 = bset1.ptr;
1407        let bset2 = bset2.ptr;
1408        let isl_rs_result = unsafe { isl_basic_set_plain_is_equal(bset1, bset2) };
1409        let isl_rs_result = match isl_rs_result {
1410            0 => false,
1411            1 => true,
1412            _ => panic!("Got isl_bool = -1"),
1413        };
1414        let err = isl_rs_ctx.last_error();
1415        if err != Error::None_ {
1416            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1417        }
1418        Ok(isl_rs_result)
1419    }
1420
1421    /// Wraps `isl_basic_set_plain_is_universe`.
1422    pub fn plain_is_universe(&self) -> Result<bool, LibISLError> {
1423        let bset = self;
1424        let isl_rs_ctx = bset.get_ctx();
1425        let bset = bset.ptr;
1426        let isl_rs_result = unsafe { isl_basic_set_plain_is_universe(bset) };
1427        let isl_rs_result = match isl_rs_result {
1428            0 => false,
1429            1 => true,
1430            _ => panic!("Got isl_bool = -1"),
1431        };
1432        let err = isl_rs_ctx.last_error();
1433        if err != Error::None_ {
1434            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1435        }
1436        Ok(isl_rs_result)
1437    }
1438
1439    /// Wraps `isl_basic_set_positive_orthant`.
1440    pub fn positive_orthant(space: Space) -> Result<BasicSet, LibISLError> {
1441        let isl_rs_ctx = space.get_ctx();
1442        let mut space = space;
1443        space.do_not_free_on_drop();
1444        let space = space.ptr;
1445        let isl_rs_result = unsafe { isl_basic_set_positive_orthant(space) };
1446        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1447                                       should_free_on_drop: true };
1448        let err = isl_rs_ctx.last_error();
1449        if err != Error::None_ {
1450            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1451        }
1452        Ok(isl_rs_result)
1453    }
1454
1455    /// Wraps `isl_basic_set_preimage_multi_aff`.
1456    pub fn preimage_multi_aff(self, ma: MultiAff) -> Result<BasicSet, LibISLError> {
1457        let bset = self;
1458        let isl_rs_ctx = bset.get_ctx();
1459        let mut bset = bset;
1460        bset.do_not_free_on_drop();
1461        let bset = bset.ptr;
1462        let mut ma = ma;
1463        ma.do_not_free_on_drop();
1464        let ma = ma.ptr;
1465        let isl_rs_result = unsafe { isl_basic_set_preimage_multi_aff(bset, ma) };
1466        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1467                                       should_free_on_drop: true };
1468        let err = isl_rs_ctx.last_error();
1469        if err != Error::None_ {
1470            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1471        }
1472        Ok(isl_rs_result)
1473    }
1474
1475    /// Wraps `isl_basic_set_project_out`.
1476    pub fn project_out(self, type_: DimType, first: u32, n: u32) -> Result<BasicSet, LibISLError> {
1477        let bset = self;
1478        let isl_rs_ctx = bset.get_ctx();
1479        let mut bset = bset;
1480        bset.do_not_free_on_drop();
1481        let bset = bset.ptr;
1482        let type_ = type_.to_i32();
1483        let isl_rs_result = unsafe { isl_basic_set_project_out(bset, type_, first, n) };
1484        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1485                                       should_free_on_drop: true };
1486        let err = isl_rs_ctx.last_error();
1487        if err != Error::None_ {
1488            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1489        }
1490        Ok(isl_rs_result)
1491    }
1492
1493    /// Wraps `isl_basic_set_read_from_str`.
1494    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<BasicSet, LibISLError> {
1495        let isl_rs_ctx = Context { ptr: ctx.ptr,
1496                                   should_free_on_drop: false };
1497        let ctx = ctx.ptr;
1498        let str_ = CString::new(str_).unwrap();
1499        let str_ = str_.as_ptr();
1500        let isl_rs_result = unsafe { isl_basic_set_read_from_str(ctx, str_) };
1501        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1502                                       should_free_on_drop: true };
1503        let err = isl_rs_ctx.last_error();
1504        if err != Error::None_ {
1505            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1506        }
1507        Ok(isl_rs_result)
1508    }
1509
1510    /// Wraps `isl_basic_set_reduced_basis`.
1511    pub fn reduced_basis(&self) -> Result<Mat, LibISLError> {
1512        let bset = self;
1513        let isl_rs_ctx = bset.get_ctx();
1514        let bset = bset.ptr;
1515        let isl_rs_result = unsafe { isl_basic_set_reduced_basis(bset) };
1516        let isl_rs_result = Mat { ptr: isl_rs_result,
1517                                  should_free_on_drop: true };
1518        let err = isl_rs_ctx.last_error();
1519        if err != Error::None_ {
1520            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1521        }
1522        Ok(isl_rs_result)
1523    }
1524
1525    /// Wraps `isl_basic_set_remove_dims`.
1526    pub fn remove_dims(self, type_: DimType, first: u32, n: u32) -> Result<BasicSet, LibISLError> {
1527        let bset = self;
1528        let isl_rs_ctx = bset.get_ctx();
1529        let mut bset = bset;
1530        bset.do_not_free_on_drop();
1531        let bset = bset.ptr;
1532        let type_ = type_.to_i32();
1533        let isl_rs_result = unsafe { isl_basic_set_remove_dims(bset, type_, first, n) };
1534        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1535                                       should_free_on_drop: true };
1536        let err = isl_rs_ctx.last_error();
1537        if err != Error::None_ {
1538            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1539        }
1540        Ok(isl_rs_result)
1541    }
1542
1543    /// Wraps `isl_basic_set_remove_divs`.
1544    pub fn remove_divs(self) -> Result<BasicSet, LibISLError> {
1545        let bset = self;
1546        let isl_rs_ctx = bset.get_ctx();
1547        let mut bset = bset;
1548        bset.do_not_free_on_drop();
1549        let bset = bset.ptr;
1550        let isl_rs_result = unsafe { isl_basic_set_remove_divs(bset) };
1551        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1552                                       should_free_on_drop: true };
1553        let err = isl_rs_ctx.last_error();
1554        if err != Error::None_ {
1555            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1556        }
1557        Ok(isl_rs_result)
1558    }
1559
1560    /// Wraps `isl_basic_set_remove_divs_involving_dims`.
1561    pub fn remove_divs_involving_dims(self, type_: DimType, first: u32, n: u32)
1562                                      -> Result<BasicSet, LibISLError> {
1563        let bset = self;
1564        let isl_rs_ctx = bset.get_ctx();
1565        let mut bset = bset;
1566        bset.do_not_free_on_drop();
1567        let bset = bset.ptr;
1568        let type_ = type_.to_i32();
1569        let isl_rs_result =
1570            unsafe { isl_basic_set_remove_divs_involving_dims(bset, type_, first, n) };
1571        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1572                                       should_free_on_drop: true };
1573        let err = isl_rs_ctx.last_error();
1574        if err != Error::None_ {
1575            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1576        }
1577        Ok(isl_rs_result)
1578    }
1579
1580    /// Wraps `isl_basic_set_remove_redundancies`.
1581    pub fn remove_redundancies(self) -> Result<BasicSet, LibISLError> {
1582        let bset = self;
1583        let isl_rs_ctx = bset.get_ctx();
1584        let mut bset = bset;
1585        bset.do_not_free_on_drop();
1586        let bset = bset.ptr;
1587        let isl_rs_result = unsafe { isl_basic_set_remove_redundancies(bset) };
1588        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1589                                       should_free_on_drop: true };
1590        let err = isl_rs_ctx.last_error();
1591        if err != Error::None_ {
1592            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1593        }
1594        Ok(isl_rs_result)
1595    }
1596
1597    /// Wraps `isl_basic_set_remove_unknown_divs`.
1598    pub fn remove_unknown_divs(self) -> Result<BasicSet, LibISLError> {
1599        let bset = self;
1600        let isl_rs_ctx = bset.get_ctx();
1601        let mut bset = bset;
1602        bset.do_not_free_on_drop();
1603        let bset = bset.ptr;
1604        let isl_rs_result = unsafe { isl_basic_set_remove_unknown_divs(bset) };
1605        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1606                                       should_free_on_drop: true };
1607        let err = isl_rs_ctx.last_error();
1608        if err != Error::None_ {
1609            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1610        }
1611        Ok(isl_rs_result)
1612    }
1613
1614    /// Wraps `isl_basic_set_sample`.
1615    pub fn sample(self) -> Result<BasicSet, LibISLError> {
1616        let bset = self;
1617        let isl_rs_ctx = bset.get_ctx();
1618        let mut bset = bset;
1619        bset.do_not_free_on_drop();
1620        let bset = bset.ptr;
1621        let isl_rs_result = unsafe { isl_basic_set_sample(bset) };
1622        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1623                                       should_free_on_drop: true };
1624        let err = isl_rs_ctx.last_error();
1625        if err != Error::None_ {
1626            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1627        }
1628        Ok(isl_rs_result)
1629    }
1630
1631    /// Wraps `isl_basic_set_sample_point`.
1632    pub fn sample_point(self) -> Result<Point, LibISLError> {
1633        let bset = self;
1634        let isl_rs_ctx = bset.get_ctx();
1635        let mut bset = bset;
1636        bset.do_not_free_on_drop();
1637        let bset = bset.ptr;
1638        let isl_rs_result = unsafe { isl_basic_set_sample_point(bset) };
1639        let isl_rs_result = Point { ptr: isl_rs_result,
1640                                    should_free_on_drop: true };
1641        let err = isl_rs_ctx.last_error();
1642        if err != Error::None_ {
1643            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1644        }
1645        Ok(isl_rs_result)
1646    }
1647
1648    /// Wraps `isl_basic_set_set_dim_name`.
1649    pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str) -> Result<BasicSet, LibISLError> {
1650        let bset = self;
1651        let isl_rs_ctx = bset.get_ctx();
1652        let mut bset = bset;
1653        bset.do_not_free_on_drop();
1654        let bset = bset.ptr;
1655        let type_ = type_.to_i32();
1656        let s = CString::new(s).unwrap();
1657        let s = s.as_ptr();
1658        let isl_rs_result = unsafe { isl_basic_set_set_dim_name(bset, type_, pos, s) };
1659        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1660                                       should_free_on_drop: true };
1661        let err = isl_rs_ctx.last_error();
1662        if err != Error::None_ {
1663            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1664        }
1665        Ok(isl_rs_result)
1666    }
1667
1668    /// Wraps `isl_basic_set_set_tuple_id`.
1669    pub fn set_tuple_id(self, id: Id) -> Result<BasicSet, LibISLError> {
1670        let bset = self;
1671        let isl_rs_ctx = bset.get_ctx();
1672        let mut bset = bset;
1673        bset.do_not_free_on_drop();
1674        let bset = bset.ptr;
1675        let mut id = id;
1676        id.do_not_free_on_drop();
1677        let id = id.ptr;
1678        let isl_rs_result = unsafe { isl_basic_set_set_tuple_id(bset, id) };
1679        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1680                                       should_free_on_drop: true };
1681        let err = isl_rs_ctx.last_error();
1682        if err != Error::None_ {
1683            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1684        }
1685        Ok(isl_rs_result)
1686    }
1687
1688    /// Wraps `isl_basic_set_set_tuple_name`.
1689    pub fn set_tuple_name(self, s: &str) -> Result<BasicSet, LibISLError> {
1690        let set = self;
1691        let isl_rs_ctx = set.get_ctx();
1692        let mut set = set;
1693        set.do_not_free_on_drop();
1694        let set = set.ptr;
1695        let s = CString::new(s).unwrap();
1696        let s = s.as_ptr();
1697        let isl_rs_result = unsafe { isl_basic_set_set_tuple_name(set, s) };
1698        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1699                                       should_free_on_drop: true };
1700        let err = isl_rs_ctx.last_error();
1701        if err != Error::None_ {
1702            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1703        }
1704        Ok(isl_rs_result)
1705    }
1706
1707    /// Wraps `isl_basic_set_solutions`.
1708    pub fn solutions(self) -> Result<BasicSet, LibISLError> {
1709        let bset = self;
1710        let isl_rs_ctx = bset.get_ctx();
1711        let mut bset = bset;
1712        bset.do_not_free_on_drop();
1713        let bset = bset.ptr;
1714        let isl_rs_result = unsafe { isl_basic_set_solutions(bset) };
1715        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1716                                       should_free_on_drop: true };
1717        let err = isl_rs_ctx.last_error();
1718        if err != Error::None_ {
1719            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1720        }
1721        Ok(isl_rs_result)
1722    }
1723
1724    /// Wraps `isl_basic_set_to_list`.
1725    pub fn to_list(self) -> Result<BasicSetList, LibISLError> {
1726        let el = self;
1727        let isl_rs_ctx = el.get_ctx();
1728        let mut el = el;
1729        el.do_not_free_on_drop();
1730        let el = el.ptr;
1731        let isl_rs_result = unsafe { isl_basic_set_to_list(el) };
1732        let isl_rs_result = BasicSetList { ptr: isl_rs_result,
1733                                           should_free_on_drop: true };
1734        let err = isl_rs_ctx.last_error();
1735        if err != Error::None_ {
1736            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1737        }
1738        Ok(isl_rs_result)
1739    }
1740
1741    /// Wraps `isl_basic_set_to_set`.
1742    pub fn to_set(self) -> Result<Set, LibISLError> {
1743        let bset = self;
1744        let isl_rs_ctx = bset.get_ctx();
1745        let mut bset = bset;
1746        bset.do_not_free_on_drop();
1747        let bset = bset.ptr;
1748        let isl_rs_result = unsafe { isl_basic_set_to_set(bset) };
1749        let isl_rs_result = Set { ptr: isl_rs_result,
1750                                  should_free_on_drop: true };
1751        let err = isl_rs_ctx.last_error();
1752        if err != Error::None_ {
1753            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1754        }
1755        Ok(isl_rs_result)
1756    }
1757
1758    /// Wraps `isl_basic_set_to_str`.
1759    pub fn to_str(&self) -> Result<&str, LibISLError> {
1760        let bset = self;
1761        let isl_rs_ctx = bset.get_ctx();
1762        let bset = bset.ptr;
1763        let isl_rs_result = unsafe { isl_basic_set_to_str(bset) };
1764        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1765        let isl_rs_result = isl_rs_result.to_str().unwrap();
1766        let err = isl_rs_ctx.last_error();
1767        if err != Error::None_ {
1768            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1769        }
1770        Ok(isl_rs_result)
1771    }
1772
1773    /// Wraps `isl_basic_set_total_dim`.
1774    pub fn total_dim(&self) -> Result<i32, LibISLError> {
1775        let bset = self;
1776        let isl_rs_ctx = bset.get_ctx();
1777        let bset = bset.ptr;
1778        let isl_rs_result = unsafe { isl_basic_set_total_dim(bset) };
1779        let err = isl_rs_ctx.last_error();
1780        if err != Error::None_ {
1781            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1782        }
1783        Ok(isl_rs_result)
1784    }
1785
1786    /// Wraps `isl_basic_set_union`.
1787    pub fn union(self, bset2: BasicSet) -> Result<Set, LibISLError> {
1788        let bset1 = self;
1789        let isl_rs_ctx = bset1.get_ctx();
1790        let mut bset1 = bset1;
1791        bset1.do_not_free_on_drop();
1792        let bset1 = bset1.ptr;
1793        let mut bset2 = bset2;
1794        bset2.do_not_free_on_drop();
1795        let bset2 = bset2.ptr;
1796        let isl_rs_result = unsafe { isl_basic_set_union(bset1, bset2) };
1797        let isl_rs_result = Set { ptr: isl_rs_result,
1798                                  should_free_on_drop: true };
1799        let err = isl_rs_ctx.last_error();
1800        if err != Error::None_ {
1801            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1802        }
1803        Ok(isl_rs_result)
1804    }
1805
1806    /// Wraps `isl_basic_set_universe`.
1807    pub fn universe(space: Space) -> Result<BasicSet, LibISLError> {
1808        let isl_rs_ctx = space.get_ctx();
1809        let mut space = space;
1810        space.do_not_free_on_drop();
1811        let space = space.ptr;
1812        let isl_rs_result = unsafe { isl_basic_set_universe(space) };
1813        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1814                                       should_free_on_drop: true };
1815        let err = isl_rs_ctx.last_error();
1816        if err != Error::None_ {
1817            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1818        }
1819        Ok(isl_rs_result)
1820    }
1821
1822    /// Wraps `isl_basic_set_unwrap`.
1823    pub fn unwrap(self) -> Result<BasicMap, LibISLError> {
1824        let bset = self;
1825        let isl_rs_ctx = bset.get_ctx();
1826        let mut bset = bset;
1827        bset.do_not_free_on_drop();
1828        let bset = bset.ptr;
1829        let isl_rs_result = unsafe { isl_basic_set_unwrap(bset) };
1830        let isl_rs_result = BasicMap { ptr: isl_rs_result,
1831                                       should_free_on_drop: true };
1832        let err = isl_rs_ctx.last_error();
1833        if err != Error::None_ {
1834            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1835        }
1836        Ok(isl_rs_result)
1837    }
1838
1839    /// Wraps `isl_basic_set_upper_bound_val`.
1840    pub fn upper_bound_val(self, type_: DimType, pos: u32, value: Val)
1841                           -> Result<BasicSet, LibISLError> {
1842        let bset = self;
1843        let isl_rs_ctx = bset.get_ctx();
1844        let mut bset = bset;
1845        bset.do_not_free_on_drop();
1846        let bset = bset.ptr;
1847        let type_ = type_.to_i32();
1848        let mut value = value;
1849        value.do_not_free_on_drop();
1850        let value = value.ptr;
1851        let isl_rs_result = unsafe { isl_basic_set_upper_bound_val(bset, type_, pos, value) };
1852        let isl_rs_result = BasicSet { ptr: isl_rs_result,
1853                                       should_free_on_drop: true };
1854        let err = isl_rs_ctx.last_error();
1855        if err != Error::None_ {
1856            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1857        }
1858        Ok(isl_rs_result)
1859    }
1860
1861    /// Does not call isl_basic_set_free() on being dropped. (For internal use
1862    /// only.)
1863    pub fn do_not_free_on_drop(&mut self) {
1864        self.should_free_on_drop = false;
1865    }
1866}
1867
1868impl Drop for BasicSet {
1869    fn drop(&mut self) {
1870        if self.should_free_on_drop {
1871            unsafe {
1872                isl_basic_set_free(self.ptr);
1873            }
1874        }
1875    }
1876}
isl_rs/bindings/basic_set.rs

isl_rs/bindings/
basic_set.rs
