isl_rs/bindings/

set.rs

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

use super::{
    Aff, BasicSet, BasicSetList, Constraint, Context, DimType, Error, FixedBox, Id, IdList,
    LibISLError, Map, MultiAff, MultiId, MultiPwAff, MultiVal, Point, PwAff, PwMultiAff, SetList,
    Space, StrideInfo, UnionSet, Val,
};
use libc::uintptr_t;
use std::ffi::{CStr, CString};
use std::os::raw::c_char;

/// Wraps `isl_set`.
pub struct Set {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_set_add_constraint(set: uintptr_t, constraint: uintptr_t) -> uintptr_t;

    fn isl_set_add_dims(set: uintptr_t, type_: i32, n: u32) -> uintptr_t;

    fn isl_set_affine_hull(set: uintptr_t) -> uintptr_t;

    fn isl_set_align_divs(set: uintptr_t) -> uintptr_t;

    fn isl_set_align_params(set: uintptr_t, model: uintptr_t) -> uintptr_t;

    fn isl_set_apply(set: uintptr_t, map: uintptr_t) -> uintptr_t;

    fn isl_set_as_pw_multi_aff(set: uintptr_t) -> uintptr_t;

    fn isl_set_bind(set: uintptr_t, tuple: uintptr_t) -> uintptr_t;

    fn isl_set_bounded_simple_hull(set: uintptr_t) -> uintptr_t;

    fn isl_set_box_from_points(pnt1: uintptr_t, pnt2: uintptr_t) -> uintptr_t;

    fn isl_set_coalesce(set: uintptr_t) -> uintptr_t;

    fn isl_set_coefficients(set: uintptr_t) -> uintptr_t;

    fn isl_set_complement(set: uintptr_t) -> uintptr_t;

    fn isl_set_compute_divs(set: uintptr_t) -> uintptr_t;

    fn isl_set_convex_hull(set: uintptr_t) -> uintptr_t;

    fn isl_set_copy(set: uintptr_t) -> uintptr_t;

    fn isl_set_count_val(set: uintptr_t) -> uintptr_t;

    fn isl_set_detect_equalities(set: uintptr_t) -> uintptr_t;

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

    fn isl_set_dim_has_any_lower_bound(set: uintptr_t, type_: i32, pos: u32) -> i32;

    fn isl_set_dim_has_any_upper_bound(set: uintptr_t, type_: i32, pos: u32) -> i32;

    fn isl_set_dim_has_lower_bound(set: uintptr_t, type_: i32, pos: u32) -> i32;

    fn isl_set_dim_has_upper_bound(set: uintptr_t, type_: i32, pos: u32) -> i32;

    fn isl_set_dim_is_bounded(set: uintptr_t, type_: i32, pos: u32) -> i32;

