isl-rs 0.3.1

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

use super::{
    Context, DimType, Error, Fold, Id, LibISLError, Point, PwQPolynomial, PwQPolynomialFoldList,
    QPolynomialFold, Set, Space, UnionPwQPolynomialFold, Val,
};
use libc::uintptr_t;
use std::ffi::CString;
use std::os::raw::c_char;

/// Wraps `isl_pw_qpolynomial_fold`.
pub struct PwQPolynomialFold {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_pw_qpolynomial_fold_add(pwf1: uintptr_t, pwf2: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_add_disjoint(pwf1: uintptr_t, pwf2: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_alloc(type_: i32, set: uintptr_t, fold: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_as_qpolynomial_fold(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_coalesce(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_copy(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_dim(pwf: uintptr_t, type_: i32) -> i32;

    fn isl_pw_qpolynomial_fold_domain(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_drop_dims(pwf: uintptr_t, type_: i32, first: u32, n: u32)
                                         -> uintptr_t;

    fn isl_pw_qpolynomial_fold_drop_unused_params(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_dump(pwf: uintptr_t) -> ();

    fn isl_pw_qpolynomial_fold_eval(pwf: uintptr_t, pnt: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_find_dim_by_name(pwf: uintptr_t, type_: i32, name: *const c_char)
                                                -> i32;

    fn isl_pw_qpolynomial_fold_fix_val(pwf: uintptr_t, type_: i32, n: u32, v: uintptr_t)
                                       -> uintptr_t;

    fn isl_pw_qpolynomial_fold_fold(pwf1: uintptr_t, pwf2: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_free(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_from_pw_qpolynomial(type_: i32, pwqp: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_from_qpolynomial_fold(fold: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_from_range(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_get_ctx(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_get_domain_space(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_get_space(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_get_type(pwf: uintptr_t) -> i32;

    fn isl_pw_qpolynomial_fold_gist(pwf: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_gist_params(pwf: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_has_equal_space(pwf1: uintptr_t, pwf2: uintptr_t) -> i32;

    fn isl_pw_qpolynomial_fold_intersect_domain(pwf: uintptr_t, set: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(pwf: uintptr_t, set: uintptr_t)
                                                               -> uintptr_t;

    fn isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(pwf: uintptr_t, set: uintptr_t)
                                                              -> uintptr_t;

    fn isl_pw_qpolynomial_fold_intersect_params(pwf: uintptr_t, set: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_involves_nan(pwf: uintptr_t) -> i32;

    fn isl_pw_qpolynomial_fold_involves_param_id(pwf: uintptr_t, id: uintptr_t) -> i32;

    fn isl_pw_qpolynomial_fold_is_zero(pwf: uintptr_t) -> i32;

    fn isl_pw_qpolynomial_fold_isa_qpolynomial_fold(pwf: uintptr_t) -> i32;

    fn isl_pw_qpolynomial_fold_max(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_min(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_move_dims(pwf: uintptr_t, dst_type: i32, dst_pos: u32,
                                         src_type: i32, src_pos: u32, n: u32)
                                         -> uintptr_t;

    fn isl_pw_qpolynomial_fold_n_piece(pwf: uintptr_t) -> i32;

    fn isl_pw_qpolynomial_fold_plain_is_equal(pwf1: uintptr_t, pwf2: uintptr_t) -> i32;

    fn isl_pw_qpolynomial_fold_project_domain_on_params(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_read_from_str(ctx: uintptr_t, str_: *const c_char) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_reset_space(pwf: uintptr_t, space: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_reset_user(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_scale_down_val(pwf: uintptr_t, v: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_scale_val(pwf: uintptr_t, v: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_set_dim_name(pwf: uintptr_t, type_: i32, pos: u32, s: *const c_char)
                                            -> uintptr_t;

    fn isl_pw_qpolynomial_fold_size(pwf: uintptr_t) -> usize;

    fn isl_pw_qpolynomial_fold_subtract_domain(pwf: uintptr_t, set: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_to_list(el: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(pwf: uintptr_t) -> uintptr_t;

    fn isl_pw_qpolynomial_fold_zero(space: uintptr_t, type_: i32) -> uintptr_t;

}

impl PwQPolynomialFold {
    /// Wraps `isl_pw_qpolynomial_fold_add`.
    pub fn add(self, pwf2: PwQPolynomialFold) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf1 = self;
        let isl_rs_ctx = pwf1.get_ctx();
        let mut pwf1 = pwf1;
        pwf1.do_not_free_on_drop();
        let pwf1 = pwf1.ptr;
        let mut pwf2 = pwf2;
        pwf2.do_not_free_on_drop();
        let pwf2 = pwf2.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_add(pwf1, pwf2) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_add_disjoint`.
    pub fn add_disjoint(self, pwf2: PwQPolynomialFold) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf1 = self;
        let isl_rs_ctx = pwf1.get_ctx();
        let mut pwf1 = pwf1;
        pwf1.do_not_free_on_drop();
        let pwf1 = pwf1.ptr;
        let mut pwf2 = pwf2;
        pwf2.do_not_free_on_drop();
        let pwf2 = pwf2.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_add_disjoint(pwf1, pwf2) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_alloc`.
    pub fn alloc(type_: Fold, set: Set, fold: QPolynomialFold)
                 -> Result<PwQPolynomialFold, LibISLError> {
        let isl_rs_ctx = set.get_ctx();
        let type_ = type_.to_i32();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut fold = fold;
        fold.do_not_free_on_drop();
        let fold = fold.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_alloc(type_, set, fold) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_as_qpolynomial_fold`.
    pub fn as_qpolynomial_fold(self) -> Result<QPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_as_qpolynomial_fold(pwf) };
        let isl_rs_result = QPolynomialFold { 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_pw_qpolynomial_fold_coalesce`.
    pub fn coalesce(self) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_coalesce(pwf) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_copy`.
    pub fn copy(&self) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_copy(pwf) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_dim`.
    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_dim(pwf, type_) };
        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_pw_qpolynomial_fold_domain`.
    pub fn domain(self) -> Result<Set, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_domain(pwf) };
        let isl_rs_result = Set { 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_pw_qpolynomial_fold_drop_dims`.
    pub fn drop_dims(self, type_: DimType, first: u32, n: u32)
                     -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_drop_dims(pwf, type_, first, n) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_drop_unused_params`.
    pub fn drop_unused_params(self) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_drop_unused_params(pwf) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_dump`.
    pub fn dump(&self) -> Result<(), LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_dump(pwf) };
        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_pw_qpolynomial_fold_eval`.
    pub fn eval(self, pnt: Point) -> Result<Val, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut pnt = pnt;
        pnt.do_not_free_on_drop();
        let pnt = pnt.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_eval(pwf, pnt) };
        let isl_rs_result = Val { 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_pw_qpolynomial_fold_find_dim_by_name`.
    pub fn find_dim_by_name(&self, type_: DimType, name: &str) -> Result<i32, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let type_ = type_.to_i32();
        let name = CString::new(name).unwrap();
        let name = name.as_ptr();
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_find_dim_by_name(pwf, type_, name) };
        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_pw_qpolynomial_fold_fix_val`.
    pub fn fix_val(self, type_: DimType, n: u32, v: Val) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let type_ = type_.to_i32();
        let mut v = v;
        v.do_not_free_on_drop();
        let v = v.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_fix_val(pwf, type_, n, v) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_fold`.
    pub fn fold(self, pwf2: PwQPolynomialFold) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf1 = self;
        let isl_rs_ctx = pwf1.get_ctx();
        let mut pwf1 = pwf1;
        pwf1.do_not_free_on_drop();
        let pwf1 = pwf1.ptr;
        let mut pwf2 = pwf2;
        pwf2.do_not_free_on_drop();
        let pwf2 = pwf2.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_fold(pwf1, pwf2) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_free`.
    pub fn free(self) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_free(pwf) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_from_pw_qpolynomial`.
    pub fn from_pw_qpolynomial(type_: Fold, pwqp: PwQPolynomial)
                               -> Result<PwQPolynomialFold, LibISLError> {
        let isl_rs_ctx = pwqp.get_ctx();
        let type_ = type_.to_i32();
        let mut pwqp = pwqp;
        pwqp.do_not_free_on_drop();
        let pwqp = pwqp.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_from_pw_qpolynomial(type_, pwqp) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_from_qpolynomial_fold`.
    pub fn from_qpolynomial_fold(fold: QPolynomialFold) -> Result<PwQPolynomialFold, LibISLError> {
        let isl_rs_ctx = fold.get_ctx();
        let mut fold = fold;
        fold.do_not_free_on_drop();
        let fold = fold.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_from_qpolynomial_fold(fold) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_from_range`.
    pub fn from_range(self) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_from_range(pwf) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let pwf = self;
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_get_ctx(pwf) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

    /// Wraps `isl_pw_qpolynomial_fold_get_domain_space`.
    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_get_domain_space(pwf) };
        let isl_rs_result = Space { 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_pw_qpolynomial_fold_get_space`.
    pub fn get_space(&self) -> Result<Space, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_get_space(pwf) };
        let isl_rs_result = Space { 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_pw_qpolynomial_fold_get_type`.
    pub fn get_type(&self) -> Result<Fold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_get_type(pwf) };
        let isl_rs_result = Fold::from_i32(isl_rs_result);
        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_pw_qpolynomial_fold_gist`.
    pub fn gist(self, context: Set) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_gist(pwf, context) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_gist_params`.
    pub fn gist_params(self, context: Set) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_gist_params(pwf, context) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_has_equal_space`.
    pub fn has_equal_space(&self, pwf2: &PwQPolynomialFold) -> Result<bool, LibISLError> {
        let pwf1 = self;
        let isl_rs_ctx = pwf1.get_ctx();
        let pwf1 = pwf1.ptr;
        let pwf2 = pwf2.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_has_equal_space(pwf1, pwf2) };
        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_pw_qpolynomial_fold_intersect_domain`.
    pub fn intersect_domain(self, set: Set) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_intersect_domain(pwf, set) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_intersect_domain_wrapped_domain`.
    pub fn intersect_domain_wrapped_domain(self, set: Set)
                                           -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result =
            unsafe { isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(pwf, set) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_intersect_domain_wrapped_range`.
    pub fn intersect_domain_wrapped_range(self, set: Set)
                                          -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result =
            unsafe { isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(pwf, set) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_intersect_params`.
    pub fn intersect_params(self, set: Set) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_intersect_params(pwf, set) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_involves_nan`.
    pub fn involves_nan(&self) -> Result<bool, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_involves_nan(pwf) };
        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_pw_qpolynomial_fold_involves_param_id`.
    pub fn involves_param_id(&self, id: &Id) -> Result<bool, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_involves_param_id(pwf, 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_pw_qpolynomial_fold_is_zero`.
    pub fn is_zero(&self) -> Result<bool, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_is_zero(pwf) };
        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_pw_qpolynomial_fold_isa_qpolynomial_fold`.
    pub fn isa_qpolynomial_fold(&self) -> Result<bool, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_isa_qpolynomial_fold(pwf) };
        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_pw_qpolynomial_fold_max`.
    pub fn max(self) -> Result<Val, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_max(pwf) };
        let isl_rs_result = Val { 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_pw_qpolynomial_fold_min`.
    pub fn min(self) -> Result<Val, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_min(pwf) };
        let isl_rs_result = Val { 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_pw_qpolynomial_fold_move_dims`.
    pub fn move_dims(self, dst_type: DimType, dst_pos: u32, src_type: DimType, src_pos: u32,
                     n: u32)
                     -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let dst_type = dst_type.to_i32();
        let src_type = src_type.to_i32();
        let isl_rs_result = unsafe {
            isl_pw_qpolynomial_fold_move_dims(pwf, dst_type, dst_pos, src_type, src_pos, n)
        };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_n_piece`.
    pub fn n_piece(&self) -> Result<i32, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_n_piece(pwf) };
        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_pw_qpolynomial_fold_plain_is_equal`.
    pub fn plain_is_equal(&self, pwf2: &PwQPolynomialFold) -> Result<bool, LibISLError> {
        let pwf1 = self;
        let isl_rs_ctx = pwf1.get_ctx();
        let pwf1 = pwf1.ptr;
        let pwf2 = pwf2.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_plain_is_equal(pwf1, pwf2) };
        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_pw_qpolynomial_fold_project_domain_on_params`.
    pub fn project_domain_on_params(self) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_project_domain_on_params(pwf) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_read_from_str`.
    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<PwQPolynomialFold, LibISLError> {
        let isl_rs_ctx = Context { ptr: ctx.ptr,
                                   should_free_on_drop: false };
        let ctx = ctx.ptr;
        let str_ = CString::new(str_).unwrap();
        let str_ = str_.as_ptr();
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_read_from_str(ctx, str_) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_reset_space`.
    pub fn reset_space(self, space: Space) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_reset_space(pwf, space) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_reset_user`.
    pub fn reset_user(self) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_reset_user(pwf) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_scale_down_val`.
    pub fn scale_down_val(self, v: Val) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut v = v;
        v.do_not_free_on_drop();
        let v = v.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_scale_down_val(pwf, v) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_scale_val`.
    pub fn scale_val(self, v: Val) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut v = v;
        v.do_not_free_on_drop();
        let v = v.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_scale_val(pwf, v) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_set_dim_name`.
    pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str)
                        -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let type_ = type_.to_i32();
        let s = CString::new(s).unwrap();
        let s = s.as_ptr();
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_set_dim_name(pwf, type_, pos, s) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_size`.
    pub fn size(&self) -> Result<usize, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_size(pwf) };
        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_pw_qpolynomial_fold_subtract_domain`.
    pub fn subtract_domain(self, set: Set) -> Result<PwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_subtract_domain(pwf, set) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_to_list`.
    pub fn to_list(self) -> Result<PwQPolynomialFoldList, LibISLError> {
        let el = self;
        let isl_rs_ctx = el.get_ctx();
        let mut el = el;
        el.do_not_free_on_drop();
        let el = el.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_to_list(el) };
        let isl_rs_result = PwQPolynomialFoldList { 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_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold`.
    pub fn to_union_pw_qpolynomial_fold(self) -> Result<UnionPwQPolynomialFold, LibISLError> {
        let pwf = self;
        let isl_rs_ctx = pwf.get_ctx();
        let mut pwf = pwf;
        pwf.do_not_free_on_drop();
        let pwf = pwf.ptr;
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(pwf) };
        let isl_rs_result = UnionPwQPolynomialFold { 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_pw_qpolynomial_fold_zero`.
    pub fn zero(space: Space, type_: Fold) -> Result<PwQPolynomialFold, LibISLError> {
        let isl_rs_ctx = space.get_ctx();
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_pw_qpolynomial_fold_zero(space, type_) };
        let isl_rs_result = PwQPolynomialFold { 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_pw_qpolynomial_fold_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 PwQPolynomialFold {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_pw_qpolynomial_fold_free(self.ptr);
            }
        }
    }
}