isl-rs 0.3.1

// Automatically generated by isl_bindings_generator.
// LICENSE: MIT

use super::{
    ASTExpr, ASTExprList, ASTNode, ASTNodeList, Aff, AffList, BasicMap, BasicMapList, BasicSet,
    BasicSetList, Constraint, ConstraintList, Context, Error, FixedBox, Id, IdList, IdToASTExpr,
    LibISLError, LocalSpace, Map, MapList, MultiAff, MultiId, MultiPwAff, MultiUnionPwAff,
    MultiVal, Point, PwAff, PwAffList, PwMultiAff, PwMultiAffList, PwQPolynomial,
    PwQPolynomialFold, PwQPolynomialFoldList, PwQPolynomialList, QPolynomial, QPolynomialFold,
    QPolynomialList, Schedule, ScheduleConstraints, ScheduleNode, Set, SetList, Space,
    UnionAccessInfo, UnionFlow, UnionMap, UnionMapList, UnionPwAff, UnionPwAffList,
    UnionPwMultiAff, UnionPwMultiAffList, UnionPwQPolynomial, UnionPwQPolynomialFold, UnionSet,
    UnionSetList, Val, ValList, Vec,
};
use libc::uintptr_t;
use std::ffi::{CStr, CString};
use std::os::raw::c_char;

/// Wraps `isl_printer`.
pub struct Printer {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_printer_end_line(p: uintptr_t) -> uintptr_t;

    fn isl_printer_flush(p: uintptr_t) -> uintptr_t;

    fn isl_printer_free(printer: uintptr_t) -> uintptr_t;

    fn isl_printer_get_ctx(printer: uintptr_t) -> uintptr_t;

    fn isl_printer_get_note(p: uintptr_t, id: uintptr_t) -> uintptr_t;

    fn isl_printer_get_output_format(p: uintptr_t) -> i32;

    fn isl_printer_get_str(printer: uintptr_t) -> *const c_char;

    fn isl_printer_get_yaml_style(p: uintptr_t) -> i32;

    fn isl_printer_has_note(p: uintptr_t, id: uintptr_t) -> i32;

    fn isl_printer_indent(p: uintptr_t, indent: i32) -> uintptr_t;

    fn isl_printer_print_aff(p: uintptr_t, aff: uintptr_t) -> uintptr_t;

    fn isl_printer_print_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_ast_expr(p: uintptr_t, expr: uintptr_t) -> uintptr_t;

    fn isl_printer_print_ast_expr_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_ast_node(p: uintptr_t, node: uintptr_t) -> uintptr_t;

    fn isl_printer_print_ast_node_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_basic_map(printer: uintptr_t, bmap: uintptr_t) -> uintptr_t;

    fn isl_printer_print_basic_map_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_basic_set(printer: uintptr_t, bset: uintptr_t) -> uintptr_t;

    fn isl_printer_print_basic_set_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_constraint(p: uintptr_t, c: uintptr_t) -> uintptr_t;

    fn isl_printer_print_constraint_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_double(p: uintptr_t, d: f64) -> uintptr_t;

    fn isl_printer_print_fixed_box(p: uintptr_t, box_: uintptr_t) -> uintptr_t;

    fn isl_printer_print_id(p: uintptr_t, id: uintptr_t) -> uintptr_t;

    fn isl_printer_print_id_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_id_to_ast_expr(p: uintptr_t, hmap: uintptr_t) -> uintptr_t;

    fn isl_printer_print_int(p: uintptr_t, i: i32) -> uintptr_t;

    fn isl_printer_print_local_space(p: uintptr_t, ls: uintptr_t) -> uintptr_t;

    fn isl_printer_print_map(printer: uintptr_t, map: uintptr_t) -> uintptr_t;

    fn isl_printer_print_map_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_multi_aff(p: uintptr_t, maff: uintptr_t) -> uintptr_t;

    fn isl_printer_print_multi_id(p: uintptr_t, mi: uintptr_t) -> uintptr_t;

    fn isl_printer_print_multi_pw_aff(p: uintptr_t, mpa: uintptr_t) -> uintptr_t;