    fn isl_set_dim_max(set: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_set_dim_max_val(set: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_set_dim_min(set: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_set_dim_min_val(set: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_set_drop_constraints_involving_dims(set: uintptr_t, type_: i32, first: u32, n: u32)
                                               -> uintptr_t;

    fn isl_set_drop_constraints_not_involving_dims(set: uintptr_t, type_: i32, first: u32, n: u32)
                                                   -> uintptr_t;

    fn isl_set_drop_unused_params(set: uintptr_t) -> uintptr_t;

    fn isl_set_dump(set: uintptr_t) -> ();

    fn isl_set_eliminate(set: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_set_eliminate_dims(set: uintptr_t, first: u32, n: u32) -> uintptr_t;

    fn isl_set_empty(space: uintptr_t) -> uintptr_t;

    fn isl_set_equate(set: uintptr_t, type1: i32, pos1: i32, type2: i32, pos2: i32) -> uintptr_t;

    fn isl_set_find_dim_by_id(set: uintptr_t, type_: i32, id: uintptr_t) -> i32;

    fn isl_set_find_dim_by_name(set: uintptr_t, type_: i32, name: *const c_char) -> i32;

    fn isl_set_fix_dim_si(set: uintptr_t, dim: u32, value: i32) -> uintptr_t;

    fn isl_set_fix_si(set: uintptr_t, type_: i32, pos: u32, value: i32) -> uintptr_t;

    fn isl_set_fix_val(set: uintptr_t, type_: i32, pos: u32, v: uintptr_t) -> uintptr_t;

    fn isl_set_flat_product(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_flatten(set: uintptr_t) -> uintptr_t;

    fn isl_set_flatten_map(set: uintptr_t) -> uintptr_t;

    fn isl_set_follows_at(set1: uintptr_t, set2: uintptr_t, pos: i32) -> i32;

    fn isl_set_free(set: uintptr_t) -> uintptr_t;

    fn isl_set_from_basic_set(bset: uintptr_t) -> uintptr_t;

    fn isl_set_from_multi_aff(ma: uintptr_t) -> uintptr_t;

    fn isl_set_from_multi_pw_aff(mpa: uintptr_t) -> uintptr_t;

    fn isl_set_from_params(set: uintptr_t) -> uintptr_t;

    fn isl_set_from_point(pnt: uintptr_t) -> uintptr_t;

    fn isl_set_from_pw_aff(pwaff: uintptr_t) -> uintptr_t;

    fn isl_set_from_pw_multi_aff(pma: uintptr_t) -> uintptr_t;

    fn isl_set_from_union_set(uset: uintptr_t) -> uintptr_t;

    fn isl_set_get_basic_set_list(set: uintptr_t) -> uintptr_t;

    fn isl_set_get_ctx(set: uintptr_t) -> uintptr_t;

    fn isl_set_get_dim_id(set: uintptr_t, type_: i32, pos: u32) -> uintptr_t;

    fn isl_set_get_dim_name(set: uintptr_t, type_: i32, pos: u32) -> *const c_char;

    fn isl_set_get_hash(set: uintptr_t) -> u32;

    fn isl_set_get_lattice_tile(set: uintptr_t) -> uintptr_t;

    fn isl_set_get_plain_multi_val_if_fixed(set: uintptr_t) -> uintptr_t;

    fn isl_set_get_simple_fixed_box_hull(set: uintptr_t) -> uintptr_t;

    fn isl_set_get_space(set: uintptr_t) -> uintptr_t;

    fn isl_set_get_stride(set: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_set_get_stride_info(set: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_set_get_tuple_id(set: uintptr_t) -> uintptr_t;

    fn isl_set_get_tuple_name(set: uintptr_t) -> *const c_char;

    fn isl_set_gist(set: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_set_gist_basic_set(set: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_set_gist_params(set: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_set_has_dim_id(set: uintptr_t, type_: i32, pos: u32) -> i32;

    fn isl_set_has_dim_name(set: uintptr_t, type_: i32, pos: u32) -> i32;

    fn isl_set_has_equal_space(set1: uintptr_t, set2: uintptr_t) -> i32;

    fn isl_set_has_tuple_id(set: uintptr_t) -> i32;

    fn isl_set_has_tuple_name(set: uintptr_t) -> i32;

    fn isl_set_identity(set: uintptr_t) -> uintptr_t;

    fn isl_set_indicator_function(set: uintptr_t) -> uintptr_t;

    fn isl_set_insert_dims(set: uintptr_t, type_: i32, pos: u32, n: u32) -> uintptr_t;

    fn isl_set_insert_domain(set: uintptr_t, domain: uintptr_t) -> uintptr_t;

    fn isl_set_intersect(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_intersect_factor_domain(set: uintptr_t, domain: uintptr_t) -> uintptr_t;

    fn isl_set_intersect_factor_range(set: uintptr_t, range: uintptr_t) -> uintptr_t;

    fn isl_set_intersect_params(set: uintptr_t, params: uintptr_t) -> uintptr_t;

    fn isl_set_involves_dims(set: uintptr_t, type_: i32, first: u32, n: u32) -> i32;

    fn isl_set_involves_locals(set: uintptr_t) -> i32;

    fn isl_set_is_bounded(set: uintptr_t) -> i32;

    fn isl_set_is_box(set: uintptr_t) -> i32;

    fn isl_set_is_disjoint(set1: uintptr_t, set2: uintptr_t) -> i32;

    fn isl_set_is_empty(set: uintptr_t) -> i32;

    fn isl_set_is_equal(set1: uintptr_t, set2: uintptr_t) -> i32;

    fn isl_set_is_params(set: uintptr_t) -> i32;

    fn isl_set_is_singleton(set: uintptr_t) -> i32;

    fn isl_set_is_strict_subset(set1: uintptr_t, set2: uintptr_t) -> i32;

    fn isl_set_is_subset(set1: uintptr_t, set2: uintptr_t) -> i32;

    fn isl_set_is_wrapping(set: uintptr_t) -> i32;

    fn isl_set_lex_ge_set(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_lex_gt_set(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_lex_le_set(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_lex_lt_set(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_lexmax(set: uintptr_t) -> uintptr_t;

    fn isl_set_lexmax_pw_multi_aff(set: uintptr_t) -> uintptr_t;

    fn isl_set_lexmin(set: uintptr_t) -> uintptr_t;

    fn isl_set_lexmin_pw_multi_aff(set: uintptr_t) -> uintptr_t;

    fn isl_set_lift(set: uintptr_t) -> uintptr_t;

    fn isl_set_lower_bound_multi_pw_aff(set: uintptr_t, lower: uintptr_t) -> uintptr_t;

    fn isl_set_lower_bound_multi_val(set: uintptr_t, lower: uintptr_t) -> uintptr_t;

    fn isl_set_lower_bound_si(set: uintptr_t, type_: i32, pos: u32, value: i32) -> uintptr_t;

    fn isl_set_lower_bound_val(set: uintptr_t, type_: i32, pos: u32, value: uintptr_t)
                               -> uintptr_t;

    fn isl_set_make_disjoint(set: uintptr_t) -> uintptr_t;

    fn isl_set_max_multi_pw_aff(set: uintptr_t) -> uintptr_t;

    fn isl_set_max_val(set: uintptr_t, obj: uintptr_t) -> uintptr_t;

    fn isl_set_min_multi_pw_aff(set: uintptr_t) -> uintptr_t;

    fn isl_set_min_val(set: uintptr_t, obj: uintptr_t) -> uintptr_t;

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

    fn isl_set_n_basic_set(set: uintptr_t) -> i32;

    fn isl_set_n_dim(set: uintptr_t) -> i32;

    fn isl_set_n_param(set: uintptr_t) -> i32;

    fn isl_set_nat_universe(space: uintptr_t) -> uintptr_t;

    fn isl_set_neg(set: uintptr_t) -> uintptr_t;

    fn isl_set_param_pw_aff_on_domain_id(domain: uintptr_t, id: uintptr_t) -> uintptr_t;

    fn isl_set_params(set: uintptr_t) -> uintptr_t;

    fn isl_set_plain_cmp(set1: uintptr_t, set2: uintptr_t) -> i32;

    fn isl_set_plain_get_val_if_fixed(set: uintptr_t, type_: i32, pos: u32) -> uintptr_t;

    fn isl_set_plain_is_disjoint(set1: uintptr_t, set2: uintptr_t) -> i32;

    fn isl_set_plain_is_empty(set: uintptr_t) -> i32;

    fn isl_set_plain_is_equal(set1: uintptr_t, set2: uintptr_t) -> i32;

    fn isl_set_plain_is_universe(set: uintptr_t) -> i32;

    fn isl_set_plain_unshifted_simple_hull(set: uintptr_t) -> uintptr_t;

    fn isl_set_polyhedral_hull(set: uintptr_t) -> uintptr_t;

    fn isl_set_preimage_multi_aff(set: uintptr_t, ma: uintptr_t) -> uintptr_t;

    fn isl_set_preimage_multi_pw_aff(set: uintptr_t, mpa: uintptr_t) -> uintptr_t;

    fn isl_set_preimage_pw_multi_aff(set: uintptr_t, pma: uintptr_t) -> uintptr_t;

    fn isl_set_product(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_project_onto_map(set: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_set_project_out(set: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_set_project_out_all_params(set: uintptr_t) -> uintptr_t;

    fn isl_set_project_out_param_id(set: uintptr_t, id: uintptr_t) -> uintptr_t;

    fn isl_set_project_out_param_id_list(set: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_set_pw_aff_on_domain_val(domain: uintptr_t, v: uintptr_t) -> uintptr_t;

    fn isl_set_pw_multi_aff_on_domain_multi_val(domain: uintptr_t, mv: uintptr_t) -> uintptr_t;

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

    fn isl_set_remove_dims(bset: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_set_remove_divs(set: uintptr_t) -> uintptr_t;

    fn isl_set_remove_divs_involving_dims(set: uintptr_t, type_: i32, first: u32, n: u32)
                                          -> uintptr_t;

    fn isl_set_remove_redundancies(set: uintptr_t) -> uintptr_t;

    fn isl_set_remove_unknown_divs(set: uintptr_t) -> uintptr_t;

    fn isl_set_reset_space(set: uintptr_t, space: uintptr_t) -> uintptr_t;

    fn isl_set_reset_tuple_id(set: uintptr_t) -> uintptr_t;

    fn isl_set_reset_user(set: uintptr_t) -> uintptr_t;

    fn isl_set_sample(set: uintptr_t) -> uintptr_t;

    fn isl_set_sample_point(set: uintptr_t) -> uintptr_t;

    fn isl_set_set_dim_id(set: uintptr_t, type_: i32, pos: u32, id: uintptr_t) -> uintptr_t;

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

    fn isl_set_set_tuple_id(set: uintptr_t, id: uintptr_t) -> uintptr_t;

    fn isl_set_set_tuple_name(set: uintptr_t, s: *const c_char) -> uintptr_t;

    fn isl_set_simple_hull(set: uintptr_t) -> uintptr_t;

    fn isl_set_size(set: uintptr_t) -> i32;

    fn isl_set_solutions(set: uintptr_t) -> uintptr_t;

    fn isl_set_split_dims(set: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_set_subtract(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_sum(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_to_list(el: uintptr_t) -> uintptr_t;

    fn isl_set_to_str(set: uintptr_t) -> *const c_char;

    fn isl_set_to_union_set(set: uintptr_t) -> uintptr_t;

    fn isl_set_translation(deltas: uintptr_t) -> uintptr_t;

    fn isl_set_tuple_dim(set: uintptr_t) -> i32;

    fn isl_set_unbind_params(set: uintptr_t, tuple: uintptr_t) -> uintptr_t;

    fn isl_set_unbind_params_insert_domain(set: uintptr_t, domain: uintptr_t) -> uintptr_t;

    fn isl_set_union(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_union_disjoint(set1: uintptr_t, set2: uintptr_t) -> uintptr_t;

    fn isl_set_universe(space: uintptr_t) -> uintptr_t;

    fn isl_set_unshifted_simple_hull(set: uintptr_t) -> uintptr_t;

    fn isl_set_unshifted_simple_hull_from_set_list(set: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_set_unwrap(set: uintptr_t) -> uintptr_t;

    fn isl_set_upper_bound_multi_pw_aff(set: uintptr_t, upper: uintptr_t) -> uintptr_t;

    fn isl_set_upper_bound_multi_val(set: uintptr_t, upper: uintptr_t) -> uintptr_t;

    fn isl_set_upper_bound_si(set: uintptr_t, type_: i32, pos: u32, value: i32) -> uintptr_t;

    fn isl_set_upper_bound_val(set: uintptr_t, type_: i32, pos: u32, value: uintptr_t)
                               -> uintptr_t;

    fn isl_set_wrapped_domain_map(set: uintptr_t) -> uintptr_t;

    fn isl_set_wrapped_reverse(set: uintptr_t) -> uintptr_t;

}

impl Set {
    /// Wraps `isl_set_add_constraint`.
    pub fn add_constraint(self, constraint: Constraint) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut constraint = constraint;
        constraint.do_not_free_on_drop();
        let constraint = constraint.ptr;
        let isl_rs_result = unsafe { isl_set_add_constraint(set, constraint) };
        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_set_add_dims`.
    pub fn add_dims(self, type_: DimType, n: u32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_add_dims(set, type_, n) };
        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_set_affine_hull`.
    pub fn affine_hull(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_affine_hull(set) };
        let isl_rs_result = BasicSet { 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_set_align_divs`.
    pub fn align_divs(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_align_divs(set) };
        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_set_align_params`.
    pub fn align_params(self, model: Space) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut model = model;
        model.do_not_free_on_drop();
        let model = model.ptr;
        let isl_rs_result = unsafe { isl_set_align_params(set, model) };
        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_set_apply`.
    pub fn apply(self, map: Map) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut map = map;
        map.do_not_free_on_drop();
        let map = map.ptr;
        let isl_rs_result = unsafe { isl_set_apply(set, map) };
        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_set_as_pw_multi_aff`.
    pub fn as_pw_multi_aff(self) -> Result<PwMultiAff, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_as_pw_multi_aff(set) };
        let isl_rs_result = PwMultiAff { 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_set_bind`.
    pub fn bind(self, tuple: MultiId) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut tuple = tuple;
        tuple.do_not_free_on_drop();
        let tuple = tuple.ptr;
        let isl_rs_result = unsafe { isl_set_bind(set, tuple) };
        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_set_bounded_simple_hull`.
    pub fn bounded_simple_hull(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_bounded_simple_hull(set) };
        let isl_rs_result = BasicSet { 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_set_box_from_points`.
    pub fn box_from_points(pnt1: Point, pnt2: Point) -> Result<Set, LibISLError> {
        let isl_rs_ctx = pnt1.get_ctx();
        let mut pnt1 = pnt1;
        pnt1.do_not_free_on_drop();
        let pnt1 = pnt1.ptr;
        let mut pnt2 = pnt2;
        pnt2.do_not_free_on_drop();
        let pnt2 = pnt2.ptr;
        let isl_rs_result = unsafe { isl_set_box_from_points(pnt1, pnt2) };
        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_set_coalesce`.
    pub fn coalesce(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_coalesce(set) };
        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_set_coefficients`.
    pub fn coefficients(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_coefficients(set) };
        let isl_rs_result = BasicSet { 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_set_complement`.
    pub fn complement(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_complement(set) };
        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_set_compute_divs`.
    pub fn compute_divs(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_compute_divs(set) };
        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_set_convex_hull`.
    pub fn convex_hull(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_convex_hull(set) };
        let isl_rs_result = BasicSet { 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_set_copy`.
    pub fn copy(&self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_copy(set) };
        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_set_count_val`.
    pub fn count_val(&self) -> Result<Val, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_count_val(set) };
        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_set_detect_equalities`.
    pub fn detect_equalities(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_detect_equalities(set) };
        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_set_dim`.
    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_dim(set, 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_set_dim_has_any_lower_bound`.
    pub fn dim_has_any_lower_bound(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_dim_has_any_lower_bound(set, type_, pos) };
        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_set_dim_has_any_upper_bound`.
    pub fn dim_has_any_upper_bound(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_dim_has_any_upper_bound(set, type_, pos) };
        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_set_dim_has_lower_bound`.
    pub fn dim_has_lower_bound(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_dim_has_lower_bound(set, type_, pos) };
        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_set_dim_has_upper_bound`.
    pub fn dim_has_upper_bound(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_dim_has_upper_bound(set, type_, pos) };
        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_set_dim_is_bounded`.
    pub fn dim_is_bounded(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_dim_is_bounded(set, type_, pos) };
        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_set_dim_max`.
    pub fn dim_max(self, pos: i32) -> Result<PwAff, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_dim_max(set, pos) };
        let isl_rs_result = PwAff { 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_set_dim_max_val`.
    pub fn dim_max_val(self, pos: i32) -> Result<Val, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_dim_max_val(set, pos) };
        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_set_dim_min`.
    pub fn dim_min(self, pos: i32) -> Result<PwAff, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_dim_min(set, pos) };
        let isl_rs_result = PwAff { 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_set_dim_min_val`.
    pub fn dim_min_val(self, pos: i32) -> Result<Val, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_dim_min_val(set, pos) };
        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_set_drop_constraints_involving_dims`.
    pub fn drop_constraints_involving_dims(self, type_: DimType, first: u32, n: u32)
                                           -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result =
            unsafe { isl_set_drop_constraints_involving_dims(set, type_, first, n) };
        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_set_drop_constraints_not_involving_dims`.
    pub fn drop_constraints_not_involving_dims(self, type_: DimType, first: u32, n: u32)
                                               -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result =
            unsafe { isl_set_drop_constraints_not_involving_dims(set, type_, first, n) };
        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_set_drop_unused_params`.
    pub fn drop_unused_params(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_drop_unused_params(set) };
        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_set_dump`.
    pub fn dump(&self) -> Result<(), LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_dump(set) };
        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_set_eliminate`.
    pub fn eliminate(self, type_: DimType, first: u32, n: u32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_eliminate(set, type_, first, n) };
        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_set_eliminate_dims`.
    pub fn eliminate_dims(self, first: u32, n: u32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_eliminate_dims(set, first, n) };
        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_set_empty`.
    pub fn empty(space: Space) -> Result<Set, LibISLError> {
        let isl_rs_ctx = space.get_ctx();
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_set_empty(space) };
        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_set_equate`.
    pub fn equate(self, type1: DimType, pos1: i32, type2: DimType, pos2: i32)
                  -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type1 = type1.to_i32();
        let type2 = type2.to_i32();
        let isl_rs_result = unsafe { isl_set_equate(set, type1, pos1, type2, pos2) };
        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_set_find_dim_by_id`.
    pub fn find_dim_by_id(&self, type_: DimType, id: &Id) -> Result<i32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_set_find_dim_by_id(set, type_, id) };
        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_set_find_dim_by_name`.
    pub fn find_dim_by_name(&self, type_: DimType, name: &str) -> Result<i32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let name = CString::new(name).unwrap();
        let name = name.as_ptr();
        let isl_rs_result = unsafe { isl_set_find_dim_by_name(set, 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_set_fix_dim_si`.
    pub fn fix_dim_si(self, dim: u32, value: i32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_fix_dim_si(set, dim, value) };
        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_set_fix_si`.
    pub fn fix_si(self, type_: DimType, pos: u32, value: i32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_fix_si(set, type_, pos, value) };
        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_set_fix_val`.
    pub fn fix_val(self, type_: DimType, pos: u32, v: Val) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.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_set_fix_val(set, type_, pos, v) };
        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_set_flat_product`.
    pub fn flat_product(self, set2: Set) -> Result<Set, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_flat_product(set1, set2) };
        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_set_flatten`.
    pub fn flatten(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_flatten(set) };
        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_set_flatten_map`.
    pub fn flatten_map(self) -> Result<Map, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_flatten_map(set) };
        let isl_rs_result = Map { 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_set_follows_at`.
    pub fn follows_at(&self, set2: &Set, pos: i32) -> Result<i32, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_follows_at(set1, set2, pos) };
        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_set_free`.
    pub fn free(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_free(set) };
        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_set_from_basic_set`.
    pub fn from_basic_set(bset: BasicSet) -> Result<Set, LibISLError> {
        let isl_rs_ctx = bset.get_ctx();
        let mut bset = bset;
        bset.do_not_free_on_drop();
        let bset = bset.ptr;
        let isl_rs_result = unsafe { isl_set_from_basic_set(bset) };
        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_set_from_multi_aff`.
    pub fn from_multi_aff(ma: MultiAff) -> Result<Set, LibISLError> {
        let isl_rs_ctx = ma.get_ctx();
        let mut ma = ma;
        ma.do_not_free_on_drop();
        let ma = ma.ptr;
        let isl_rs_result = unsafe { isl_set_from_multi_aff(ma) };
        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_set_from_multi_pw_aff`.
    pub fn from_multi_pw_aff(mpa: MultiPwAff) -> Result<Set, LibISLError> {
        let isl_rs_ctx = mpa.get_ctx();
        let mut mpa = mpa;
        mpa.do_not_free_on_drop();
        let mpa = mpa.ptr;
        let isl_rs_result = unsafe { isl_set_from_multi_pw_aff(mpa) };
        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_set_from_params`.
    pub fn from_params(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_from_params(set) };
        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_set_from_point`.
    pub fn from_point(pnt: Point) -> Result<Set, LibISLError> {
        let isl_rs_ctx = pnt.get_ctx();
        let mut pnt = pnt;
        pnt.do_not_free_on_drop();
        let pnt = pnt.ptr;
        let isl_rs_result = unsafe { isl_set_from_point(pnt) };
        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_set_from_pw_aff`.
    pub fn from_pw_aff(pwaff: PwAff) -> Result<Set, LibISLError> {
        let isl_rs_ctx = pwaff.get_ctx();
        let mut pwaff = pwaff;
        pwaff.do_not_free_on_drop();
        let pwaff = pwaff.ptr;
        let isl_rs_result = unsafe { isl_set_from_pw_aff(pwaff) };
        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_set_from_pw_multi_aff`.
    pub fn from_pw_multi_aff(pma: PwMultiAff) -> Result<Set, LibISLError> {
        let isl_rs_ctx = pma.get_ctx();
        let mut pma = pma;
        pma.do_not_free_on_drop();
        let pma = pma.ptr;
        let isl_rs_result = unsafe { isl_set_from_pw_multi_aff(pma) };
        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_set_from_union_set`.
    pub fn from_union_set(uset: UnionSet) -> Result<Set, LibISLError> {
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_set_from_union_set(uset) };
        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_set_get_basic_set_list`.
    pub fn get_basic_set_list(&self) -> Result<BasicSetList, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_basic_set_list(set) };
        let isl_rs_result = BasicSetList { 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_set_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let set = self;
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_ctx(set) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

    /// Wraps `isl_set_get_dim_id`.
    pub fn get_dim_id(&self, type_: DimType, pos: u32) -> Result<Id, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_get_dim_id(set, type_, pos) };
        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_set_get_dim_name`.
    pub fn get_dim_name(&self, type_: DimType, pos: u32) -> Result<&str, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_get_dim_name(set, type_, pos) };
        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_set_get_hash`.
    pub fn get_hash(&self) -> Result<u32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_hash(set) };
        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_set_get_lattice_tile`.
    pub fn get_lattice_tile(&self) -> Result<FixedBox, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_lattice_tile(set) };
        let isl_rs_result = FixedBox { 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_set_get_plain_multi_val_if_fixed`.
    pub fn get_plain_multi_val_if_fixed(&self) -> Result<MultiVal, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_plain_multi_val_if_fixed(set) };
        let isl_rs_result = MultiVal { 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_set_get_simple_fixed_box_hull`.
    pub fn get_simple_fixed_box_hull(&self) -> Result<FixedBox, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_simple_fixed_box_hull(set) };
        let isl_rs_result = FixedBox { 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_set_get_space`.
    pub fn get_space(&self) -> Result<Space, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_space(set) };
        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_set_get_stride`.
    pub fn get_stride(&self, pos: i32) -> Result<Val, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_stride(set, pos) };
        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_set_get_stride_info`.
    pub fn get_stride_info(&self, pos: i32) -> Result<StrideInfo, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_stride_info(set, pos) };
        let isl_rs_result = StrideInfo { 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_set_get_tuple_id`.
    pub fn get_tuple_id(&self) -> Result<Id, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_tuple_id(set) };
        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_set_get_tuple_name`.
    pub fn get_tuple_name(&self) -> Result<&str, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_get_tuple_name(set) };
        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_set_gist`.
    pub fn gist(self, context: Set) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_set_gist(set, context) };
        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_set_gist_basic_set`.
    pub fn gist_basic_set(self, context: BasicSet) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_set_gist_basic_set(set, context) };
        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_set_gist_params`.
    pub fn gist_params(self, context: Set) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_set_gist_params(set, context) };
        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_set_has_dim_id`.
    pub fn has_dim_id(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_has_dim_id(set, type_, pos) };
        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_set_has_dim_name`.
    pub fn has_dim_name(&self, type_: DimType, pos: u32) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_has_dim_name(set, type_, pos) };
        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_set_has_equal_space`.
    pub fn has_equal_space(&self, set2: &Set) -> Result<bool, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_has_equal_space(set1, set2) };
        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_set_has_tuple_id`.
    pub fn has_tuple_id(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_has_tuple_id(set) };
        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_set_has_tuple_name`.
    pub fn has_tuple_name(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_has_tuple_name(set) };
        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_set_identity`.
    pub fn identity(self) -> Result<Map, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_identity(set) };
        let isl_rs_result = Map { 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_set_indicator_function`.
    pub fn indicator_function(self) -> Result<PwAff, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_indicator_function(set) };
        let isl_rs_result = PwAff { 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_set_insert_dims`.
    pub fn insert_dims(self, type_: DimType, pos: u32, n: u32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_insert_dims(set, type_, pos, n) };
        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_set_insert_domain`.
    pub fn insert_domain(self, domain: Space) -> Result<Map, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_set_insert_domain(set, domain) };
        let isl_rs_result = Map { 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_set_intersect`.
    pub fn intersect(self, set2: Set) -> Result<Set, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_intersect(set1, set2) };
        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_set_intersect_factor_domain`.
    pub fn intersect_factor_domain(self, domain: Set) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_set_intersect_factor_domain(set, domain) };
        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_set_intersect_factor_range`.
    pub fn intersect_factor_range(self, range: Set) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut range = range;
        range.do_not_free_on_drop();
        let range = range.ptr;
        let isl_rs_result = unsafe { isl_set_intersect_factor_range(set, range) };
        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_set_intersect_params`.
    pub fn intersect_params(self, params: Set) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut params = params;
        params.do_not_free_on_drop();
        let params = params.ptr;
        let isl_rs_result = unsafe { isl_set_intersect_params(set, params) };
        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_set_involves_dims`.
    pub fn involves_dims(&self, type_: DimType, first: u32, n: u32) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_involves_dims(set, type_, first, n) };
        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_set_involves_locals`.
    pub fn involves_locals(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_involves_locals(set) };
        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_set_is_bounded`.
    pub fn is_bounded(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_is_bounded(set) };
        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_set_is_box`.
    pub fn is_box(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_is_box(set) };
        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_set_is_disjoint`.
    pub fn is_disjoint(&self, set2: &Set) -> Result<bool, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_is_disjoint(set1, set2) };
        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_set_is_empty`.
    pub fn is_empty(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_is_empty(set) };
        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_set_is_equal`.
    pub fn is_equal(&self, set2: &Set) -> Result<bool, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_is_equal(set1, set2) };
        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_set_is_params`.
    pub fn is_params(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_is_params(set) };
        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_set_is_singleton`.
    pub fn is_singleton(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_is_singleton(set) };
        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_set_is_strict_subset`.
    pub fn is_strict_subset(&self, set2: &Set) -> Result<bool, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_is_strict_subset(set1, set2) };
        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_set_is_subset`.
    pub fn is_subset(&self, set2: &Set) -> Result<bool, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_is_subset(set1, set2) };
        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_set_is_wrapping`.
    pub fn is_wrapping(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_is_wrapping(set) };
        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_set_lex_ge_set`.
    pub fn lex_ge_set(self, set2: Set) -> Result<Map, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_lex_ge_set(set1, set2) };
        let isl_rs_result = Map { 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_set_lex_gt_set`.
    pub fn lex_gt_set(self, set2: Set) -> Result<Map, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_lex_gt_set(set1, set2) };
        let isl_rs_result = Map { 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_set_lex_le_set`.
    pub fn lex_le_set(self, set2: Set) -> Result<Map, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_lex_le_set(set1, set2) };
        let isl_rs_result = Map { 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_set_lex_lt_set`.
    pub fn lex_lt_set(self, set2: Set) -> Result<Map, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_lex_lt_set(set1, set2) };
        let isl_rs_result = Map { 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_set_lexmax`.
    pub fn lexmax(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_lexmax(set) };
        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_set_lexmax_pw_multi_aff`.
    pub fn lexmax_pw_multi_aff(self) -> Result<PwMultiAff, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_lexmax_pw_multi_aff(set) };
        let isl_rs_result = PwMultiAff { 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_set_lexmin`.
    pub fn lexmin(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_lexmin(set) };
        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_set_lexmin_pw_multi_aff`.
    pub fn lexmin_pw_multi_aff(self) -> Result<PwMultiAff, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_lexmin_pw_multi_aff(set) };
        let isl_rs_result = PwMultiAff { 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_set_lift`.
    pub fn lift(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_lift(set) };
        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_set_lower_bound_multi_pw_aff`.
    pub fn lower_bound_multi_pw_aff(self, lower: MultiPwAff) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut lower = lower;
        lower.do_not_free_on_drop();
        let lower = lower.ptr;
        let isl_rs_result = unsafe { isl_set_lower_bound_multi_pw_aff(set, lower) };
        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_set_lower_bound_multi_val`.
    pub fn lower_bound_multi_val(self, lower: MultiVal) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut lower = lower;
        lower.do_not_free_on_drop();
        let lower = lower.ptr;
        let isl_rs_result = unsafe { isl_set_lower_bound_multi_val(set, lower) };
        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_set_lower_bound_si`.
    pub fn lower_bound_si(self, type_: DimType, pos: u32, value: i32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_lower_bound_si(set, type_, pos, value) };
        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_set_lower_bound_val`.
    pub fn lower_bound_val(self, type_: DimType, pos: u32, value: Val) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let mut value = value;
        value.do_not_free_on_drop();
        let value = value.ptr;
        let isl_rs_result = unsafe { isl_set_lower_bound_val(set, type_, pos, value) };
        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_set_make_disjoint`.
    pub fn make_disjoint(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_make_disjoint(set) };
        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_set_max_multi_pw_aff`.
    pub fn max_multi_pw_aff(self) -> Result<MultiPwAff, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_max_multi_pw_aff(set) };
        let isl_rs_result = MultiPwAff { 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_set_max_val`.
    pub fn max_val(&self, obj: &Aff) -> Result<Val, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let obj = obj.ptr;
        let isl_rs_result = unsafe { isl_set_max_val(set, obj) };
        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_set_min_multi_pw_aff`.
    pub fn min_multi_pw_aff(self) -> Result<MultiPwAff, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_min_multi_pw_aff(set) };
        let isl_rs_result = MultiPwAff { 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_set_min_val`.
    pub fn min_val(&self, obj: &Aff) -> Result<Val, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let obj = obj.ptr;
        let isl_rs_result = unsafe { isl_set_min_val(set, obj) };
        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_set_move_dims`.
    pub fn move_dims(self, dst_type: DimType, dst_pos: u32, src_type: DimType, src_pos: u32,
                     n: u32)
                     -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let dst_type = dst_type.to_i32();
        let src_type = src_type.to_i32();
        let isl_rs_result =
            unsafe { isl_set_move_dims(set, dst_type, dst_pos, src_type, src_pos, n) };
        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_set_n_basic_set`.
    pub fn n_basic_set(&self) -> Result<i32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_n_basic_set(set) };
        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_set_n_dim`.
    pub fn n_dim(&self) -> Result<i32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_n_dim(set) };
        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_set_n_param`.
    pub fn n_param(&self) -> Result<i32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_n_param(set) };
        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_set_nat_universe`.
    pub fn nat_universe(space: Space) -> Result<Set, LibISLError> {
        let isl_rs_ctx = space.get_ctx();
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_set_nat_universe(space) };
        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_set_neg`.
    pub fn neg(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_neg(set) };
        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_set_param_pw_aff_on_domain_id`.
    pub fn param_pw_aff_on_domain_id(self, id: Id) -> Result<PwAff, LibISLError> {
        let domain = self;
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let mut id = id;
        id.do_not_free_on_drop();
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_set_param_pw_aff_on_domain_id(domain, id) };
        let isl_rs_result = PwAff { 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_set_params`.
    pub fn params(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_params(set) };
        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_set_plain_cmp`.
    pub fn plain_cmp(&self, set2: &Set) -> Result<i32, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_plain_cmp(set1, set2) };
        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_set_plain_get_val_if_fixed`.
    pub fn plain_get_val_if_fixed(&self, type_: DimType, pos: u32) -> Result<Val, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_plain_get_val_if_fixed(set, type_, pos) };
        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_set_plain_is_disjoint`.
    pub fn plain_is_disjoint(&self, set2: &Set) -> Result<bool, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_plain_is_disjoint(set1, set2) };
        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_set_plain_is_empty`.
    pub fn plain_is_empty(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_plain_is_empty(set) };
        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_set_plain_is_equal`.
    pub fn plain_is_equal(&self, set2: &Set) -> Result<bool, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let set1 = set1.ptr;
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_plain_is_equal(set1, set2) };
        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_set_plain_is_universe`.
    pub fn plain_is_universe(&self) -> Result<bool, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_plain_is_universe(set) };
        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_set_plain_unshifted_simple_hull`.
    pub fn plain_unshifted_simple_hull(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_plain_unshifted_simple_hull(set) };
        let isl_rs_result = BasicSet { 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_set_polyhedral_hull`.
    pub fn polyhedral_hull(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_polyhedral_hull(set) };
        let isl_rs_result = BasicSet { 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_set_preimage_multi_aff`.
    pub fn preimage_multi_aff(self, ma: MultiAff) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut ma = ma;
        ma.do_not_free_on_drop();
        let ma = ma.ptr;
        let isl_rs_result = unsafe { isl_set_preimage_multi_aff(set, ma) };
        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_set_preimage_multi_pw_aff`.
    pub fn preimage_multi_pw_aff(self, mpa: MultiPwAff) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut mpa = mpa;
        mpa.do_not_free_on_drop();
        let mpa = mpa.ptr;
        let isl_rs_result = unsafe { isl_set_preimage_multi_pw_aff(set, mpa) };
        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_set_preimage_pw_multi_aff`.
    pub fn preimage_pw_multi_aff(self, pma: PwMultiAff) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut pma = pma;
        pma.do_not_free_on_drop();
        let pma = pma.ptr;
        let isl_rs_result = unsafe { isl_set_preimage_pw_multi_aff(set, pma) };
        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_set_product`.
    pub fn product(self, set2: Set) -> Result<Set, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_product(set1, set2) };
        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_set_project_onto_map`.
    pub fn project_onto_map(self, type_: DimType, first: u32, n: u32) -> Result<Map, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_project_onto_map(set, type_, first, n) };
        let isl_rs_result = Map { 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_set_project_out`.
    pub fn project_out(self, type_: DimType, first: u32, n: u32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_project_out(set, type_, first, n) };
        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_set_project_out_all_params`.
    pub fn project_out_all_params(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_project_out_all_params(set) };
        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_set_project_out_param_id`.
    pub fn project_out_param_id(self, id: Id) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut id = id;
        id.do_not_free_on_drop();
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_set_project_out_param_id(set, id) };
        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_set_project_out_param_id_list`.
    pub fn project_out_param_id_list(self, list: IdList) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut list = list;
        list.do_not_free_on_drop();
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_set_project_out_param_id_list(set, list) };
        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_set_pw_aff_on_domain_val`.
    pub fn pw_aff_on_domain_val(self, v: Val) -> Result<PwAff, LibISLError> {
        let domain = self;
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let mut v = v;
        v.do_not_free_on_drop();
        let v = v.ptr;
        let isl_rs_result = unsafe { isl_set_pw_aff_on_domain_val(domain, v) };
        let isl_rs_result = PwAff { 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_set_pw_multi_aff_on_domain_multi_val`.
    pub fn pw_multi_aff_on_domain_multi_val(self, mv: MultiVal) -> Result<PwMultiAff, LibISLError> {
        let domain = self;
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let mut mv = mv;
        mv.do_not_free_on_drop();
        let mv = mv.ptr;
        let isl_rs_result = unsafe { isl_set_pw_multi_aff_on_domain_multi_val(domain, mv) };
        let isl_rs_result = PwMultiAff { 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_set_read_from_str`.
    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<Set, 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_set_read_from_str(ctx, str_) };
        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_set_remove_dims`.
    pub fn remove_dims(self, type_: DimType, first: u32, n: u32) -> Result<Set, LibISLError> {
        let bset = self;
        let isl_rs_ctx = bset.get_ctx();
        let mut bset = bset;
        bset.do_not_free_on_drop();
        let bset = bset.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_remove_dims(bset, type_, first, n) };
        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_set_remove_divs`.
    pub fn remove_divs(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_remove_divs(set) };
        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_set_remove_divs_involving_dims`.
    pub fn remove_divs_involving_dims(self, type_: DimType, first: u32, n: u32)
                                      -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_remove_divs_involving_dims(set, type_, first, n) };
        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_set_remove_redundancies`.
    pub fn remove_redundancies(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_remove_redundancies(set) };
        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_set_remove_unknown_divs`.
    pub fn remove_unknown_divs(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_remove_unknown_divs(set) };
        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_set_reset_space`.
    pub fn reset_space(self, space: Space) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_set_reset_space(set, space) };
        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_set_reset_tuple_id`.
    pub fn reset_tuple_id(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_reset_tuple_id(set) };
        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_set_reset_user`.
    pub fn reset_user(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_reset_user(set) };
        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_set_sample`.
    pub fn sample(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_sample(set) };
        let isl_rs_result = BasicSet { 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_set_sample_point`.
    pub fn sample_point(self) -> Result<Point, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_sample_point(set) };
        let isl_rs_result = Point { 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_set_set_dim_id`.
    pub fn set_dim_id(self, type_: DimType, pos: u32, id: Id) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let mut id = id;
        id.do_not_free_on_drop();
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_set_set_dim_id(set, type_, pos, id) };
        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_set_set_dim_name`.
    pub fn set_dim_name(self, type_: DimType, pos: u32, s: &str) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let s = CString::new(s).unwrap();
        let s = s.as_ptr();
        let isl_rs_result = unsafe { isl_set_set_dim_name(set, type_, pos, s) };
        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_set_set_tuple_id`.
    pub fn set_tuple_id(self, id: Id) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut id = id;
        id.do_not_free_on_drop();
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_set_set_tuple_id(set, id) };
        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_set_set_tuple_name`.
    pub fn set_tuple_name(self, s: &str) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let s = CString::new(s).unwrap();
        let s = s.as_ptr();
        let isl_rs_result = unsafe { isl_set_set_tuple_name(set, s) };
        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_set_simple_hull`.
    pub fn simple_hull(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_simple_hull(set) };
        let isl_rs_result = BasicSet { 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_set_size`.
    pub fn size(&self) -> Result<i32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_size(set) };
        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_set_solutions`.
    pub fn solutions(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_solutions(set) };
        let isl_rs_result = BasicSet { 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_set_split_dims`.
    pub fn split_dims(self, type_: DimType, first: u32, n: u32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_split_dims(set, type_, first, n) };
        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_set_subtract`.
    pub fn subtract(self, set2: Set) -> Result<Set, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_subtract(set1, set2) };
        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_set_sum`.
    pub fn sum(self, set2: Set) -> Result<Set, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_sum(set1, set2) };
        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_set_to_list`.
    pub fn to_list(self) -> Result<SetList, 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_set_to_list(el) };
        let isl_rs_result = SetList { 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_set_to_str`.
    pub fn to_str(&self) -> Result<&str, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_to_str(set) };
        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_set_to_union_set`.
    pub fn to_union_set(self) -> Result<UnionSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_to_union_set(set) };
        let isl_rs_result = UnionSet { 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_set_translation`.
    pub fn translation(self) -> Result<Map, LibISLError> {
        let deltas = self;
        let isl_rs_ctx = deltas.get_ctx();
        let mut deltas = deltas;
        deltas.do_not_free_on_drop();
        let deltas = deltas.ptr;
        let isl_rs_result = unsafe { isl_set_translation(deltas) };
        let isl_rs_result = Map { 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_set_tuple_dim`.
    pub fn tuple_dim(&self) -> Result<i32, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_tuple_dim(set) };
        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_set_unbind_params`.
    pub fn unbind_params(self, tuple: MultiId) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut tuple = tuple;
        tuple.do_not_free_on_drop();
        let tuple = tuple.ptr;
        let isl_rs_result = unsafe { isl_set_unbind_params(set, tuple) };
        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_set_unbind_params_insert_domain`.
    pub fn unbind_params_insert_domain(self, domain: MultiId) -> Result<Map, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_set_unbind_params_insert_domain(set, domain) };
        let isl_rs_result = Map { 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_set_union`.
    pub fn union(self, set2: Set) -> Result<Set, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_union(set1, set2) };
        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_set_union_disjoint`.
    pub fn union_disjoint(self, set2: Set) -> Result<Set, LibISLError> {
        let set1 = self;
        let isl_rs_ctx = set1.get_ctx();
        let mut set1 = set1;
        set1.do_not_free_on_drop();
        let set1 = set1.ptr;
        let mut set2 = set2;
        set2.do_not_free_on_drop();
        let set2 = set2.ptr;
        let isl_rs_result = unsafe { isl_set_union_disjoint(set1, set2) };
        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_set_universe`.
    pub fn universe(space: Space) -> Result<Set, LibISLError> {
        let isl_rs_ctx = space.get_ctx();
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_set_universe(space) };
        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_set_unshifted_simple_hull`.
    pub fn unshifted_simple_hull(self) -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_unshifted_simple_hull(set) };
        let isl_rs_result = BasicSet { 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_set_unshifted_simple_hull_from_set_list`.
    pub fn unshifted_simple_hull_from_set_list(self, list: SetList)
                                               -> Result<BasicSet, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut list = list;
        list.do_not_free_on_drop();
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_set_unshifted_simple_hull_from_set_list(set, list) };
        let isl_rs_result = BasicSet { 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_set_unwrap`.
    pub fn unwrap(self) -> Result<Map, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_unwrap(set) };
        let isl_rs_result = Map { 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_set_upper_bound_multi_pw_aff`.
    pub fn upper_bound_multi_pw_aff(self, upper: MultiPwAff) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut upper = upper;
        upper.do_not_free_on_drop();
        let upper = upper.ptr;
        let isl_rs_result = unsafe { isl_set_upper_bound_multi_pw_aff(set, upper) };
        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_set_upper_bound_multi_val`.
    pub fn upper_bound_multi_val(self, upper: MultiVal) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let mut upper = upper;
        upper.do_not_free_on_drop();
        let upper = upper.ptr;
        let isl_rs_result = unsafe { isl_set_upper_bound_multi_val(set, upper) };
        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_set_upper_bound_si`.
    pub fn upper_bound_si(self, type_: DimType, pos: u32, value: i32) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_set_upper_bound_si(set, type_, pos, value) };
        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_set_upper_bound_val`.
    pub fn upper_bound_val(self, type_: DimType, pos: u32, value: Val) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let type_ = type_.to_i32();
        let mut value = value;
        value.do_not_free_on_drop();
        let value = value.ptr;
        let isl_rs_result = unsafe { isl_set_upper_bound_val(set, type_, pos, value) };
        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_set_wrapped_domain_map`.
    pub fn wrapped_domain_map(self) -> Result<Map, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_wrapped_domain_map(set) };
        let isl_rs_result = Map { 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_set_wrapped_reverse`.
    pub fn wrapped_reverse(self) -> Result<Set, LibISLError> {
        let set = self;
        let isl_rs_ctx = set.get_ctx();
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_set_wrapped_reverse(set) };
        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)
    }

    /// Does not call isl_set_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 Set {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_set_free(self.ptr);
            }
        }
    }
}