isl-rs 0.3.1

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

use super::{
    BasicSet, BasicSetList, Context, DimType, Error, LibISLError, MultiAff, MultiUnionPwAff,
    MultiVal, Point, PwMultiAff, Schedule, Set, SetList, Space, UnionMap, UnionPwMultiAff,
    UnionSetList,
};
use libc::uintptr_t;
use std::ffi::{CStr, CString};
use std::os::raw::c_char;

/// Wraps `isl_union_set`.
pub struct UnionSet {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_union_set_add_set(uset: uintptr_t, set: uintptr_t) -> uintptr_t;

    fn isl_union_set_affine_hull(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_align_params(uset: uintptr_t, model: uintptr_t) -> uintptr_t;

    fn isl_union_set_apply(uset: uintptr_t, umap: uintptr_t) -> uintptr_t;

    fn isl_union_set_as_set(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_coalesce(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_coefficients(bset: uintptr_t) -> uintptr_t;

    fn isl_union_set_compute_divs(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_compute_schedule(domain: uintptr_t, validity: uintptr_t, proximity: uintptr_t)
                                      -> uintptr_t;

    fn isl_union_set_contains(uset: uintptr_t, space: uintptr_t) -> i32;

    fn isl_union_set_copy(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_detect_equalities(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_dim(uset: uintptr_t, type_: i32) -> i32;

    fn isl_union_set_drop_unused_params(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_dump(uset: uintptr_t) -> ();

    fn isl_union_set_empty(space: uintptr_t) -> uintptr_t;

    fn isl_union_set_empty_ctx(ctx: uintptr_t) -> uintptr_t;

    fn isl_union_set_empty_space(space: uintptr_t) -> uintptr_t;

    fn isl_union_set_extract_set(uset: uintptr_t, space: uintptr_t) -> uintptr_t;

    fn isl_union_set_free(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_from_basic_set(bset: uintptr_t) -> uintptr_t;

    fn isl_union_set_from_point(pnt: uintptr_t) -> uintptr_t;

    fn isl_union_set_from_set(set: uintptr_t) -> uintptr_t;

    fn isl_union_set_get_basic_set_list(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_get_ctx(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_get_hash(uset: uintptr_t) -> u32;

    fn isl_union_set_get_set_list(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_get_space(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_gist(uset: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_union_set_gist_params(uset: uintptr_t, set: uintptr_t) -> uintptr_t;

    fn isl_union_set_identity(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_identity_union_pw_multi_aff(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_intersect(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;

    fn isl_union_set_intersect_params(uset: uintptr_t, set: uintptr_t) -> uintptr_t;

    fn isl_union_set_is_disjoint(uset1: uintptr_t, uset2: uintptr_t) -> i32;

    fn isl_union_set_is_empty(uset: uintptr_t) -> i32;

    fn isl_union_set_is_equal(uset1: uintptr_t, uset2: uintptr_t) -> i32;

    fn isl_union_set_is_params(uset: uintptr_t) -> i32;

    fn isl_union_set_is_strict_subset(uset1: uintptr_t, uset2: uintptr_t) -> i32;

    fn isl_union_set_is_subset(uset1: uintptr_t, uset2: uintptr_t) -> i32;

    fn isl_union_set_isa_set(uset: uintptr_t) -> i32;

    fn isl_union_set_lex_ge_union_set(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;

    fn isl_union_set_lex_gt_union_set(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;

    fn isl_union_set_lex_le_union_set(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;

    fn isl_union_set_lex_lt_union_set(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;

    fn isl_union_set_lexmax(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_lexmin(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_lift(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_min_multi_union_pw_aff(uset: uintptr_t, obj: uintptr_t) -> uintptr_t;

    fn isl_union_set_n_set(uset: uintptr_t) -> i32;

    fn isl_union_set_params(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_plain_unshifted_simple_hull(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_polyhedral_hull(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_preimage_multi_aff(uset: uintptr_t, ma: uintptr_t) -> uintptr_t;

    fn isl_union_set_preimage_pw_multi_aff(uset: uintptr_t, pma: uintptr_t) -> uintptr_t;

    fn isl_union_set_preimage_union_pw_multi_aff(uset: uintptr_t, upma: uintptr_t) -> uintptr_t;

    fn isl_union_set_product(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;

    fn isl_union_set_project_out(uset: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_union_set_project_out_all_params(uset: uintptr_t) -> uintptr_t;

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

    fn isl_union_set_remove_divs(bset: uintptr_t) -> uintptr_t;

    fn isl_union_set_remove_redundancies(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_reset_user(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_sample(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_sample_point(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_simple_hull(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_solutions(bset: uintptr_t) -> uintptr_t;

    fn isl_union_set_subtract(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;

    fn isl_union_set_to_list(el: uintptr_t) -> uintptr_t;

    fn isl_union_set_to_str(uset: uintptr_t) -> *const c_char;

    fn isl_union_set_union(uset1: uintptr_t, uset2: uintptr_t) -> uintptr_t;

    fn isl_union_set_universe(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_unwrap(uset: uintptr_t) -> uintptr_t;

    fn isl_union_set_wrapped_domain_map(uset: uintptr_t) -> uintptr_t;

}

impl UnionSet {
    /// Wraps `isl_union_set_add_set`.
    pub fn add_set(self, set: Set) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_union_set_add_set(uset, 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_union_set_affine_hull`.
    pub fn affine_hull(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_affine_hull(uset) };
        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_union_set_align_params`.
    pub fn align_params(self, model: Space) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut model = model;
        model.do_not_free_on_drop();
        let model = model.ptr;
        let isl_rs_result = unsafe { isl_union_set_align_params(uset, model) };
        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_union_set_apply`.
    pub fn apply(self, umap: UnionMap) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_set_apply(uset, umap) };
        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_union_set_as_set`.
    pub fn as_set(self) -> Result<Set, LibISLError> {
        let uset = self;
        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_union_set_as_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_union_set_coalesce`.
    pub fn coalesce(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_coalesce(uset) };
        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_union_set_coefficients`.
    pub fn coefficients(self) -> Result<UnionSet, 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 isl_rs_result = unsafe { isl_union_set_coefficients(bset) };
        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_union_set_compute_divs`.
    pub fn compute_divs(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_compute_divs(uset) };
        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_union_set_compute_schedule`.
    pub fn compute_schedule(self, validity: UnionMap, proximity: UnionMap)
                            -> Result<Schedule, 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 validity = validity;
        validity.do_not_free_on_drop();
        let validity = validity.ptr;
        let mut proximity = proximity;
        proximity.do_not_free_on_drop();
        let proximity = proximity.ptr;
        let isl_rs_result = unsafe { isl_union_set_compute_schedule(domain, validity, proximity) };
        let isl_rs_result = Schedule { 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_union_set_contains`.
    pub fn contains(&self, space: &Space) -> Result<bool, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_union_set_contains(uset, space) };
        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_union_set_copy`.
    pub fn copy(&self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_copy(uset) };
        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_union_set_detect_equalities`.
    pub fn detect_equalities(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_detect_equalities(uset) };
        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_union_set_dim`.
    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_union_set_dim(uset, 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_union_set_drop_unused_params`.
    pub fn drop_unused_params(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_drop_unused_params(uset) };
        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_union_set_dump`.
    pub fn dump(&self) -> Result<(), LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_dump(uset) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_union_set_empty`.
    pub fn empty(space: Space) -> Result<UnionSet, 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_union_set_empty(space) };
        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_union_set_empty_ctx`.
    pub fn empty_ctx(ctx: &Context) -> Result<UnionSet, LibISLError> {
        let isl_rs_ctx = Context { ptr: ctx.ptr,
                                   should_free_on_drop: false };
        let ctx = ctx.ptr;
        let isl_rs_result = unsafe { isl_union_set_empty_ctx(ctx) };
        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_union_set_empty_space`.
    pub fn empty_space(space: Space) -> Result<UnionSet, 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_union_set_empty_space(space) };
        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_union_set_extract_set`.
    pub fn extract_set(&self, space: Space) -> Result<Set, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_union_set_extract_set(uset, 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_union_set_free`.
    pub fn free(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_free(uset) };
        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_union_set_from_basic_set`.
    pub fn from_basic_set(bset: BasicSet) -> Result<UnionSet, 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_union_set_from_basic_set(bset) };
        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_union_set_from_point`.
    pub fn from_point(pnt: Point) -> Result<UnionSet, 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_union_set_from_point(pnt) };
        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_union_set_from_set`.
    pub fn from_set(set: Set) -> Result<UnionSet, LibISLError> {
        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_union_set_from_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_union_set_get_basic_set_list`.
    pub fn get_basic_set_list(&self) -> Result<BasicSetList, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_get_basic_set_list(uset) };
        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_union_set_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let uset = self;
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_get_ctx(uset) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

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

    /// Wraps `isl_union_set_get_set_list`.
    pub fn get_set_list(&self) -> Result<SetList, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_get_set_list(uset) };
        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_union_set_get_space`.
    pub fn get_space(&self) -> Result<Space, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_get_space(uset) };
        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_union_set_gist`.
    pub fn gist(self, context: UnionSet) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_union_set_gist(uset, context) };
        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_union_set_gist_params`.
    pub fn gist_params(self, set: Set) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_union_set_gist_params(uset, 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_union_set_identity`.
    pub fn identity(self) -> Result<UnionMap, LibISLError> {
        let uset = self;
        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_union_set_identity(uset) };
        let isl_rs_result = UnionMap { 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_union_set_identity_union_pw_multi_aff`.
    pub fn identity_union_pw_multi_aff(self) -> Result<UnionPwMultiAff, LibISLError> {
        let uset = self;
        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_union_set_identity_union_pw_multi_aff(uset) };
        let isl_rs_result = UnionPwMultiAff { 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_union_set_intersect`.
    pub fn intersect(self, uset2: UnionSet) -> Result<UnionSet, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let mut uset1 = uset1;
        uset1.do_not_free_on_drop();
        let uset1 = uset1.ptr;
        let mut uset2 = uset2;
        uset2.do_not_free_on_drop();
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_intersect(uset1, uset2) };
        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_union_set_intersect_params`.
    pub fn intersect_params(self, set: Set) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_union_set_intersect_params(uset, 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_union_set_is_disjoint`.
    pub fn is_disjoint(&self, uset2: &UnionSet) -> Result<bool, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let uset1 = uset1.ptr;
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_is_disjoint(uset1, uset2) };
        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_union_set_is_empty`.
    pub fn is_empty(&self) -> Result<bool, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_is_empty(uset) };
        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_union_set_is_equal`.
    pub fn is_equal(&self, uset2: &UnionSet) -> Result<bool, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let uset1 = uset1.ptr;
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_is_equal(uset1, uset2) };
        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_union_set_is_params`.
    pub fn is_params(&self) -> Result<bool, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_is_params(uset) };
        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_union_set_is_strict_subset`.
    pub fn is_strict_subset(&self, uset2: &UnionSet) -> Result<bool, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let uset1 = uset1.ptr;
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_is_strict_subset(uset1, uset2) };
        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_union_set_is_subset`.
    pub fn is_subset(&self, uset2: &UnionSet) -> Result<bool, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let uset1 = uset1.ptr;
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_is_subset(uset1, uset2) };
        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_union_set_isa_set`.
    pub fn isa_set(&self) -> Result<bool, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_isa_set(uset) };
        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_union_set_lex_ge_union_set`.
    pub fn lex_ge_union_set(self, uset2: UnionSet) -> Result<UnionMap, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let mut uset1 = uset1;
        uset1.do_not_free_on_drop();
        let uset1 = uset1.ptr;
        let mut uset2 = uset2;
        uset2.do_not_free_on_drop();
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_lex_ge_union_set(uset1, uset2) };
        let isl_rs_result = UnionMap { 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_union_set_lex_gt_union_set`.
    pub fn lex_gt_union_set(self, uset2: UnionSet) -> Result<UnionMap, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let mut uset1 = uset1;
        uset1.do_not_free_on_drop();
        let uset1 = uset1.ptr;
        let mut uset2 = uset2;
        uset2.do_not_free_on_drop();
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_lex_gt_union_set(uset1, uset2) };
        let isl_rs_result = UnionMap { 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_union_set_lex_le_union_set`.
    pub fn lex_le_union_set(self, uset2: UnionSet) -> Result<UnionMap, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let mut uset1 = uset1;
        uset1.do_not_free_on_drop();
        let uset1 = uset1.ptr;
        let mut uset2 = uset2;
        uset2.do_not_free_on_drop();
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_lex_le_union_set(uset1, uset2) };
        let isl_rs_result = UnionMap { 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_union_set_lex_lt_union_set`.
    pub fn lex_lt_union_set(self, uset2: UnionSet) -> Result<UnionMap, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let mut uset1 = uset1;
        uset1.do_not_free_on_drop();
        let uset1 = uset1.ptr;
        let mut uset2 = uset2;
        uset2.do_not_free_on_drop();
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_lex_lt_union_set(uset1, uset2) };
        let isl_rs_result = UnionMap { 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_union_set_lexmax`.
    pub fn lexmax(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_lexmax(uset) };
        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_union_set_lexmin`.
    pub fn lexmin(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_lexmin(uset) };
        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_union_set_lift`.
    pub fn lift(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_lift(uset) };
        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_union_set_min_multi_union_pw_aff`.
    pub fn min_multi_union_pw_aff(&self, obj: &MultiUnionPwAff) -> Result<MultiVal, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let obj = obj.ptr;
        let isl_rs_result = unsafe { isl_union_set_min_multi_union_pw_aff(uset, obj) };
        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_union_set_n_set`.
    pub fn n_set(&self) -> Result<i32, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_n_set(uset) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_union_set_params`.
    pub fn params(self) -> Result<Set, LibISLError> {
        let uset = self;
        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_union_set_params(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_union_set_plain_unshifted_simple_hull`.
    pub fn plain_unshifted_simple_hull(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_plain_unshifted_simple_hull(uset) };
        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_union_set_polyhedral_hull`.
    pub fn polyhedral_hull(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_polyhedral_hull(uset) };
        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_union_set_preimage_multi_aff`.
    pub fn preimage_multi_aff(self, ma: MultiAff) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut ma = ma;
        ma.do_not_free_on_drop();
        let ma = ma.ptr;
        let isl_rs_result = unsafe { isl_union_set_preimage_multi_aff(uset, ma) };
        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_union_set_preimage_pw_multi_aff`.
    pub fn preimage_pw_multi_aff(self, pma: PwMultiAff) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut pma = pma;
        pma.do_not_free_on_drop();
        let pma = pma.ptr;
        let isl_rs_result = unsafe { isl_union_set_preimage_pw_multi_aff(uset, pma) };
        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_union_set_preimage_union_pw_multi_aff`.
    pub fn preimage_union_pw_multi_aff(self, upma: UnionPwMultiAff)
                                       -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let mut upma = upma;
        upma.do_not_free_on_drop();
        let upma = upma.ptr;
        let isl_rs_result = unsafe { isl_union_set_preimage_union_pw_multi_aff(uset, upma) };
        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_union_set_product`.
    pub fn product(self, uset2: UnionSet) -> Result<UnionSet, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let mut uset1 = uset1;
        uset1.do_not_free_on_drop();
        let uset1 = uset1.ptr;
        let mut uset2 = uset2;
        uset2.do_not_free_on_drop();
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_product(uset1, uset2) };
        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_union_set_project_out`.
    pub fn project_out(self, type_: DimType, first: u32, n: u32) -> Result<UnionSet, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_union_set_project_out(uset, type_, first, n) };
        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_union_set_project_out_all_params`.
    pub fn project_out_all_params(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_project_out_all_params(uset) };
        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_union_set_read_from_str`.
    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<UnionSet, 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_union_set_read_from_str(ctx, str_) };
        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_union_set_remove_divs`.
    pub fn remove_divs(self) -> Result<UnionSet, 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 isl_rs_result = unsafe { isl_union_set_remove_divs(bset) };
        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_union_set_remove_redundancies`.
    pub fn remove_redundancies(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_remove_redundancies(uset) };
        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_union_set_reset_user`.
    pub fn reset_user(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_reset_user(uset) };
        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_union_set_sample`.
    pub fn sample(self) -> Result<BasicSet, LibISLError> {
        let uset = self;
        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_union_set_sample(uset) };
        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_union_set_sample_point`.
    pub fn sample_point(self) -> Result<Point, LibISLError> {
        let uset = self;
        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_union_set_sample_point(uset) };
        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_union_set_simple_hull`.
    pub fn simple_hull(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_simple_hull(uset) };
        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_union_set_solutions`.
    pub fn solutions(self) -> Result<UnionSet, 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 isl_rs_result = unsafe { isl_union_set_solutions(bset) };
        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_union_set_subtract`.
    pub fn subtract(self, uset2: UnionSet) -> Result<UnionSet, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let mut uset1 = uset1;
        uset1.do_not_free_on_drop();
        let uset1 = uset1.ptr;
        let mut uset2 = uset2;
        uset2.do_not_free_on_drop();
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_subtract(uset1, uset2) };
        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_union_set_to_list`.
    pub fn to_list(self) -> Result<UnionSetList, 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_union_set_to_list(el) };
        let isl_rs_result = UnionSetList { 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_union_set_to_str`.
    pub fn to_str(&self) -> Result<&str, LibISLError> {
        let uset = self;
        let isl_rs_ctx = uset.get_ctx();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_set_to_str(uset) };
        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_union_set_union`.
    pub fn union(self, uset2: UnionSet) -> Result<UnionSet, LibISLError> {
        let uset1 = self;
        let isl_rs_ctx = uset1.get_ctx();
        let mut uset1 = uset1;
        uset1.do_not_free_on_drop();
        let uset1 = uset1.ptr;
        let mut uset2 = uset2;
        uset2.do_not_free_on_drop();
        let uset2 = uset2.ptr;
        let isl_rs_result = unsafe { isl_union_set_union(uset1, uset2) };
        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_union_set_universe`.
    pub fn universe(self) -> Result<UnionSet, LibISLError> {
        let uset = self;
        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_union_set_universe(uset) };
        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_union_set_unwrap`.
    pub fn unwrap(self) -> Result<UnionMap, LibISLError> {
        let uset = self;
        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_union_set_unwrap(uset) };
        let isl_rs_result = UnionMap { 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_union_set_wrapped_domain_map`.
    pub fn wrapped_domain_map(self) -> Result<UnionMap, LibISLError> {
        let uset = self;
        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_union_set_wrapped_domain_map(uset) };
        let isl_rs_result = UnionMap { 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_union_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 UnionSet {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_union_set_free(self.ptr);
            }
        }
    }
}