    fn isl_printer_print_multi_union_pw_aff(p: uintptr_t, mupa: uintptr_t) -> uintptr_t;

    fn isl_printer_print_multi_val(p: uintptr_t, mv: uintptr_t) -> uintptr_t;

    fn isl_printer_print_point(printer: uintptr_t, pnt: uintptr_t) -> uintptr_t;

    fn isl_printer_print_pw_aff(p: uintptr_t, pwaff: uintptr_t) -> uintptr_t;

    fn isl_printer_print_pw_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_pw_multi_aff(p: uintptr_t, pma: uintptr_t) -> uintptr_t;

    fn isl_printer_print_pw_multi_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_pw_qpolynomial(p: uintptr_t, pwqp: uintptr_t) -> uintptr_t;

    fn isl_printer_print_pw_qpolynomial_fold(p: uintptr_t, pwf: uintptr_t) -> uintptr_t;

    fn isl_printer_print_pw_qpolynomial_fold_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_pw_qpolynomial_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_qpolynomial(p: uintptr_t, qp: uintptr_t) -> uintptr_t;

    fn isl_printer_print_qpolynomial_fold(p: uintptr_t, fold: uintptr_t) -> uintptr_t;

    fn isl_printer_print_qpolynomial_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_schedule(p: uintptr_t, schedule: uintptr_t) -> uintptr_t;

    fn isl_printer_print_schedule_constraints(p: uintptr_t, sc: uintptr_t) -> uintptr_t;

    fn isl_printer_print_schedule_node(p: uintptr_t, node: uintptr_t) -> uintptr_t;

    fn isl_printer_print_set(printer: uintptr_t, map: uintptr_t) -> uintptr_t;

    fn isl_printer_print_set_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_space(p: uintptr_t, space: uintptr_t) -> uintptr_t;

    fn isl_printer_print_str(p: uintptr_t, s: *const c_char) -> uintptr_t;

