1use super::{
5 Aff, Context, DimType, Error, Id, LibISLError, MultiAff, MultiId, MultiPwAff, MultiVal, PwAff,
6 PwMultiAff, Set, Space, UnionMap, UnionPwAff, UnionPwAffList, UnionPwMultiAff, UnionSet, Val,
7};
8use libc::uintptr_t;
9use std::ffi::{CStr, CString};
10use std::os::raw::c_char;
11
12pub struct MultiUnionPwAff {
14 pub ptr: uintptr_t,
15 pub should_free_on_drop: bool,
16}
17
18extern "C" {
19
20 fn isl_multi_union_pw_aff_add(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
21
22 fn isl_multi_union_pw_aff_align_params(multi: uintptr_t, model: uintptr_t) -> uintptr_t;
23
24 fn isl_multi_union_pw_aff_apply_aff(mupa: uintptr_t, aff: uintptr_t) -> uintptr_t;
25
26 fn isl_multi_union_pw_aff_apply_multi_aff(mupa: uintptr_t, ma: uintptr_t) -> uintptr_t;
27
28 fn isl_multi_union_pw_aff_apply_pw_aff(mupa: uintptr_t, pa: uintptr_t) -> uintptr_t;
29
30 fn isl_multi_union_pw_aff_apply_pw_multi_aff(mupa: uintptr_t, pma: uintptr_t) -> uintptr_t;
31
32 fn isl_multi_union_pw_aff_bind(mupa: uintptr_t, tuple: uintptr_t) -> uintptr_t;
33
34 fn isl_multi_union_pw_aff_coalesce(mupa: uintptr_t) -> uintptr_t;
35
36 fn isl_multi_union_pw_aff_copy(multi: uintptr_t) -> uintptr_t;
37
38 fn isl_multi_union_pw_aff_dim(multi: uintptr_t, type_: i32) -> i32;
39
40 fn isl_multi_union_pw_aff_domain(mupa: uintptr_t) -> uintptr_t;
41
42 fn isl_multi_union_pw_aff_drop_dims(multi: uintptr_t, type_: i32, first: u32, n: u32)
43 -> uintptr_t;
44
45 fn isl_multi_union_pw_aff_dump(mupa: uintptr_t) -> ();
46
47 fn isl_multi_union_pw_aff_extract_multi_pw_aff(mupa: uintptr_t, space: uintptr_t) -> uintptr_t;
48
49 fn isl_multi_union_pw_aff_factor_range(multi: uintptr_t) -> uintptr_t;
50
51 fn isl_multi_union_pw_aff_find_dim_by_id(multi: uintptr_t, type_: i32, id: uintptr_t) -> i32;
52
53 fn isl_multi_union_pw_aff_find_dim_by_name(multi: uintptr_t, type_: i32, name: *const c_char)
54 -> i32;
55
56 fn isl_multi_union_pw_aff_flat_range_product(multi1: uintptr_t, multi2: uintptr_t)
57 -> uintptr_t;
58
59 fn isl_multi_union_pw_aff_flatten_range(multi: uintptr_t) -> uintptr_t;
60
61 fn isl_multi_union_pw_aff_floor(mupa: uintptr_t) -> uintptr_t;
62
63 fn isl_multi_union_pw_aff_free(multi: uintptr_t) -> uintptr_t;
64
65 fn isl_multi_union_pw_aff_from_multi_aff(ma: uintptr_t) -> uintptr_t;
66
67 fn isl_multi_union_pw_aff_from_multi_pw_aff(mpa: uintptr_t) -> uintptr_t;
68
69 fn isl_multi_union_pw_aff_from_range(multi: uintptr_t) -> uintptr_t;
70
71 fn isl_multi_union_pw_aff_from_union_map(umap: uintptr_t) -> uintptr_t;
72
73 fn isl_multi_union_pw_aff_from_union_pw_aff(upa: uintptr_t) -> uintptr_t;
74
75 fn isl_multi_union_pw_aff_from_union_pw_aff_list(space: uintptr_t, list: uintptr_t)
76 -> uintptr_t;
77
78 fn isl_multi_union_pw_aff_from_union_pw_multi_aff(upma: uintptr_t) -> uintptr_t;
79
80 fn isl_multi_union_pw_aff_get_at(multi: uintptr_t, pos: i32) -> uintptr_t;
81
82 fn isl_multi_union_pw_aff_get_ctx(multi: uintptr_t) -> uintptr_t;
83
84 fn isl_multi_union_pw_aff_get_dim_id(multi: uintptr_t, type_: i32, pos: u32) -> uintptr_t;
85
86 fn isl_multi_union_pw_aff_get_domain_space(multi: uintptr_t) -> uintptr_t;
87
88 fn isl_multi_union_pw_aff_get_list(multi: uintptr_t) -> uintptr_t;
89
90 fn isl_multi_union_pw_aff_get_range_tuple_id(multi: uintptr_t) -> uintptr_t;
91
92 fn isl_multi_union_pw_aff_get_space(multi: uintptr_t) -> uintptr_t;
93
94 fn isl_multi_union_pw_aff_get_tuple_id(multi: uintptr_t, type_: i32) -> uintptr_t;
95
96 fn isl_multi_union_pw_aff_get_tuple_name(multi: uintptr_t, type_: i32) -> *const c_char;
97
98 fn isl_multi_union_pw_aff_get_union_pw_aff(multi: uintptr_t, pos: i32) -> uintptr_t;
99
100 fn isl_multi_union_pw_aff_gist(mupa: uintptr_t, context: uintptr_t) -> uintptr_t;
101
102 fn isl_multi_union_pw_aff_gist_params(mupa: uintptr_t, context: uintptr_t) -> uintptr_t;
103
104 fn isl_multi_union_pw_aff_has_range_tuple_id(multi: uintptr_t) -> i32;
105
106 fn isl_multi_union_pw_aff_has_tuple_id(multi: uintptr_t, type_: i32) -> i32;
107
108 fn isl_multi_union_pw_aff_intersect_domain(mupa: uintptr_t, uset: uintptr_t) -> uintptr_t;
109
110 fn isl_multi_union_pw_aff_intersect_params(mupa: uintptr_t, params: uintptr_t) -> uintptr_t;
111
112 fn isl_multi_union_pw_aff_intersect_range(mupa: uintptr_t, set: uintptr_t) -> uintptr_t;
113
114 fn isl_multi_union_pw_aff_involves_nan(multi: uintptr_t) -> i32;
115
116 fn isl_multi_union_pw_aff_max_multi_val(mupa: uintptr_t) -> uintptr_t;
117
118 fn isl_multi_union_pw_aff_min_multi_val(mupa: uintptr_t) -> uintptr_t;
119
120 fn isl_multi_union_pw_aff_mod_multi_val(multi: uintptr_t, mv: uintptr_t) -> uintptr_t;
121
122 fn isl_multi_union_pw_aff_multi_aff_on_domain(domain: uintptr_t, ma: uintptr_t) -> uintptr_t;
123
124 fn isl_multi_union_pw_aff_multi_val_on_domain(domain: uintptr_t, mv: uintptr_t) -> uintptr_t;
125
126 fn isl_multi_union_pw_aff_neg(multi: uintptr_t) -> uintptr_t;
127
128 fn isl_multi_union_pw_aff_plain_is_equal(multi1: uintptr_t, multi2: uintptr_t) -> i32;
129
130 fn isl_multi_union_pw_aff_pullback_union_pw_multi_aff(mupa: uintptr_t, upma: uintptr_t)
131 -> uintptr_t;
132
133 fn isl_multi_union_pw_aff_pw_multi_aff_on_domain(domain: uintptr_t, pma: uintptr_t)
134 -> uintptr_t;
135
136 fn isl_multi_union_pw_aff_range_factor_domain(multi: uintptr_t) -> uintptr_t;
137
138 fn isl_multi_union_pw_aff_range_factor_range(multi: uintptr_t) -> uintptr_t;
139
140 fn isl_multi_union_pw_aff_range_is_wrapping(multi: uintptr_t) -> i32;
141
142 fn isl_multi_union_pw_aff_range_product(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
143
144 fn isl_multi_union_pw_aff_range_splice(multi1: uintptr_t, pos: u32, multi2: uintptr_t)
145 -> uintptr_t;
146
147 fn isl_multi_union_pw_aff_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
148
149 fn isl_multi_union_pw_aff_reset_range_tuple_id(multi: uintptr_t) -> uintptr_t;
150
151 fn isl_multi_union_pw_aff_reset_tuple_id(multi: uintptr_t, type_: i32) -> uintptr_t;
152
153 fn isl_multi_union_pw_aff_reset_user(multi: uintptr_t) -> uintptr_t;
154
155 fn isl_multi_union_pw_aff_scale_down_multi_val(multi: uintptr_t, mv: uintptr_t) -> uintptr_t;
156
157 fn isl_multi_union_pw_aff_scale_down_val(multi: uintptr_t, v: uintptr_t) -> uintptr_t;
158
159 fn isl_multi_union_pw_aff_scale_multi_val(multi: uintptr_t, mv: uintptr_t) -> uintptr_t;
160
161 fn isl_multi_union_pw_aff_scale_val(multi: uintptr_t, v: uintptr_t) -> uintptr_t;
162
163 fn isl_multi_union_pw_aff_set_at(multi: uintptr_t, pos: i32, el: uintptr_t) -> uintptr_t;
164
165 fn isl_multi_union_pw_aff_set_dim_id(multi: uintptr_t, type_: i32, pos: u32, id: uintptr_t)
166 -> uintptr_t;
167
168 fn isl_multi_union_pw_aff_set_dim_name(multi: uintptr_t, type_: i32, pos: u32,
169 s: *const c_char)
170 -> uintptr_t;
171
172 fn isl_multi_union_pw_aff_set_range_tuple_id(multi: uintptr_t, id: uintptr_t) -> uintptr_t;
173
174 fn isl_multi_union_pw_aff_set_tuple_id(multi: uintptr_t, type_: i32, id: uintptr_t)
175 -> uintptr_t;
176
177 fn isl_multi_union_pw_aff_set_tuple_name(multi: uintptr_t, type_: i32, s: *const c_char)
178 -> uintptr_t;
179
180 fn isl_multi_union_pw_aff_set_union_pw_aff(multi: uintptr_t, pos: i32, el: uintptr_t)
181 -> uintptr_t;
182
183 fn isl_multi_union_pw_aff_size(multi: uintptr_t) -> i32;
184
185 fn isl_multi_union_pw_aff_sub(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;
186
187 fn isl_multi_union_pw_aff_to_str(mupa: uintptr_t) -> *const c_char;
188
189 fn isl_multi_union_pw_aff_union_add(mupa1: uintptr_t, mupa2: uintptr_t) -> uintptr_t;
190
191 fn isl_multi_union_pw_aff_zero(space: uintptr_t) -> uintptr_t;
192
193 fn isl_multi_union_pw_aff_zero_union_set(mupa: uintptr_t) -> uintptr_t;
194
195}
196
197impl MultiUnionPwAff {
198 pub fn add(self, multi2: MultiUnionPwAff) -> Result<MultiUnionPwAff, LibISLError> {
200 let multi1 = self;
201 let isl_rs_ctx = multi1.get_ctx();
202 let mut multi1 = multi1;
203 multi1.do_not_free_on_drop();
204 let multi1 = multi1.ptr;
205 let mut multi2 = multi2;
206 multi2.do_not_free_on_drop();
207 let multi2 = multi2.ptr;
208 let isl_rs_result = unsafe { isl_multi_union_pw_aff_add(multi1, multi2) };
209 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
210 should_free_on_drop: true };
211 let err = isl_rs_ctx.last_error();
212 if err != Error::None_ {
213 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
214 }
215 Ok(isl_rs_result)
216 }
217
218 pub fn align_params(self, model: Space) -> Result<MultiUnionPwAff, LibISLError> {
220 let multi = self;
221 let isl_rs_ctx = multi.get_ctx();
222 let mut multi = multi;
223 multi.do_not_free_on_drop();
224 let multi = multi.ptr;
225 let mut model = model;
226 model.do_not_free_on_drop();
227 let model = model.ptr;
228 let isl_rs_result = unsafe { isl_multi_union_pw_aff_align_params(multi, model) };
229 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
230 should_free_on_drop: true };
231 let err = isl_rs_ctx.last_error();
232 if err != Error::None_ {
233 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
234 }
235 Ok(isl_rs_result)
236 }
237
238 pub fn apply_aff(self, aff: Aff) -> Result<UnionPwAff, LibISLError> {
240 let mupa = self;
241 let isl_rs_ctx = mupa.get_ctx();
242 let mut mupa = mupa;
243 mupa.do_not_free_on_drop();
244 let mupa = mupa.ptr;
245 let mut aff = aff;
246 aff.do_not_free_on_drop();
247 let aff = aff.ptr;
248 let isl_rs_result = unsafe { isl_multi_union_pw_aff_apply_aff(mupa, aff) };
249 let isl_rs_result = UnionPwAff { ptr: isl_rs_result,
250 should_free_on_drop: true };
251 let err = isl_rs_ctx.last_error();
252 if err != Error::None_ {
253 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
254 }
255 Ok(isl_rs_result)
256 }
257
258 pub fn apply_multi_aff(self, ma: MultiAff) -> Result<MultiUnionPwAff, LibISLError> {
260 let mupa = self;
261 let isl_rs_ctx = mupa.get_ctx();
262 let mut mupa = mupa;
263 mupa.do_not_free_on_drop();
264 let mupa = mupa.ptr;
265 let mut ma = ma;
266 ma.do_not_free_on_drop();
267 let ma = ma.ptr;
268 let isl_rs_result = unsafe { isl_multi_union_pw_aff_apply_multi_aff(mupa, ma) };
269 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
270 should_free_on_drop: true };
271 let err = isl_rs_ctx.last_error();
272 if err != Error::None_ {
273 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
274 }
275 Ok(isl_rs_result)
276 }
277
278 pub fn apply_pw_aff(self, pa: PwAff) -> Result<UnionPwAff, LibISLError> {
280 let mupa = self;
281 let isl_rs_ctx = mupa.get_ctx();
282 let mut mupa = mupa;
283 mupa.do_not_free_on_drop();
284 let mupa = mupa.ptr;
285 let mut pa = pa;
286 pa.do_not_free_on_drop();
287 let pa = pa.ptr;
288 let isl_rs_result = unsafe { isl_multi_union_pw_aff_apply_pw_aff(mupa, pa) };
289 let isl_rs_result = UnionPwAff { ptr: isl_rs_result,
290 should_free_on_drop: true };
291 let err = isl_rs_ctx.last_error();
292 if err != Error::None_ {
293 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
294 }
295 Ok(isl_rs_result)
296 }
297
298 pub fn apply_pw_multi_aff(self, pma: PwMultiAff) -> Result<MultiUnionPwAff, LibISLError> {
300 let mupa = self;
301 let isl_rs_ctx = mupa.get_ctx();
302 let mut mupa = mupa;
303 mupa.do_not_free_on_drop();
304 let mupa = mupa.ptr;
305 let mut pma = pma;
306 pma.do_not_free_on_drop();
307 let pma = pma.ptr;
308 let isl_rs_result = unsafe { isl_multi_union_pw_aff_apply_pw_multi_aff(mupa, pma) };
309 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
310 should_free_on_drop: true };
311 let err = isl_rs_ctx.last_error();
312 if err != Error::None_ {
313 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
314 }
315 Ok(isl_rs_result)
316 }
317
318 pub fn bind(self, tuple: MultiId) -> Result<UnionSet, LibISLError> {
320 let mupa = self;
321 let isl_rs_ctx = mupa.get_ctx();
322 let mut mupa = mupa;
323 mupa.do_not_free_on_drop();
324 let mupa = mupa.ptr;
325 let mut tuple = tuple;
326 tuple.do_not_free_on_drop();
327 let tuple = tuple.ptr;
328 let isl_rs_result = unsafe { isl_multi_union_pw_aff_bind(mupa, tuple) };
329 let isl_rs_result = UnionSet { ptr: isl_rs_result,
330 should_free_on_drop: true };
331 let err = isl_rs_ctx.last_error();
332 if err != Error::None_ {
333 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
334 }
335 Ok(isl_rs_result)
336 }
337
338 pub fn coalesce(self) -> Result<MultiUnionPwAff, LibISLError> {
340 let mupa = self;
341 let isl_rs_ctx = mupa.get_ctx();
342 let mut mupa = mupa;
343 mupa.do_not_free_on_drop();
344 let mupa = mupa.ptr;
345 let isl_rs_result = unsafe { isl_multi_union_pw_aff_coalesce(mupa) };
346 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
347 should_free_on_drop: true };
348 let err = isl_rs_ctx.last_error();
349 if err != Error::None_ {
350 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
351 }
352 Ok(isl_rs_result)
353 }
354
355 pub fn copy(&self) -> Result<MultiUnionPwAff, LibISLError> {
357 let multi = self;
358 let isl_rs_ctx = multi.get_ctx();
359 let multi = multi.ptr;
360 let isl_rs_result = unsafe { isl_multi_union_pw_aff_copy(multi) };
361 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
362 should_free_on_drop: true };
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 pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
372 let multi = self;
373 let isl_rs_ctx = multi.get_ctx();
374 let multi = multi.ptr;
375 let type_ = type_.to_i32();
376 let isl_rs_result = unsafe { isl_multi_union_pw_aff_dim(multi, type_) };
377 let err = isl_rs_ctx.last_error();
378 if err != Error::None_ {
379 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
380 }
381 Ok(isl_rs_result)
382 }
383
384 pub fn domain(self) -> Result<UnionSet, LibISLError> {
386 let mupa = self;
387 let isl_rs_ctx = mupa.get_ctx();
388 let mut mupa = mupa;
389 mupa.do_not_free_on_drop();
390 let mupa = mupa.ptr;
391 let isl_rs_result = unsafe { isl_multi_union_pw_aff_domain(mupa) };
392 let isl_rs_result = UnionSet { ptr: isl_rs_result,
393 should_free_on_drop: true };
394 let err = isl_rs_ctx.last_error();
395 if err != Error::None_ {
396 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
397 }
398 Ok(isl_rs_result)
399 }
400
401 pub fn drop_dims(self, type_: DimType, first: u32, n: u32)
403 -> Result<MultiUnionPwAff, LibISLError> {
404 let multi = self;
405 let isl_rs_ctx = multi.get_ctx();
406 let mut multi = multi;
407 multi.do_not_free_on_drop();
408 let multi = multi.ptr;
409 let type_ = type_.to_i32();
410 let isl_rs_result = unsafe { isl_multi_union_pw_aff_drop_dims(multi, type_, first, n) };
411 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
412 should_free_on_drop: true };
413 let err = isl_rs_ctx.last_error();
414 if err != Error::None_ {
415 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
416 }
417 Ok(isl_rs_result)
418 }
419
420 pub fn dump(&self) -> Result<(), LibISLError> {
422 let mupa = self;
423 let isl_rs_ctx = mupa.get_ctx();
424 let mupa = mupa.ptr;
425 let isl_rs_result = unsafe { isl_multi_union_pw_aff_dump(mupa) };
426 let err = isl_rs_ctx.last_error();
427 if err != Error::None_ {
428 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
429 }
430 Ok(isl_rs_result)
431 }
432
433 pub fn extract_multi_pw_aff(&self, space: Space) -> Result<MultiPwAff, LibISLError> {
435 let mupa = self;
436 let isl_rs_ctx = mupa.get_ctx();
437 let mupa = mupa.ptr;
438 let mut space = space;
439 space.do_not_free_on_drop();
440 let space = space.ptr;
441 let isl_rs_result = unsafe { isl_multi_union_pw_aff_extract_multi_pw_aff(mupa, space) };
442 let isl_rs_result = MultiPwAff { ptr: isl_rs_result,
443 should_free_on_drop: true };
444 let err = isl_rs_ctx.last_error();
445 if err != Error::None_ {
446 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
447 }
448 Ok(isl_rs_result)
449 }
450
451 pub fn factor_range(self) -> Result<MultiUnionPwAff, LibISLError> {
453 let multi = self;
454 let isl_rs_ctx = multi.get_ctx();
455 let mut multi = multi;
456 multi.do_not_free_on_drop();
457 let multi = multi.ptr;
458 let isl_rs_result = unsafe { isl_multi_union_pw_aff_factor_range(multi) };
459 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
460 should_free_on_drop: true };
461 let err = isl_rs_ctx.last_error();
462 if err != Error::None_ {
463 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
464 }
465 Ok(isl_rs_result)
466 }
467
468 pub fn find_dim_by_id(&self, type_: DimType, id: &Id) -> Result<i32, LibISLError> {
470 let multi = self;
471 let isl_rs_ctx = multi.get_ctx();
472 let multi = multi.ptr;
473 let type_ = type_.to_i32();
474 let id = id.ptr;
475 let isl_rs_result = unsafe { isl_multi_union_pw_aff_find_dim_by_id(multi, type_, id) };
476 let err = isl_rs_ctx.last_error();
477 if err != Error::None_ {
478 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
479 }
480 Ok(isl_rs_result)
481 }
482
483 pub fn find_dim_by_name(&self, type_: DimType, name: &str) -> Result<i32, LibISLError> {
485 let multi = self;
486 let isl_rs_ctx = multi.get_ctx();
487 let multi = multi.ptr;
488 let type_ = type_.to_i32();
489 let name = CString::new(name).unwrap();
490 let name = name.as_ptr();
491 let isl_rs_result = unsafe { isl_multi_union_pw_aff_find_dim_by_name(multi, type_, name) };
492 let err = isl_rs_ctx.last_error();
493 if err != Error::None_ {
494 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
495 }
496 Ok(isl_rs_result)
497 }
498
499 pub fn flat_range_product(self, multi2: MultiUnionPwAff)
501 -> Result<MultiUnionPwAff, LibISLError> {
502 let multi1 = self;
503 let isl_rs_ctx = multi1.get_ctx();
504 let mut multi1 = multi1;
505 multi1.do_not_free_on_drop();
506 let multi1 = multi1.ptr;
507 let mut multi2 = multi2;
508 multi2.do_not_free_on_drop();
509 let multi2 = multi2.ptr;
510 let isl_rs_result = unsafe { isl_multi_union_pw_aff_flat_range_product(multi1, multi2) };
511 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
512 should_free_on_drop: true };
513 let err = isl_rs_ctx.last_error();
514 if err != Error::None_ {
515 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
516 }
517 Ok(isl_rs_result)
518 }
519
520 pub fn flatten_range(self) -> Result<MultiUnionPwAff, LibISLError> {
522 let multi = self;
523 let isl_rs_ctx = multi.get_ctx();
524 let mut multi = multi;
525 multi.do_not_free_on_drop();
526 let multi = multi.ptr;
527 let isl_rs_result = unsafe { isl_multi_union_pw_aff_flatten_range(multi) };
528 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
529 should_free_on_drop: true };
530 let err = isl_rs_ctx.last_error();
531 if err != Error::None_ {
532 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
533 }
534 Ok(isl_rs_result)
535 }
536
537 pub fn floor(self) -> Result<MultiUnionPwAff, LibISLError> {
539 let mupa = self;
540 let isl_rs_ctx = mupa.get_ctx();
541 let mut mupa = mupa;
542 mupa.do_not_free_on_drop();
543 let mupa = mupa.ptr;
544 let isl_rs_result = unsafe { isl_multi_union_pw_aff_floor(mupa) };
545 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
546 should_free_on_drop: true };
547 let err = isl_rs_ctx.last_error();
548 if err != Error::None_ {
549 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
550 }
551 Ok(isl_rs_result)
552 }
553
554 pub fn free(self) -> Result<MultiUnionPwAff, LibISLError> {
556 let multi = self;
557 let isl_rs_ctx = multi.get_ctx();
558 let mut multi = multi;
559 multi.do_not_free_on_drop();
560 let multi = multi.ptr;
561 let isl_rs_result = unsafe { isl_multi_union_pw_aff_free(multi) };
562 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
563 should_free_on_drop: true };
564 let err = isl_rs_ctx.last_error();
565 if err != Error::None_ {
566 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
567 }
568 Ok(isl_rs_result)
569 }
570
571 pub fn from_multi_aff(ma: MultiAff) -> Result<MultiUnionPwAff, LibISLError> {
573 let isl_rs_ctx = ma.get_ctx();
574 let mut ma = ma;
575 ma.do_not_free_on_drop();
576 let ma = ma.ptr;
577 let isl_rs_result = unsafe { isl_multi_union_pw_aff_from_multi_aff(ma) };
578 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
579 should_free_on_drop: true };
580 let err = isl_rs_ctx.last_error();
581 if err != Error::None_ {
582 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
583 }
584 Ok(isl_rs_result)
585 }
586
587 pub fn from_multi_pw_aff(mpa: MultiPwAff) -> Result<MultiUnionPwAff, LibISLError> {
589 let isl_rs_ctx = mpa.get_ctx();
590 let mut mpa = mpa;
591 mpa.do_not_free_on_drop();
592 let mpa = mpa.ptr;
593 let isl_rs_result = unsafe { isl_multi_union_pw_aff_from_multi_pw_aff(mpa) };
594 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
595 should_free_on_drop: true };
596 let err = isl_rs_ctx.last_error();
597 if err != Error::None_ {
598 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
599 }
600 Ok(isl_rs_result)
601 }
602
603 pub fn from_range(self) -> Result<MultiUnionPwAff, LibISLError> {
605 let multi = self;
606 let isl_rs_ctx = multi.get_ctx();
607 let mut multi = multi;
608 multi.do_not_free_on_drop();
609 let multi = multi.ptr;
610 let isl_rs_result = unsafe { isl_multi_union_pw_aff_from_range(multi) };
611 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
612 should_free_on_drop: true };
613 let err = isl_rs_ctx.last_error();
614 if err != Error::None_ {
615 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
616 }
617 Ok(isl_rs_result)
618 }
619
620 pub fn from_union_map(umap: UnionMap) -> Result<MultiUnionPwAff, LibISLError> {
622 let isl_rs_ctx = umap.get_ctx();
623 let mut umap = umap;
624 umap.do_not_free_on_drop();
625 let umap = umap.ptr;
626 let isl_rs_result = unsafe { isl_multi_union_pw_aff_from_union_map(umap) };
627 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
628 should_free_on_drop: true };
629 let err = isl_rs_ctx.last_error();
630 if err != Error::None_ {
631 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
632 }
633 Ok(isl_rs_result)
634 }
635
636 pub fn from_union_pw_aff(upa: UnionPwAff) -> Result<MultiUnionPwAff, LibISLError> {
638 let isl_rs_ctx = upa.get_ctx();
639 let mut upa = upa;
640 upa.do_not_free_on_drop();
641 let upa = upa.ptr;
642 let isl_rs_result = unsafe { isl_multi_union_pw_aff_from_union_pw_aff(upa) };
643 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
644 should_free_on_drop: true };
645 let err = isl_rs_ctx.last_error();
646 if err != Error::None_ {
647 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
648 }
649 Ok(isl_rs_result)
650 }
651
652 pub fn from_union_pw_aff_list(space: Space, list: UnionPwAffList)
654 -> Result<MultiUnionPwAff, LibISLError> {
655 let isl_rs_ctx = space.get_ctx();
656 let mut space = space;
657 space.do_not_free_on_drop();
658 let space = space.ptr;
659 let mut list = list;
660 list.do_not_free_on_drop();
661 let list = list.ptr;
662 let isl_rs_result = unsafe { isl_multi_union_pw_aff_from_union_pw_aff_list(space, list) };
663 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
664 should_free_on_drop: true };
665 let err = isl_rs_ctx.last_error();
666 if err != Error::None_ {
667 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
668 }
669 Ok(isl_rs_result)
670 }
671
672 pub fn from_union_pw_multi_aff(upma: UnionPwMultiAff) -> Result<MultiUnionPwAff, LibISLError> {
674 let isl_rs_ctx = upma.get_ctx();
675 let mut upma = upma;
676 upma.do_not_free_on_drop();
677 let upma = upma.ptr;
678 let isl_rs_result = unsafe { isl_multi_union_pw_aff_from_union_pw_multi_aff(upma) };
679 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
680 should_free_on_drop: true };
681 let err = isl_rs_ctx.last_error();
682 if err != Error::None_ {
683 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
684 }
685 Ok(isl_rs_result)
686 }
687
688 pub fn get_at(&self, pos: i32) -> Result<UnionPwAff, LibISLError> {
690 let multi = self;
691 let isl_rs_ctx = multi.get_ctx();
692 let multi = multi.ptr;
693 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_at(multi, pos) };
694 let isl_rs_result = UnionPwAff { ptr: isl_rs_result,
695 should_free_on_drop: true };
696 let err = isl_rs_ctx.last_error();
697 if err != Error::None_ {
698 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
699 }
700 Ok(isl_rs_result)
701 }
702
703 pub fn get_ctx(&self) -> Context {
705 let multi = self;
706 let multi = multi.ptr;
707 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_ctx(multi) };
708 let isl_rs_result = Context { ptr: isl_rs_result,
709 should_free_on_drop: false };
710 isl_rs_result
711 }
712
713 pub fn get_dim_id(&self, type_: DimType, pos: u32) -> Result<Id, LibISLError> {
715 let multi = self;
716 let isl_rs_ctx = multi.get_ctx();
717 let multi = multi.ptr;
718 let type_ = type_.to_i32();
719 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_dim_id(multi, type_, pos) };
720 let isl_rs_result = Id { ptr: isl_rs_result,
721 should_free_on_drop: true };
722 let err = isl_rs_ctx.last_error();
723 if err != Error::None_ {
724 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
725 }
726 Ok(isl_rs_result)
727 }
728
729 pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
731 let multi = self;
732 let isl_rs_ctx = multi.get_ctx();
733 let multi = multi.ptr;
734 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_domain_space(multi) };
735 let isl_rs_result = Space { ptr: isl_rs_result,
736 should_free_on_drop: true };
737 let err = isl_rs_ctx.last_error();
738 if err != Error::None_ {
739 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
740 }
741 Ok(isl_rs_result)
742 }
743
744 pub fn get_list(&self) -> Result<UnionPwAffList, LibISLError> {
746 let multi = self;
747 let isl_rs_ctx = multi.get_ctx();
748 let multi = multi.ptr;
749 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_list(multi) };
750 let isl_rs_result = UnionPwAffList { ptr: isl_rs_result,
751 should_free_on_drop: true };
752 let err = isl_rs_ctx.last_error();
753 if err != Error::None_ {
754 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
755 }
756 Ok(isl_rs_result)
757 }
758
759 pub fn get_range_tuple_id(&self) -> Result<Id, LibISLError> {
761 let multi = self;
762 let isl_rs_ctx = multi.get_ctx();
763 let multi = multi.ptr;
764 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_range_tuple_id(multi) };
765 let isl_rs_result = Id { ptr: isl_rs_result,
766 should_free_on_drop: true };
767 let err = isl_rs_ctx.last_error();
768 if err != Error::None_ {
769 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
770 }
771 Ok(isl_rs_result)
772 }
773
774 pub fn get_space(&self) -> Result<Space, LibISLError> {
776 let multi = self;
777 let isl_rs_ctx = multi.get_ctx();
778 let multi = multi.ptr;
779 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_space(multi) };
780 let isl_rs_result = Space { ptr: isl_rs_result,
781 should_free_on_drop: true };
782 let err = isl_rs_ctx.last_error();
783 if err != Error::None_ {
784 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
785 }
786 Ok(isl_rs_result)
787 }
788
789 pub fn get_tuple_id(&self, type_: DimType) -> Result<Id, LibISLError> {
791 let multi = self;
792 let isl_rs_ctx = multi.get_ctx();
793 let multi = multi.ptr;
794 let type_ = type_.to_i32();
795 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_tuple_id(multi, type_) };
796 let isl_rs_result = Id { ptr: isl_rs_result,
797 should_free_on_drop: true };
798 let err = isl_rs_ctx.last_error();
799 if err != Error::None_ {
800 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
801 }
802 Ok(isl_rs_result)
803 }
804
805 pub fn get_tuple_name(&self, type_: DimType) -> Result<&str, LibISLError> {
807 let multi = self;
808 let isl_rs_ctx = multi.get_ctx();
809 let multi = multi.ptr;
810 let type_ = type_.to_i32();
811 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_tuple_name(multi, type_) };
812 let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
813 let isl_rs_result = isl_rs_result.to_str().unwrap();
814 let err = isl_rs_ctx.last_error();
815 if err != Error::None_ {
816 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
817 }
818 Ok(isl_rs_result)
819 }
820
821 pub fn get_union_pw_aff(&self, pos: i32) -> Result<UnionPwAff, LibISLError> {
823 let multi = self;
824 let isl_rs_ctx = multi.get_ctx();
825 let multi = multi.ptr;
826 let isl_rs_result = unsafe { isl_multi_union_pw_aff_get_union_pw_aff(multi, pos) };
827 let isl_rs_result = UnionPwAff { ptr: isl_rs_result,
828 should_free_on_drop: true };
829 let err = isl_rs_ctx.last_error();
830 if err != Error::None_ {
831 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
832 }
833 Ok(isl_rs_result)
834 }
835
836 pub fn gist(self, context: UnionSet) -> Result<MultiUnionPwAff, LibISLError> {
838 let mupa = self;
839 let isl_rs_ctx = mupa.get_ctx();
840 let mut mupa = mupa;
841 mupa.do_not_free_on_drop();
842 let mupa = mupa.ptr;
843 let mut context = context;
844 context.do_not_free_on_drop();
845 let context = context.ptr;
846 let isl_rs_result = unsafe { isl_multi_union_pw_aff_gist(mupa, context) };
847 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
848 should_free_on_drop: true };
849 let err = isl_rs_ctx.last_error();
850 if err != Error::None_ {
851 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
852 }
853 Ok(isl_rs_result)
854 }
855
856 pub fn gist_params(self, context: Set) -> Result<MultiUnionPwAff, LibISLError> {
858 let mupa = self;
859 let isl_rs_ctx = mupa.get_ctx();
860 let mut mupa = mupa;
861 mupa.do_not_free_on_drop();
862 let mupa = mupa.ptr;
863 let mut context = context;
864 context.do_not_free_on_drop();
865 let context = context.ptr;
866 let isl_rs_result = unsafe { isl_multi_union_pw_aff_gist_params(mupa, context) };
867 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
868 should_free_on_drop: true };
869 let err = isl_rs_ctx.last_error();
870 if err != Error::None_ {
871 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
872 }
873 Ok(isl_rs_result)
874 }
875
876 pub fn has_range_tuple_id(&self) -> Result<bool, LibISLError> {
878 let multi = self;
879 let isl_rs_ctx = multi.get_ctx();
880 let multi = multi.ptr;
881 let isl_rs_result = unsafe { isl_multi_union_pw_aff_has_range_tuple_id(multi) };
882 let isl_rs_result = match isl_rs_result {
883 0 => false,
884 1 => true,
885 _ => panic!("Got isl_bool = -1"),
886 };
887 let err = isl_rs_ctx.last_error();
888 if err != Error::None_ {
889 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
890 }
891 Ok(isl_rs_result)
892 }
893
894 pub fn has_tuple_id(&self, type_: DimType) -> Result<bool, LibISLError> {
896 let multi = self;
897 let isl_rs_ctx = multi.get_ctx();
898 let multi = multi.ptr;
899 let type_ = type_.to_i32();
900 let isl_rs_result = unsafe { isl_multi_union_pw_aff_has_tuple_id(multi, type_) };
901 let isl_rs_result = match isl_rs_result {
902 0 => false,
903 1 => true,
904 _ => panic!("Got isl_bool = -1"),
905 };
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 pub fn intersect_domain(self, uset: UnionSet) -> Result<MultiUnionPwAff, LibISLError> {
915 let mupa = self;
916 let isl_rs_ctx = mupa.get_ctx();
917 let mut mupa = mupa;
918 mupa.do_not_free_on_drop();
919 let mupa = mupa.ptr;
920 let mut uset = uset;
921 uset.do_not_free_on_drop();
922 let uset = uset.ptr;
923 let isl_rs_result = unsafe { isl_multi_union_pw_aff_intersect_domain(mupa, uset) };
924 let isl_rs_result = MultiUnionPwAff { 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 pub fn intersect_params(self, params: Set) -> Result<MultiUnionPwAff, LibISLError> {
935 let mupa = self;
936 let isl_rs_ctx = mupa.get_ctx();
937 let mut mupa = mupa;
938 mupa.do_not_free_on_drop();
939 let mupa = mupa.ptr;
940 let mut params = params;
941 params.do_not_free_on_drop();
942 let params = params.ptr;
943 let isl_rs_result = unsafe { isl_multi_union_pw_aff_intersect_params(mupa, params) };
944 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
945 should_free_on_drop: true };
946 let err = isl_rs_ctx.last_error();
947 if err != Error::None_ {
948 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
949 }
950 Ok(isl_rs_result)
951 }
952
953 pub fn intersect_range(self, set: Set) -> Result<MultiUnionPwAff, LibISLError> {
955 let mupa = self;
956 let isl_rs_ctx = mupa.get_ctx();
957 let mut mupa = mupa;
958 mupa.do_not_free_on_drop();
959 let mupa = mupa.ptr;
960 let mut set = set;
961 set.do_not_free_on_drop();
962 let set = set.ptr;
963 let isl_rs_result = unsafe { isl_multi_union_pw_aff_intersect_range(mupa, set) };
964 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
965 should_free_on_drop: true };
966 let err = isl_rs_ctx.last_error();
967 if err != Error::None_ {
968 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
969 }
970 Ok(isl_rs_result)
971 }
972
973 pub fn involves_nan(&self) -> Result<bool, LibISLError> {
975 let multi = self;
976 let isl_rs_ctx = multi.get_ctx();
977 let multi = multi.ptr;
978 let isl_rs_result = unsafe { isl_multi_union_pw_aff_involves_nan(multi) };
979 let isl_rs_result = match isl_rs_result {
980 0 => false,
981 1 => true,
982 _ => panic!("Got isl_bool = -1"),
983 };
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 pub fn max_multi_val(self) -> Result<MultiVal, LibISLError> {
993 let mupa = self;
994 let isl_rs_ctx = mupa.get_ctx();
995 let mut mupa = mupa;
996 mupa.do_not_free_on_drop();
997 let mupa = mupa.ptr;
998 let isl_rs_result = unsafe { isl_multi_union_pw_aff_max_multi_val(mupa) };
999 let isl_rs_result = MultiVal { ptr: isl_rs_result,
1000 should_free_on_drop: true };
1001 let err = isl_rs_ctx.last_error();
1002 if err != Error::None_ {
1003 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1004 }
1005 Ok(isl_rs_result)
1006 }
1007
1008 pub fn min_multi_val(self) -> Result<MultiVal, LibISLError> {
1010 let mupa = self;
1011 let isl_rs_ctx = mupa.get_ctx();
1012 let mut mupa = mupa;
1013 mupa.do_not_free_on_drop();
1014 let mupa = mupa.ptr;
1015 let isl_rs_result = unsafe { isl_multi_union_pw_aff_min_multi_val(mupa) };
1016 let isl_rs_result = MultiVal { ptr: isl_rs_result,
1017 should_free_on_drop: true };
1018 let err = isl_rs_ctx.last_error();
1019 if err != Error::None_ {
1020 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1021 }
1022 Ok(isl_rs_result)
1023 }
1024
1025 pub fn mod_multi_val(self, mv: MultiVal) -> Result<MultiUnionPwAff, LibISLError> {
1027 let multi = self;
1028 let isl_rs_ctx = multi.get_ctx();
1029 let mut multi = multi;
1030 multi.do_not_free_on_drop();
1031 let multi = multi.ptr;
1032 let mut mv = mv;
1033 mv.do_not_free_on_drop();
1034 let mv = mv.ptr;
1035 let isl_rs_result = unsafe { isl_multi_union_pw_aff_mod_multi_val(multi, mv) };
1036 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1037 should_free_on_drop: true };
1038 let err = isl_rs_ctx.last_error();
1039 if err != Error::None_ {
1040 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1041 }
1042 Ok(isl_rs_result)
1043 }
1044
1045 pub fn multi_aff_on_domain(domain: UnionSet, ma: MultiAff)
1047 -> Result<MultiUnionPwAff, LibISLError> {
1048 let isl_rs_ctx = domain.get_ctx();
1049 let mut domain = domain;
1050 domain.do_not_free_on_drop();
1051 let domain = domain.ptr;
1052 let mut ma = ma;
1053 ma.do_not_free_on_drop();
1054 let ma = ma.ptr;
1055 let isl_rs_result = unsafe { isl_multi_union_pw_aff_multi_aff_on_domain(domain, ma) };
1056 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1057 should_free_on_drop: true };
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 pub fn multi_val_on_domain(domain: UnionSet, mv: MultiVal)
1067 -> Result<MultiUnionPwAff, LibISLError> {
1068 let isl_rs_ctx = domain.get_ctx();
1069 let mut domain = domain;
1070 domain.do_not_free_on_drop();
1071 let domain = domain.ptr;
1072 let mut mv = mv;
1073 mv.do_not_free_on_drop();
1074 let mv = mv.ptr;
1075 let isl_rs_result = unsafe { isl_multi_union_pw_aff_multi_val_on_domain(domain, mv) };
1076 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1077 should_free_on_drop: true };
1078 let err = isl_rs_ctx.last_error();
1079 if err != Error::None_ {
1080 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1081 }
1082 Ok(isl_rs_result)
1083 }
1084
1085 pub fn neg(self) -> Result<MultiUnionPwAff, LibISLError> {
1087 let multi = self;
1088 let isl_rs_ctx = multi.get_ctx();
1089 let mut multi = multi;
1090 multi.do_not_free_on_drop();
1091 let multi = multi.ptr;
1092 let isl_rs_result = unsafe { isl_multi_union_pw_aff_neg(multi) };
1093 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1094 should_free_on_drop: true };
1095 let err = isl_rs_ctx.last_error();
1096 if err != Error::None_ {
1097 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1098 }
1099 Ok(isl_rs_result)
1100 }
1101
1102 pub fn plain_is_equal(&self, multi2: &MultiUnionPwAff) -> Result<bool, LibISLError> {
1104 let multi1 = self;
1105 let isl_rs_ctx = multi1.get_ctx();
1106 let multi1 = multi1.ptr;
1107 let multi2 = multi2.ptr;
1108 let isl_rs_result = unsafe { isl_multi_union_pw_aff_plain_is_equal(multi1, multi2) };
1109 let isl_rs_result = match isl_rs_result {
1110 0 => false,
1111 1 => true,
1112 _ => panic!("Got isl_bool = -1"),
1113 };
1114 let err = isl_rs_ctx.last_error();
1115 if err != Error::None_ {
1116 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1117 }
1118 Ok(isl_rs_result)
1119 }
1120
1121 pub fn pullback_union_pw_multi_aff(self, upma: UnionPwMultiAff)
1123 -> Result<MultiUnionPwAff, LibISLError> {
1124 let mupa = self;
1125 let isl_rs_ctx = mupa.get_ctx();
1126 let mut mupa = mupa;
1127 mupa.do_not_free_on_drop();
1128 let mupa = mupa.ptr;
1129 let mut upma = upma;
1130 upma.do_not_free_on_drop();
1131 let upma = upma.ptr;
1132 let isl_rs_result =
1133 unsafe { isl_multi_union_pw_aff_pullback_union_pw_multi_aff(mupa, upma) };
1134 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1135 should_free_on_drop: true };
1136 let err = isl_rs_ctx.last_error();
1137 if err != Error::None_ {
1138 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1139 }
1140 Ok(isl_rs_result)
1141 }
1142
1143 pub fn pw_multi_aff_on_domain(domain: UnionSet, pma: PwMultiAff)
1145 -> Result<MultiUnionPwAff, LibISLError> {
1146 let isl_rs_ctx = domain.get_ctx();
1147 let mut domain = domain;
1148 domain.do_not_free_on_drop();
1149 let domain = domain.ptr;
1150 let mut pma = pma;
1151 pma.do_not_free_on_drop();
1152 let pma = pma.ptr;
1153 let isl_rs_result = unsafe { isl_multi_union_pw_aff_pw_multi_aff_on_domain(domain, pma) };
1154 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1155 should_free_on_drop: true };
1156 let err = isl_rs_ctx.last_error();
1157 if err != Error::None_ {
1158 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1159 }
1160 Ok(isl_rs_result)
1161 }
1162
1163 pub fn range_factor_domain(self) -> Result<MultiUnionPwAff, LibISLError> {
1165 let multi = self;
1166 let isl_rs_ctx = multi.get_ctx();
1167 let mut multi = multi;
1168 multi.do_not_free_on_drop();
1169 let multi = multi.ptr;
1170 let isl_rs_result = unsafe { isl_multi_union_pw_aff_range_factor_domain(multi) };
1171 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1172 should_free_on_drop: true };
1173 let err = isl_rs_ctx.last_error();
1174 if err != Error::None_ {
1175 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1176 }
1177 Ok(isl_rs_result)
1178 }
1179
1180 pub fn range_factor_range(self) -> Result<MultiUnionPwAff, LibISLError> {
1182 let multi = self;
1183 let isl_rs_ctx = multi.get_ctx();
1184 let mut multi = multi;
1185 multi.do_not_free_on_drop();
1186 let multi = multi.ptr;
1187 let isl_rs_result = unsafe { isl_multi_union_pw_aff_range_factor_range(multi) };
1188 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1189 should_free_on_drop: true };
1190 let err = isl_rs_ctx.last_error();
1191 if err != Error::None_ {
1192 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1193 }
1194 Ok(isl_rs_result)
1195 }
1196
1197 pub fn range_is_wrapping(&self) -> Result<bool, LibISLError> {
1199 let multi = self;
1200 let isl_rs_ctx = multi.get_ctx();
1201 let multi = multi.ptr;
1202 let isl_rs_result = unsafe { isl_multi_union_pw_aff_range_is_wrapping(multi) };
1203 let isl_rs_result = match isl_rs_result {
1204 0 => false,
1205 1 => true,
1206 _ => panic!("Got isl_bool = -1"),
1207 };
1208 let err = isl_rs_ctx.last_error();
1209 if err != Error::None_ {
1210 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1211 }
1212 Ok(isl_rs_result)
1213 }
1214
1215 pub fn range_product(self, multi2: MultiUnionPwAff) -> Result<MultiUnionPwAff, LibISLError> {
1217 let multi1 = self;
1218 let isl_rs_ctx = multi1.get_ctx();
1219 let mut multi1 = multi1;
1220 multi1.do_not_free_on_drop();
1221 let multi1 = multi1.ptr;
1222 let mut multi2 = multi2;
1223 multi2.do_not_free_on_drop();
1224 let multi2 = multi2.ptr;
1225 let isl_rs_result = unsafe { isl_multi_union_pw_aff_range_product(multi1, multi2) };
1226 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1227 should_free_on_drop: true };
1228 let err = isl_rs_ctx.last_error();
1229 if err != Error::None_ {
1230 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1231 }
1232 Ok(isl_rs_result)
1233 }
1234
1235 pub fn range_splice(self, pos: u32, multi2: MultiUnionPwAff)
1237 -> Result<MultiUnionPwAff, LibISLError> {
1238 let multi1 = self;
1239 let isl_rs_ctx = multi1.get_ctx();
1240 let mut multi1 = multi1;
1241 multi1.do_not_free_on_drop();
1242 let multi1 = multi1.ptr;
1243 let mut multi2 = multi2;
1244 multi2.do_not_free_on_drop();
1245 let multi2 = multi2.ptr;
1246 let isl_rs_result = unsafe { isl_multi_union_pw_aff_range_splice(multi1, pos, multi2) };
1247 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1248 should_free_on_drop: true };
1249 let err = isl_rs_ctx.last_error();
1250 if err != Error::None_ {
1251 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1252 }
1253 Ok(isl_rs_result)
1254 }
1255
1256 pub fn read_from_str(ctx: &Context, str_: &str) -> Result<MultiUnionPwAff, LibISLError> {
1258 let isl_rs_ctx = Context { ptr: ctx.ptr,
1259 should_free_on_drop: false };
1260 let ctx = ctx.ptr;
1261 let str_ = CString::new(str_).unwrap();
1262 let str_ = str_.as_ptr();
1263 let isl_rs_result = unsafe { isl_multi_union_pw_aff_read_from_str(ctx, str_) };
1264 let isl_rs_result = MultiUnionPwAff { 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 pub fn reset_range_tuple_id(self) -> Result<MultiUnionPwAff, LibISLError> {
1275 let multi = self;
1276 let isl_rs_ctx = multi.get_ctx();
1277 let mut multi = multi;
1278 multi.do_not_free_on_drop();
1279 let multi = multi.ptr;
1280 let isl_rs_result = unsafe { isl_multi_union_pw_aff_reset_range_tuple_id(multi) };
1281 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1282 should_free_on_drop: true };
1283 let err = isl_rs_ctx.last_error();
1284 if err != Error::None_ {
1285 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1286 }
1287 Ok(isl_rs_result)
1288 }
1289
1290 pub fn reset_tuple_id(self, type_: DimType) -> Result<MultiUnionPwAff, LibISLError> {
1292 let multi = self;
1293 let isl_rs_ctx = multi.get_ctx();
1294 let mut multi = multi;
1295 multi.do_not_free_on_drop();
1296 let multi = multi.ptr;
1297 let type_ = type_.to_i32();
1298 let isl_rs_result = unsafe { isl_multi_union_pw_aff_reset_tuple_id(multi, type_) };
1299 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1300 should_free_on_drop: true };
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 pub fn reset_user(self) -> Result<MultiUnionPwAff, LibISLError> {
1310 let multi = self;
1311 let isl_rs_ctx = multi.get_ctx();
1312 let mut multi = multi;
1313 multi.do_not_free_on_drop();
1314 let multi = multi.ptr;
1315 let isl_rs_result = unsafe { isl_multi_union_pw_aff_reset_user(multi) };
1316 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1317 should_free_on_drop: true };
1318 let err = isl_rs_ctx.last_error();
1319 if err != Error::None_ {
1320 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1321 }
1322 Ok(isl_rs_result)
1323 }
1324
1325 pub fn scale_down_multi_val(self, mv: MultiVal) -> Result<MultiUnionPwAff, LibISLError> {
1327 let multi = self;
1328 let isl_rs_ctx = multi.get_ctx();
1329 let mut multi = multi;
1330 multi.do_not_free_on_drop();
1331 let multi = multi.ptr;
1332 let mut mv = mv;
1333 mv.do_not_free_on_drop();
1334 let mv = mv.ptr;
1335 let isl_rs_result = unsafe { isl_multi_union_pw_aff_scale_down_multi_val(multi, mv) };
1336 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1337 should_free_on_drop: true };
1338 let err = isl_rs_ctx.last_error();
1339 if err != Error::None_ {
1340 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1341 }
1342 Ok(isl_rs_result)
1343 }
1344
1345 pub fn scale_down_val(self, v: Val) -> Result<MultiUnionPwAff, LibISLError> {
1347 let multi = self;
1348 let isl_rs_ctx = multi.get_ctx();
1349 let mut multi = multi;
1350 multi.do_not_free_on_drop();
1351 let multi = multi.ptr;
1352 let mut v = v;
1353 v.do_not_free_on_drop();
1354 let v = v.ptr;
1355 let isl_rs_result = unsafe { isl_multi_union_pw_aff_scale_down_val(multi, v) };
1356 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1357 should_free_on_drop: true };
1358 let err = isl_rs_ctx.last_error();
1359 if err != Error::None_ {
1360 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1361 }
1362 Ok(isl_rs_result)
1363 }
1364
1365 pub fn scale_multi_val(self, mv: MultiVal) -> Result<MultiUnionPwAff, LibISLError> {
1367 let multi = self;
1368 let isl_rs_ctx = multi.get_ctx();
1369 let mut multi = multi;
1370 multi.do_not_free_on_drop();
1371 let multi = multi.ptr;
1372 let mut mv = mv;
1373 mv.do_not_free_on_drop();
1374 let mv = mv.ptr;
1375 let isl_rs_result = unsafe { isl_multi_union_pw_aff_scale_multi_val(multi, mv) };
1376 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1377 should_free_on_drop: true };
1378 let err = isl_rs_ctx.last_error();
1379 if err != Error::None_ {
1380 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1381 }
1382 Ok(isl_rs_result)
1383 }
1384
1385 pub fn scale_val(self, v: Val) -> Result<MultiUnionPwAff, LibISLError> {
1387 let multi = self;
1388 let isl_rs_ctx = multi.get_ctx();
1389 let mut multi = multi;
1390 multi.do_not_free_on_drop();
1391 let multi = multi.ptr;
1392 let mut v = v;
1393 v.do_not_free_on_drop();
1394 let v = v.ptr;
1395 let isl_rs_result = unsafe { isl_multi_union_pw_aff_scale_val(multi, v) };
1396 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1397 should_free_on_drop: true };
1398 let err = isl_rs_ctx.last_error();
1399 if err != Error::None_ {
1400 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1401 }
1402 Ok(isl_rs_result)
1403 }
1404
1405 pub fn set_at(self, pos: i32, el: UnionPwAff) -> Result<MultiUnionPwAff, LibISLError> {
1407 let multi = self;
1408 let isl_rs_ctx = multi.get_ctx();
1409 let mut multi = multi;
1410 multi.do_not_free_on_drop();
1411 let multi = multi.ptr;
1412 let mut el = el;
1413 el.do_not_free_on_drop();
1414 let el = el.ptr;
1415 let isl_rs_result = unsafe { isl_multi_union_pw_aff_set_at(multi, pos, el) };
1416 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1417 should_free_on_drop: true };
1418 let err = isl_rs_ctx.last_error();
1419 if err != Error::None_ {
1420 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1421 }
1422 Ok(isl_rs_result)
1423 }
1424
1425 pub fn set_dim_id(self, type_: DimType, pos: u32, id: Id)
1427 -> Result<MultiUnionPwAff, LibISLError> {
1428 let multi = self;
1429 let isl_rs_ctx = multi.get_ctx();
1430 let mut multi = multi;
1431 multi.do_not_free_on_drop();
1432 let multi = multi.ptr;
1433 let type_ = type_.to_i32();
1434 let mut id = id;
1435 id.do_not_free_on_drop();
1436 let id = id.ptr;
1437 let isl_rs_result = unsafe { isl_multi_union_pw_aff_set_dim_id(multi, type_, pos, id) };
1438 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1439 should_free_on_drop: true };
1440 let err = isl_rs_ctx.last_error();
1441 if err != Error::None_ {
1442 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1443 }
1444 Ok(isl_rs_result)
1445 }
1446
1447 pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str)
1449 -> Result<MultiUnionPwAff, LibISLError> {
1450 let multi = self;
1451 let isl_rs_ctx = multi.get_ctx();
1452 let mut multi = multi;
1453 multi.do_not_free_on_drop();
1454 let multi = multi.ptr;
1455 let type_ = type_.to_i32();
1456 let s = CString::new(s).unwrap();
1457 let s = s.as_ptr();
1458 let isl_rs_result = unsafe { isl_multi_union_pw_aff_set_dim_name(multi, type_, pos, s) };
1459 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1460 should_free_on_drop: true };
1461 let err = isl_rs_ctx.last_error();
1462 if err != Error::None_ {
1463 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1464 }
1465 Ok(isl_rs_result)
1466 }
1467
1468 pub fn set_range_tuple_id(self, id: Id) -> Result<MultiUnionPwAff, LibISLError> {
1470 let multi = self;
1471 let isl_rs_ctx = multi.get_ctx();
1472 let mut multi = multi;
1473 multi.do_not_free_on_drop();
1474 let multi = multi.ptr;
1475 let mut id = id;
1476 id.do_not_free_on_drop();
1477 let id = id.ptr;
1478 let isl_rs_result = unsafe { isl_multi_union_pw_aff_set_range_tuple_id(multi, id) };
1479 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1480 should_free_on_drop: true };
1481 let err = isl_rs_ctx.last_error();
1482 if err != Error::None_ {
1483 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1484 }
1485 Ok(isl_rs_result)
1486 }
1487
1488 pub fn set_tuple_id(self, type_: DimType, id: Id) -> Result<MultiUnionPwAff, LibISLError> {
1490 let multi = self;
1491 let isl_rs_ctx = multi.get_ctx();
1492 let mut multi = multi;
1493 multi.do_not_free_on_drop();
1494 let multi = multi.ptr;
1495 let type_ = type_.to_i32();
1496 let mut id = id;
1497 id.do_not_free_on_drop();
1498 let id = id.ptr;
1499 let isl_rs_result = unsafe { isl_multi_union_pw_aff_set_tuple_id(multi, type_, id) };
1500 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1501 should_free_on_drop: true };
1502 let err = isl_rs_ctx.last_error();
1503 if err != Error::None_ {
1504 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1505 }
1506 Ok(isl_rs_result)
1507 }
1508
1509 pub fn set_tuple_name(self, type_: DimType, s: &str) -> Result<MultiUnionPwAff, LibISLError> {
1511 let multi = self;
1512 let isl_rs_ctx = multi.get_ctx();
1513 let mut multi = multi;
1514 multi.do_not_free_on_drop();
1515 let multi = multi.ptr;
1516 let type_ = type_.to_i32();
1517 let s = CString::new(s).unwrap();
1518 let s = s.as_ptr();
1519 let isl_rs_result = unsafe { isl_multi_union_pw_aff_set_tuple_name(multi, type_, s) };
1520 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1521 should_free_on_drop: true };
1522 let err = isl_rs_ctx.last_error();
1523 if err != Error::None_ {
1524 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1525 }
1526 Ok(isl_rs_result)
1527 }
1528
1529 pub fn set_union_pw_aff(self, pos: i32, el: UnionPwAff)
1531 -> Result<MultiUnionPwAff, LibISLError> {
1532 let multi = self;
1533 let isl_rs_ctx = multi.get_ctx();
1534 let mut multi = multi;
1535 multi.do_not_free_on_drop();
1536 let multi = multi.ptr;
1537 let mut el = el;
1538 el.do_not_free_on_drop();
1539 let el = el.ptr;
1540 let isl_rs_result = unsafe { isl_multi_union_pw_aff_set_union_pw_aff(multi, pos, el) };
1541 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1542 should_free_on_drop: true };
1543 let err = isl_rs_ctx.last_error();
1544 if err != Error::None_ {
1545 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1546 }
1547 Ok(isl_rs_result)
1548 }
1549
1550 pub fn size(&self) -> Result<i32, LibISLError> {
1552 let multi = self;
1553 let isl_rs_ctx = multi.get_ctx();
1554 let multi = multi.ptr;
1555 let isl_rs_result = unsafe { isl_multi_union_pw_aff_size(multi) };
1556 let err = isl_rs_ctx.last_error();
1557 if err != Error::None_ {
1558 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1559 }
1560 Ok(isl_rs_result)
1561 }
1562
1563 pub fn sub(self, multi2: MultiUnionPwAff) -> Result<MultiUnionPwAff, LibISLError> {
1565 let multi1 = self;
1566 let isl_rs_ctx = multi1.get_ctx();
1567 let mut multi1 = multi1;
1568 multi1.do_not_free_on_drop();
1569 let multi1 = multi1.ptr;
1570 let mut multi2 = multi2;
1571 multi2.do_not_free_on_drop();
1572 let multi2 = multi2.ptr;
1573 let isl_rs_result = unsafe { isl_multi_union_pw_aff_sub(multi1, multi2) };
1574 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1575 should_free_on_drop: true };
1576 let err = isl_rs_ctx.last_error();
1577 if err != Error::None_ {
1578 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1579 }
1580 Ok(isl_rs_result)
1581 }
1582
1583 pub fn to_str(&self) -> Result<&str, LibISLError> {
1585 let mupa = self;
1586 let isl_rs_ctx = mupa.get_ctx();
1587 let mupa = mupa.ptr;
1588 let isl_rs_result = unsafe { isl_multi_union_pw_aff_to_str(mupa) };
1589 let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1590 let isl_rs_result = isl_rs_result.to_str().unwrap();
1591 let err = isl_rs_ctx.last_error();
1592 if err != Error::None_ {
1593 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1594 }
1595 Ok(isl_rs_result)
1596 }
1597
1598 pub fn union_add(self, mupa2: MultiUnionPwAff) -> Result<MultiUnionPwAff, LibISLError> {
1600 let mupa1 = self;
1601 let isl_rs_ctx = mupa1.get_ctx();
1602 let mut mupa1 = mupa1;
1603 mupa1.do_not_free_on_drop();
1604 let mupa1 = mupa1.ptr;
1605 let mut mupa2 = mupa2;
1606 mupa2.do_not_free_on_drop();
1607 let mupa2 = mupa2.ptr;
1608 let isl_rs_result = unsafe { isl_multi_union_pw_aff_union_add(mupa1, mupa2) };
1609 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1610 should_free_on_drop: true };
1611 let err = isl_rs_ctx.last_error();
1612 if err != Error::None_ {
1613 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1614 }
1615 Ok(isl_rs_result)
1616 }
1617
1618 pub fn zero(space: Space) -> Result<MultiUnionPwAff, LibISLError> {
1620 let isl_rs_ctx = space.get_ctx();
1621 let mut space = space;
1622 space.do_not_free_on_drop();
1623 let space = space.ptr;
1624 let isl_rs_result = unsafe { isl_multi_union_pw_aff_zero(space) };
1625 let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
1626 should_free_on_drop: true };
1627 let err = isl_rs_ctx.last_error();
1628 if err != Error::None_ {
1629 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1630 }
1631 Ok(isl_rs_result)
1632 }
1633
1634 pub fn zero_union_set(self) -> Result<UnionSet, LibISLError> {
1636 let mupa = self;
1637 let isl_rs_ctx = mupa.get_ctx();
1638 let mut mupa = mupa;
1639 mupa.do_not_free_on_drop();
1640 let mupa = mupa.ptr;
1641 let isl_rs_result = unsafe { isl_multi_union_pw_aff_zero_union_set(mupa) };
1642 let isl_rs_result = UnionSet { ptr: isl_rs_result,
1643 should_free_on_drop: true };
1644 let err = isl_rs_ctx.last_error();
1645 if err != Error::None_ {
1646 return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1647 }
1648 Ok(isl_rs_result)
1649 }
1650
1651 pub fn do_not_free_on_drop(&mut self) {
1654 self.should_free_on_drop = false;
1655 }
1656}
1657
1658impl Drop for MultiUnionPwAff {
1659 fn drop(&mut self) {
1660 if self.should_free_on_drop {
1661 unsafe {
1662 isl_multi_union_pw_aff_free(self.ptr);
1663 }
1664 }
1665 }
1666}