isl_rs/bindings/
schedule_constraints.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Context, Error, LibISLError, Schedule, Set, UnionMap, UnionSet};
5use libc::uintptr_t;
6use std::ffi::{CStr, CString};
7use std::os::raw::c_char;
8
9/// Wraps `isl_schedule_constraints`.
10pub struct ScheduleConstraints {
11    pub ptr: uintptr_t,
12    pub should_free_on_drop: bool,
13}
14
15extern "C" {
16
17    fn isl_schedule_constraints_apply(sc: uintptr_t, umap: uintptr_t) -> uintptr_t;
18
19    fn isl_schedule_constraints_compute_schedule(sc: uintptr_t) -> uintptr_t;
20
21    fn isl_schedule_constraints_copy(sc: uintptr_t) -> uintptr_t;
22
23    fn isl_schedule_constraints_dump(sc: uintptr_t) -> ();
24
25    fn isl_schedule_constraints_free(sc: uintptr_t) -> uintptr_t;
26
27    fn isl_schedule_constraints_get_coincidence(sc: uintptr_t) -> uintptr_t;
28
29    fn isl_schedule_constraints_get_conditional_validity(sc: uintptr_t) -> uintptr_t;
30
31    fn isl_schedule_constraints_get_conditional_validity_condition(sc: uintptr_t) -> uintptr_t;
32
33    fn isl_schedule_constraints_get_context(sc: uintptr_t) -> uintptr_t;
34
35    fn isl_schedule_constraints_get_ctx(sc: uintptr_t) -> uintptr_t;
36
37    fn isl_schedule_constraints_get_domain(sc: uintptr_t) -> uintptr_t;
38
39    fn isl_schedule_constraints_get_proximity(sc: uintptr_t) -> uintptr_t;
40
41    fn isl_schedule_constraints_get_validity(sc: uintptr_t) -> uintptr_t;
42
43    fn isl_schedule_constraints_on_domain(domain: uintptr_t) -> uintptr_t;
44
45    fn isl_schedule_constraints_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;
46
47    fn isl_schedule_constraints_set_coincidence(sc: uintptr_t, coincidence: uintptr_t)
48                                                -> uintptr_t;
49
50    fn isl_schedule_constraints_set_conditional_validity(sc: uintptr_t, condition: uintptr_t,
51                                                         validity: uintptr_t)
52                                                         -> uintptr_t;
53
54    fn isl_schedule_constraints_set_context(sc: uintptr_t, context: uintptr_t) -> uintptr_t;
55
56    fn isl_schedule_constraints_set_proximity(sc: uintptr_t, proximity: uintptr_t) -> uintptr_t;
57
58    fn isl_schedule_constraints_set_validity(sc: uintptr_t, validity: uintptr_t) -> uintptr_t;
59
60    fn isl_schedule_constraints_to_str(sc: uintptr_t) -> *const c_char;
61
62}
63
64impl ScheduleConstraints {
65    /// Wraps `isl_schedule_constraints_apply`.
66    pub fn apply(self, umap: UnionMap) -> Result<ScheduleConstraints, LibISLError> {
67        let sc = self;
68        let isl_rs_ctx = sc.get_ctx();
69        let mut sc = sc;
70        sc.do_not_free_on_drop();
71        let sc = sc.ptr;
72        let mut umap = umap;
73        umap.do_not_free_on_drop();
74        let umap = umap.ptr;
75        let isl_rs_result = unsafe { isl_schedule_constraints_apply(sc, umap) };
76        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
77                                                  should_free_on_drop: true };
78        let err = isl_rs_ctx.last_error();
79        if err != Error::None_ {
80            let err_msg = isl_rs_ctx.last_error_msg();
81            isl_rs_ctx.reset_error();
82            return Err(LibISLError::new(err, err_msg));
83        }
84        Ok(isl_rs_result)
85    }
86
87    /// Wraps `isl_schedule_constraints_compute_schedule`.
88    pub fn compute_schedule(self) -> Result<Schedule, LibISLError> {
89        let sc = self;
90        let isl_rs_ctx = sc.get_ctx();
91        let mut sc = sc;
92        sc.do_not_free_on_drop();
93        let sc = sc.ptr;
94        let isl_rs_result = unsafe { isl_schedule_constraints_compute_schedule(sc) };
95        let isl_rs_result = Schedule { ptr: isl_rs_result,
96                                       should_free_on_drop: true };
97        let err = isl_rs_ctx.last_error();
98        if err != Error::None_ {
99            let err_msg = isl_rs_ctx.last_error_msg();
100            isl_rs_ctx.reset_error();
101            return Err(LibISLError::new(err, err_msg));
102        }
103        Ok(isl_rs_result)
104    }
105
106    /// Wraps `isl_schedule_constraints_copy`.
107    pub fn copy(&self) -> Result<ScheduleConstraints, LibISLError> {
108        let sc = self;
109        let isl_rs_ctx = sc.get_ctx();
110        let sc = sc.ptr;
111        let isl_rs_result = unsafe { isl_schedule_constraints_copy(sc) };
112        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
113                                                  should_free_on_drop: true };
114        let err = isl_rs_ctx.last_error();
115        if err != Error::None_ {
116            let err_msg = isl_rs_ctx.last_error_msg();
117            isl_rs_ctx.reset_error();
118            return Err(LibISLError::new(err, err_msg));
119        }
120        Ok(isl_rs_result)
121    }
122
123    /// Wraps `isl_schedule_constraints_dump`.
124    pub fn dump(&self) -> Result<(), LibISLError> {
125        let sc = self;
126        let isl_rs_ctx = sc.get_ctx();
127        let sc = sc.ptr;
128        let isl_rs_result = unsafe { isl_schedule_constraints_dump(sc) };
129        let err = isl_rs_ctx.last_error();
130        if err != Error::None_ {
131            let err_msg = isl_rs_ctx.last_error_msg();
132            isl_rs_ctx.reset_error();
133            return Err(LibISLError::new(err, err_msg));
134        }
135        Ok(isl_rs_result)
136    }
137
138    /// Wraps `isl_schedule_constraints_free`.
139    pub fn free(self) -> Result<ScheduleConstraints, LibISLError> {
140        let sc = self;
141        let isl_rs_ctx = sc.get_ctx();
142        let mut sc = sc;
143        sc.do_not_free_on_drop();
144        let sc = sc.ptr;
145        let isl_rs_result = unsafe { isl_schedule_constraints_free(sc) };
146        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
147                                                  should_free_on_drop: true };
148        let err = isl_rs_ctx.last_error();
149        if err != Error::None_ {
150            let err_msg = isl_rs_ctx.last_error_msg();
151            isl_rs_ctx.reset_error();
152            return Err(LibISLError::new(err, err_msg));
153        }
154        Ok(isl_rs_result)
155    }
156
157    /// Wraps `isl_schedule_constraints_get_coincidence`.
158    pub fn get_coincidence(&self) -> Result<UnionMap, LibISLError> {
159        let sc = self;
160        let isl_rs_ctx = sc.get_ctx();
161        let sc = sc.ptr;
162        let isl_rs_result = unsafe { isl_schedule_constraints_get_coincidence(sc) };
163        let isl_rs_result = UnionMap { ptr: isl_rs_result,
164                                       should_free_on_drop: true };
165        let err = isl_rs_ctx.last_error();
166        if err != Error::None_ {
167            let err_msg = isl_rs_ctx.last_error_msg();
168            isl_rs_ctx.reset_error();
169            return Err(LibISLError::new(err, err_msg));
170        }
171        Ok(isl_rs_result)
172    }
173
174    /// Wraps `isl_schedule_constraints_get_conditional_validity`.
175    pub fn get_conditional_validity(&self) -> Result<UnionMap, LibISLError> {
176        let sc = self;
177        let isl_rs_ctx = sc.get_ctx();
178        let sc = sc.ptr;
179        let isl_rs_result = unsafe { isl_schedule_constraints_get_conditional_validity(sc) };
180        let isl_rs_result = UnionMap { ptr: isl_rs_result,
181                                       should_free_on_drop: true };
182        let err = isl_rs_ctx.last_error();
183        if err != Error::None_ {
184            let err_msg = isl_rs_ctx.last_error_msg();
185            isl_rs_ctx.reset_error();
186            return Err(LibISLError::new(err, err_msg));
187        }
188        Ok(isl_rs_result)
189    }
190
191    /// Wraps `isl_schedule_constraints_get_conditional_validity_condition`.
192    pub fn get_conditional_validity_condition(&self) -> Result<UnionMap, LibISLError> {
193        let sc = self;
194        let isl_rs_ctx = sc.get_ctx();
195        let sc = sc.ptr;
196        let isl_rs_result =
197            unsafe { isl_schedule_constraints_get_conditional_validity_condition(sc) };
198        let isl_rs_result = UnionMap { ptr: isl_rs_result,
199                                       should_free_on_drop: true };
200        let err = isl_rs_ctx.last_error();
201        if err != Error::None_ {
202            let err_msg = isl_rs_ctx.last_error_msg();
203            isl_rs_ctx.reset_error();
204            return Err(LibISLError::new(err, err_msg));
205        }
206        Ok(isl_rs_result)
207    }
208
209    /// Wraps `isl_schedule_constraints_get_context`.
210    pub fn get_context(&self) -> Result<Set, LibISLError> {
211        let sc = self;
212        let isl_rs_ctx = sc.get_ctx();
213        let sc = sc.ptr;
214        let isl_rs_result = unsafe { isl_schedule_constraints_get_context(sc) };
215        let isl_rs_result = Set { ptr: isl_rs_result,
216                                  should_free_on_drop: true };
217        let err = isl_rs_ctx.last_error();
218        if err != Error::None_ {
219            let err_msg = isl_rs_ctx.last_error_msg();
220            isl_rs_ctx.reset_error();
221            return Err(LibISLError::new(err, err_msg));
222        }
223        Ok(isl_rs_result)
224    }
225
226    /// Wraps `isl_schedule_constraints_get_ctx`.
227    pub fn get_ctx(&self) -> Context {
228        let sc = self;
229        let sc = sc.ptr;
230        let isl_rs_result = unsafe { isl_schedule_constraints_get_ctx(sc) };
231        let isl_rs_result = Context { ptr: isl_rs_result,
232                                      should_free_on_drop: false };
233        isl_rs_result
234    }
235
236    /// Wraps `isl_schedule_constraints_get_domain`.
237    pub fn get_domain(&self) -> Result<UnionSet, LibISLError> {
238        let sc = self;
239        let isl_rs_ctx = sc.get_ctx();
240        let sc = sc.ptr;
241        let isl_rs_result = unsafe { isl_schedule_constraints_get_domain(sc) };
242        let isl_rs_result = UnionSet { ptr: isl_rs_result,
243                                       should_free_on_drop: true };
244        let err = isl_rs_ctx.last_error();
245        if err != Error::None_ {
246            let err_msg = isl_rs_ctx.last_error_msg();
247            isl_rs_ctx.reset_error();
248            return Err(LibISLError::new(err, err_msg));
249        }
250        Ok(isl_rs_result)
251    }
252
253    /// Wraps `isl_schedule_constraints_get_proximity`.
254    pub fn get_proximity(&self) -> Result<UnionMap, LibISLError> {
255        let sc = self;
256        let isl_rs_ctx = sc.get_ctx();
257        let sc = sc.ptr;
258        let isl_rs_result = unsafe { isl_schedule_constraints_get_proximity(sc) };
259        let isl_rs_result = UnionMap { ptr: isl_rs_result,
260                                       should_free_on_drop: true };
261        let err = isl_rs_ctx.last_error();
262        if err != Error::None_ {
263            let err_msg = isl_rs_ctx.last_error_msg();
264            isl_rs_ctx.reset_error();
265            return Err(LibISLError::new(err, err_msg));
266        }
267        Ok(isl_rs_result)
268    }
269
270    /// Wraps `isl_schedule_constraints_get_validity`.
271    pub fn get_validity(&self) -> Result<UnionMap, LibISLError> {
272        let sc = self;
273        let isl_rs_ctx = sc.get_ctx();
274        let sc = sc.ptr;
275        let isl_rs_result = unsafe { isl_schedule_constraints_get_validity(sc) };
276        let isl_rs_result = UnionMap { ptr: isl_rs_result,
277                                       should_free_on_drop: true };
278        let err = isl_rs_ctx.last_error();
279        if err != Error::None_ {
280            let err_msg = isl_rs_ctx.last_error_msg();
281            isl_rs_ctx.reset_error();
282            return Err(LibISLError::new(err, err_msg));
283        }
284        Ok(isl_rs_result)
285    }
286
287    /// Wraps `isl_schedule_constraints_on_domain`.
288    pub fn on_domain(domain: UnionSet) -> Result<ScheduleConstraints, LibISLError> {
289        let isl_rs_ctx = domain.get_ctx();
290        let mut domain = domain;
291        domain.do_not_free_on_drop();
292        let domain = domain.ptr;
293        let isl_rs_result = unsafe { isl_schedule_constraints_on_domain(domain) };
294        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
295                                                  should_free_on_drop: true };
296        let err = isl_rs_ctx.last_error();
297        if err != Error::None_ {
298            let err_msg = isl_rs_ctx.last_error_msg();
299            isl_rs_ctx.reset_error();
300            return Err(LibISLError::new(err, err_msg));
301        }
302        Ok(isl_rs_result)
303    }
304
305    /// Wraps `isl_schedule_constraints_read_from_str`.
306    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<ScheduleConstraints, LibISLError> {
307        let isl_rs_ctx = Context { ptr: ctx.ptr,
308                                   should_free_on_drop: false };
309        let ctx = ctx.ptr;
310        let str_ = CString::new(str_).unwrap();
311        let str_ = str_.as_ptr();
312        let isl_rs_result = unsafe { isl_schedule_constraints_read_from_str(ctx, str_) };
313        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
314                                                  should_free_on_drop: true };
315        let err = isl_rs_ctx.last_error();
316        if err != Error::None_ {
317            let err_msg = isl_rs_ctx.last_error_msg();
318            isl_rs_ctx.reset_error();
319            return Err(LibISLError::new(err, err_msg));
320        }
321        Ok(isl_rs_result)
322    }
323
324    /// Wraps `isl_schedule_constraints_set_coincidence`.
325    pub fn set_coincidence(self, coincidence: UnionMap)
326                           -> Result<ScheduleConstraints, LibISLError> {
327        let sc = self;
328        let isl_rs_ctx = sc.get_ctx();
329        let mut sc = sc;
330        sc.do_not_free_on_drop();
331        let sc = sc.ptr;
332        let mut coincidence = coincidence;
333        coincidence.do_not_free_on_drop();
334        let coincidence = coincidence.ptr;
335        let isl_rs_result = unsafe { isl_schedule_constraints_set_coincidence(sc, coincidence) };
336        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
337                                                  should_free_on_drop: true };
338        let err = isl_rs_ctx.last_error();
339        if err != Error::None_ {
340            let err_msg = isl_rs_ctx.last_error_msg();
341            isl_rs_ctx.reset_error();
342            return Err(LibISLError::new(err, err_msg));
343        }
344        Ok(isl_rs_result)
345    }
346
347    /// Wraps `isl_schedule_constraints_set_conditional_validity`.
348    pub fn set_conditional_validity(self, condition: UnionMap, validity: UnionMap)
349                                    -> Result<ScheduleConstraints, LibISLError> {
350        let sc = self;
351        let isl_rs_ctx = sc.get_ctx();
352        let mut sc = sc;
353        sc.do_not_free_on_drop();
354        let sc = sc.ptr;
355        let mut condition = condition;
356        condition.do_not_free_on_drop();
357        let condition = condition.ptr;
358        let mut validity = validity;
359        validity.do_not_free_on_drop();
360        let validity = validity.ptr;
361        let isl_rs_result =
362            unsafe { isl_schedule_constraints_set_conditional_validity(sc, condition, validity) };
363        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
364                                                  should_free_on_drop: true };
365        let err = isl_rs_ctx.last_error();
366        if err != Error::None_ {
367            let err_msg = isl_rs_ctx.last_error_msg();
368            isl_rs_ctx.reset_error();
369            return Err(LibISLError::new(err, err_msg));
370        }
371        Ok(isl_rs_result)
372    }
373
374    /// Wraps `isl_schedule_constraints_set_context`.
375    pub fn set_context(self, context: Set) -> Result<ScheduleConstraints, LibISLError> {
376        let sc = self;
377        let isl_rs_ctx = sc.get_ctx();
378        let mut sc = sc;
379        sc.do_not_free_on_drop();
380        let sc = sc.ptr;
381        let mut context = context;
382        context.do_not_free_on_drop();
383        let context = context.ptr;
384        let isl_rs_result = unsafe { isl_schedule_constraints_set_context(sc, context) };
385        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
386                                                  should_free_on_drop: true };
387        let err = isl_rs_ctx.last_error();
388        if err != Error::None_ {
389            let err_msg = isl_rs_ctx.last_error_msg();
390            isl_rs_ctx.reset_error();
391            return Err(LibISLError::new(err, err_msg));
392        }
393        Ok(isl_rs_result)
394    }
395
396    /// Wraps `isl_schedule_constraints_set_proximity`.
397    pub fn set_proximity(self, proximity: UnionMap) -> Result<ScheduleConstraints, LibISLError> {
398        let sc = self;
399        let isl_rs_ctx = sc.get_ctx();
400        let mut sc = sc;
401        sc.do_not_free_on_drop();
402        let sc = sc.ptr;
403        let mut proximity = proximity;
404        proximity.do_not_free_on_drop();
405        let proximity = proximity.ptr;
406        let isl_rs_result = unsafe { isl_schedule_constraints_set_proximity(sc, proximity) };
407        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
408                                                  should_free_on_drop: true };
409        let err = isl_rs_ctx.last_error();
410        if err != Error::None_ {
411            let err_msg = isl_rs_ctx.last_error_msg();
412            isl_rs_ctx.reset_error();
413            return Err(LibISLError::new(err, err_msg));
414        }
415        Ok(isl_rs_result)
416    }
417
418    /// Wraps `isl_schedule_constraints_set_validity`.
419    pub fn set_validity(self, validity: UnionMap) -> Result<ScheduleConstraints, LibISLError> {
420        let sc = self;
421        let isl_rs_ctx = sc.get_ctx();
422        let mut sc = sc;
423        sc.do_not_free_on_drop();
424        let sc = sc.ptr;
425        let mut validity = validity;
426        validity.do_not_free_on_drop();
427        let validity = validity.ptr;
428        let isl_rs_result = unsafe { isl_schedule_constraints_set_validity(sc, validity) };
429        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
430                                                  should_free_on_drop: true };
431        let err = isl_rs_ctx.last_error();
432        if err != Error::None_ {
433            let err_msg = isl_rs_ctx.last_error_msg();
434            isl_rs_ctx.reset_error();
435            return Err(LibISLError::new(err, err_msg));
436        }
437        Ok(isl_rs_result)
438    }
439
440    /// Wraps `isl_schedule_constraints_to_str`.
441    pub fn to_str(&self) -> Result<&str, LibISLError> {
442        let sc = self;
443        let isl_rs_ctx = sc.get_ctx();
444        let sc = sc.ptr;
445        let isl_rs_result = unsafe { isl_schedule_constraints_to_str(sc) };
446        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
447        let isl_rs_result = isl_rs_result.to_str().unwrap();
448        let err = isl_rs_ctx.last_error();
449        if err != Error::None_ {
450            let err_msg = isl_rs_ctx.last_error_msg();
451            isl_rs_ctx.reset_error();
452            return Err(LibISLError::new(err, err_msg));
453        }
454        Ok(isl_rs_result)
455    }
456
457    /// Does not call isl_schedule_constraints_free() on being dropped. (For
458    /// internal use only.)
459    pub fn do_not_free_on_drop(&mut self) {
460        self.should_free_on_drop = false;
461    }
462}
463
464impl Drop for ScheduleConstraints {
465    fn drop(&mut self) {
466        if self.should_free_on_drop {
467            unsafe {
468                isl_schedule_constraints_free(self.ptr);
469            }
470        }
471    }
472}
isl_rs/bindings/schedule_constraints.rs

isl_rs/bindings/
schedule_constraints.rs