    fn isl_printer_print_union_access_info(p: uintptr_t, access: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_flow(p: uintptr_t, flow: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_map(p: uintptr_t, umap: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_map_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_pw_aff(p: uintptr_t, upa: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_pw_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_pw_multi_aff(p: uintptr_t, upma: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_pw_multi_aff_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_pw_qpolynomial(p: uintptr_t, upwqp: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_pw_qpolynomial_fold(p: uintptr_t, upwf: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_set(p: uintptr_t, uset: uintptr_t) -> uintptr_t;

    fn isl_printer_print_union_set_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_val(p: uintptr_t, v: uintptr_t) -> uintptr_t;

    fn isl_printer_print_val_list(p: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_printer_print_vec(printer: uintptr_t, vec: uintptr_t) -> uintptr_t;

    fn isl_printer_set_indent(p: uintptr_t, indent: i32) -> uintptr_t;

    fn isl_printer_set_indent_prefix(p: uintptr_t, prefix: *const c_char) -> uintptr_t;

    fn isl_printer_set_isl_int_width(p: uintptr_t, width: i32) -> uintptr_t;

    fn isl_printer_set_note(p: uintptr_t, id: uintptr_t, note: uintptr_t) -> uintptr_t;

    fn isl_printer_set_output_format(p: uintptr_t, output_format: i32) -> uintptr_t;

    fn isl_printer_set_prefix(p: uintptr_t, prefix: *const c_char) -> uintptr_t;

    fn isl_printer_set_suffix(p: uintptr_t, suffix: *const c_char) -> uintptr_t;

    fn isl_printer_set_yaml_style(p: uintptr_t, yaml_style: i32) -> uintptr_t;

    fn isl_printer_start_line(p: uintptr_t) -> uintptr_t;

    fn isl_printer_to_str(ctx: uintptr_t) -> uintptr_t;

    fn isl_printer_yaml_end_mapping(p: uintptr_t) -> uintptr_t;

    fn isl_printer_yaml_end_sequence(p: uintptr_t) -> uintptr_t;

    fn isl_printer_yaml_next(p: uintptr_t) -> uintptr_t;

    fn isl_printer_yaml_start_mapping(p: uintptr_t) -> uintptr_t;

    fn isl_printer_yaml_start_sequence(p: uintptr_t) -> uintptr_t;

}

impl Printer {
    /// Wraps `isl_printer_end_line`.
    pub fn end_line(self) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_end_line(p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_flush`.
    pub fn flush(self) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_flush(p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_free`.
    pub fn free(self) -> Result<Printer, LibISLError> {
        let printer = self;
        let isl_rs_ctx = printer.get_ctx();
        let mut printer = printer;
        printer.do_not_free_on_drop();
        let printer = printer.ptr;
        let isl_rs_result = unsafe { isl_printer_free(printer) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let printer = self;
        let printer = printer.ptr;
        let isl_rs_result = unsafe { isl_printer_get_ctx(printer) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

    /// Wraps `isl_printer_get_note`.
    pub fn get_note(&self, id: Id) -> Result<Id, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let p = p.ptr;
        let mut id = id;
        id.do_not_free_on_drop();
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_printer_get_note(p, id) };
        let isl_rs_result = Id { ptr: isl_rs_result,
                                 should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_get_output_format`.
    pub fn get_output_format(&self) -> Result<i32, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_get_output_format(p) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_get_str`.
    pub fn get_str(&self) -> Result<&str, LibISLError> {
        let printer = self;
        let isl_rs_ctx = printer.get_ctx();
        let printer = printer.ptr;
        let isl_rs_result = unsafe { isl_printer_get_str(printer) };
        let isl_rs_result = unsafe { CStr::from_ptr(isl_rs_result) };
        let isl_rs_result = isl_rs_result.to_str().unwrap();
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_get_yaml_style`.
    pub fn get_yaml_style(&self) -> Result<i32, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_get_yaml_style(p) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_has_note`.
    pub fn has_note(&self, id: &Id) -> Result<bool, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let p = p.ptr;
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_printer_has_note(p, id) };
        let isl_rs_result = match isl_rs_result {
            0 => false,
            1 => true,
            _ => {
                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
            }
        };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_indent`.
    pub fn indent(self, indent: i32) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_indent(p, indent) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_aff`.
    pub fn print_aff(self, aff: &Aff) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let aff = aff.ptr;
        let isl_rs_result = unsafe { isl_printer_print_aff(p, aff) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_aff_list`.
    pub fn print_aff_list(self, list: &AffList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_aff_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_ast_expr`.
    pub fn print_ast_expr(self, expr: &ASTExpr) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let expr = expr.ptr;
        let isl_rs_result = unsafe { isl_printer_print_ast_expr(p, expr) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_ast_expr_list`.
    pub fn print_ast_expr_list(self, list: &ASTExprList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_ast_expr_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_ast_node`.
    pub fn print_ast_node(self, node: &ASTNode) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let node = node.ptr;
        let isl_rs_result = unsafe { isl_printer_print_ast_node(p, node) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_ast_node_list`.
    pub fn print_ast_node_list(self, list: &ASTNodeList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_ast_node_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_basic_map`.
    pub fn print_basic_map(self, bmap: &BasicMap) -> Result<Printer, LibISLError> {
        let printer = self;
        let isl_rs_ctx = printer.get_ctx();
        let mut printer = printer;
        printer.do_not_free_on_drop();
        let printer = printer.ptr;
        let bmap = bmap.ptr;
        let isl_rs_result = unsafe { isl_printer_print_basic_map(printer, bmap) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_basic_map_list`.
    pub fn print_basic_map_list(self, list: &BasicMapList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_basic_map_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_basic_set`.
    pub fn print_basic_set(self, bset: &BasicSet) -> Result<Printer, LibISLError> {
        let printer = self;
        let isl_rs_ctx = printer.get_ctx();
        let mut printer = printer;
        printer.do_not_free_on_drop();
        let printer = printer.ptr;
        let bset = bset.ptr;
        let isl_rs_result = unsafe { isl_printer_print_basic_set(printer, bset) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_basic_set_list`.
    pub fn print_basic_set_list(self, list: &BasicSetList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_basic_set_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_constraint`.
    pub fn print_constraint(self, c: &Constraint) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let c = c.ptr;
        let isl_rs_result = unsafe { isl_printer_print_constraint(p, c) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_constraint_list`.
    pub fn print_constraint_list(self, list: &ConstraintList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_constraint_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_double`.
    pub fn print_double(self, d: f64) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_print_double(p, d) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_fixed_box`.
    pub fn print_fixed_box(self, box_: &FixedBox) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let box_ = box_.ptr;
        let isl_rs_result = unsafe { isl_printer_print_fixed_box(p, box_) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_id`.
    pub fn print_id(self, id: &Id) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_printer_print_id(p, id) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_id_list`.
    pub fn print_id_list(self, list: &IdList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_id_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_id_to_ast_expr`.
    pub fn print_id_to_ast_expr(self, hmap: &IdToASTExpr) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let hmap = hmap.ptr;
        let isl_rs_result = unsafe { isl_printer_print_id_to_ast_expr(p, hmap) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_int`.
    pub fn print_int(self, i: i32) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_print_int(p, i) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_local_space`.
    pub fn print_local_space(self, ls: &LocalSpace) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let ls = ls.ptr;
        let isl_rs_result = unsafe { isl_printer_print_local_space(p, ls) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_map`.
    pub fn print_map(self, map: &Map) -> Result<Printer, LibISLError> {
        let printer = self;
        let isl_rs_ctx = printer.get_ctx();
        let mut printer = printer;
        printer.do_not_free_on_drop();
        let printer = printer.ptr;
        let map = map.ptr;
        let isl_rs_result = unsafe { isl_printer_print_map(printer, map) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_map_list`.
    pub fn print_map_list(self, list: &MapList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_map_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_multi_aff`.
    pub fn print_multi_aff(self, maff: &MultiAff) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let maff = maff.ptr;
        let isl_rs_result = unsafe { isl_printer_print_multi_aff(p, maff) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_multi_id`.
    pub fn print_multi_id(self, mi: &MultiId) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let mi = mi.ptr;
        let isl_rs_result = unsafe { isl_printer_print_multi_id(p, mi) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_multi_pw_aff`.
    pub fn print_multi_pw_aff(self, mpa: &MultiPwAff) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let mpa = mpa.ptr;
        let isl_rs_result = unsafe { isl_printer_print_multi_pw_aff(p, mpa) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_multi_union_pw_aff`.
    pub fn print_multi_union_pw_aff(self, mupa: &MultiUnionPwAff) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let mupa = mupa.ptr;
        let isl_rs_result = unsafe { isl_printer_print_multi_union_pw_aff(p, mupa) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_multi_val`.
    pub fn print_multi_val(self, mv: &MultiVal) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let mv = mv.ptr;
        let isl_rs_result = unsafe { isl_printer_print_multi_val(p, mv) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_point`.
    pub fn print_point(self, pnt: &Point) -> Result<Printer, LibISLError> {
        let printer = self;
        let isl_rs_ctx = printer.get_ctx();
        let mut printer = printer;
        printer.do_not_free_on_drop();
        let printer = printer.ptr;
        let pnt = pnt.ptr;
        let isl_rs_result = unsafe { isl_printer_print_point(printer, pnt) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_pw_aff`.
    pub fn print_pw_aff(self, pwaff: &PwAff) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let pwaff = pwaff.ptr;
        let isl_rs_result = unsafe { isl_printer_print_pw_aff(p, pwaff) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_pw_aff_list`.
    pub fn print_pw_aff_list(self, list: &PwAffList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_pw_aff_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_pw_multi_aff`.
    pub fn print_pw_multi_aff(self, pma: &PwMultiAff) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let pma = pma.ptr;
        let isl_rs_result = unsafe { isl_printer_print_pw_multi_aff(p, pma) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_pw_multi_aff_list`.
    pub fn print_pw_multi_aff_list(self, list: &PwMultiAffList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_pw_multi_aff_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_pw_qpolynomial`.
    pub fn print_pw_qpolynomial(self, pwqp: &PwQPolynomial) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let pwqp = pwqp.ptr;
        let isl_rs_result = unsafe { isl_printer_print_pw_qpolynomial(p, pwqp) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_pw_qpolynomial_fold`.
    pub fn print_pw_qpolynomial_fold(self, pwf: &PwQPolynomialFold)
                                     -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_printer_print_pw_qpolynomial_fold(p, pwf) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_pw_qpolynomial_fold_list`.
    pub fn print_pw_qpolynomial_fold_list(self, list: &PwQPolynomialFoldList)
                                          -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_pw_qpolynomial_fold_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_pw_qpolynomial_list`.
    pub fn print_pw_qpolynomial_list(self, list: &PwQPolynomialList)
                                     -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_pw_qpolynomial_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_qpolynomial`.
    pub fn print_qpolynomial(self, qp: &QPolynomial) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let qp = qp.ptr;
        let isl_rs_result = unsafe { isl_printer_print_qpolynomial(p, qp) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_qpolynomial_fold`.
    pub fn print_qpolynomial_fold(self, fold: &QPolynomialFold) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let fold = fold.ptr;
        let isl_rs_result = unsafe { isl_printer_print_qpolynomial_fold(p, fold) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_qpolynomial_list`.
    pub fn print_qpolynomial_list(self, list: &QPolynomialList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_qpolynomial_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_schedule`.
    pub fn print_schedule(self, schedule: &Schedule) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let schedule = schedule.ptr;
        let isl_rs_result = unsafe { isl_printer_print_schedule(p, schedule) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_schedule_constraints`.
    pub fn print_schedule_constraints(self, sc: &ScheduleConstraints)
                                      -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_printer_print_schedule_constraints(p, sc) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_schedule_node`.
    pub fn print_schedule_node(self, node: &ScheduleNode) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let node = node.ptr;
        let isl_rs_result = unsafe { isl_printer_print_schedule_node(p, node) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_set`.
    pub fn print_set(self, map: &Set) -> Result<Printer, LibISLError> {
        let printer = self;
        let isl_rs_ctx = printer.get_ctx();
        let mut printer = printer;
        printer.do_not_free_on_drop();
        let printer = printer.ptr;
        let map = map.ptr;
        let isl_rs_result = unsafe { isl_printer_print_set(printer, map) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_set_list`.
    pub fn print_set_list(self, list: &SetList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_set_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_space`.
    pub fn print_space(self, space: &Space) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_printer_print_space(p, space) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_str`.
    pub fn print_str(self, s: &str) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let s = CString::new(s).unwrap();
        let s = s.as_ptr();
        let isl_rs_result = unsafe { isl_printer_print_str(p, s) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_access_info`.
    pub fn print_union_access_info(self, access: &UnionAccessInfo) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let access = access.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_access_info(p, access) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_flow`.
    pub fn print_union_flow(self, flow: &UnionFlow) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let flow = flow.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_flow(p, flow) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_map`.
    pub fn print_union_map(self, umap: &UnionMap) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_map(p, umap) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_map_list`.
    pub fn print_union_map_list(self, list: &UnionMapList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_map_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_pw_aff`.
    pub fn print_union_pw_aff(self, upa: &UnionPwAff) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let upa = upa.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_pw_aff(p, upa) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_pw_aff_list`.
    pub fn print_union_pw_aff_list(self, list: &UnionPwAffList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_pw_aff_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_pw_multi_aff`.
    pub fn print_union_pw_multi_aff(self, upma: &UnionPwMultiAff) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let upma = upma.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_pw_multi_aff(p, upma) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_pw_multi_aff_list`.
    pub fn print_union_pw_multi_aff_list(self, list: &UnionPwMultiAffList)
                                         -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_pw_multi_aff_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_pw_qpolynomial`.
    pub fn print_union_pw_qpolynomial(self, upwqp: &UnionPwQPolynomial)
                                      -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let upwqp = upwqp.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_pw_qpolynomial(p, upwqp) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_pw_qpolynomial_fold`.
    pub fn print_union_pw_qpolynomial_fold(self, upwf: &UnionPwQPolynomialFold)
                                           -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let upwf = upwf.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_pw_qpolynomial_fold(p, upwf) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_set`.
    pub fn print_union_set(self, uset: &UnionSet) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_set(p, uset) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_union_set_list`.
    pub fn print_union_set_list(self, list: &UnionSetList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_union_set_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_val`.
    pub fn print_val(self, v: &Val) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let v = v.ptr;
        let isl_rs_result = unsafe { isl_printer_print_val(p, v) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_val_list`.
    pub fn print_val_list(self, list: &ValList) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_printer_print_val_list(p, list) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_print_vec`.
    pub fn print_vec(self, vec: &Vec) -> Result<Printer, LibISLError> {
        let printer = self;
        let isl_rs_ctx = printer.get_ctx();
        let mut printer = printer;
        printer.do_not_free_on_drop();
        let printer = printer.ptr;
        let vec = vec.ptr;
        let isl_rs_result = unsafe { isl_printer_print_vec(printer, vec) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_set_indent`.
    pub fn set_indent(self, indent: i32) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_set_indent(p, indent) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_set_indent_prefix`.
    pub fn set_indent_prefix(self, prefix: &str) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let prefix = CString::new(prefix).unwrap();
        let prefix = prefix.as_ptr();
        let isl_rs_result = unsafe { isl_printer_set_indent_prefix(p, prefix) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_set_isl_int_width`.
    pub fn set_isl_int_width(self, width: i32) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_set_isl_int_width(p, width) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_set_note`.
    pub fn set_note(self, id: Id, note: Id) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let mut id = id;
        id.do_not_free_on_drop();
        let id = id.ptr;
        let mut note = note;
        note.do_not_free_on_drop();
        let note = note.ptr;
        let isl_rs_result = unsafe { isl_printer_set_note(p, id, note) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_set_output_format`.
    pub fn set_output_format(self, output_format: i32) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_set_output_format(p, output_format) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_set_prefix`.
    pub fn set_prefix(self, prefix: &str) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let prefix = CString::new(prefix).unwrap();
        let prefix = prefix.as_ptr();
        let isl_rs_result = unsafe { isl_printer_set_prefix(p, prefix) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_set_suffix`.
    pub fn set_suffix(self, suffix: &str) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let suffix = CString::new(suffix).unwrap();
        let suffix = suffix.as_ptr();
        let isl_rs_result = unsafe { isl_printer_set_suffix(p, suffix) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_set_yaml_style`.
    pub fn set_yaml_style(self, yaml_style: i32) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_set_yaml_style(p, yaml_style) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_start_line`.
    pub fn start_line(self) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_start_line(p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_to_str`.
    pub fn to_str(ctx: &Context) -> Result<Printer, LibISLError> {
        let isl_rs_ctx = Context { ptr: ctx.ptr,
                                   should_free_on_drop: false };
        let ctx = ctx.ptr;
        let isl_rs_result = unsafe { isl_printer_to_str(ctx) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_yaml_end_mapping`.
    pub fn yaml_end_mapping(self) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_yaml_end_mapping(p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_yaml_end_sequence`.
    pub fn yaml_end_sequence(self) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_yaml_end_sequence(p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_yaml_next`.
    pub fn yaml_next(self) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_yaml_next(p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_yaml_start_mapping`.
    pub fn yaml_start_mapping(self) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_yaml_start_mapping(p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_printer_yaml_start_sequence`.
    pub fn yaml_start_sequence(self) -> Result<Printer, LibISLError> {
        let p = self;
        let isl_rs_ctx = p.get_ctx();
        let mut p = p;
        p.do_not_free_on_drop();
        let p = p.ptr;
        let isl_rs_result = unsafe { isl_printer_yaml_start_sequence(p) };
        let isl_rs_result = Printer { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Does not call isl_printer_free() on being dropped. (For internal use
    /// only.)
    pub fn do_not_free_on_drop(&mut self) {
        self.should_free_on_drop = false;
    }
}

impl Drop for Printer {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_printer_free(self.ptr);
            }
        }
    }
}