isl_rs/bindings/
schedule_node.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{
5    ASTLoopType, Context, Error, Id, LibISLError, MultiUnionPwAff, MultiVal, Schedule,
6    ScheduleNodeType, Set, Space, UnionMap, UnionPwMultiAff, UnionSet, UnionSetList,
7};
8use libc::uintptr_t;
9use std::ffi::CStr;
10use std::os::raw::c_char;
11
12/// Wraps `isl_schedule_node`.
13pub struct ScheduleNode {
14    pub ptr: uintptr_t,
15    pub should_free_on_drop: bool,
16}
17
18extern "C" {
19
20    fn isl_schedule_node_align_params(node: uintptr_t, space: uintptr_t) -> uintptr_t;
21
22    fn isl_schedule_node_ancestor(node: uintptr_t, generation: i32) -> uintptr_t;
23
24    fn isl_schedule_node_band_get_ast_build_options(node: uintptr_t) -> uintptr_t;
25
26    fn isl_schedule_node_band_get_ast_isolate_option(node: uintptr_t) -> uintptr_t;
27
28    fn isl_schedule_node_band_get_partial_schedule(node: uintptr_t) -> uintptr_t;
29
30    fn isl_schedule_node_band_get_partial_schedule_union_map(node: uintptr_t) -> uintptr_t;
31
32    fn isl_schedule_node_band_get_permutable(node: uintptr_t) -> i32;
33
34    fn isl_schedule_node_band_get_space(node: uintptr_t) -> uintptr_t;
35
36    fn isl_schedule_node_band_member_get_ast_loop_type(node: uintptr_t, pos: i32) -> i32;
37
38    fn isl_schedule_node_band_member_get_coincident(node: uintptr_t, pos: i32) -> i32;
39
40    fn isl_schedule_node_band_member_get_isolate_ast_loop_type(node: uintptr_t, pos: i32) -> i32;
41
42    fn isl_schedule_node_band_member_set_ast_loop_type(node: uintptr_t, pos: i32, type_: i32)
43                                                       -> uintptr_t;
44
45    fn isl_schedule_node_band_member_set_coincident(node: uintptr_t, pos: i32, coincident: i32)
46                                                    -> uintptr_t;
47
48    fn isl_schedule_node_band_member_set_isolate_ast_loop_type(node: uintptr_t, pos: i32,
49                                                               type_: i32)
50                                                               -> uintptr_t;
51
52    fn isl_schedule_node_band_mod(node: uintptr_t, mv: uintptr_t) -> uintptr_t;
53
54    fn isl_schedule_node_band_n_member(node: uintptr_t) -> i32;
55
56    fn isl_schedule_node_band_scale(node: uintptr_t, mv: uintptr_t) -> uintptr_t;
57
58    fn isl_schedule_node_band_scale_down(node: uintptr_t, mv: uintptr_t) -> uintptr_t;
59
60    fn isl_schedule_node_band_set_ast_build_options(node: uintptr_t, options: uintptr_t)
61                                                    -> uintptr_t;
62
63    fn isl_schedule_node_band_set_permutable(node: uintptr_t, permutable: i32) -> uintptr_t;
64
65    fn isl_schedule_node_band_shift(node: uintptr_t, shift: uintptr_t) -> uintptr_t;
66
67    fn isl_schedule_node_band_sink(node: uintptr_t) -> uintptr_t;
68
69    fn isl_schedule_node_band_split(node: uintptr_t, pos: i32) -> uintptr_t;
70
71    fn isl_schedule_node_band_tile(node: uintptr_t, sizes: uintptr_t) -> uintptr_t;
72
73    fn isl_schedule_node_child(node: uintptr_t, pos: i32) -> uintptr_t;
74
75    fn isl_schedule_node_context_get_context(node: uintptr_t) -> uintptr_t;
76
77    fn isl_schedule_node_copy(node: uintptr_t) -> uintptr_t;
78
79    fn isl_schedule_node_cut(node: uintptr_t) -> uintptr_t;
80
81    fn isl_schedule_node_delete(node: uintptr_t) -> uintptr_t;
82
83    fn isl_schedule_node_domain_get_domain(node: uintptr_t) -> uintptr_t;
84
85    fn isl_schedule_node_dump(node: uintptr_t) -> ();
86
87    fn isl_schedule_node_expansion_get_contraction(node: uintptr_t) -> uintptr_t;
88
89    fn isl_schedule_node_expansion_get_expansion(node: uintptr_t) -> uintptr_t;
90
91    fn isl_schedule_node_extension_get_extension(node: uintptr_t) -> uintptr_t;
92
93    fn isl_schedule_node_filter_get_filter(node: uintptr_t) -> uintptr_t;
94
95    fn isl_schedule_node_first_child(node: uintptr_t) -> uintptr_t;
96
97    fn isl_schedule_node_free(node: uintptr_t) -> uintptr_t;
98
99    fn isl_schedule_node_from_domain(domain: uintptr_t) -> uintptr_t;
100
101    fn isl_schedule_node_from_extension(extension: uintptr_t) -> uintptr_t;
102
103    fn isl_schedule_node_get_ancestor_child_position(node: uintptr_t, ancestor: uintptr_t) -> i32;
104
105    fn isl_schedule_node_get_child(node: uintptr_t, pos: i32) -> uintptr_t;
106
107    fn isl_schedule_node_get_child_position(node: uintptr_t) -> i32;
108
109    fn isl_schedule_node_get_ctx(node: uintptr_t) -> uintptr_t;
110
111    fn isl_schedule_node_get_domain(node: uintptr_t) -> uintptr_t;
112
113    fn isl_schedule_node_get_parent_type(node: uintptr_t) -> i32;
114
115    fn isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(node: uintptr_t) -> uintptr_t;
116
117    fn isl_schedule_node_get_prefix_schedule_relation(node: uintptr_t) -> uintptr_t;
118
119    fn isl_schedule_node_get_prefix_schedule_union_map(node: uintptr_t) -> uintptr_t;
120
121    fn isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(node: uintptr_t) -> uintptr_t;
122
123    fn isl_schedule_node_get_schedule(node: uintptr_t) -> uintptr_t;
124
125    fn isl_schedule_node_get_schedule_depth(node: uintptr_t) -> i32;
126
127    fn isl_schedule_node_get_shared_ancestor(node1: uintptr_t, node2: uintptr_t) -> uintptr_t;
128
129    fn isl_schedule_node_get_subtree_contraction(node: uintptr_t) -> uintptr_t;
130
131    fn isl_schedule_node_get_subtree_expansion(node: uintptr_t) -> uintptr_t;
132
133    fn isl_schedule_node_get_subtree_schedule_union_map(node: uintptr_t) -> uintptr_t;
134
135    fn isl_schedule_node_get_tree_depth(node: uintptr_t) -> i32;
136
137    fn isl_schedule_node_get_type(node: uintptr_t) -> i32;
138
139    fn isl_schedule_node_get_universe_domain(node: uintptr_t) -> uintptr_t;
140
141    fn isl_schedule_node_graft_after(node: uintptr_t, graft: uintptr_t) -> uintptr_t;
142
143    fn isl_schedule_node_graft_before(node: uintptr_t, graft: uintptr_t) -> uintptr_t;
144
145    fn isl_schedule_node_grandchild(node: uintptr_t, pos1: i32, pos2: i32) -> uintptr_t;
146
147    fn isl_schedule_node_grandparent(node: uintptr_t) -> uintptr_t;
148
149    fn isl_schedule_node_group(node: uintptr_t, group_id: uintptr_t) -> uintptr_t;
150
151    fn isl_schedule_node_guard_get_guard(node: uintptr_t) -> uintptr_t;
152
153    fn isl_schedule_node_has_children(node: uintptr_t) -> i32;
154
155    fn isl_schedule_node_has_next_sibling(node: uintptr_t) -> i32;
156
157    fn isl_schedule_node_has_parent(node: uintptr_t) -> i32;
158
159    fn isl_schedule_node_has_previous_sibling(node: uintptr_t) -> i32;
160
161    fn isl_schedule_node_insert_context(node: uintptr_t, context: uintptr_t) -> uintptr_t;
162
163    fn isl_schedule_node_insert_filter(node: uintptr_t, filter: uintptr_t) -> uintptr_t;
164
165    fn isl_schedule_node_insert_guard(node: uintptr_t, context: uintptr_t) -> uintptr_t;
166
167    fn isl_schedule_node_insert_mark(node: uintptr_t, mark: uintptr_t) -> uintptr_t;
168
169    fn isl_schedule_node_insert_partial_schedule(node: uintptr_t, schedule: uintptr_t)
170                                                 -> uintptr_t;
171
172    fn isl_schedule_node_insert_sequence(node: uintptr_t, filters: uintptr_t) -> uintptr_t;
173
174    fn isl_schedule_node_insert_set(node: uintptr_t, filters: uintptr_t) -> uintptr_t;
175
176    fn isl_schedule_node_is_equal(node1: uintptr_t, node2: uintptr_t) -> i32;
177
178    fn isl_schedule_node_is_subtree_anchored(node: uintptr_t) -> i32;
179
180    fn isl_schedule_node_mark_get_id(node: uintptr_t) -> uintptr_t;
181
182    fn isl_schedule_node_n_children(node: uintptr_t) -> i32;
183
184    fn isl_schedule_node_next_sibling(node: uintptr_t) -> uintptr_t;
185
186    fn isl_schedule_node_order_after(node: uintptr_t, filter: uintptr_t) -> uintptr_t;
187
188    fn isl_schedule_node_order_before(node: uintptr_t, filter: uintptr_t) -> uintptr_t;
189
190    fn isl_schedule_node_parent(node: uintptr_t) -> uintptr_t;
191
192    fn isl_schedule_node_previous_sibling(node: uintptr_t) -> uintptr_t;
193
194    fn isl_schedule_node_reset_user(node: uintptr_t) -> uintptr_t;
195
196    fn isl_schedule_node_root(node: uintptr_t) -> uintptr_t;
197
198    fn isl_schedule_node_sequence_splice_child(node: uintptr_t, pos: i32) -> uintptr_t;
199
200    fn isl_schedule_node_sequence_splice_children(node: uintptr_t) -> uintptr_t;
201
202    fn isl_schedule_node_to_str(node: uintptr_t) -> *const c_char;
203
204}
205
206impl ScheduleNode {
207    /// Wraps `isl_schedule_node_align_params`.
208    pub fn align_params(self, space: Space) -> Result<ScheduleNode, LibISLError> {
209        let node = self;
210        let isl_rs_ctx = node.get_ctx();
211        let mut node = node;
212        node.do_not_free_on_drop();
213        let node = node.ptr;
214        let mut space = space;
215        space.do_not_free_on_drop();
216        let space = space.ptr;
217        let isl_rs_result = unsafe { isl_schedule_node_align_params(node, space) };
218        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
219                                           should_free_on_drop: true };
220        let err = isl_rs_ctx.last_error();
221        if err != Error::None_ {
222            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
223        }
224        Ok(isl_rs_result)
225    }
226
227    /// Wraps `isl_schedule_node_ancestor`.
228    pub fn ancestor(self, generation: i32) -> Result<ScheduleNode, LibISLError> {
229        let node = self;
230        let isl_rs_ctx = node.get_ctx();
231        let mut node = node;
232        node.do_not_free_on_drop();
233        let node = node.ptr;
234        let isl_rs_result = unsafe { isl_schedule_node_ancestor(node, generation) };
235        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
236                                           should_free_on_drop: true };
237        let err = isl_rs_ctx.last_error();
238        if err != Error::None_ {
239            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
240        }
241        Ok(isl_rs_result)
242    }
243
244    /// Wraps `isl_schedule_node_band_get_ast_build_options`.
245    pub fn band_get_ast_build_options(&self) -> Result<UnionSet, LibISLError> {
246        let node = self;
247        let isl_rs_ctx = node.get_ctx();
248        let node = node.ptr;
249        let isl_rs_result = unsafe { isl_schedule_node_band_get_ast_build_options(node) };
250        let isl_rs_result = UnionSet { ptr: isl_rs_result,
251                                       should_free_on_drop: true };
252        let err = isl_rs_ctx.last_error();
253        if err != Error::None_ {
254            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
255        }
256        Ok(isl_rs_result)
257    }
258
259    /// Wraps `isl_schedule_node_band_get_ast_isolate_option`.
260    pub fn band_get_ast_isolate_option(&self) -> Result<Set, LibISLError> {
261        let node = self;
262        let isl_rs_ctx = node.get_ctx();
263        let node = node.ptr;
264        let isl_rs_result = unsafe { isl_schedule_node_band_get_ast_isolate_option(node) };
265        let isl_rs_result = Set { ptr: isl_rs_result,
266                                  should_free_on_drop: true };
267        let err = isl_rs_ctx.last_error();
268        if err != Error::None_ {
269            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
270        }
271        Ok(isl_rs_result)
272    }
273
274    /// Wraps `isl_schedule_node_band_get_partial_schedule`.
275    pub fn band_get_partial_schedule(&self) -> Result<MultiUnionPwAff, LibISLError> {
276        let node = self;
277        let isl_rs_ctx = node.get_ctx();
278        let node = node.ptr;
279        let isl_rs_result = unsafe { isl_schedule_node_band_get_partial_schedule(node) };
280        let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
281                                              should_free_on_drop: true };
282        let err = isl_rs_ctx.last_error();
283        if err != Error::None_ {
284            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
285        }
286        Ok(isl_rs_result)
287    }
288
289    /// Wraps `isl_schedule_node_band_get_partial_schedule_union_map`.
290    pub fn band_get_partial_schedule_union_map(&self) -> Result<UnionMap, LibISLError> {
291        let node = self;
292        let isl_rs_ctx = node.get_ctx();
293        let node = node.ptr;
294        let isl_rs_result = unsafe { isl_schedule_node_band_get_partial_schedule_union_map(node) };
295        let isl_rs_result = UnionMap { ptr: isl_rs_result,
296                                       should_free_on_drop: true };
297        let err = isl_rs_ctx.last_error();
298        if err != Error::None_ {
299            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
300        }
301        Ok(isl_rs_result)
302    }
303
304    /// Wraps `isl_schedule_node_band_get_permutable`.
305    pub fn band_get_permutable(&self) -> Result<bool, LibISLError> {
306        let node = self;
307        let isl_rs_ctx = node.get_ctx();
308        let node = node.ptr;
309        let isl_rs_result = unsafe { isl_schedule_node_band_get_permutable(node) };
310        let isl_rs_result = match isl_rs_result {
311            0 => false,
312            1 => true,
313            _ => panic!("Got isl_bool = -1"),
314        };
315        let err = isl_rs_ctx.last_error();
316        if err != Error::None_ {
317            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
318        }
319        Ok(isl_rs_result)
320    }
321
322    /// Wraps `isl_schedule_node_band_get_space`.
323    pub fn band_get_space(&self) -> Result<Space, LibISLError> {
324        let node = self;
325        let isl_rs_ctx = node.get_ctx();
326        let node = node.ptr;
327        let isl_rs_result = unsafe { isl_schedule_node_band_get_space(node) };
328        let isl_rs_result = Space { ptr: isl_rs_result,
329                                    should_free_on_drop: true };
330        let err = isl_rs_ctx.last_error();
331        if err != Error::None_ {
332            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
333        }
334        Ok(isl_rs_result)
335    }
336
337    /// Wraps `isl_schedule_node_band_member_get_ast_loop_type`.
338    pub fn band_member_get_ast_loop_type(&self, pos: i32) -> Result<ASTLoopType, LibISLError> {
339        let node = self;
340        let isl_rs_ctx = node.get_ctx();
341        let node = node.ptr;
342        let isl_rs_result = unsafe { isl_schedule_node_band_member_get_ast_loop_type(node, pos) };
343        let isl_rs_result = ASTLoopType::from_i32(isl_rs_result);
344        let err = isl_rs_ctx.last_error();
345        if err != Error::None_ {
346            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
347        }
348        Ok(isl_rs_result)
349    }
350
351    /// Wraps `isl_schedule_node_band_member_get_coincident`.
352    pub fn band_member_get_coincident(&self, pos: i32) -> Result<bool, LibISLError> {
353        let node = self;
354        let isl_rs_ctx = node.get_ctx();
355        let node = node.ptr;
356        let isl_rs_result = unsafe { isl_schedule_node_band_member_get_coincident(node, pos) };
357        let isl_rs_result = match isl_rs_result {
358            0 => false,
359            1 => true,
360            _ => panic!("Got isl_bool = -1"),
361        };
362        let err = isl_rs_ctx.last_error();
363        if err != Error::None_ {
364            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
365        }
366        Ok(isl_rs_result)
367    }
368
369    /// Wraps `isl_schedule_node_band_member_get_isolate_ast_loop_type`.
370    pub fn band_member_get_isolate_ast_loop_type(&self, pos: i32)
371                                                 -> Result<ASTLoopType, LibISLError> {
372        let node = self;
373        let isl_rs_ctx = node.get_ctx();
374        let node = node.ptr;
375        let isl_rs_result =
376            unsafe { isl_schedule_node_band_member_get_isolate_ast_loop_type(node, pos) };
377        let isl_rs_result = ASTLoopType::from_i32(isl_rs_result);
378        let err = isl_rs_ctx.last_error();
379        if err != Error::None_ {
380            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
381        }
382        Ok(isl_rs_result)
383    }
384
385    /// Wraps `isl_schedule_node_band_member_set_ast_loop_type`.
386    pub fn band_member_set_ast_loop_type(self, pos: i32, type_: ASTLoopType)
387                                         -> Result<ScheduleNode, LibISLError> {
388        let node = self;
389        let isl_rs_ctx = node.get_ctx();
390        let mut node = node;
391        node.do_not_free_on_drop();
392        let node = node.ptr;
393        let type_ = type_.to_i32();
394        let isl_rs_result =
395            unsafe { isl_schedule_node_band_member_set_ast_loop_type(node, pos, type_) };
396        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
397                                           should_free_on_drop: true };
398        let err = isl_rs_ctx.last_error();
399        if err != Error::None_ {
400            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
401        }
402        Ok(isl_rs_result)
403    }
404
405    /// Wraps `isl_schedule_node_band_member_set_coincident`.
406    pub fn band_member_set_coincident(self, pos: i32, coincident: i32)
407                                      -> Result<ScheduleNode, LibISLError> {
408        let node = self;
409        let isl_rs_ctx = node.get_ctx();
410        let mut node = node;
411        node.do_not_free_on_drop();
412        let node = node.ptr;
413        let isl_rs_result =
414            unsafe { isl_schedule_node_band_member_set_coincident(node, pos, coincident) };
415        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
416                                           should_free_on_drop: true };
417        let err = isl_rs_ctx.last_error();
418        if err != Error::None_ {
419            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
420        }
421        Ok(isl_rs_result)
422    }
423
424    /// Wraps `isl_schedule_node_band_member_set_isolate_ast_loop_type`.
425    pub fn band_member_set_isolate_ast_loop_type(self, pos: i32, type_: ASTLoopType)
426                                                 -> Result<ScheduleNode, LibISLError> {
427        let node = self;
428        let isl_rs_ctx = node.get_ctx();
429        let mut node = node;
430        node.do_not_free_on_drop();
431        let node = node.ptr;
432        let type_ = type_.to_i32();
433        let isl_rs_result =
434            unsafe { isl_schedule_node_band_member_set_isolate_ast_loop_type(node, pos, type_) };
435        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
436                                           should_free_on_drop: true };
437        let err = isl_rs_ctx.last_error();
438        if err != Error::None_ {
439            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
440        }
441        Ok(isl_rs_result)
442    }
443
444    /// Wraps `isl_schedule_node_band_mod`.
445    pub fn band_mod(self, mv: MultiVal) -> Result<ScheduleNode, LibISLError> {
446        let node = self;
447        let isl_rs_ctx = node.get_ctx();
448        let mut node = node;
449        node.do_not_free_on_drop();
450        let node = node.ptr;
451        let mut mv = mv;
452        mv.do_not_free_on_drop();
453        let mv = mv.ptr;
454        let isl_rs_result = unsafe { isl_schedule_node_band_mod(node, mv) };
455        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
456                                           should_free_on_drop: true };
457        let err = isl_rs_ctx.last_error();
458        if err != Error::None_ {
459            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
460        }
461        Ok(isl_rs_result)
462    }
463
464    /// Wraps `isl_schedule_node_band_n_member`.
465    pub fn band_n_member(&self) -> Result<i32, LibISLError> {
466        let node = self;
467        let isl_rs_ctx = node.get_ctx();
468        let node = node.ptr;
469        let isl_rs_result = unsafe { isl_schedule_node_band_n_member(node) };
470        let err = isl_rs_ctx.last_error();
471        if err != Error::None_ {
472            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
473        }
474        Ok(isl_rs_result)
475    }
476
477    /// Wraps `isl_schedule_node_band_scale`.
478    pub fn band_scale(self, mv: MultiVal) -> Result<ScheduleNode, LibISLError> {
479        let node = self;
480        let isl_rs_ctx = node.get_ctx();
481        let mut node = node;
482        node.do_not_free_on_drop();
483        let node = node.ptr;
484        let mut mv = mv;
485        mv.do_not_free_on_drop();
486        let mv = mv.ptr;
487        let isl_rs_result = unsafe { isl_schedule_node_band_scale(node, mv) };
488        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
489                                           should_free_on_drop: true };
490        let err = isl_rs_ctx.last_error();
491        if err != Error::None_ {
492            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
493        }
494        Ok(isl_rs_result)
495    }
496
497    /// Wraps `isl_schedule_node_band_scale_down`.
498    pub fn band_scale_down(self, mv: MultiVal) -> Result<ScheduleNode, LibISLError> {
499        let node = self;
500        let isl_rs_ctx = node.get_ctx();
501        let mut node = node;
502        node.do_not_free_on_drop();
503        let node = node.ptr;
504        let mut mv = mv;
505        mv.do_not_free_on_drop();
506        let mv = mv.ptr;
507        let isl_rs_result = unsafe { isl_schedule_node_band_scale_down(node, mv) };
508        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
509                                           should_free_on_drop: true };
510        let err = isl_rs_ctx.last_error();
511        if err != Error::None_ {
512            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
513        }
514        Ok(isl_rs_result)
515    }
516
517    /// Wraps `isl_schedule_node_band_set_ast_build_options`.
518    pub fn band_set_ast_build_options(self, options: UnionSet)
519                                      -> Result<ScheduleNode, LibISLError> {
520        let node = self;
521        let isl_rs_ctx = node.get_ctx();
522        let mut node = node;
523        node.do_not_free_on_drop();
524        let node = node.ptr;
525        let mut options = options;
526        options.do_not_free_on_drop();
527        let options = options.ptr;
528        let isl_rs_result = unsafe { isl_schedule_node_band_set_ast_build_options(node, options) };
529        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
530                                           should_free_on_drop: true };
531        let err = isl_rs_ctx.last_error();
532        if err != Error::None_ {
533            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
534        }
535        Ok(isl_rs_result)
536    }
537
538    /// Wraps `isl_schedule_node_band_set_permutable`.
539    pub fn band_set_permutable(self, permutable: i32) -> Result<ScheduleNode, LibISLError> {
540        let node = self;
541        let isl_rs_ctx = node.get_ctx();
542        let mut node = node;
543        node.do_not_free_on_drop();
544        let node = node.ptr;
545        let isl_rs_result = unsafe { isl_schedule_node_band_set_permutable(node, permutable) };
546        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
547                                           should_free_on_drop: true };
548        let err = isl_rs_ctx.last_error();
549        if err != Error::None_ {
550            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
551        }
552        Ok(isl_rs_result)
553    }
554
555    /// Wraps `isl_schedule_node_band_shift`.
556    pub fn band_shift(self, shift: MultiUnionPwAff) -> Result<ScheduleNode, LibISLError> {
557        let node = self;
558        let isl_rs_ctx = node.get_ctx();
559        let mut node = node;
560        node.do_not_free_on_drop();
561        let node = node.ptr;
562        let mut shift = shift;
563        shift.do_not_free_on_drop();
564        let shift = shift.ptr;
565        let isl_rs_result = unsafe { isl_schedule_node_band_shift(node, shift) };
566        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
567                                           should_free_on_drop: true };
568        let err = isl_rs_ctx.last_error();
569        if err != Error::None_ {
570            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
571        }
572        Ok(isl_rs_result)
573    }
574
575    /// Wraps `isl_schedule_node_band_sink`.
576    pub fn band_sink(self) -> Result<ScheduleNode, LibISLError> {
577        let node = self;
578        let isl_rs_ctx = node.get_ctx();
579        let mut node = node;
580        node.do_not_free_on_drop();
581        let node = node.ptr;
582        let isl_rs_result = unsafe { isl_schedule_node_band_sink(node) };
583        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
584                                           should_free_on_drop: true };
585        let err = isl_rs_ctx.last_error();
586        if err != Error::None_ {
587            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
588        }
589        Ok(isl_rs_result)
590    }
591
592    /// Wraps `isl_schedule_node_band_split`.
593    pub fn band_split(self, pos: i32) -> Result<ScheduleNode, LibISLError> {
594        let node = self;
595        let isl_rs_ctx = node.get_ctx();
596        let mut node = node;
597        node.do_not_free_on_drop();
598        let node = node.ptr;
599        let isl_rs_result = unsafe { isl_schedule_node_band_split(node, pos) };
600        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
601                                           should_free_on_drop: true };
602        let err = isl_rs_ctx.last_error();
603        if err != Error::None_ {
604            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
605        }
606        Ok(isl_rs_result)
607    }
608
609    /// Wraps `isl_schedule_node_band_tile`.
610    pub fn band_tile(self, sizes: MultiVal) -> Result<ScheduleNode, LibISLError> {
611        let node = self;
612        let isl_rs_ctx = node.get_ctx();
613        let mut node = node;
614        node.do_not_free_on_drop();
615        let node = node.ptr;
616        let mut sizes = sizes;
617        sizes.do_not_free_on_drop();
618        let sizes = sizes.ptr;
619        let isl_rs_result = unsafe { isl_schedule_node_band_tile(node, sizes) };
620        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
621                                           should_free_on_drop: true };
622        let err = isl_rs_ctx.last_error();
623        if err != Error::None_ {
624            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
625        }
626        Ok(isl_rs_result)
627    }
628
629    /// Wraps `isl_schedule_node_child`.
630    pub fn child(self, pos: i32) -> Result<ScheduleNode, LibISLError> {
631        let node = self;
632        let isl_rs_ctx = node.get_ctx();
633        let mut node = node;
634        node.do_not_free_on_drop();
635        let node = node.ptr;
636        let isl_rs_result = unsafe { isl_schedule_node_child(node, pos) };
637        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
638                                           should_free_on_drop: true };
639        let err = isl_rs_ctx.last_error();
640        if err != Error::None_ {
641            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
642        }
643        Ok(isl_rs_result)
644    }
645
646    /// Wraps `isl_schedule_node_context_get_context`.
647    pub fn context_get_context(&self) -> Result<Set, LibISLError> {
648        let node = self;
649        let isl_rs_ctx = node.get_ctx();
650        let node = node.ptr;
651        let isl_rs_result = unsafe { isl_schedule_node_context_get_context(node) };
652        let isl_rs_result = Set { ptr: isl_rs_result,
653                                  should_free_on_drop: true };
654        let err = isl_rs_ctx.last_error();
655        if err != Error::None_ {
656            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
657        }
658        Ok(isl_rs_result)
659    }
660
661    /// Wraps `isl_schedule_node_copy`.
662    pub fn copy(&self) -> Result<ScheduleNode, LibISLError> {
663        let node = self;
664        let isl_rs_ctx = node.get_ctx();
665        let node = node.ptr;
666        let isl_rs_result = unsafe { isl_schedule_node_copy(node) };
667        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
668                                           should_free_on_drop: true };
669        let err = isl_rs_ctx.last_error();
670        if err != Error::None_ {
671            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
672        }
673        Ok(isl_rs_result)
674    }
675
676    /// Wraps `isl_schedule_node_cut`.
677    pub fn cut(self) -> Result<ScheduleNode, LibISLError> {
678        let node = self;
679        let isl_rs_ctx = node.get_ctx();
680        let mut node = node;
681        node.do_not_free_on_drop();
682        let node = node.ptr;
683        let isl_rs_result = unsafe { isl_schedule_node_cut(node) };
684        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
685                                           should_free_on_drop: true };
686        let err = isl_rs_ctx.last_error();
687        if err != Error::None_ {
688            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
689        }
690        Ok(isl_rs_result)
691    }
692
693    /// Wraps `isl_schedule_node_delete`.
694    pub fn delete(self) -> Result<ScheduleNode, LibISLError> {
695        let node = self;
696        let isl_rs_ctx = node.get_ctx();
697        let mut node = node;
698        node.do_not_free_on_drop();
699        let node = node.ptr;
700        let isl_rs_result = unsafe { isl_schedule_node_delete(node) };
701        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
702                                           should_free_on_drop: true };
703        let err = isl_rs_ctx.last_error();
704        if err != Error::None_ {
705            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
706        }
707        Ok(isl_rs_result)
708    }
709
710    /// Wraps `isl_schedule_node_domain_get_domain`.
711    pub fn domain_get_domain(&self) -> Result<UnionSet, LibISLError> {
712        let node = self;
713        let isl_rs_ctx = node.get_ctx();
714        let node = node.ptr;
715        let isl_rs_result = unsafe { isl_schedule_node_domain_get_domain(node) };
716        let isl_rs_result = UnionSet { ptr: isl_rs_result,
717                                       should_free_on_drop: true };
718        let err = isl_rs_ctx.last_error();
719        if err != Error::None_ {
720            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
721        }
722        Ok(isl_rs_result)
723    }
724
725    /// Wraps `isl_schedule_node_dump`.
726    pub fn dump(&self) -> Result<(), LibISLError> {
727        let node = self;
728        let isl_rs_ctx = node.get_ctx();
729        let node = node.ptr;
730        let isl_rs_result = unsafe { isl_schedule_node_dump(node) };
731        let err = isl_rs_ctx.last_error();
732        if err != Error::None_ {
733            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
734        }
735        Ok(isl_rs_result)
736    }
737
738    /// Wraps `isl_schedule_node_expansion_get_contraction`.
739    pub fn expansion_get_contraction(&self) -> Result<UnionPwMultiAff, LibISLError> {
740        let node = self;
741        let isl_rs_ctx = node.get_ctx();
742        let node = node.ptr;
743        let isl_rs_result = unsafe { isl_schedule_node_expansion_get_contraction(node) };
744        let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
745                                              should_free_on_drop: true };
746        let err = isl_rs_ctx.last_error();
747        if err != Error::None_ {
748            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
749        }
750        Ok(isl_rs_result)
751    }
752
753    /// Wraps `isl_schedule_node_expansion_get_expansion`.
754    pub fn expansion_get_expansion(&self) -> Result<UnionMap, LibISLError> {
755        let node = self;
756        let isl_rs_ctx = node.get_ctx();
757        let node = node.ptr;
758        let isl_rs_result = unsafe { isl_schedule_node_expansion_get_expansion(node) };
759        let isl_rs_result = UnionMap { ptr: isl_rs_result,
760                                       should_free_on_drop: true };
761        let err = isl_rs_ctx.last_error();
762        if err != Error::None_ {
763            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
764        }
765        Ok(isl_rs_result)
766    }
767
768    /// Wraps `isl_schedule_node_extension_get_extension`.
769    pub fn extension_get_extension(&self) -> Result<UnionMap, LibISLError> {
770        let node = self;
771        let isl_rs_ctx = node.get_ctx();
772        let node = node.ptr;
773        let isl_rs_result = unsafe { isl_schedule_node_extension_get_extension(node) };
774        let isl_rs_result = UnionMap { ptr: isl_rs_result,
775                                       should_free_on_drop: true };
776        let err = isl_rs_ctx.last_error();
777        if err != Error::None_ {
778            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
779        }
780        Ok(isl_rs_result)
781    }
782
783    /// Wraps `isl_schedule_node_filter_get_filter`.
784    pub fn filter_get_filter(&self) -> Result<UnionSet, LibISLError> {
785        let node = self;
786        let isl_rs_ctx = node.get_ctx();
787        let node = node.ptr;
788        let isl_rs_result = unsafe { isl_schedule_node_filter_get_filter(node) };
789        let isl_rs_result = UnionSet { ptr: isl_rs_result,
790                                       should_free_on_drop: true };
791        let err = isl_rs_ctx.last_error();
792        if err != Error::None_ {
793            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
794        }
795        Ok(isl_rs_result)
796    }
797
798    /// Wraps `isl_schedule_node_first_child`.
799    pub fn first_child(self) -> Result<ScheduleNode, LibISLError> {
800        let node = self;
801        let isl_rs_ctx = node.get_ctx();
802        let mut node = node;
803        node.do_not_free_on_drop();
804        let node = node.ptr;
805        let isl_rs_result = unsafe { isl_schedule_node_first_child(node) };
806        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
807                                           should_free_on_drop: true };
808        let err = isl_rs_ctx.last_error();
809        if err != Error::None_ {
810            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
811        }
812        Ok(isl_rs_result)
813    }
814
815    /// Wraps `isl_schedule_node_free`.
816    pub fn free(self) -> Result<ScheduleNode, LibISLError> {
817        let node = self;
818        let isl_rs_ctx = node.get_ctx();
819        let mut node = node;
820        node.do_not_free_on_drop();
821        let node = node.ptr;
822        let isl_rs_result = unsafe { isl_schedule_node_free(node) };
823        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
824                                           should_free_on_drop: true };
825        let err = isl_rs_ctx.last_error();
826        if err != Error::None_ {
827            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
828        }
829        Ok(isl_rs_result)
830    }
831
832    /// Wraps `isl_schedule_node_from_domain`.
833    pub fn from_domain(domain: UnionSet) -> Result<ScheduleNode, LibISLError> {
834        let isl_rs_ctx = domain.get_ctx();
835        let mut domain = domain;
836        domain.do_not_free_on_drop();
837        let domain = domain.ptr;
838        let isl_rs_result = unsafe { isl_schedule_node_from_domain(domain) };
839        let isl_rs_result = ScheduleNode { 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_schedule_node_from_extension`.
849    pub fn from_extension(extension: UnionMap) -> Result<ScheduleNode, LibISLError> {
850        let isl_rs_ctx = extension.get_ctx();
851        let mut extension = extension;
852        extension.do_not_free_on_drop();
853        let extension = extension.ptr;
854        let isl_rs_result = unsafe { isl_schedule_node_from_extension(extension) };
855        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
856                                           should_free_on_drop: true };
857        let err = isl_rs_ctx.last_error();
858        if err != Error::None_ {
859            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
860        }
861        Ok(isl_rs_result)
862    }
863
864    /// Wraps `isl_schedule_node_get_ancestor_child_position`.
865    pub fn get_ancestor_child_position(&self, ancestor: &ScheduleNode) -> Result<i32, LibISLError> {
866        let node = self;
867        let isl_rs_ctx = node.get_ctx();
868        let node = node.ptr;
869        let ancestor = ancestor.ptr;
870        let isl_rs_result =
871            unsafe { isl_schedule_node_get_ancestor_child_position(node, ancestor) };
872        let err = isl_rs_ctx.last_error();
873        if err != Error::None_ {
874            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
875        }
876        Ok(isl_rs_result)
877    }
878
879    /// Wraps `isl_schedule_node_get_child`.
880    pub fn get_child(&self, pos: i32) -> Result<ScheduleNode, LibISLError> {
881        let node = self;
882        let isl_rs_ctx = node.get_ctx();
883        let node = node.ptr;
884        let isl_rs_result = unsafe { isl_schedule_node_get_child(node, pos) };
885        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
886                                           should_free_on_drop: true };
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    /// Wraps `isl_schedule_node_get_child_position`.
895    pub fn get_child_position(&self) -> Result<i32, LibISLError> {
896        let node = self;
897        let isl_rs_ctx = node.get_ctx();
898        let node = node.ptr;
899        let isl_rs_result = unsafe { isl_schedule_node_get_child_position(node) };
900        let err = isl_rs_ctx.last_error();
901        if err != Error::None_ {
902            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
903        }
904        Ok(isl_rs_result)
905    }
906
907    /// Wraps `isl_schedule_node_get_ctx`.
908    pub fn get_ctx(&self) -> Context {
909        let node = self;
910        let node = node.ptr;
911        let isl_rs_result = unsafe { isl_schedule_node_get_ctx(node) };
912        let isl_rs_result = Context { ptr: isl_rs_result,
913                                      should_free_on_drop: false };
914        isl_rs_result
915    }
916
917    /// Wraps `isl_schedule_node_get_domain`.
918    pub fn get_domain(&self) -> Result<UnionSet, LibISLError> {
919        let node = self;
920        let isl_rs_ctx = node.get_ctx();
921        let node = node.ptr;
922        let isl_rs_result = unsafe { isl_schedule_node_get_domain(node) };
923        let isl_rs_result = UnionSet { ptr: isl_rs_result,
924                                       should_free_on_drop: true };
925        let err = isl_rs_ctx.last_error();
926        if err != Error::None_ {
927            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
928        }
929        Ok(isl_rs_result)
930    }
931
932    /// Wraps `isl_schedule_node_get_parent_type`.
933    pub fn get_parent_type(&self) -> Result<ScheduleNodeType, LibISLError> {
934        let node = self;
935        let isl_rs_ctx = node.get_ctx();
936        let node = node.ptr;
937        let isl_rs_result = unsafe { isl_schedule_node_get_parent_type(node) };
938        let isl_rs_result = ScheduleNodeType::from_i32(isl_rs_result);
939        let err = isl_rs_ctx.last_error();
940        if err != Error::None_ {
941            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
942        }
943        Ok(isl_rs_result)
944    }
945
946    /// Wraps `isl_schedule_node_get_prefix_schedule_multi_union_pw_aff`.
947    pub fn get_prefix_schedule_multi_union_pw_aff(&self) -> Result<MultiUnionPwAff, LibISLError> {
948        let node = self;
949        let isl_rs_ctx = node.get_ctx();
950        let node = node.ptr;
951        let isl_rs_result =
952            unsafe { isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(node) };
953        let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
954                                              should_free_on_drop: true };
955        let err = isl_rs_ctx.last_error();
956        if err != Error::None_ {
957            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
958        }
959        Ok(isl_rs_result)
960    }
961
962    /// Wraps `isl_schedule_node_get_prefix_schedule_relation`.
963    pub fn get_prefix_schedule_relation(&self) -> Result<UnionMap, LibISLError> {
964        let node = self;
965        let isl_rs_ctx = node.get_ctx();
966        let node = node.ptr;
967        let isl_rs_result = unsafe { isl_schedule_node_get_prefix_schedule_relation(node) };
968        let isl_rs_result = UnionMap { ptr: isl_rs_result,
969                                       should_free_on_drop: true };
970        let err = isl_rs_ctx.last_error();
971        if err != Error::None_ {
972            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
973        }
974        Ok(isl_rs_result)
975    }
976
977    /// Wraps `isl_schedule_node_get_prefix_schedule_union_map`.
978    pub fn get_prefix_schedule_union_map(&self) -> Result<UnionMap, LibISLError> {
979        let node = self;
980        let isl_rs_ctx = node.get_ctx();
981        let node = node.ptr;
982        let isl_rs_result = unsafe { isl_schedule_node_get_prefix_schedule_union_map(node) };
983        let isl_rs_result = UnionMap { ptr: isl_rs_result,
984                                       should_free_on_drop: true };
985        let err = isl_rs_ctx.last_error();
986        if err != Error::None_ {
987            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
988        }
989        Ok(isl_rs_result)
990    }
991
992    /// Wraps `isl_schedule_node_get_prefix_schedule_union_pw_multi_aff`.
993    pub fn get_prefix_schedule_union_pw_multi_aff(&self) -> Result<UnionPwMultiAff, LibISLError> {
994        let node = self;
995        let isl_rs_ctx = node.get_ctx();
996        let node = node.ptr;
997        let isl_rs_result =
998            unsafe { isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(node) };
999        let isl_rs_result = UnionPwMultiAff { 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    /// Wraps `isl_schedule_node_get_schedule`.
1009    pub fn get_schedule(&self) -> Result<Schedule, LibISLError> {
1010        let node = self;
1011        let isl_rs_ctx = node.get_ctx();
1012        let node = node.ptr;
1013        let isl_rs_result = unsafe { isl_schedule_node_get_schedule(node) };
1014        let isl_rs_result = Schedule { ptr: isl_rs_result,
1015                                       should_free_on_drop: true };
1016        let err = isl_rs_ctx.last_error();
1017        if err != Error::None_ {
1018            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1019        }
1020        Ok(isl_rs_result)
1021    }
1022
1023    /// Wraps `isl_schedule_node_get_schedule_depth`.
1024    pub fn get_schedule_depth(&self) -> Result<i32, LibISLError> {
1025        let node = self;
1026        let isl_rs_ctx = node.get_ctx();
1027        let node = node.ptr;
1028        let isl_rs_result = unsafe { isl_schedule_node_get_schedule_depth(node) };
1029        let err = isl_rs_ctx.last_error();
1030        if err != Error::None_ {
1031            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1032        }
1033        Ok(isl_rs_result)
1034    }
1035
1036    /// Wraps `isl_schedule_node_get_shared_ancestor`.
1037    pub fn get_shared_ancestor(&self, node2: &ScheduleNode) -> Result<ScheduleNode, LibISLError> {
1038        let node1 = self;
1039        let isl_rs_ctx = node1.get_ctx();
1040        let node1 = node1.ptr;
1041        let node2 = node2.ptr;
1042        let isl_rs_result = unsafe { isl_schedule_node_get_shared_ancestor(node1, node2) };
1043        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1044                                           should_free_on_drop: true };
1045        let err = isl_rs_ctx.last_error();
1046        if err != Error::None_ {
1047            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1048        }
1049        Ok(isl_rs_result)
1050    }
1051
1052    /// Wraps `isl_schedule_node_get_subtree_contraction`.
1053    pub fn get_subtree_contraction(&self) -> Result<UnionPwMultiAff, LibISLError> {
1054        let node = self;
1055        let isl_rs_ctx = node.get_ctx();
1056        let node = node.ptr;
1057        let isl_rs_result = unsafe { isl_schedule_node_get_subtree_contraction(node) };
1058        let isl_rs_result = UnionPwMultiAff { ptr: isl_rs_result,
1059                                              should_free_on_drop: true };
1060        let err = isl_rs_ctx.last_error();
1061        if err != Error::None_ {
1062            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1063        }
1064        Ok(isl_rs_result)
1065    }
1066
1067    /// Wraps `isl_schedule_node_get_subtree_expansion`.
1068    pub fn get_subtree_expansion(&self) -> Result<UnionMap, LibISLError> {
1069        let node = self;
1070        let isl_rs_ctx = node.get_ctx();
1071        let node = node.ptr;
1072        let isl_rs_result = unsafe { isl_schedule_node_get_subtree_expansion(node) };
1073        let isl_rs_result = UnionMap { ptr: isl_rs_result,
1074                                       should_free_on_drop: true };
1075        let err = isl_rs_ctx.last_error();
1076        if err != Error::None_ {
1077            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1078        }
1079        Ok(isl_rs_result)
1080    }
1081
1082    /// Wraps `isl_schedule_node_get_subtree_schedule_union_map`.
1083    pub fn get_subtree_schedule_union_map(&self) -> Result<UnionMap, LibISLError> {
1084        let node = self;
1085        let isl_rs_ctx = node.get_ctx();
1086        let node = node.ptr;
1087        let isl_rs_result = unsafe { isl_schedule_node_get_subtree_schedule_union_map(node) };
1088        let isl_rs_result = UnionMap { ptr: isl_rs_result,
1089                                       should_free_on_drop: true };
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_schedule_node_get_tree_depth`.
1098    pub fn get_tree_depth(&self) -> Result<i32, LibISLError> {
1099        let node = self;
1100        let isl_rs_ctx = node.get_ctx();
1101        let node = node.ptr;
1102        let isl_rs_result = unsafe { isl_schedule_node_get_tree_depth(node) };
1103        let err = isl_rs_ctx.last_error();
1104        if err != Error::None_ {
1105            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1106        }
1107        Ok(isl_rs_result)
1108    }
1109
1110    /// Wraps `isl_schedule_node_get_type`.
1111    pub fn get_type(&self) -> Result<ScheduleNodeType, LibISLError> {
1112        let node = self;
1113        let isl_rs_ctx = node.get_ctx();
1114        let node = node.ptr;
1115        let isl_rs_result = unsafe { isl_schedule_node_get_type(node) };
1116        let isl_rs_result = ScheduleNodeType::from_i32(isl_rs_result);
1117        let err = isl_rs_ctx.last_error();
1118        if err != Error::None_ {
1119            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1120        }
1121        Ok(isl_rs_result)
1122    }
1123
1124    /// Wraps `isl_schedule_node_get_universe_domain`.
1125    pub fn get_universe_domain(&self) -> Result<UnionSet, LibISLError> {
1126        let node = self;
1127        let isl_rs_ctx = node.get_ctx();
1128        let node = node.ptr;
1129        let isl_rs_result = unsafe { isl_schedule_node_get_universe_domain(node) };
1130        let isl_rs_result = UnionSet { ptr: isl_rs_result,
1131                                       should_free_on_drop: true };
1132        let err = isl_rs_ctx.last_error();
1133        if err != Error::None_ {
1134            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1135        }
1136        Ok(isl_rs_result)
1137    }
1138
1139    /// Wraps `isl_schedule_node_graft_after`.
1140    pub fn graft_after(self, graft: ScheduleNode) -> Result<ScheduleNode, LibISLError> {
1141        let node = self;
1142        let isl_rs_ctx = node.get_ctx();
1143        let mut node = node;
1144        node.do_not_free_on_drop();
1145        let node = node.ptr;
1146        let mut graft = graft;
1147        graft.do_not_free_on_drop();
1148        let graft = graft.ptr;
1149        let isl_rs_result = unsafe { isl_schedule_node_graft_after(node, graft) };
1150        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1151                                           should_free_on_drop: true };
1152        let err = isl_rs_ctx.last_error();
1153        if err != Error::None_ {
1154            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1155        }
1156        Ok(isl_rs_result)
1157    }
1158
1159    /// Wraps `isl_schedule_node_graft_before`.
1160    pub fn graft_before(self, graft: ScheduleNode) -> Result<ScheduleNode, LibISLError> {
1161        let node = self;
1162        let isl_rs_ctx = node.get_ctx();
1163        let mut node = node;
1164        node.do_not_free_on_drop();
1165        let node = node.ptr;
1166        let mut graft = graft;
1167        graft.do_not_free_on_drop();
1168        let graft = graft.ptr;
1169        let isl_rs_result = unsafe { isl_schedule_node_graft_before(node, graft) };
1170        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1171                                           should_free_on_drop: true };
1172        let err = isl_rs_ctx.last_error();
1173        if err != Error::None_ {
1174            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1175        }
1176        Ok(isl_rs_result)
1177    }
1178
1179    /// Wraps `isl_schedule_node_grandchild`.
1180    pub fn grandchild(self, pos1: i32, pos2: i32) -> Result<ScheduleNode, LibISLError> {
1181        let node = self;
1182        let isl_rs_ctx = node.get_ctx();
1183        let mut node = node;
1184        node.do_not_free_on_drop();
1185        let node = node.ptr;
1186        let isl_rs_result = unsafe { isl_schedule_node_grandchild(node, pos1, pos2) };
1187        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1188                                           should_free_on_drop: true };
1189        let err = isl_rs_ctx.last_error();
1190        if err != Error::None_ {
1191            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1192        }
1193        Ok(isl_rs_result)
1194    }
1195
1196    /// Wraps `isl_schedule_node_grandparent`.
1197    pub fn grandparent(self) -> Result<ScheduleNode, LibISLError> {
1198        let node = self;
1199        let isl_rs_ctx = node.get_ctx();
1200        let mut node = node;
1201        node.do_not_free_on_drop();
1202        let node = node.ptr;
1203        let isl_rs_result = unsafe { isl_schedule_node_grandparent(node) };
1204        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1205                                           should_free_on_drop: true };
1206        let err = isl_rs_ctx.last_error();
1207        if err != Error::None_ {
1208            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1209        }
1210        Ok(isl_rs_result)
1211    }
1212
1213    /// Wraps `isl_schedule_node_group`.
1214    pub fn group(self, group_id: Id) -> Result<ScheduleNode, LibISLError> {
1215        let node = self;
1216        let isl_rs_ctx = node.get_ctx();
1217        let mut node = node;
1218        node.do_not_free_on_drop();
1219        let node = node.ptr;
1220        let mut group_id = group_id;
1221        group_id.do_not_free_on_drop();
1222        let group_id = group_id.ptr;
1223        let isl_rs_result = unsafe { isl_schedule_node_group(node, group_id) };
1224        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1225                                           should_free_on_drop: true };
1226        let err = isl_rs_ctx.last_error();
1227        if err != Error::None_ {
1228            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1229        }
1230        Ok(isl_rs_result)
1231    }
1232
1233    /// Wraps `isl_schedule_node_guard_get_guard`.
1234    pub fn guard_get_guard(&self) -> Result<Set, LibISLError> {
1235        let node = self;
1236        let isl_rs_ctx = node.get_ctx();
1237        let node = node.ptr;
1238        let isl_rs_result = unsafe { isl_schedule_node_guard_get_guard(node) };
1239        let isl_rs_result = Set { ptr: isl_rs_result,
1240                                  should_free_on_drop: true };
1241        let err = isl_rs_ctx.last_error();
1242        if err != Error::None_ {
1243            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1244        }
1245        Ok(isl_rs_result)
1246    }
1247
1248    /// Wraps `isl_schedule_node_has_children`.
1249    pub fn has_children(&self) -> Result<bool, LibISLError> {
1250        let node = self;
1251        let isl_rs_ctx = node.get_ctx();
1252        let node = node.ptr;
1253        let isl_rs_result = unsafe { isl_schedule_node_has_children(node) };
1254        let isl_rs_result = match isl_rs_result {
1255            0 => false,
1256            1 => true,
1257            _ => panic!("Got isl_bool = -1"),
1258        };
1259        let err = isl_rs_ctx.last_error();
1260        if err != Error::None_ {
1261            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1262        }
1263        Ok(isl_rs_result)
1264    }
1265
1266    /// Wraps `isl_schedule_node_has_next_sibling`.
1267    pub fn has_next_sibling(&self) -> Result<bool, LibISLError> {
1268        let node = self;
1269        let isl_rs_ctx = node.get_ctx();
1270        let node = node.ptr;
1271        let isl_rs_result = unsafe { isl_schedule_node_has_next_sibling(node) };
1272        let isl_rs_result = match isl_rs_result {
1273            0 => false,
1274            1 => true,
1275            _ => panic!("Got isl_bool = -1"),
1276        };
1277        let err = isl_rs_ctx.last_error();
1278        if err != Error::None_ {
1279            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1280        }
1281        Ok(isl_rs_result)
1282    }
1283
1284    /// Wraps `isl_schedule_node_has_parent`.
1285    pub fn has_parent(&self) -> Result<bool, LibISLError> {
1286        let node = self;
1287        let isl_rs_ctx = node.get_ctx();
1288        let node = node.ptr;
1289        let isl_rs_result = unsafe { isl_schedule_node_has_parent(node) };
1290        let isl_rs_result = match isl_rs_result {
1291            0 => false,
1292            1 => true,
1293            _ => panic!("Got isl_bool = -1"),
1294        };
1295        let err = isl_rs_ctx.last_error();
1296        if err != Error::None_ {
1297            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1298        }
1299        Ok(isl_rs_result)
1300    }
1301
1302    /// Wraps `isl_schedule_node_has_previous_sibling`.
1303    pub fn has_previous_sibling(&self) -> Result<bool, LibISLError> {
1304        let node = self;
1305        let isl_rs_ctx = node.get_ctx();
1306        let node = node.ptr;
1307        let isl_rs_result = unsafe { isl_schedule_node_has_previous_sibling(node) };
1308        let isl_rs_result = match isl_rs_result {
1309            0 => false,
1310            1 => true,
1311            _ => panic!("Got isl_bool = -1"),
1312        };
1313        let err = isl_rs_ctx.last_error();
1314        if err != Error::None_ {
1315            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1316        }
1317        Ok(isl_rs_result)
1318    }
1319
1320    /// Wraps `isl_schedule_node_insert_context`.
1321    pub fn insert_context(self, context: Set) -> Result<ScheduleNode, LibISLError> {
1322        let node = self;
1323        let isl_rs_ctx = node.get_ctx();
1324        let mut node = node;
1325        node.do_not_free_on_drop();
1326        let node = node.ptr;
1327        let mut context = context;
1328        context.do_not_free_on_drop();
1329        let context = context.ptr;
1330        let isl_rs_result = unsafe { isl_schedule_node_insert_context(node, context) };
1331        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1332                                           should_free_on_drop: true };
1333        let err = isl_rs_ctx.last_error();
1334        if err != Error::None_ {
1335            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1336        }
1337        Ok(isl_rs_result)
1338    }
1339
1340    /// Wraps `isl_schedule_node_insert_filter`.
1341    pub fn insert_filter(self, filter: UnionSet) -> Result<ScheduleNode, LibISLError> {
1342        let node = self;
1343        let isl_rs_ctx = node.get_ctx();
1344        let mut node = node;
1345        node.do_not_free_on_drop();
1346        let node = node.ptr;
1347        let mut filter = filter;
1348        filter.do_not_free_on_drop();
1349        let filter = filter.ptr;
1350        let isl_rs_result = unsafe { isl_schedule_node_insert_filter(node, filter) };
1351        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1352                                           should_free_on_drop: true };
1353        let err = isl_rs_ctx.last_error();
1354        if err != Error::None_ {
1355            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1356        }
1357        Ok(isl_rs_result)
1358    }
1359
1360    /// Wraps `isl_schedule_node_insert_guard`.
1361    pub fn insert_guard(self, context: Set) -> Result<ScheduleNode, LibISLError> {
1362        let node = self;
1363        let isl_rs_ctx = node.get_ctx();
1364        let mut node = node;
1365        node.do_not_free_on_drop();
1366        let node = node.ptr;
1367        let mut context = context;
1368        context.do_not_free_on_drop();
1369        let context = context.ptr;
1370        let isl_rs_result = unsafe { isl_schedule_node_insert_guard(node, context) };
1371        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1372                                           should_free_on_drop: true };
1373        let err = isl_rs_ctx.last_error();
1374        if err != Error::None_ {
1375            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1376        }
1377        Ok(isl_rs_result)
1378    }
1379
1380    /// Wraps `isl_schedule_node_insert_mark`.
1381    pub fn insert_mark(self, mark: Id) -> Result<ScheduleNode, LibISLError> {
1382        let node = self;
1383        let isl_rs_ctx = node.get_ctx();
1384        let mut node = node;
1385        node.do_not_free_on_drop();
1386        let node = node.ptr;
1387        let mut mark = mark;
1388        mark.do_not_free_on_drop();
1389        let mark = mark.ptr;
1390        let isl_rs_result = unsafe { isl_schedule_node_insert_mark(node, mark) };
1391        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1392                                           should_free_on_drop: true };
1393        let err = isl_rs_ctx.last_error();
1394        if err != Error::None_ {
1395            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1396        }
1397        Ok(isl_rs_result)
1398    }
1399
1400    /// Wraps `isl_schedule_node_insert_partial_schedule`.
1401    pub fn insert_partial_schedule(self, schedule: MultiUnionPwAff)
1402                                   -> Result<ScheduleNode, LibISLError> {
1403        let node = self;
1404        let isl_rs_ctx = node.get_ctx();
1405        let mut node = node;
1406        node.do_not_free_on_drop();
1407        let node = node.ptr;
1408        let mut schedule = schedule;
1409        schedule.do_not_free_on_drop();
1410        let schedule = schedule.ptr;
1411        let isl_rs_result = unsafe { isl_schedule_node_insert_partial_schedule(node, schedule) };
1412        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1413                                           should_free_on_drop: true };
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_schedule_node_insert_sequence`.
1422    pub fn insert_sequence(self, filters: UnionSetList) -> Result<ScheduleNode, LibISLError> {
1423        let node = self;
1424        let isl_rs_ctx = node.get_ctx();
1425        let mut node = node;
1426        node.do_not_free_on_drop();
1427        let node = node.ptr;
1428        let mut filters = filters;
1429        filters.do_not_free_on_drop();
1430        let filters = filters.ptr;
1431        let isl_rs_result = unsafe { isl_schedule_node_insert_sequence(node, filters) };
1432        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1433                                           should_free_on_drop: true };
1434        let err = isl_rs_ctx.last_error();
1435        if err != Error::None_ {
1436            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1437        }
1438        Ok(isl_rs_result)
1439    }
1440
1441    /// Wraps `isl_schedule_node_insert_set`.
1442    pub fn insert_set(self, filters: UnionSetList) -> Result<ScheduleNode, LibISLError> {
1443        let node = self;
1444        let isl_rs_ctx = node.get_ctx();
1445        let mut node = node;
1446        node.do_not_free_on_drop();
1447        let node = node.ptr;
1448        let mut filters = filters;
1449        filters.do_not_free_on_drop();
1450        let filters = filters.ptr;
1451        let isl_rs_result = unsafe { isl_schedule_node_insert_set(node, filters) };
1452        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1453                                           should_free_on_drop: true };
1454        let err = isl_rs_ctx.last_error();
1455        if err != Error::None_ {
1456            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1457        }
1458        Ok(isl_rs_result)
1459    }
1460
1461    /// Wraps `isl_schedule_node_is_equal`.
1462    pub fn is_equal(&self, node2: &ScheduleNode) -> Result<bool, LibISLError> {
1463        let node1 = self;
1464        let isl_rs_ctx = node1.get_ctx();
1465        let node1 = node1.ptr;
1466        let node2 = node2.ptr;
1467        let isl_rs_result = unsafe { isl_schedule_node_is_equal(node1, node2) };
1468        let isl_rs_result = match isl_rs_result {
1469            0 => false,
1470            1 => true,
1471            _ => panic!("Got isl_bool = -1"),
1472        };
1473        let err = isl_rs_ctx.last_error();
1474        if err != Error::None_ {
1475            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1476        }
1477        Ok(isl_rs_result)
1478    }
1479
1480    /// Wraps `isl_schedule_node_is_subtree_anchored`.
1481    pub fn is_subtree_anchored(&self) -> Result<bool, LibISLError> {
1482        let node = self;
1483        let isl_rs_ctx = node.get_ctx();
1484        let node = node.ptr;
1485        let isl_rs_result = unsafe { isl_schedule_node_is_subtree_anchored(node) };
1486        let isl_rs_result = match isl_rs_result {
1487            0 => false,
1488            1 => true,
1489            _ => panic!("Got isl_bool = -1"),
1490        };
1491        let err = isl_rs_ctx.last_error();
1492        if err != Error::None_ {
1493            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1494        }
1495        Ok(isl_rs_result)
1496    }
1497
1498    /// Wraps `isl_schedule_node_mark_get_id`.
1499    pub fn mark_get_id(&self) -> Result<Id, LibISLError> {
1500        let node = self;
1501        let isl_rs_ctx = node.get_ctx();
1502        let node = node.ptr;
1503        let isl_rs_result = unsafe { isl_schedule_node_mark_get_id(node) };
1504        let isl_rs_result = Id { ptr: isl_rs_result,
1505                                 should_free_on_drop: true };
1506        let err = isl_rs_ctx.last_error();
1507        if err != Error::None_ {
1508            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1509        }
1510        Ok(isl_rs_result)
1511    }
1512
1513    /// Wraps `isl_schedule_node_n_children`.
1514    pub fn n_children(&self) -> Result<i32, LibISLError> {
1515        let node = self;
1516        let isl_rs_ctx = node.get_ctx();
1517        let node = node.ptr;
1518        let isl_rs_result = unsafe { isl_schedule_node_n_children(node) };
1519        let err = isl_rs_ctx.last_error();
1520        if err != Error::None_ {
1521            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1522        }
1523        Ok(isl_rs_result)
1524    }
1525
1526    /// Wraps `isl_schedule_node_next_sibling`.
1527    pub fn next_sibling(self) -> Result<ScheduleNode, LibISLError> {
1528        let node = self;
1529        let isl_rs_ctx = node.get_ctx();
1530        let mut node = node;
1531        node.do_not_free_on_drop();
1532        let node = node.ptr;
1533        let isl_rs_result = unsafe { isl_schedule_node_next_sibling(node) };
1534        let isl_rs_result = ScheduleNode { 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_schedule_node_order_after`.
1544    pub fn order_after(self, filter: UnionSet) -> Result<ScheduleNode, LibISLError> {
1545        let node = self;
1546        let isl_rs_ctx = node.get_ctx();
1547        let mut node = node;
1548        node.do_not_free_on_drop();
1549        let node = node.ptr;
1550        let mut filter = filter;
1551        filter.do_not_free_on_drop();
1552        let filter = filter.ptr;
1553        let isl_rs_result = unsafe { isl_schedule_node_order_after(node, filter) };
1554        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1555                                           should_free_on_drop: true };
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    /// Wraps `isl_schedule_node_order_before`.
1564    pub fn order_before(self, filter: UnionSet) -> Result<ScheduleNode, LibISLError> {
1565        let node = self;
1566        let isl_rs_ctx = node.get_ctx();
1567        let mut node = node;
1568        node.do_not_free_on_drop();
1569        let node = node.ptr;
1570        let mut filter = filter;
1571        filter.do_not_free_on_drop();
1572        let filter = filter.ptr;
1573        let isl_rs_result = unsafe { isl_schedule_node_order_before(node, filter) };
1574        let isl_rs_result = ScheduleNode { 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    /// Wraps `isl_schedule_node_parent`.
1584    pub fn parent(self) -> Result<ScheduleNode, LibISLError> {
1585        let node = self;
1586        let isl_rs_ctx = node.get_ctx();
1587        let mut node = node;
1588        node.do_not_free_on_drop();
1589        let node = node.ptr;
1590        let isl_rs_result = unsafe { isl_schedule_node_parent(node) };
1591        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1592                                           should_free_on_drop: true };
1593        let err = isl_rs_ctx.last_error();
1594        if err != Error::None_ {
1595            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1596        }
1597        Ok(isl_rs_result)
1598    }
1599
1600    /// Wraps `isl_schedule_node_previous_sibling`.
1601    pub fn previous_sibling(self) -> Result<ScheduleNode, LibISLError> {
1602        let node = self;
1603        let isl_rs_ctx = node.get_ctx();
1604        let mut node = node;
1605        node.do_not_free_on_drop();
1606        let node = node.ptr;
1607        let isl_rs_result = unsafe { isl_schedule_node_previous_sibling(node) };
1608        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1609                                           should_free_on_drop: true };
1610        let err = isl_rs_ctx.last_error();
1611        if err != Error::None_ {
1612            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1613        }
1614        Ok(isl_rs_result)
1615    }
1616
1617    /// Wraps `isl_schedule_node_reset_user`.
1618    pub fn reset_user(self) -> Result<ScheduleNode, LibISLError> {
1619        let node = self;
1620        let isl_rs_ctx = node.get_ctx();
1621        let mut node = node;
1622        node.do_not_free_on_drop();
1623        let node = node.ptr;
1624        let isl_rs_result = unsafe { isl_schedule_node_reset_user(node) };
1625        let isl_rs_result = ScheduleNode { 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    /// Wraps `isl_schedule_node_root`.
1635    pub fn root(self) -> Result<ScheduleNode, LibISLError> {
1636        let node = self;
1637        let isl_rs_ctx = node.get_ctx();
1638        let mut node = node;
1639        node.do_not_free_on_drop();
1640        let node = node.ptr;
1641        let isl_rs_result = unsafe { isl_schedule_node_root(node) };
1642        let isl_rs_result = ScheduleNode { 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    /// Wraps `isl_schedule_node_sequence_splice_child`.
1652    pub fn sequence_splice_child(self, pos: i32) -> Result<ScheduleNode, LibISLError> {
1653        let node = self;
1654        let isl_rs_ctx = node.get_ctx();
1655        let mut node = node;
1656        node.do_not_free_on_drop();
1657        let node = node.ptr;
1658        let isl_rs_result = unsafe { isl_schedule_node_sequence_splice_child(node, pos) };
1659        let isl_rs_result = ScheduleNode { 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_schedule_node_sequence_splice_children`.
1669    pub fn sequence_splice_children(self) -> Result<ScheduleNode, LibISLError> {
1670        let node = self;
1671        let isl_rs_ctx = node.get_ctx();
1672        let mut node = node;
1673        node.do_not_free_on_drop();
1674        let node = node.ptr;
1675        let isl_rs_result = unsafe { isl_schedule_node_sequence_splice_children(node) };
1676        let isl_rs_result = ScheduleNode { ptr: isl_rs_result,
1677                                           should_free_on_drop: true };
1678        let err = isl_rs_ctx.last_error();
1679        if err != Error::None_ {
1680            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1681        }
1682        Ok(isl_rs_result)
1683    }
1684
1685    /// Wraps `isl_schedule_node_to_str`.
1686    pub fn to_str(&self) -> Result<&str, LibISLError> {
1687        let node = self;
1688        let isl_rs_ctx = node.get_ctx();
1689        let node = node.ptr;
1690        let isl_rs_result = unsafe { isl_schedule_node_to_str(node) };
1691        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
1692        let isl_rs_result = isl_rs_result.to_str().unwrap();
1693        let err = isl_rs_ctx.last_error();
1694        if err != Error::None_ {
1695            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
1696        }
1697        Ok(isl_rs_result)
1698    }
1699
1700    /// Does not call isl_schedule_node_free() on being dropped. (For internal
1701    /// use only.)
1702    pub fn do_not_free_on_drop(&mut self) {
1703        self.should_free_on_drop = false;
1704    }
1705}
1706
1707impl Drop for ScheduleNode {
1708    fn drop(&mut self) {
1709        if self.should_free_on_drop {
1710            unsafe {
1711                isl_schedule_node_free(self.ptr);
1712            }
1713        }
1714    }
1715}
isl_rs/bindings/schedule_node.rs

isl_rs/bindings/
schedule_node.rs
