isl_rs/bindings/
printer.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{
5    ASTExpr, ASTExprList, ASTNode, ASTNodeList, Aff, AffList, BasicMap, BasicMapList, BasicSet,
6    BasicSetList, Constraint, ConstraintList, Context, Error, FixedBox, Id, IdList, IdToASTExpr,
7    LibISLError, LocalSpace, Map, MapList, MultiAff, MultiId, MultiPwAff, MultiUnionPwAff,
8    MultiVal, Point, PwAff, PwAffList, PwMultiAff, PwMultiAffList, PwQPolynomial,
9    PwQPolynomialFold, PwQPolynomialFoldList, PwQPolynomialList, QPolynomial, QPolynomialFold,
10    QPolynomialList, Schedule, ScheduleConstraints, ScheduleNode, Set, SetList, Space,
11    UnionAccessInfo, UnionFlow, UnionMap, UnionMapList, UnionPwAff, UnionPwAffList,
12    UnionPwMultiAff, UnionPwMultiAffList, UnionPwQPolynomial, UnionPwQPolynomialFold, UnionSet,
13    UnionSetList, Val, ValList, Vec,
14};
15use libc::uintptr_t;
16use std::ffi::{CStr, CString};
17use std::os::raw::c_char;
18
19/// Wraps `isl_printer`.
20pub struct Printer {
21    pub ptr: uintptr_t,
22    pub should_free_on_drop: bool,
23}
24
25extern "C" {
26
27    fn isl_printer_end_line(p: uintptr_t) -> uintptr_t;
28
29    fn isl_printer_flush(p: uintptr_t) -> uintptr_t;
30
31    fn isl_printer_free(printer: uintptr_t) -> uintptr_t;
32
33    fn isl_printer_get_ctx(printer: uintptr_t) -> uintptr_t;
34
35    fn isl_printer_get_note(p: uintptr_t, id: uintptr_t) -> uintptr_t;
36
37    fn isl_printer_get_output_format(p: uintptr_t) -> i32;
38
39    fn isl_printer_get_str(printer: uintptr_t) -> *const c_char;
40
41    fn isl_printer_get_yaml_style(p: uintptr_t) -> i32;
42
43    fn isl_printer_has_note(p: uintptr_t, id: uintptr_t) -> i32;
44
45    fn isl_printer_indent(p: uintptr_t, indent: i32) -> uintptr_t;
46
47    fn isl_printer_print_aff(p: uintptr_t, aff: uintptr_t) -> uintptr_t;
48
49    fn isl_printer_print_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
50
51    fn isl_printer_print_ast_expr(p: uintptr_t, expr: uintptr_t) -> uintptr_t;
52
53    fn isl_printer_print_ast_expr_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
54
55    fn isl_printer_print_ast_node(p: uintptr_t, node: uintptr_t) -> uintptr_t;
56
57    fn isl_printer_print_ast_node_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
58
59    fn isl_printer_print_basic_map(printer: uintptr_t, bmap: uintptr_t) -> uintptr_t;
60
61    fn isl_printer_print_basic_map_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
62
63    fn isl_printer_print_basic_set(printer: uintptr_t, bset: uintptr_t) -> uintptr_t;
64
65    fn isl_printer_print_basic_set_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
66
67    fn isl_printer_print_constraint(p: uintptr_t, c: uintptr_t) -> uintptr_t;
68
69    fn isl_printer_print_constraint_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
70
71    fn isl_printer_print_double(p: uintptr_t, d: f64) -> uintptr_t;
72
73    fn isl_printer_print_fixed_box(p: uintptr_t, box_: uintptr_t) -> uintptr_t;
74
75    fn isl_printer_print_id(p: uintptr_t, id: uintptr_t) -> uintptr_t;
76
77    fn isl_printer_print_id_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
78
79    fn isl_printer_print_id_to_ast_expr(p: uintptr_t, hmap: uintptr_t) -> uintptr_t;
80
81    fn isl_printer_print_int(p: uintptr_t, i: i32) -> uintptr_t;
82
83    fn isl_printer_print_local_space(p: uintptr_t, ls: uintptr_t) -> uintptr_t;
84
85    fn isl_printer_print_map(printer: uintptr_t, map: uintptr_t) -> uintptr_t;
86
87    fn isl_printer_print_map_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
88
89    fn isl_printer_print_multi_aff(p: uintptr_t, maff: uintptr_t) -> uintptr_t;
90
91    fn isl_printer_print_multi_id(p: uintptr_t, mi: uintptr_t) -> uintptr_t;
92
93    fn isl_printer_print_multi_pw_aff(p: uintptr_t, mpa: uintptr_t) -> uintptr_t;
94
95    fn isl_printer_print_multi_union_pw_aff(p: uintptr_t, mupa: uintptr_t) -> uintptr_t;
96
97    fn isl_printer_print_multi_val(p: uintptr_t, mv: uintptr_t) -> uintptr_t;
98
99    fn isl_printer_print_point(printer: uintptr_t, pnt: uintptr_t) -> uintptr_t;
100
101    fn isl_printer_print_pw_aff(p: uintptr_t, pwaff: uintptr_t) -> uintptr_t;
102
103    fn isl_printer_print_pw_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
104
105    fn isl_printer_print_pw_multi_aff(p: uintptr_t, pma: uintptr_t) -> uintptr_t;
106
107    fn isl_printer_print_pw_multi_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
108
109    fn isl_printer_print_pw_qpolynomial(p: uintptr_t, pwqp: uintptr_t) -> uintptr_t;
110
111    fn isl_printer_print_pw_qpolynomial_fold(p: uintptr_t, pwf: uintptr_t) -> uintptr_t;
112
113    fn isl_printer_print_pw_qpolynomial_fold_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
114
115    fn isl_printer_print_pw_qpolynomial_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
116
117    fn isl_printer_print_qpolynomial(p: uintptr_t, qp: uintptr_t) -> uintptr_t;
118
119    fn isl_printer_print_qpolynomial_fold(p: uintptr_t, fold: uintptr_t) -> uintptr_t;
120
121    fn isl_printer_print_qpolynomial_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
122
123    fn isl_printer_print_schedule(p: uintptr_t, schedule: uintptr_t) -> uintptr_t;
124
125    fn isl_printer_print_schedule_constraints(p: uintptr_t, sc: uintptr_t) -> uintptr_t;
126
127    fn isl_printer_print_schedule_node(p: uintptr_t, node: uintptr_t) -> uintptr_t;
128
129    fn isl_printer_print_set(printer: uintptr_t, map: uintptr_t) -> uintptr_t;
130
131    fn isl_printer_print_set_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
132
133    fn isl_printer_print_space(p: uintptr_t, space: uintptr_t) -> uintptr_t;
134
135    fn isl_printer_print_str(p: uintptr_t, s: *const c_char) -> uintptr_t;
136
137    fn isl_printer_print_union_access_info(p: uintptr_t, access: uintptr_t) -> uintptr_t;
138
139    fn isl_printer_print_union_flow(p: uintptr_t, flow: uintptr_t) -> uintptr_t;
140
141    fn isl_printer_print_union_map(p: uintptr_t, umap: uintptr_t) -> uintptr_t;
142
143    fn isl_printer_print_union_map_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
144
145    fn isl_printer_print_union_pw_aff(p: uintptr_t, upa: uintptr_t) -> uintptr_t;
146
147    fn isl_printer_print_union_pw_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
148
149    fn isl_printer_print_union_pw_multi_aff(p: uintptr_t, upma: uintptr_t) -> uintptr_t;
150
151    fn isl_printer_print_union_pw_multi_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
152
153    fn isl_printer_print_union_pw_qpolynomial(p: uintptr_t, upwqp: uintptr_t) -> uintptr_t;
154
155    fn isl_printer_print_union_pw_qpolynomial_fold(p: uintptr_t, upwf: uintptr_t) -> uintptr_t;
156
157    fn isl_printer_print_union_set(p: uintptr_t, uset: uintptr_t) -> uintptr_t;
158
159    fn isl_printer_print_union_set_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
160
161    fn isl_printer_print_val(p: uintptr_t, v: uintptr_t) -> uintptr_t;
162
163    fn isl_printer_print_val_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;
164
165    fn isl_printer_print_vec(printer: uintptr_t, vec: uintptr_t) -> uintptr_t;
166
167    fn isl_printer_set_indent(p: uintptr_t, indent: i32) -> uintptr_t;
168
169    fn isl_printer_set_indent_prefix(p: uintptr_t, prefix: *const c_char) -> uintptr_t;
170
171    fn isl_printer_set_isl_int_width(p: uintptr_t, width: i32) -> uintptr_t;
172
173    fn isl_printer_set_note(p: uintptr_t, id: uintptr_t, note: uintptr_t) -> uintptr_t;
174
175    fn isl_printer_set_output_format(p: uintptr_t, output_format: i32) -> uintptr_t;
176
177    fn isl_printer_set_prefix(p: uintptr_t, prefix: *const c_char) -> uintptr_t;
178
179    fn isl_printer_set_suffix(p: uintptr_t, suffix: *const c_char) -> uintptr_t;
180
181    fn isl_printer_set_yaml_style(p: uintptr_t, yaml_style: i32) -> uintptr_t;
182
183    fn isl_printer_start_line(p: uintptr_t) -> uintptr_t;
184
185    fn isl_printer_to_str(ctx: uintptr_t) -> uintptr_t;
186
187    fn isl_printer_yaml_end_mapping(p: uintptr_t) -> uintptr_t;
188
189    fn isl_printer_yaml_end_sequence(p: uintptr_t) -> uintptr_t;
190
191    fn isl_printer_yaml_next(p: uintptr_t) -> uintptr_t;
192
193    fn isl_printer_yaml_start_mapping(p: uintptr_t) -> uintptr_t;
194
195    fn isl_printer_yaml_start_sequence(p: uintptr_t) -> uintptr_t;
196
197}
198
199impl Printer {
200    /// Wraps `isl_printer_end_line`.
201    pub fn end_line(self) -> Result<Printer, LibISLError> {
202        let p = self;
203        let isl_rs_ctx = p.get_ctx();
204        let mut p = p;
205        p.do_not_free_on_drop();
206        let p = p.ptr;
207        let isl_rs_result = unsafe { isl_printer_end_line(p) };
208        let isl_rs_result = Printer { ptr: isl_rs_result,
209                                      should_free_on_drop: true };
210        let err = isl_rs_ctx.last_error();
211        if err != Error::None_ {
212            let err_msg = isl_rs_ctx.last_error_msg();
213            isl_rs_ctx.reset_error();
214            return Err(LibISLError::new(err, err_msg));
215        }
216        Ok(isl_rs_result)
217    }
218
219    /// Wraps `isl_printer_flush`.
220    pub fn flush(self) -> Result<Printer, LibISLError> {
221        let p = self;
222        let isl_rs_ctx = p.get_ctx();
223        let mut p = p;
224        p.do_not_free_on_drop();
225        let p = p.ptr;
226        let isl_rs_result = unsafe { isl_printer_flush(p) };
227        let isl_rs_result = Printer { ptr: isl_rs_result,
228                                      should_free_on_drop: true };
229        let err = isl_rs_ctx.last_error();
230        if err != Error::None_ {
231            let err_msg = isl_rs_ctx.last_error_msg();
232            isl_rs_ctx.reset_error();
233            return Err(LibISLError::new(err, err_msg));
234        }
235        Ok(isl_rs_result)
236    }
237
238    /// Wraps `isl_printer_free`.
239    pub fn free(self) -> Result<Printer, LibISLError> {
240        let printer = self;
241        let isl_rs_ctx = printer.get_ctx();
242        let mut printer = printer;
243        printer.do_not_free_on_drop();
244        let printer = printer.ptr;
245        let isl_rs_result = unsafe { isl_printer_free(printer) };
246        let isl_rs_result = Printer { ptr: isl_rs_result,
247                                      should_free_on_drop: true };
248        let err = isl_rs_ctx.last_error();
249        if err != Error::None_ {
250            let err_msg = isl_rs_ctx.last_error_msg();
251            isl_rs_ctx.reset_error();
252            return Err(LibISLError::new(err, err_msg));
253        }
254        Ok(isl_rs_result)
255    }
256
257    /// Wraps `isl_printer_get_ctx`.
258    pub fn get_ctx(&self) -> Context {
259        let printer = self;
260        let printer = printer.ptr;
261        let isl_rs_result = unsafe { isl_printer_get_ctx(printer) };
262        let isl_rs_result = Context { ptr: isl_rs_result,
263                                      should_free_on_drop: false };
264        isl_rs_result
265    }
266
267    /// Wraps `isl_printer_get_note`.
268    pub fn get_note(&self, id: Id) -> Result<Id, LibISLError> {
269        let p = self;
270        let isl_rs_ctx = p.get_ctx();
271        let p = p.ptr;
272        let mut id = id;
273        id.do_not_free_on_drop();
274        let id = id.ptr;
275        let isl_rs_result = unsafe { isl_printer_get_note(p, id) };
276        let isl_rs_result = Id { 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_printer_get_output_format`.
288    pub fn get_output_format(&self) -> Result<i32, LibISLError> {
289        let p = self;
290        let isl_rs_ctx = p.get_ctx();
291        let p = p.ptr;
292        let isl_rs_result = unsafe { isl_printer_get_output_format(p) };
293        let err = isl_rs_ctx.last_error();
294        if err != Error::None_ {
295            let err_msg = isl_rs_ctx.last_error_msg();
296            isl_rs_ctx.reset_error();
297            return Err(LibISLError::new(err, err_msg));
298        }
299        Ok(isl_rs_result)
300    }
301
302    /// Wraps `isl_printer_get_str`.
303    pub fn get_str(&self) -> Result<&str, LibISLError> {
304        let printer = self;
305        let isl_rs_ctx = printer.get_ctx();
306        let printer = printer.ptr;
307        let isl_rs_result = unsafe { isl_printer_get_str(printer) };
308        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
309        let isl_rs_result = isl_rs_result.to_str().unwrap();
310        let err = isl_rs_ctx.last_error();
311        if err != Error::None_ {
312            let err_msg = isl_rs_ctx.last_error_msg();
313            isl_rs_ctx.reset_error();
314            return Err(LibISLError::new(err, err_msg));
315        }
316        Ok(isl_rs_result)
317    }
318
319    /// Wraps `isl_printer_get_yaml_style`.
320    pub fn get_yaml_style(&self) -> Result<i32, LibISLError> {
321        let p = self;
322        let isl_rs_ctx = p.get_ctx();
323        let p = p.ptr;
324        let isl_rs_result = unsafe { isl_printer_get_yaml_style(p) };
325        let err = isl_rs_ctx.last_error();
326        if err != Error::None_ {
327            let err_msg = isl_rs_ctx.last_error_msg();
328            isl_rs_ctx.reset_error();
329            return Err(LibISLError::new(err, err_msg));
330        }
331        Ok(isl_rs_result)
332    }
333
334    /// Wraps `isl_printer_has_note`.
335    pub fn has_note(&self, id: &Id) -> Result<bool, LibISLError> {
336        let p = self;
337        let isl_rs_ctx = p.get_ctx();
338        let p = p.ptr;
339        let id = id.ptr;
340        let isl_rs_result = unsafe { isl_printer_has_note(p, id) };
341        let isl_rs_result = match isl_rs_result {
342            0 => false,
343            1 => true,
344            _ => {
345                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
346            }
347        };
348        let err = isl_rs_ctx.last_error();
349        if err != Error::None_ {
350            let err_msg = isl_rs_ctx.last_error_msg();
351            isl_rs_ctx.reset_error();
352            return Err(LibISLError::new(err, err_msg));
353        }
354        Ok(isl_rs_result)
355    }
356
357    /// Wraps `isl_printer_indent`.
358    pub fn indent(self, indent: i32) -> Result<Printer, LibISLError> {
359        let p = self;
360        let isl_rs_ctx = p.get_ctx();
361        let mut p = p;
362        p.do_not_free_on_drop();
363        let p = p.ptr;
364        let isl_rs_result = unsafe { isl_printer_indent(p, indent) };
365        let isl_rs_result = Printer { ptr: isl_rs_result,
366                                      should_free_on_drop: true };
367        let err = isl_rs_ctx.last_error();
368        if err != Error::None_ {
369            let err_msg = isl_rs_ctx.last_error_msg();
370            isl_rs_ctx.reset_error();
371            return Err(LibISLError::new(err, err_msg));
372        }
373        Ok(isl_rs_result)
374    }
375
376    /// Wraps `isl_printer_print_aff`.
377    pub fn print_aff(self, aff: &Aff) -> Result<Printer, LibISLError> {
378        let p = self;
379        let isl_rs_ctx = p.get_ctx();
380        let mut p = p;
381        p.do_not_free_on_drop();
382        let p = p.ptr;
383        let aff = aff.ptr;
384        let isl_rs_result = unsafe { isl_printer_print_aff(p, aff) };
385        let isl_rs_result = Printer { 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_printer_print_aff_list`.
397    pub fn print_aff_list(self, list: &AffList) -> Result<Printer, LibISLError> {
398        let p = self;
399        let isl_rs_ctx = p.get_ctx();
400        let mut p = p;
401        p.do_not_free_on_drop();
402        let p = p.ptr;
403        let list = list.ptr;
404        let isl_rs_result = unsafe { isl_printer_print_aff_list(p, list) };
405        let isl_rs_result = Printer { ptr: isl_rs_result,
406                                      should_free_on_drop: true };
407        let err = isl_rs_ctx.last_error();
408        if err != Error::None_ {
409            let err_msg = isl_rs_ctx.last_error_msg();
410            isl_rs_ctx.reset_error();
411            return Err(LibISLError::new(err, err_msg));
412        }
413        Ok(isl_rs_result)
414    }
415
416    /// Wraps `isl_printer_print_ast_expr`.
417    pub fn print_ast_expr(self, expr: &ASTExpr) -> Result<Printer, LibISLError> {
418        let p = self;
419        let isl_rs_ctx = p.get_ctx();
420        let mut p = p;
421        p.do_not_free_on_drop();
422        let p = p.ptr;
423        let expr = expr.ptr;
424        let isl_rs_result = unsafe { isl_printer_print_ast_expr(p, expr) };
425        let isl_rs_result = Printer { ptr: isl_rs_result,
426                                      should_free_on_drop: true };
427        let err = isl_rs_ctx.last_error();
428        if err != Error::None_ {
429            let err_msg = isl_rs_ctx.last_error_msg();
430            isl_rs_ctx.reset_error();
431            return Err(LibISLError::new(err, err_msg));
432        }
433        Ok(isl_rs_result)
434    }
435
436    /// Wraps `isl_printer_print_ast_expr_list`.
437    pub fn print_ast_expr_list(self, list: &ASTExprList) -> Result<Printer, LibISLError> {
438        let p = self;
439        let isl_rs_ctx = p.get_ctx();
440        let mut p = p;
441        p.do_not_free_on_drop();
442        let p = p.ptr;
443        let list = list.ptr;
444        let isl_rs_result = unsafe { isl_printer_print_ast_expr_list(p, list) };
445        let isl_rs_result = Printer { ptr: isl_rs_result,
446                                      should_free_on_drop: true };
447        let err = isl_rs_ctx.last_error();
448        if err != Error::None_ {
449            let err_msg = isl_rs_ctx.last_error_msg();
450            isl_rs_ctx.reset_error();
451            return Err(LibISLError::new(err, err_msg));
452        }
453        Ok(isl_rs_result)
454    }
455
456    /// Wraps `isl_printer_print_ast_node`.
457    pub fn print_ast_node(self, node: &ASTNode) -> Result<Printer, LibISLError> {
458        let p = self;
459        let isl_rs_ctx = p.get_ctx();
460        let mut p = p;
461        p.do_not_free_on_drop();
462        let p = p.ptr;
463        let node = node.ptr;
464        let isl_rs_result = unsafe { isl_printer_print_ast_node(p, node) };
465        let isl_rs_result = Printer { ptr: isl_rs_result,
466                                      should_free_on_drop: true };
467        let err = isl_rs_ctx.last_error();
468        if err != Error::None_ {
469            let err_msg = isl_rs_ctx.last_error_msg();
470            isl_rs_ctx.reset_error();
471            return Err(LibISLError::new(err, err_msg));
472        }
473        Ok(isl_rs_result)
474    }
475
476    /// Wraps `isl_printer_print_ast_node_list`.
477    pub fn print_ast_node_list(self, list: &ASTNodeList) -> Result<Printer, LibISLError> {
478        let p = self;
479        let isl_rs_ctx = p.get_ctx();
480        let mut p = p;
481        p.do_not_free_on_drop();
482        let p = p.ptr;
483        let list = list.ptr;
484        let isl_rs_result = unsafe { isl_printer_print_ast_node_list(p, list) };
485        let isl_rs_result = Printer { ptr: isl_rs_result,
486                                      should_free_on_drop: true };
487        let err = isl_rs_ctx.last_error();
488        if err != Error::None_ {
489            let err_msg = isl_rs_ctx.last_error_msg();
490            isl_rs_ctx.reset_error();
491            return Err(LibISLError::new(err, err_msg));
492        }
493        Ok(isl_rs_result)
494    }
495
496    /// Wraps `isl_printer_print_basic_map`.
497    pub fn print_basic_map(self, bmap: &BasicMap) -> Result<Printer, LibISLError> {
498        let printer = self;
499        let isl_rs_ctx = printer.get_ctx();
500        let mut printer = printer;
501        printer.do_not_free_on_drop();
502        let printer = printer.ptr;
503        let bmap = bmap.ptr;
504        let isl_rs_result = unsafe { isl_printer_print_basic_map(printer, bmap) };
505        let isl_rs_result = Printer { ptr: isl_rs_result,
506                                      should_free_on_drop: true };
507        let err = isl_rs_ctx.last_error();
508        if err != Error::None_ {
509            let err_msg = isl_rs_ctx.last_error_msg();
510            isl_rs_ctx.reset_error();
511            return Err(LibISLError::new(err, err_msg));
512        }
513        Ok(isl_rs_result)
514    }
515
516    /// Wraps `isl_printer_print_basic_map_list`.
517    pub fn print_basic_map_list(self, list: &BasicMapList) -> Result<Printer, LibISLError> {
518        let p = self;
519        let isl_rs_ctx = p.get_ctx();
520        let mut p = p;
521        p.do_not_free_on_drop();
522        let p = p.ptr;
523        let list = list.ptr;
524        let isl_rs_result = unsafe { isl_printer_print_basic_map_list(p, list) };
525        let isl_rs_result = Printer { ptr: isl_rs_result,
526                                      should_free_on_drop: true };
527        let err = isl_rs_ctx.last_error();
528        if err != Error::None_ {
529            let err_msg = isl_rs_ctx.last_error_msg();
530            isl_rs_ctx.reset_error();
531            return Err(LibISLError::new(err, err_msg));
532        }
533        Ok(isl_rs_result)
534    }
535
536    /// Wraps `isl_printer_print_basic_set`.
537    pub fn print_basic_set(self, bset: &BasicSet) -> Result<Printer, LibISLError> {
538        let printer = self;
539        let isl_rs_ctx = printer.get_ctx();
540        let mut printer = printer;
541        printer.do_not_free_on_drop();
542        let printer = printer.ptr;
543        let bset = bset.ptr;
544        let isl_rs_result = unsafe { isl_printer_print_basic_set(printer, bset) };
545        let isl_rs_result = Printer { ptr: isl_rs_result,
546                                      should_free_on_drop: true };
547        let err = isl_rs_ctx.last_error();
548        if err != Error::None_ {
549            let err_msg = isl_rs_ctx.last_error_msg();
550            isl_rs_ctx.reset_error();
551            return Err(LibISLError::new(err, err_msg));
552        }
553        Ok(isl_rs_result)
554    }
555
556    /// Wraps `isl_printer_print_basic_set_list`.
557    pub fn print_basic_set_list(self, list: &BasicSetList) -> Result<Printer, LibISLError> {
558        let p = self;
559        let isl_rs_ctx = p.get_ctx();
560        let mut p = p;
561        p.do_not_free_on_drop();
562        let p = p.ptr;
563        let list = list.ptr;
564        let isl_rs_result = unsafe { isl_printer_print_basic_set_list(p, list) };
565        let isl_rs_result = Printer { ptr: isl_rs_result,
566                                      should_free_on_drop: true };
567        let err = isl_rs_ctx.last_error();
568        if err != Error::None_ {
569            let err_msg = isl_rs_ctx.last_error_msg();
570            isl_rs_ctx.reset_error();
571            return Err(LibISLError::new(err, err_msg));
572        }
573        Ok(isl_rs_result)
574    }
575
576    /// Wraps `isl_printer_print_constraint`.
577    pub fn print_constraint(self, c: &Constraint) -> Result<Printer, LibISLError> {
578        let p = self;
579        let isl_rs_ctx = p.get_ctx();
580        let mut p = p;
581        p.do_not_free_on_drop();
582        let p = p.ptr;
583        let c = c.ptr;
584        let isl_rs_result = unsafe { isl_printer_print_constraint(p, c) };
585        let isl_rs_result = Printer { ptr: isl_rs_result,
586                                      should_free_on_drop: true };
587        let err = isl_rs_ctx.last_error();
588        if err != Error::None_ {
589            let err_msg = isl_rs_ctx.last_error_msg();
590            isl_rs_ctx.reset_error();
591            return Err(LibISLError::new(err, err_msg));
592        }
593        Ok(isl_rs_result)
594    }
595
596    /// Wraps `isl_printer_print_constraint_list`.
597    pub fn print_constraint_list(self, list: &ConstraintList) -> Result<Printer, LibISLError> {
598        let p = self;
599        let isl_rs_ctx = p.get_ctx();
600        let mut p = p;
601        p.do_not_free_on_drop();
602        let p = p.ptr;
603        let list = list.ptr;
604        let isl_rs_result = unsafe { isl_printer_print_constraint_list(p, list) };
605        let isl_rs_result = Printer { ptr: isl_rs_result,
606                                      should_free_on_drop: true };
607        let err = isl_rs_ctx.last_error();
608        if err != Error::None_ {
609            let err_msg = isl_rs_ctx.last_error_msg();
610            isl_rs_ctx.reset_error();
611            return Err(LibISLError::new(err, err_msg));
612        }
613        Ok(isl_rs_result)
614    }
615
616    /// Wraps `isl_printer_print_double`.
617    pub fn print_double(self, d: f64) -> Result<Printer, LibISLError> {
618        let p = self;
619        let isl_rs_ctx = p.get_ctx();
620        let mut p = p;
621        p.do_not_free_on_drop();
622        let p = p.ptr;
623        let isl_rs_result = unsafe { isl_printer_print_double(p, d) };
624        let isl_rs_result = Printer { ptr: isl_rs_result,
625                                      should_free_on_drop: true };
626        let err = isl_rs_ctx.last_error();
627        if err != Error::None_ {
628            let err_msg = isl_rs_ctx.last_error_msg();
629            isl_rs_ctx.reset_error();
630            return Err(LibISLError::new(err, err_msg));
631        }
632        Ok(isl_rs_result)
633    }
634
635    /// Wraps `isl_printer_print_fixed_box`.
636    pub fn print_fixed_box(self, box_: &FixedBox) -> Result<Printer, LibISLError> {
637        let p = self;
638        let isl_rs_ctx = p.get_ctx();
639        let mut p = p;
640        p.do_not_free_on_drop();
641        let p = p.ptr;
642        let box_ = box_.ptr;
643        let isl_rs_result = unsafe { isl_printer_print_fixed_box(p, box_) };
644        let isl_rs_result = Printer { ptr: isl_rs_result,
645                                      should_free_on_drop: true };
646        let err = isl_rs_ctx.last_error();
647        if err != Error::None_ {
648            let err_msg = isl_rs_ctx.last_error_msg();
649            isl_rs_ctx.reset_error();
650            return Err(LibISLError::new(err, err_msg));
651        }
652        Ok(isl_rs_result)
653    }
654
655    /// Wraps `isl_printer_print_id`.
656    pub fn print_id(self, id: &Id) -> Result<Printer, LibISLError> {
657        let p = self;
658        let isl_rs_ctx = p.get_ctx();
659        let mut p = p;
660        p.do_not_free_on_drop();
661        let p = p.ptr;
662        let id = id.ptr;
663        let isl_rs_result = unsafe { isl_printer_print_id(p, id) };
664        let isl_rs_result = Printer { ptr: isl_rs_result,
665                                      should_free_on_drop: true };
666        let err = isl_rs_ctx.last_error();
667        if err != Error::None_ {
668            let err_msg = isl_rs_ctx.last_error_msg();
669            isl_rs_ctx.reset_error();
670            return Err(LibISLError::new(err, err_msg));
671        }
672        Ok(isl_rs_result)
673    }
674
675    /// Wraps `isl_printer_print_id_list`.
676    pub fn print_id_list(self, list: &IdList) -> Result<Printer, LibISLError> {
677        let p = self;
678        let isl_rs_ctx = p.get_ctx();
679        let mut p = p;
680        p.do_not_free_on_drop();
681        let p = p.ptr;
682        let list = list.ptr;
683        let isl_rs_result = unsafe { isl_printer_print_id_list(p, list) };
684        let isl_rs_result = Printer { ptr: isl_rs_result,
685                                      should_free_on_drop: true };
686        let err = isl_rs_ctx.last_error();
687        if err != Error::None_ {
688            let err_msg = isl_rs_ctx.last_error_msg();
689            isl_rs_ctx.reset_error();
690            return Err(LibISLError::new(err, err_msg));
691        }
692        Ok(isl_rs_result)
693    }
694
695    /// Wraps `isl_printer_print_id_to_ast_expr`.
696    pub fn print_id_to_ast_expr(self, hmap: &IdToASTExpr) -> Result<Printer, LibISLError> {
697        let p = self;
698        let isl_rs_ctx = p.get_ctx();
699        let mut p = p;
700        p.do_not_free_on_drop();
701        let p = p.ptr;
702        let hmap = hmap.ptr;
703        let isl_rs_result = unsafe { isl_printer_print_id_to_ast_expr(p, hmap) };
704        let isl_rs_result = Printer { ptr: isl_rs_result,
705                                      should_free_on_drop: true };
706        let err = isl_rs_ctx.last_error();
707        if err != Error::None_ {
708            let err_msg = isl_rs_ctx.last_error_msg();
709            isl_rs_ctx.reset_error();
710            return Err(LibISLError::new(err, err_msg));
711        }
712        Ok(isl_rs_result)
713    }
714
715    /// Wraps `isl_printer_print_int`.
716    pub fn print_int(self, i: i32) -> Result<Printer, LibISLError> {
717        let p = self;
718        let isl_rs_ctx = p.get_ctx();
719        let mut p = p;
720        p.do_not_free_on_drop();
721        let p = p.ptr;
722        let isl_rs_result = unsafe { isl_printer_print_int(p, i) };
723        let isl_rs_result = Printer { ptr: isl_rs_result,
724                                      should_free_on_drop: true };
725        let err = isl_rs_ctx.last_error();
726        if err != Error::None_ {
727            let err_msg = isl_rs_ctx.last_error_msg();
728            isl_rs_ctx.reset_error();
729            return Err(LibISLError::new(err, err_msg));
730        }
731        Ok(isl_rs_result)
732    }
733
734    /// Wraps `isl_printer_print_local_space`.
735    pub fn print_local_space(self, ls: &LocalSpace) -> Result<Printer, LibISLError> {
736        let p = self;
737        let isl_rs_ctx = p.get_ctx();
738        let mut p = p;
739        p.do_not_free_on_drop();
740        let p = p.ptr;
741        let ls = ls.ptr;
742        let isl_rs_result = unsafe { isl_printer_print_local_space(p, ls) };
743        let isl_rs_result = Printer { ptr: isl_rs_result,
744                                      should_free_on_drop: true };
745        let err = isl_rs_ctx.last_error();
746        if err != Error::None_ {
747            let err_msg = isl_rs_ctx.last_error_msg();
748            isl_rs_ctx.reset_error();
749            return Err(LibISLError::new(err, err_msg));
750        }
751        Ok(isl_rs_result)
752    }
753
754    /// Wraps `isl_printer_print_map`.
755    pub fn print_map(self, map: &Map) -> Result<Printer, LibISLError> {
756        let printer = self;
757        let isl_rs_ctx = printer.get_ctx();
758        let mut printer = printer;
759        printer.do_not_free_on_drop();
760        let printer = printer.ptr;
761        let map = map.ptr;
762        let isl_rs_result = unsafe { isl_printer_print_map(printer, map) };
763        let isl_rs_result = Printer { ptr: isl_rs_result,
764                                      should_free_on_drop: true };
765        let err = isl_rs_ctx.last_error();
766        if err != Error::None_ {
767            let err_msg = isl_rs_ctx.last_error_msg();
768            isl_rs_ctx.reset_error();
769            return Err(LibISLError::new(err, err_msg));
770        }
771        Ok(isl_rs_result)
772    }
773
774    /// Wraps `isl_printer_print_map_list`.
775    pub fn print_map_list(self, list: &MapList) -> Result<Printer, LibISLError> {
776        let p = self;
777        let isl_rs_ctx = p.get_ctx();
778        let mut p = p;
779        p.do_not_free_on_drop();
780        let p = p.ptr;
781        let list = list.ptr;
782        let isl_rs_result = unsafe { isl_printer_print_map_list(p, list) };
783        let isl_rs_result = Printer { ptr: isl_rs_result,
784                                      should_free_on_drop: true };
785        let err = isl_rs_ctx.last_error();
786        if err != Error::None_ {
787            let err_msg = isl_rs_ctx.last_error_msg();
788            isl_rs_ctx.reset_error();
789            return Err(LibISLError::new(err, err_msg));
790        }
791        Ok(isl_rs_result)
792    }
793
794    /// Wraps `isl_printer_print_multi_aff`.
795    pub fn print_multi_aff(self, maff: &MultiAff) -> Result<Printer, LibISLError> {
796        let p = self;
797        let isl_rs_ctx = p.get_ctx();
798        let mut p = p;
799        p.do_not_free_on_drop();
800        let p = p.ptr;
801        let maff = maff.ptr;
802        let isl_rs_result = unsafe { isl_printer_print_multi_aff(p, maff) };
803        let isl_rs_result = Printer { ptr: isl_rs_result,
804                                      should_free_on_drop: true };
805        let err = isl_rs_ctx.last_error();
806        if err != Error::None_ {
807            let err_msg = isl_rs_ctx.last_error_msg();
808            isl_rs_ctx.reset_error();
809            return Err(LibISLError::new(err, err_msg));
810        }
811        Ok(isl_rs_result)
812    }
813
814    /// Wraps `isl_printer_print_multi_id`.
815    pub fn print_multi_id(self, mi: &MultiId) -> Result<Printer, LibISLError> {
816        let p = self;
817        let isl_rs_ctx = p.get_ctx();
818        let mut p = p;
819        p.do_not_free_on_drop();
820        let p = p.ptr;
821        let mi = mi.ptr;
822        let isl_rs_result = unsafe { isl_printer_print_multi_id(p, mi) };
823        let isl_rs_result = Printer { ptr: isl_rs_result,
824                                      should_free_on_drop: true };
825        let err = isl_rs_ctx.last_error();
826        if err != Error::None_ {
827            let err_msg = isl_rs_ctx.last_error_msg();
828            isl_rs_ctx.reset_error();
829            return Err(LibISLError::new(err, err_msg));
830        }
831        Ok(isl_rs_result)
832    }
833
834    /// Wraps `isl_printer_print_multi_pw_aff`.
835    pub fn print_multi_pw_aff(self, mpa: &MultiPwAff) -> Result<Printer, LibISLError> {
836        let p = self;
837        let isl_rs_ctx = p.get_ctx();
838        let mut p = p;
839        p.do_not_free_on_drop();
840        let p = p.ptr;
841        let mpa = mpa.ptr;
842        let isl_rs_result = unsafe { isl_printer_print_multi_pw_aff(p, mpa) };
843        let isl_rs_result = Printer { ptr: isl_rs_result,
844                                      should_free_on_drop: true };
845        let err = isl_rs_ctx.last_error();
846        if err != Error::None_ {
847            let err_msg = isl_rs_ctx.last_error_msg();
848            isl_rs_ctx.reset_error();
849            return Err(LibISLError::new(err, err_msg));
850        }
851        Ok(isl_rs_result)
852    }
853
854    /// Wraps `isl_printer_print_multi_union_pw_aff`.
855    pub fn print_multi_union_pw_aff(self, mupa: &MultiUnionPwAff) -> Result<Printer, LibISLError> {
856        let p = self;
857        let isl_rs_ctx = p.get_ctx();
858        let mut p = p;
859        p.do_not_free_on_drop();
860        let p = p.ptr;
861        let mupa = mupa.ptr;
862        let isl_rs_result = unsafe { isl_printer_print_multi_union_pw_aff(p, mupa) };
863        let isl_rs_result = Printer { ptr: isl_rs_result,
864                                      should_free_on_drop: true };
865        let err = isl_rs_ctx.last_error();
866        if err != Error::None_ {
867            let err_msg = isl_rs_ctx.last_error_msg();
868            isl_rs_ctx.reset_error();
869            return Err(LibISLError::new(err, err_msg));
870        }
871        Ok(isl_rs_result)
872    }
873
874    /// Wraps `isl_printer_print_multi_val`.
875    pub fn print_multi_val(self, mv: &MultiVal) -> Result<Printer, LibISLError> {
876        let p = self;
877        let isl_rs_ctx = p.get_ctx();
878        let mut p = p;
879        p.do_not_free_on_drop();
880        let p = p.ptr;
881        let mv = mv.ptr;
882        let isl_rs_result = unsafe { isl_printer_print_multi_val(p, mv) };
883        let isl_rs_result = Printer { ptr: isl_rs_result,
884                                      should_free_on_drop: true };
885        let err = isl_rs_ctx.last_error();
886        if err != Error::None_ {
887            let err_msg = isl_rs_ctx.last_error_msg();
888            isl_rs_ctx.reset_error();
889            return Err(LibISLError::new(err, err_msg));
890        }
891        Ok(isl_rs_result)
892    }
893
894    /// Wraps `isl_printer_print_point`.
895    pub fn print_point(self, pnt: &Point) -> Result<Printer, LibISLError> {
896        let printer = self;
897        let isl_rs_ctx = printer.get_ctx();
898        let mut printer = printer;
899        printer.do_not_free_on_drop();
900        let printer = printer.ptr;
901        let pnt = pnt.ptr;
902        let isl_rs_result = unsafe { isl_printer_print_point(printer, pnt) };
903        let isl_rs_result = Printer { ptr: isl_rs_result,
904                                      should_free_on_drop: true };
905        let err = isl_rs_ctx.last_error();
906        if err != Error::None_ {
907            let err_msg = isl_rs_ctx.last_error_msg();
908            isl_rs_ctx.reset_error();
909            return Err(LibISLError::new(err, err_msg));
910        }
911        Ok(isl_rs_result)
912    }
913
914    /// Wraps `isl_printer_print_pw_aff`.
915    pub fn print_pw_aff(self, pwaff: &PwAff) -> Result<Printer, LibISLError> {
916        let p = self;
917        let isl_rs_ctx = p.get_ctx();
918        let mut p = p;
919        p.do_not_free_on_drop();
920        let p = p.ptr;
921        let pwaff = pwaff.ptr;
922        let isl_rs_result = unsafe { isl_printer_print_pw_aff(p, pwaff) };
923        let isl_rs_result = Printer { ptr: isl_rs_result,
924                                      should_free_on_drop: true };
925        let err = isl_rs_ctx.last_error();
926        if err != Error::None_ {
927            let err_msg = isl_rs_ctx.last_error_msg();
928            isl_rs_ctx.reset_error();
929            return Err(LibISLError::new(err, err_msg));
930        }
931        Ok(isl_rs_result)
932    }
933
934    /// Wraps `isl_printer_print_pw_aff_list`.
935    pub fn print_pw_aff_list(self, list: &PwAffList) -> Result<Printer, LibISLError> {
936        let p = self;
937        let isl_rs_ctx = p.get_ctx();
938        let mut p = p;
939        p.do_not_free_on_drop();
940        let p = p.ptr;
941        let list = list.ptr;
942        let isl_rs_result = unsafe { isl_printer_print_pw_aff_list(p, list) };
943        let isl_rs_result = Printer { ptr: isl_rs_result,
944                                      should_free_on_drop: true };
945        let err = isl_rs_ctx.last_error();
946        if err != Error::None_ {
947            let err_msg = isl_rs_ctx.last_error_msg();
948            isl_rs_ctx.reset_error();
949            return Err(LibISLError::new(err, err_msg));
950        }
951        Ok(isl_rs_result)
952    }
953
954    /// Wraps `isl_printer_print_pw_multi_aff`.
955    pub fn print_pw_multi_aff(self, pma: &PwMultiAff) -> Result<Printer, LibISLError> {
956        let p = self;
957        let isl_rs_ctx = p.get_ctx();
958        let mut p = p;
959        p.do_not_free_on_drop();
960        let p = p.ptr;
961        let pma = pma.ptr;
962        let isl_rs_result = unsafe { isl_printer_print_pw_multi_aff(p, pma) };
963        let isl_rs_result = Printer { ptr: isl_rs_result,
964                                      should_free_on_drop: true };
965        let err = isl_rs_ctx.last_error();
966        if err != Error::None_ {
967            let err_msg = isl_rs_ctx.last_error_msg();
968            isl_rs_ctx.reset_error();
969            return Err(LibISLError::new(err, err_msg));
970        }
971        Ok(isl_rs_result)
972    }
973
974    /// Wraps `isl_printer_print_pw_multi_aff_list`.
975    pub fn print_pw_multi_aff_list(self, list: &PwMultiAffList) -> Result<Printer, LibISLError> {
976        let p = self;
977        let isl_rs_ctx = p.get_ctx();
978        let mut p = p;
979        p.do_not_free_on_drop();
980        let p = p.ptr;
981        let list = list.ptr;
982        let isl_rs_result = unsafe { isl_printer_print_pw_multi_aff_list(p, list) };
983        let isl_rs_result = Printer { ptr: isl_rs_result,
984                                      should_free_on_drop: true };
985        let err = isl_rs_ctx.last_error();
986        if err != Error::None_ {
987            let err_msg = isl_rs_ctx.last_error_msg();
988            isl_rs_ctx.reset_error();
989            return Err(LibISLError::new(err, err_msg));
990        }
991        Ok(isl_rs_result)
992    }
993
994    /// Wraps `isl_printer_print_pw_qpolynomial`.
995    pub fn print_pw_qpolynomial(self, pwqp: &PwQPolynomial) -> Result<Printer, LibISLError> {
996        let p = self;
997        let isl_rs_ctx = p.get_ctx();
998        let mut p = p;
999        p.do_not_free_on_drop();
1000        let p = p.ptr;
1001        let pwqp = pwqp.ptr;
1002        let isl_rs_result = unsafe { isl_printer_print_pw_qpolynomial(p, pwqp) };
1003        let isl_rs_result = Printer { ptr: isl_rs_result,
1004                                      should_free_on_drop: true };
1005        let err = isl_rs_ctx.last_error();
1006        if err != Error::None_ {
1007            let err_msg = isl_rs_ctx.last_error_msg();
1008            isl_rs_ctx.reset_error();
1009            return Err(LibISLError::new(err, err_msg));
1010        }
1011        Ok(isl_rs_result)
1012    }
1013
1014    /// Wraps `isl_printer_print_pw_qpolynomial_fold`.
1015    pub fn print_pw_qpolynomial_fold(self, pwf: &PwQPolynomialFold)
1016                                     -> Result<Printer, LibISLError> {
1017        let p = self;
1018        let isl_rs_ctx = p.get_ctx();
1019        let mut p = p;
1020        p.do_not_free_on_drop();
1021        let p = p.ptr;
1022        let pwf = pwf.ptr;
1023        let isl_rs_result = unsafe { isl_printer_print_pw_qpolynomial_fold(p, pwf) };
1024        let isl_rs_result = Printer { ptr: isl_rs_result,
1025                                      should_free_on_drop: true };
1026        let err = isl_rs_ctx.last_error();
1027        if err != Error::None_ {
1028            let err_msg = isl_rs_ctx.last_error_msg();
1029            isl_rs_ctx.reset_error();
1030            return Err(LibISLError::new(err, err_msg));
1031        }
1032        Ok(isl_rs_result)
1033    }
1034
1035    /// Wraps `isl_printer_print_pw_qpolynomial_fold_list`.
1036    pub fn print_pw_qpolynomial_fold_list(self, list: &PwQPolynomialFoldList)
1037                                          -> Result<Printer, LibISLError> {
1038        let p = self;
1039        let isl_rs_ctx = p.get_ctx();
1040        let mut p = p;
1041        p.do_not_free_on_drop();
1042        let p = p.ptr;
1043        let list = list.ptr;
1044        let isl_rs_result = unsafe { isl_printer_print_pw_qpolynomial_fold_list(p, list) };
1045        let isl_rs_result = Printer { ptr: isl_rs_result,
1046                                      should_free_on_drop: true };
1047        let err = isl_rs_ctx.last_error();
1048        if err != Error::None_ {
1049            let err_msg = isl_rs_ctx.last_error_msg();
1050            isl_rs_ctx.reset_error();
1051            return Err(LibISLError::new(err, err_msg));
1052        }
1053        Ok(isl_rs_result)
1054    }
1055
1056    /// Wraps `isl_printer_print_pw_qpolynomial_list`.
1057    pub fn print_pw_qpolynomial_list(self, list: &PwQPolynomialList)
1058                                     -> Result<Printer, LibISLError> {
1059        let p = self;
1060        let isl_rs_ctx = p.get_ctx();
1061        let mut p = p;
1062        p.do_not_free_on_drop();
1063        let p = p.ptr;
1064        let list = list.ptr;
1065        let isl_rs_result = unsafe { isl_printer_print_pw_qpolynomial_list(p, list) };
1066        let isl_rs_result = Printer { ptr: isl_rs_result,
1067                                      should_free_on_drop: true };
1068        let err = isl_rs_ctx.last_error();
1069        if err != Error::None_ {
1070            let err_msg = isl_rs_ctx.last_error_msg();
1071            isl_rs_ctx.reset_error();
1072            return Err(LibISLError::new(err, err_msg));
1073        }
1074        Ok(isl_rs_result)
1075    }
1076
1077    /// Wraps `isl_printer_print_qpolynomial`.
1078    pub fn print_qpolynomial(self, qp: &QPolynomial) -> Result<Printer, LibISLError> {
1079        let p = self;
1080        let isl_rs_ctx = p.get_ctx();
1081        let mut p = p;
1082        p.do_not_free_on_drop();
1083        let p = p.ptr;
1084        let qp = qp.ptr;
1085        let isl_rs_result = unsafe { isl_printer_print_qpolynomial(p, qp) };
1086        let isl_rs_result = Printer { ptr: isl_rs_result,
1087                                      should_free_on_drop: true };
1088        let err = isl_rs_ctx.last_error();
1089        if err != Error::None_ {
1090            let err_msg = isl_rs_ctx.last_error_msg();
1091            isl_rs_ctx.reset_error();
1092            return Err(LibISLError::new(err, err_msg));
1093        }
1094        Ok(isl_rs_result)
1095    }
1096
1097    /// Wraps `isl_printer_print_qpolynomial_fold`.
1098    pub fn print_qpolynomial_fold(self, fold: &QPolynomialFold) -> Result<Printer, LibISLError> {
1099        let p = self;
1100        let isl_rs_ctx = p.get_ctx();
1101        let mut p = p;
1102        p.do_not_free_on_drop();
1103        let p = p.ptr;
1104        let fold = fold.ptr;
1105        let isl_rs_result = unsafe { isl_printer_print_qpolynomial_fold(p, fold) };
1106        let isl_rs_result = Printer { ptr: isl_rs_result,
1107                                      should_free_on_drop: true };
1108        let err = isl_rs_ctx.last_error();
1109        if err != Error::None_ {
1110            let err_msg = isl_rs_ctx.last_error_msg();
1111            isl_rs_ctx.reset_error();
1112            return Err(LibISLError::new(err, err_msg));
1113        }
1114        Ok(isl_rs_result)
1115    }
1116
1117    /// Wraps `isl_printer_print_qpolynomial_list`.
1118    pub fn print_qpolynomial_list(self, list: &QPolynomialList) -> Result<Printer, LibISLError> {
1119        let p = self;
1120        let isl_rs_ctx = p.get_ctx();
1121        let mut p = p;
1122        p.do_not_free_on_drop();
1123        let p = p.ptr;
1124        let list = list.ptr;
1125        let isl_rs_result = unsafe { isl_printer_print_qpolynomial_list(p, list) };
1126        let isl_rs_result = Printer { ptr: isl_rs_result,
1127                                      should_free_on_drop: true };
1128        let err = isl_rs_ctx.last_error();
1129        if err != Error::None_ {
1130            let err_msg = isl_rs_ctx.last_error_msg();
1131            isl_rs_ctx.reset_error();
1132            return Err(LibISLError::new(err, err_msg));
1133        }
1134        Ok(isl_rs_result)
1135    }
1136
1137    /// Wraps `isl_printer_print_schedule`.
1138    pub fn print_schedule(self, schedule: &Schedule) -> Result<Printer, LibISLError> {
1139        let p = self;
1140        let isl_rs_ctx = p.get_ctx();
1141        let mut p = p;
1142        p.do_not_free_on_drop();
1143        let p = p.ptr;
1144        let schedule = schedule.ptr;
1145        let isl_rs_result = unsafe { isl_printer_print_schedule(p, schedule) };
1146        let isl_rs_result = Printer { ptr: isl_rs_result,
1147                                      should_free_on_drop: true };
1148        let err = isl_rs_ctx.last_error();
1149        if err != Error::None_ {
1150            let err_msg = isl_rs_ctx.last_error_msg();
1151            isl_rs_ctx.reset_error();
1152            return Err(LibISLError::new(err, err_msg));
1153        }
1154        Ok(isl_rs_result)
1155    }
1156
1157    /// Wraps `isl_printer_print_schedule_constraints`.
1158    pub fn print_schedule_constraints(self, sc: &ScheduleConstraints)
1159                                      -> Result<Printer, LibISLError> {
1160        let p = self;
1161        let isl_rs_ctx = p.get_ctx();
1162        let mut p = p;
1163        p.do_not_free_on_drop();
1164        let p = p.ptr;
1165        let sc = sc.ptr;
1166        let isl_rs_result = unsafe { isl_printer_print_schedule_constraints(p, sc) };
1167        let isl_rs_result = Printer { ptr: isl_rs_result,
1168                                      should_free_on_drop: true };
1169        let err = isl_rs_ctx.last_error();
1170        if err != Error::None_ {
1171            let err_msg = isl_rs_ctx.last_error_msg();
1172            isl_rs_ctx.reset_error();
1173            return Err(LibISLError::new(err, err_msg));
1174        }
1175        Ok(isl_rs_result)
1176    }
1177
1178    /// Wraps `isl_printer_print_schedule_node`.
1179    pub fn print_schedule_node(self, node: &ScheduleNode) -> Result<Printer, LibISLError> {
1180        let p = self;
1181        let isl_rs_ctx = p.get_ctx();
1182        let mut p = p;
1183        p.do_not_free_on_drop();
1184        let p = p.ptr;
1185        let node = node.ptr;
1186        let isl_rs_result = unsafe { isl_printer_print_schedule_node(p, node) };
1187        let isl_rs_result = Printer { ptr: isl_rs_result,
1188                                      should_free_on_drop: true };
1189        let err = isl_rs_ctx.last_error();
1190        if err != Error::None_ {
1191            let err_msg = isl_rs_ctx.last_error_msg();
1192            isl_rs_ctx.reset_error();
1193            return Err(LibISLError::new(err, err_msg));
1194        }
1195        Ok(isl_rs_result)
1196    }
1197
1198    /// Wraps `isl_printer_print_set`.
1199    pub fn print_set(self, map: &Set) -> Result<Printer, LibISLError> {
1200        let printer = self;
1201        let isl_rs_ctx = printer.get_ctx();
1202        let mut printer = printer;
1203        printer.do_not_free_on_drop();
1204        let printer = printer.ptr;
1205        let map = map.ptr;
1206        let isl_rs_result = unsafe { isl_printer_print_set(printer, map) };
1207        let isl_rs_result = Printer { ptr: isl_rs_result,
1208                                      should_free_on_drop: true };
1209        let err = isl_rs_ctx.last_error();
1210        if err != Error::None_ {
1211            let err_msg = isl_rs_ctx.last_error_msg();
1212            isl_rs_ctx.reset_error();
1213            return Err(LibISLError::new(err, err_msg));
1214        }
1215        Ok(isl_rs_result)
1216    }
1217
1218    /// Wraps `isl_printer_print_set_list`.
1219    pub fn print_set_list(self, list: &SetList) -> Result<Printer, LibISLError> {
1220        let p = self;
1221        let isl_rs_ctx = p.get_ctx();
1222        let mut p = p;
1223        p.do_not_free_on_drop();
1224        let p = p.ptr;
1225        let list = list.ptr;
1226        let isl_rs_result = unsafe { isl_printer_print_set_list(p, list) };
1227        let isl_rs_result = Printer { ptr: isl_rs_result,
1228                                      should_free_on_drop: true };
1229        let err = isl_rs_ctx.last_error();
1230        if err != Error::None_ {
1231            let err_msg = isl_rs_ctx.last_error_msg();
1232            isl_rs_ctx.reset_error();
1233            return Err(LibISLError::new(err, err_msg));
1234        }
1235        Ok(isl_rs_result)
1236    }
1237
1238    /// Wraps `isl_printer_print_space`.
1239    pub fn print_space(self, space: &Space) -> Result<Printer, LibISLError> {
1240        let p = self;
1241        let isl_rs_ctx = p.get_ctx();
1242        let mut p = p;
1243        p.do_not_free_on_drop();
1244        let p = p.ptr;
1245        let space = space.ptr;
1246        let isl_rs_result = unsafe { isl_printer_print_space(p, space) };
1247        let isl_rs_result = Printer { ptr: isl_rs_result,
1248                                      should_free_on_drop: true };
1249        let err = isl_rs_ctx.last_error();
1250        if err != Error::None_ {
1251            let err_msg = isl_rs_ctx.last_error_msg();
1252            isl_rs_ctx.reset_error();
1253            return Err(LibISLError::new(err, err_msg));
1254        }
1255        Ok(isl_rs_result)
1256    }
1257
1258    /// Wraps `isl_printer_print_str`.
1259    pub fn print_str(self, s: &str) -> Result<Printer, LibISLError> {
1260        let p = self;
1261        let isl_rs_ctx = p.get_ctx();
1262        let mut p = p;
1263        p.do_not_free_on_drop();
1264        let p = p.ptr;
1265        let s = CString::new(s).unwrap();
1266        let s = s.as_ptr();
1267        let isl_rs_result = unsafe { isl_printer_print_str(p, s) };
1268        let isl_rs_result = Printer { ptr: isl_rs_result,
1269                                      should_free_on_drop: true };
1270        let err = isl_rs_ctx.last_error();
1271        if err != Error::None_ {
1272            let err_msg = isl_rs_ctx.last_error_msg();
1273            isl_rs_ctx.reset_error();
1274            return Err(LibISLError::new(err, err_msg));
1275        }
1276        Ok(isl_rs_result)
1277    }
1278
1279    /// Wraps `isl_printer_print_union_access_info`.
1280    pub fn print_union_access_info(self, access: &UnionAccessInfo) -> Result<Printer, LibISLError> {
1281        let p = self;
1282        let isl_rs_ctx = p.get_ctx();
1283        let mut p = p;
1284        p.do_not_free_on_drop();
1285        let p = p.ptr;
1286        let access = access.ptr;
1287        let isl_rs_result = unsafe { isl_printer_print_union_access_info(p, access) };
1288        let isl_rs_result = Printer { ptr: isl_rs_result,
1289                                      should_free_on_drop: true };
1290        let err = isl_rs_ctx.last_error();
1291        if err != Error::None_ {
1292            let err_msg = isl_rs_ctx.last_error_msg();
1293            isl_rs_ctx.reset_error();
1294            return Err(LibISLError::new(err, err_msg));
1295        }
1296        Ok(isl_rs_result)
1297    }
1298
1299    /// Wraps `isl_printer_print_union_flow`.
1300    pub fn print_union_flow(self, flow: &UnionFlow) -> Result<Printer, LibISLError> {
1301        let p = self;
1302        let isl_rs_ctx = p.get_ctx();
1303        let mut p = p;
1304        p.do_not_free_on_drop();
1305        let p = p.ptr;
1306        let flow = flow.ptr;
1307        let isl_rs_result = unsafe { isl_printer_print_union_flow(p, flow) };
1308        let isl_rs_result = Printer { ptr: isl_rs_result,
1309                                      should_free_on_drop: true };
1310        let err = isl_rs_ctx.last_error();
1311        if err != Error::None_ {
1312            let err_msg = isl_rs_ctx.last_error_msg();
1313            isl_rs_ctx.reset_error();
1314            return Err(LibISLError::new(err, err_msg));
1315        }
1316        Ok(isl_rs_result)
1317    }
1318
1319    /// Wraps `isl_printer_print_union_map`.
1320    pub fn print_union_map(self, umap: &UnionMap) -> Result<Printer, LibISLError> {
1321        let p = self;
1322        let isl_rs_ctx = p.get_ctx();
1323        let mut p = p;
1324        p.do_not_free_on_drop();
1325        let p = p.ptr;
1326        let umap = umap.ptr;
1327        let isl_rs_result = unsafe { isl_printer_print_union_map(p, umap) };
1328        let isl_rs_result = Printer { ptr: isl_rs_result,
1329                                      should_free_on_drop: true };
1330        let err = isl_rs_ctx.last_error();
1331        if err != Error::None_ {
1332            let err_msg = isl_rs_ctx.last_error_msg();
1333            isl_rs_ctx.reset_error();
1334            return Err(LibISLError::new(err, err_msg));
1335        }
1336        Ok(isl_rs_result)
1337    }
1338
1339    /// Wraps `isl_printer_print_union_map_list`.
1340    pub fn print_union_map_list(self, list: &UnionMapList) -> Result<Printer, LibISLError> {
1341        let p = self;
1342        let isl_rs_ctx = p.get_ctx();
1343        let mut p = p;
1344        p.do_not_free_on_drop();
1345        let p = p.ptr;
1346        let list = list.ptr;
1347        let isl_rs_result = unsafe { isl_printer_print_union_map_list(p, list) };
1348        let isl_rs_result = Printer { ptr: isl_rs_result,
1349                                      should_free_on_drop: true };
1350        let err = isl_rs_ctx.last_error();
1351        if err != Error::None_ {
1352            let err_msg = isl_rs_ctx.last_error_msg();
1353            isl_rs_ctx.reset_error();
1354            return Err(LibISLError::new(err, err_msg));
1355        }
1356        Ok(isl_rs_result)
1357    }
1358
1359    /// Wraps `isl_printer_print_union_pw_aff`.
1360    pub fn print_union_pw_aff(self, upa: &UnionPwAff) -> Result<Printer, LibISLError> {
1361        let p = self;
1362        let isl_rs_ctx = p.get_ctx();
1363        let mut p = p;
1364        p.do_not_free_on_drop();
1365        let p = p.ptr;
1366        let upa = upa.ptr;
1367        let isl_rs_result = unsafe { isl_printer_print_union_pw_aff(p, upa) };
1368        let isl_rs_result = Printer { ptr: isl_rs_result,
1369                                      should_free_on_drop: true };
1370        let err = isl_rs_ctx.last_error();
1371        if err != Error::None_ {
1372            let err_msg = isl_rs_ctx.last_error_msg();
1373            isl_rs_ctx.reset_error();
1374            return Err(LibISLError::new(err, err_msg));
1375        }
1376        Ok(isl_rs_result)
1377    }
1378
1379    /// Wraps `isl_printer_print_union_pw_aff_list`.
1380    pub fn print_union_pw_aff_list(self, list: &UnionPwAffList) -> Result<Printer, LibISLError> {
1381        let p = self;
1382        let isl_rs_ctx = p.get_ctx();
1383        let mut p = p;
1384        p.do_not_free_on_drop();
1385        let p = p.ptr;
1386        let list = list.ptr;
1387        let isl_rs_result = unsafe { isl_printer_print_union_pw_aff_list(p, list) };
1388        let isl_rs_result = Printer { ptr: isl_rs_result,
1389                                      should_free_on_drop: true };
1390        let err = isl_rs_ctx.last_error();
1391        if err != Error::None_ {
1392            let err_msg = isl_rs_ctx.last_error_msg();
1393            isl_rs_ctx.reset_error();
1394            return Err(LibISLError::new(err, err_msg));
1395        }
1396        Ok(isl_rs_result)
1397    }
1398
1399    /// Wraps `isl_printer_print_union_pw_multi_aff`.
1400    pub fn print_union_pw_multi_aff(self, upma: &UnionPwMultiAff) -> Result<Printer, LibISLError> {
1401        let p = self;
1402        let isl_rs_ctx = p.get_ctx();
1403        let mut p = p;
1404        p.do_not_free_on_drop();
1405        let p = p.ptr;
1406        let upma = upma.ptr;
1407        let isl_rs_result = unsafe { isl_printer_print_union_pw_multi_aff(p, upma) };
1408        let isl_rs_result = Printer { ptr: isl_rs_result,
1409                                      should_free_on_drop: true };
1410        let err = isl_rs_ctx.last_error();
1411        if err != Error::None_ {
1412            let err_msg = isl_rs_ctx.last_error_msg();
1413            isl_rs_ctx.reset_error();
1414            return Err(LibISLError::new(err, err_msg));
1415        }
1416        Ok(isl_rs_result)
1417    }
1418
1419    /// Wraps `isl_printer_print_union_pw_multi_aff_list`.
1420    pub fn print_union_pw_multi_aff_list(self, list: &UnionPwMultiAffList)
1421                                         -> Result<Printer, LibISLError> {
1422        let p = self;
1423        let isl_rs_ctx = p.get_ctx();
1424        let mut p = p;
1425        p.do_not_free_on_drop();
1426        let p = p.ptr;
1427        let list = list.ptr;
1428        let isl_rs_result = unsafe { isl_printer_print_union_pw_multi_aff_list(p, list) };
1429        let isl_rs_result = Printer { ptr: isl_rs_result,
1430                                      should_free_on_drop: true };
1431        let err = isl_rs_ctx.last_error();
1432        if err != Error::None_ {
1433            let err_msg = isl_rs_ctx.last_error_msg();
1434            isl_rs_ctx.reset_error();
1435            return Err(LibISLError::new(err, err_msg));
1436        }
1437        Ok(isl_rs_result)
1438    }
1439
1440    /// Wraps `isl_printer_print_union_pw_qpolynomial`.
1441    pub fn print_union_pw_qpolynomial(self, upwqp: &UnionPwQPolynomial)
1442                                      -> Result<Printer, LibISLError> {
1443        let p = self;
1444        let isl_rs_ctx = p.get_ctx();
1445        let mut p = p;
1446        p.do_not_free_on_drop();
1447        let p = p.ptr;
1448        let upwqp = upwqp.ptr;
1449        let isl_rs_result = unsafe { isl_printer_print_union_pw_qpolynomial(p, upwqp) };
1450        let isl_rs_result = Printer { ptr: isl_rs_result,
1451                                      should_free_on_drop: true };
1452        let err = isl_rs_ctx.last_error();
1453        if err != Error::None_ {
1454            let err_msg = isl_rs_ctx.last_error_msg();
1455            isl_rs_ctx.reset_error();
1456            return Err(LibISLError::new(err, err_msg));
1457        }
1458        Ok(isl_rs_result)
1459    }
1460
1461    /// Wraps `isl_printer_print_union_pw_qpolynomial_fold`.
1462    pub fn print_union_pw_qpolynomial_fold(self, upwf: &UnionPwQPolynomialFold)
1463                                           -> Result<Printer, LibISLError> {
1464        let p = self;
1465        let isl_rs_ctx = p.get_ctx();
1466        let mut p = p;
1467        p.do_not_free_on_drop();
1468        let p = p.ptr;
1469        let upwf = upwf.ptr;
1470        let isl_rs_result = unsafe { isl_printer_print_union_pw_qpolynomial_fold(p, upwf) };
1471        let isl_rs_result = Printer { ptr: isl_rs_result,
1472                                      should_free_on_drop: true };
1473        let err = isl_rs_ctx.last_error();
1474        if err != Error::None_ {
1475            let err_msg = isl_rs_ctx.last_error_msg();
1476            isl_rs_ctx.reset_error();
1477            return Err(LibISLError::new(err, err_msg));
1478        }
1479        Ok(isl_rs_result)
1480    }
1481
1482    /// Wraps `isl_printer_print_union_set`.
1483    pub fn print_union_set(self, uset: &UnionSet) -> Result<Printer, LibISLError> {
1484        let p = self;
1485        let isl_rs_ctx = p.get_ctx();
1486        let mut p = p;
1487        p.do_not_free_on_drop();
1488        let p = p.ptr;
1489        let uset = uset.ptr;
1490        let isl_rs_result = unsafe { isl_printer_print_union_set(p, uset) };
1491        let isl_rs_result = Printer { ptr: isl_rs_result,
1492                                      should_free_on_drop: true };
1493        let err = isl_rs_ctx.last_error();
1494        if err != Error::None_ {
1495            let err_msg = isl_rs_ctx.last_error_msg();
1496            isl_rs_ctx.reset_error();
1497            return Err(LibISLError::new(err, err_msg));
1498        }
1499        Ok(isl_rs_result)
1500    }
1501
1502    /// Wraps `isl_printer_print_union_set_list`.
1503    pub fn print_union_set_list(self, list: &UnionSetList) -> Result<Printer, LibISLError> {
1504        let p = self;
1505        let isl_rs_ctx = p.get_ctx();
1506        let mut p = p;
1507        p.do_not_free_on_drop();
1508        let p = p.ptr;
1509        let list = list.ptr;
1510        let isl_rs_result = unsafe { isl_printer_print_union_set_list(p, list) };
1511        let isl_rs_result = Printer { ptr: isl_rs_result,
1512                                      should_free_on_drop: true };
1513        let err = isl_rs_ctx.last_error();
1514        if err != Error::None_ {
1515            let err_msg = isl_rs_ctx.last_error_msg();
1516            isl_rs_ctx.reset_error();
1517            return Err(LibISLError::new(err, err_msg));
1518        }
1519        Ok(isl_rs_result)
1520    }
1521
1522    /// Wraps `isl_printer_print_val`.
1523    pub fn print_val(self, v: &Val) -> Result<Printer, LibISLError> {
1524        let p = self;
1525        let isl_rs_ctx = p.get_ctx();
1526        let mut p = p;
1527        p.do_not_free_on_drop();
1528        let p = p.ptr;
1529        let v = v.ptr;
1530        let isl_rs_result = unsafe { isl_printer_print_val(p, v) };
1531        let isl_rs_result = Printer { ptr: isl_rs_result,
1532                                      should_free_on_drop: true };
1533        let err = isl_rs_ctx.last_error();
1534        if err != Error::None_ {
1535            let err_msg = isl_rs_ctx.last_error_msg();
1536            isl_rs_ctx.reset_error();
1537            return Err(LibISLError::new(err, err_msg));
1538        }
1539        Ok(isl_rs_result)
1540    }
1541
1542    /// Wraps `isl_printer_print_val_list`.
1543    pub fn print_val_list(self, list: &ValList) -> Result<Printer, LibISLError> {
1544        let p = self;
1545        let isl_rs_ctx = p.get_ctx();
1546        let mut p = p;
1547        p.do_not_free_on_drop();
1548        let p = p.ptr;
1549        let list = list.ptr;
1550        let isl_rs_result = unsafe { isl_printer_print_val_list(p, list) };
1551        let isl_rs_result = Printer { ptr: isl_rs_result,
1552                                      should_free_on_drop: true };
1553        let err = isl_rs_ctx.last_error();
1554        if err != Error::None_ {
1555            let err_msg = isl_rs_ctx.last_error_msg();
1556            isl_rs_ctx.reset_error();
1557            return Err(LibISLError::new(err, err_msg));
1558        }
1559        Ok(isl_rs_result)
1560    }
1561
1562    /// Wraps `isl_printer_print_vec`.
1563    pub fn print_vec(self, vec: &Vec) -> Result<Printer, LibISLError> {
1564        let printer = self;
1565        let isl_rs_ctx = printer.get_ctx();
1566        let mut printer = printer;
1567        printer.do_not_free_on_drop();
1568        let printer = printer.ptr;
1569        let vec = vec.ptr;
1570        let isl_rs_result = unsafe { isl_printer_print_vec(printer, vec) };
1571        let isl_rs_result = Printer { ptr: isl_rs_result,
1572                                      should_free_on_drop: true };
1573        let err = isl_rs_ctx.last_error();
1574        if err != Error::None_ {
1575            let err_msg = isl_rs_ctx.last_error_msg();
1576            isl_rs_ctx.reset_error();
1577            return Err(LibISLError::new(err, err_msg));
1578        }
1579        Ok(isl_rs_result)
1580    }
1581
1582    /// Wraps `isl_printer_set_indent`.
1583    pub fn set_indent(self, indent: i32) -> Result<Printer, LibISLError> {
1584        let p = self;
1585        let isl_rs_ctx = p.get_ctx();
1586        let mut p = p;
1587        p.do_not_free_on_drop();
1588        let p = p.ptr;
1589        let isl_rs_result = unsafe { isl_printer_set_indent(p, indent) };
1590        let isl_rs_result = Printer { ptr: isl_rs_result,
1591                                      should_free_on_drop: true };
1592        let err = isl_rs_ctx.last_error();
1593        if err != Error::None_ {
1594            let err_msg = isl_rs_ctx.last_error_msg();
1595            isl_rs_ctx.reset_error();
1596            return Err(LibISLError::new(err, err_msg));
1597        }
1598        Ok(isl_rs_result)
1599    }
1600
1601    /// Wraps `isl_printer_set_indent_prefix`.
1602    pub fn set_indent_prefix(self, prefix: &str) -> Result<Printer, LibISLError> {
1603        let p = self;
1604        let isl_rs_ctx = p.get_ctx();
1605        let mut p = p;
1606        p.do_not_free_on_drop();
1607        let p = p.ptr;
1608        let prefix = CString::new(prefix).unwrap();
1609        let prefix = prefix.as_ptr();
1610        let isl_rs_result = unsafe { isl_printer_set_indent_prefix(p, prefix) };
1611        let isl_rs_result = Printer { ptr: isl_rs_result,
1612                                      should_free_on_drop: true };
1613        let err = isl_rs_ctx.last_error();
1614        if err != Error::None_ {
1615            let err_msg = isl_rs_ctx.last_error_msg();
1616            isl_rs_ctx.reset_error();
1617            return Err(LibISLError::new(err, err_msg));
1618        }
1619        Ok(isl_rs_result)
1620    }
1621
1622    /// Wraps `isl_printer_set_isl_int_width`.
1623    pub fn set_isl_int_width(self, width: i32) -> Result<Printer, LibISLError> {
1624        let p = self;
1625        let isl_rs_ctx = p.get_ctx();
1626        let mut p = p;
1627        p.do_not_free_on_drop();
1628        let p = p.ptr;
1629        let isl_rs_result = unsafe { isl_printer_set_isl_int_width(p, width) };
1630        let isl_rs_result = Printer { ptr: isl_rs_result,
1631                                      should_free_on_drop: true };
1632        let err = isl_rs_ctx.last_error();
1633        if err != Error::None_ {
1634            let err_msg = isl_rs_ctx.last_error_msg();
1635            isl_rs_ctx.reset_error();
1636            return Err(LibISLError::new(err, err_msg));
1637        }
1638        Ok(isl_rs_result)
1639    }
1640
1641    /// Wraps `isl_printer_set_note`.
1642    pub fn set_note(self, id: Id, note: Id) -> Result<Printer, LibISLError> {
1643        let p = self;
1644        let isl_rs_ctx = p.get_ctx();
1645        let mut p = p;
1646        p.do_not_free_on_drop();
1647        let p = p.ptr;
1648        let mut id = id;
1649        id.do_not_free_on_drop();
1650        let id = id.ptr;
1651        let mut note = note;
1652        note.do_not_free_on_drop();
1653        let note = note.ptr;
1654        let isl_rs_result = unsafe { isl_printer_set_note(p, id, note) };
1655        let isl_rs_result = Printer { ptr: isl_rs_result,
1656                                      should_free_on_drop: true };
1657        let err = isl_rs_ctx.last_error();
1658        if err != Error::None_ {
1659            let err_msg = isl_rs_ctx.last_error_msg();
1660            isl_rs_ctx.reset_error();
1661            return Err(LibISLError::new(err, err_msg));
1662        }
1663        Ok(isl_rs_result)
1664    }
1665
1666    /// Wraps `isl_printer_set_output_format`.
1667    pub fn set_output_format(self, output_format: i32) -> Result<Printer, LibISLError> {
1668        let p = self;
1669        let isl_rs_ctx = p.get_ctx();
1670        let mut p = p;
1671        p.do_not_free_on_drop();
1672        let p = p.ptr;
1673        let isl_rs_result = unsafe { isl_printer_set_output_format(p, output_format) };
1674        let isl_rs_result = Printer { ptr: isl_rs_result,
1675                                      should_free_on_drop: true };
1676        let err = isl_rs_ctx.last_error();
1677        if err != Error::None_ {
1678            let err_msg = isl_rs_ctx.last_error_msg();
1679            isl_rs_ctx.reset_error();
1680            return Err(LibISLError::new(err, err_msg));
1681        }
1682        Ok(isl_rs_result)
1683    }
1684
1685    /// Wraps `isl_printer_set_prefix`.
1686    pub fn set_prefix(self, prefix: &str) -> Result<Printer, LibISLError> {
1687        let p = self;
1688        let isl_rs_ctx = p.get_ctx();
1689        let mut p = p;
1690        p.do_not_free_on_drop();
1691        let p = p.ptr;
1692        let prefix = CString::new(prefix).unwrap();
1693        let prefix = prefix.as_ptr();
1694        let isl_rs_result = unsafe { isl_printer_set_prefix(p, prefix) };
1695        let isl_rs_result = Printer { ptr: isl_rs_result,
1696                                      should_free_on_drop: true };
1697        let err = isl_rs_ctx.last_error();
1698        if err != Error::None_ {
1699            let err_msg = isl_rs_ctx.last_error_msg();
1700            isl_rs_ctx.reset_error();
1701            return Err(LibISLError::new(err, err_msg));
1702        }
1703        Ok(isl_rs_result)
1704    }
1705
1706    /// Wraps `isl_printer_set_suffix`.
1707    pub fn set_suffix(self, suffix: &str) -> Result<Printer, LibISLError> {
1708        let p = self;
1709        let isl_rs_ctx = p.get_ctx();
1710        let mut p = p;
1711        p.do_not_free_on_drop();
1712        let p = p.ptr;
1713        let suffix = CString::new(suffix).unwrap();
1714        let suffix = suffix.as_ptr();
1715        let isl_rs_result = unsafe { isl_printer_set_suffix(p, suffix) };
1716        let isl_rs_result = Printer { ptr: isl_rs_result,
1717                                      should_free_on_drop: true };
1718        let err = isl_rs_ctx.last_error();
1719        if err != Error::None_ {
1720            let err_msg = isl_rs_ctx.last_error_msg();
1721            isl_rs_ctx.reset_error();
1722            return Err(LibISLError::new(err, err_msg));
1723        }
1724        Ok(isl_rs_result)
1725    }
1726
1727    /// Wraps `isl_printer_set_yaml_style`.
1728    pub fn set_yaml_style(self, yaml_style: i32) -> Result<Printer, LibISLError> {
1729        let p = self;
1730        let isl_rs_ctx = p.get_ctx();
1731        let mut p = p;
1732        p.do_not_free_on_drop();
1733        let p = p.ptr;
1734        let isl_rs_result = unsafe { isl_printer_set_yaml_style(p, yaml_style) };
1735        let isl_rs_result = Printer { ptr: isl_rs_result,
1736                                      should_free_on_drop: true };
1737        let err = isl_rs_ctx.last_error();
1738        if err != Error::None_ {
1739            let err_msg = isl_rs_ctx.last_error_msg();
1740            isl_rs_ctx.reset_error();
1741            return Err(LibISLError::new(err, err_msg));
1742        }
1743        Ok(isl_rs_result)
1744    }
1745
1746    /// Wraps `isl_printer_start_line`.
1747    pub fn start_line(self) -> Result<Printer, LibISLError> {
1748        let p = self;
1749        let isl_rs_ctx = p.get_ctx();
1750        let mut p = p;
1751        p.do_not_free_on_drop();
1752        let p = p.ptr;
1753        let isl_rs_result = unsafe { isl_printer_start_line(p) };
1754        let isl_rs_result = Printer { ptr: isl_rs_result,
1755                                      should_free_on_drop: true };
1756        let err = isl_rs_ctx.last_error();
1757        if err != Error::None_ {
1758            let err_msg = isl_rs_ctx.last_error_msg();
1759            isl_rs_ctx.reset_error();
1760            return Err(LibISLError::new(err, err_msg));
1761        }
1762        Ok(isl_rs_result)
1763    }
1764
1765    /// Wraps `isl_printer_to_str`.
1766    pub fn to_str(ctx: &Context) -> Result<Printer, LibISLError> {
1767        let isl_rs_ctx = Context { ptr: ctx.ptr,
1768                                   should_free_on_drop: false };
1769        let ctx = ctx.ptr;
1770        let isl_rs_result = unsafe { isl_printer_to_str(ctx) };
1771        let isl_rs_result = Printer { ptr: isl_rs_result,
1772                                      should_free_on_drop: true };
1773        let err = isl_rs_ctx.last_error();
1774        if err != Error::None_ {
1775            let err_msg = isl_rs_ctx.last_error_msg();
1776            isl_rs_ctx.reset_error();
1777            return Err(LibISLError::new(err, err_msg));
1778        }
1779        Ok(isl_rs_result)
1780    }
1781
1782    /// Wraps `isl_printer_yaml_end_mapping`.
1783    pub fn yaml_end_mapping(self) -> Result<Printer, LibISLError> {
1784        let p = self;
1785        let isl_rs_ctx = p.get_ctx();
1786        let mut p = p;
1787        p.do_not_free_on_drop();
1788        let p = p.ptr;
1789        let isl_rs_result = unsafe { isl_printer_yaml_end_mapping(p) };
1790        let isl_rs_result = Printer { ptr: isl_rs_result,
1791                                      should_free_on_drop: true };
1792        let err = isl_rs_ctx.last_error();
1793        if err != Error::None_ {
1794            let err_msg = isl_rs_ctx.last_error_msg();
1795            isl_rs_ctx.reset_error();
1796            return Err(LibISLError::new(err, err_msg));
1797        }
1798        Ok(isl_rs_result)
1799    }
1800
1801    /// Wraps `isl_printer_yaml_end_sequence`.
1802    pub fn yaml_end_sequence(self) -> Result<Printer, LibISLError> {
1803        let p = self;
1804        let isl_rs_ctx = p.get_ctx();
1805        let mut p = p;
1806        p.do_not_free_on_drop();
1807        let p = p.ptr;
1808        let isl_rs_result = unsafe { isl_printer_yaml_end_sequence(p) };
1809        let isl_rs_result = Printer { ptr: isl_rs_result,
1810                                      should_free_on_drop: true };
1811        let err = isl_rs_ctx.last_error();
1812        if err != Error::None_ {
1813            let err_msg = isl_rs_ctx.last_error_msg();
1814            isl_rs_ctx.reset_error();
1815            return Err(LibISLError::new(err, err_msg));
1816        }
1817        Ok(isl_rs_result)
1818    }
1819
1820    /// Wraps `isl_printer_yaml_next`.
1821    pub fn yaml_next(self) -> Result<Printer, LibISLError> {
1822        let p = self;
1823        let isl_rs_ctx = p.get_ctx();
1824        let mut p = p;
1825        p.do_not_free_on_drop();
1826        let p = p.ptr;
1827        let isl_rs_result = unsafe { isl_printer_yaml_next(p) };
1828        let isl_rs_result = Printer { ptr: isl_rs_result,
1829                                      should_free_on_drop: true };
1830        let err = isl_rs_ctx.last_error();
1831        if err != Error::None_ {
1832            let err_msg = isl_rs_ctx.last_error_msg();
1833            isl_rs_ctx.reset_error();
1834            return Err(LibISLError::new(err, err_msg));
1835        }
1836        Ok(isl_rs_result)
1837    }
1838
1839    /// Wraps `isl_printer_yaml_start_mapping`.
1840    pub fn yaml_start_mapping(self) -> Result<Printer, LibISLError> {
1841        let p = self;
1842        let isl_rs_ctx = p.get_ctx();
1843        let mut p = p;
1844        p.do_not_free_on_drop();
1845        let p = p.ptr;
1846        let isl_rs_result = unsafe { isl_printer_yaml_start_mapping(p) };
1847        let isl_rs_result = Printer { ptr: isl_rs_result,
1848                                      should_free_on_drop: true };
1849        let err = isl_rs_ctx.last_error();
1850        if err != Error::None_ {
1851            let err_msg = isl_rs_ctx.last_error_msg();
1852            isl_rs_ctx.reset_error();
1853            return Err(LibISLError::new(err, err_msg));
1854        }
1855        Ok(isl_rs_result)
1856    }
1857
1858    /// Wraps `isl_printer_yaml_start_sequence`.
1859    pub fn yaml_start_sequence(self) -> Result<Printer, LibISLError> {
1860        let p = self;
1861        let isl_rs_ctx = p.get_ctx();
1862        let mut p = p;
1863        p.do_not_free_on_drop();
1864        let p = p.ptr;
1865        let isl_rs_result = unsafe { isl_printer_yaml_start_sequence(p) };
1866        let isl_rs_result = Printer { ptr: isl_rs_result,
1867                                      should_free_on_drop: true };
1868        let err = isl_rs_ctx.last_error();
1869        if err != Error::None_ {
1870            let err_msg = isl_rs_ctx.last_error_msg();
1871            isl_rs_ctx.reset_error();
1872            return Err(LibISLError::new(err, err_msg));
1873        }
1874        Ok(isl_rs_result)
1875    }
1876
1877    /// Does not call isl_printer_free() on being dropped. (For internal use
1878    /// only.)
1879    pub fn do_not_free_on_drop(&mut self) {
1880        self.should_free_on_drop = false;
1881    }
1882}
1883
1884impl Drop for Printer {
1885    fn drop(&mut self) {
1886        if self.should_free_on_drop {
1887            unsafe {
1888                isl_printer_free(self.ptr);
1889            }
1890        }
1891    }
1892}
isl_rs/bindings/printer.rs

isl_rs/bindings/
printer.rs
