isl_rs/bindings/

union_map.rs

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

use super::{
    BasicMap, Context, DimType, Error, Id, IdList, LibISLError, Map, MapList, MultiAff, MultiId,
    MultiPwAff, MultiUnionPwAff, PwMultiAff, Set, Space, UnionMapList, UnionPwAff, UnionPwMultiAff,
    UnionSet, Val,
};
use libc::uintptr_t;
use std::ffi::{CStr, CString};
use std::os::raw::c_char;

/// Wraps `isl_union_map`.
pub struct UnionMap {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_union_map_add_map(umap: uintptr_t, map: uintptr_t) -> uintptr_t;

    fn isl_union_map_affine_hull(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_align_params(umap: uintptr_t, model: uintptr_t) -> uintptr_t;

    fn isl_union_map_apply_domain(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_apply_range(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_as_map(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_as_multi_union_pw_aff(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_as_union_pw_multi_aff(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_bind_range(umap: uintptr_t, tuple: uintptr_t) -> uintptr_t;

    fn isl_union_map_coalesce(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_compute_divs(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_contains(umap: uintptr_t, space: uintptr_t) -> i32;

    fn isl_union_map_copy(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_curry(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_deltas(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_deltas_map(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_detect_equalities(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_dim(umap: uintptr_t, type_: i32) -> i32;

    fn isl_union_map_domain(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_domain_factor_domain(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_domain_factor_range(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_domain_map(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_domain_map_union_pw_multi_aff(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_domain_product(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_domain_reverse(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_drop_unused_params(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_dump(umap: uintptr_t) -> ();

    fn isl_union_map_empty(space: uintptr_t) -> uintptr_t;

    fn isl_union_map_empty_ctx(ctx: uintptr_t) -> uintptr_t;

    fn isl_union_map_empty_space(space: uintptr_t) -> uintptr_t;

    fn isl_union_map_eq_at_multi_union_pw_aff(umap: uintptr_t, mupa: uintptr_t) -> uintptr_t;

    fn isl_union_map_extract_map(umap: uintptr_t, space: uintptr_t) -> uintptr_t;

    fn isl_union_map_factor_domain(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_factor_range(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_find_dim_by_name(umap: uintptr_t, type_: i32, name: *const c_char) -> i32;

    fn isl_union_map_fixed_power_val(umap: uintptr_t, exp: uintptr_t) -> uintptr_t;

    fn isl_union_map_flat_domain_product(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_flat_range_product(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_free(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_from_basic_map(bmap: uintptr_t) -> uintptr_t;

    fn isl_union_map_from_domain(uset: uintptr_t) -> uintptr_t;

    fn isl_union_map_from_domain_and_range(domain: uintptr_t, range: uintptr_t) -> uintptr_t;

    fn isl_union_map_from_map(map: uintptr_t) -> uintptr_t;

    fn isl_union_map_from_multi_union_pw_aff(mupa: uintptr_t) -> uintptr_t;

    fn isl_union_map_from_range(uset: uintptr_t) -> uintptr_t;

    fn isl_union_map_from_union_pw_aff(upa: uintptr_t) -> uintptr_t;

    fn isl_union_map_from_union_pw_multi_aff(upma: uintptr_t) -> uintptr_t;

    fn isl_union_map_get_ctx(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_get_dim_id(umap: uintptr_t, type_: i32, pos: u32) -> uintptr_t;

    fn isl_union_map_get_hash(umap: uintptr_t) -> u32;

    fn isl_union_map_get_map_list(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_get_space(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_gist(umap: uintptr_t, context: uintptr_t) -> uintptr_t;

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

    fn isl_union_map_gist_params(umap: uintptr_t, set: uintptr_t) -> uintptr_t;

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

    fn isl_union_map_intersect(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

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

    fn isl_union_map_intersect_domain_factor_domain(umap: uintptr_t, factor: uintptr_t)
                                                    -> uintptr_t;

    fn isl_union_map_intersect_domain_factor_range(umap: uintptr_t, factor: uintptr_t)
                                                   -> uintptr_t;

    fn isl_union_map_intersect_domain_space(umap: uintptr_t, space: uintptr_t) -> uintptr_t;

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

    fn isl_union_map_intersect_domain_wrapped_domain_union_set(umap: uintptr_t, domain: uintptr_t)
                                                               -> uintptr_t;

    fn isl_union_map_intersect_params(umap: uintptr_t, set: uintptr_t) -> uintptr_t;

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

    fn isl_union_map_intersect_range_factor_domain(umap: uintptr_t, factor: uintptr_t)
                                                   -> uintptr_t;

    fn isl_union_map_intersect_range_factor_range(umap: uintptr_t, factor: uintptr_t) -> uintptr_t;

    fn isl_union_map_intersect_range_space(umap: uintptr_t, space: uintptr_t) -> uintptr_t;

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

    fn isl_union_map_intersect_range_wrapped_domain_union_set(umap: uintptr_t, domain: uintptr_t)
                                                              -> uintptr_t;

    fn isl_union_map_involves_dims(umap: uintptr_t, type_: i32, first: u32, n: u32) -> i32;

    fn isl_union_map_is_bijective(umap: uintptr_t) -> i32;

    fn isl_union_map_is_disjoint(umap1: uintptr_t, umap2: uintptr_t) -> i32;

    fn isl_union_map_is_empty(umap: uintptr_t) -> i32;

    fn isl_union_map_is_equal(umap1: uintptr_t, umap2: uintptr_t) -> i32;

    fn isl_union_map_is_identity(umap: uintptr_t) -> i32;

    fn isl_union_map_is_injective(umap: uintptr_t) -> i32;

    fn isl_union_map_is_single_valued(umap: uintptr_t) -> i32;

    fn isl_union_map_is_strict_subset(umap1: uintptr_t, umap2: uintptr_t) -> i32;

    fn isl_union_map_is_subset(umap1: uintptr_t, umap2: uintptr_t) -> i32;

    fn isl_union_map_isa_map(umap: uintptr_t) -> i32;

    fn isl_union_map_lex_ge_at_multi_union_pw_aff(umap: uintptr_t, mupa: uintptr_t) -> uintptr_t;

    fn isl_union_map_lex_ge_union_map(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_lex_gt_at_multi_union_pw_aff(umap: uintptr_t, mupa: uintptr_t) -> uintptr_t;

    fn isl_union_map_lex_gt_union_map(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_lex_le_at_multi_union_pw_aff(umap: uintptr_t, mupa: uintptr_t) -> uintptr_t;

    fn isl_union_map_lex_le_union_map(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_lex_lt_at_multi_union_pw_aff(umap: uintptr_t, mupa: uintptr_t) -> uintptr_t;

    fn isl_union_map_lex_lt_union_map(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_lexmax(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_lexmin(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_n_map(umap: uintptr_t) -> i32;

    fn isl_union_map_params(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_plain_is_empty(umap: uintptr_t) -> i32;

    fn isl_union_map_plain_is_injective(umap: uintptr_t) -> i32;

    fn isl_union_map_plain_unshifted_simple_hull(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_polyhedral_hull(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_preimage_domain_multi_aff(umap: uintptr_t, ma: uintptr_t) -> uintptr_t;

    fn isl_union_map_preimage_domain_multi_pw_aff(umap: uintptr_t, mpa: uintptr_t) -> uintptr_t;

    fn isl_union_map_preimage_domain_pw_multi_aff(umap: uintptr_t, pma: uintptr_t) -> uintptr_t;

    fn isl_union_map_preimage_domain_union_pw_multi_aff(umap: uintptr_t, upma: uintptr_t)
                                                        -> uintptr_t;

    fn isl_union_map_preimage_range_multi_aff(umap: uintptr_t, ma: uintptr_t) -> uintptr_t;

    fn isl_union_map_preimage_range_pw_multi_aff(umap: uintptr_t, pma: uintptr_t) -> uintptr_t;

    fn isl_union_map_preimage_range_union_pw_multi_aff(umap: uintptr_t, upma: uintptr_t)
                                                       -> uintptr_t;

    fn isl_union_map_product(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_project_out(umap: uintptr_t, type_: i32, first: u32, n: u32) -> uintptr_t;

    fn isl_union_map_project_out_all_params(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_project_out_param_id(umap: uintptr_t, id: uintptr_t) -> uintptr_t;

    fn isl_union_map_project_out_param_id_list(umap: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_union_map_range(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_range_curry(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_range_factor_domain(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_range_factor_range(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_range_map(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_range_product(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_range_reverse(umap: uintptr_t) -> uintptr_t;

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

    fn isl_union_map_remove_divs(bmap: uintptr_t) -> uintptr_t;

    fn isl_union_map_remove_redundancies(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_reset_user(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_reverse(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_sample(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_simple_hull(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_subtract(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_subtract_domain(umap: uintptr_t, dom: uintptr_t) -> uintptr_t;

    fn isl_union_map_subtract_range(umap: uintptr_t, dom: uintptr_t) -> uintptr_t;

    fn isl_union_map_to_list(el: uintptr_t) -> uintptr_t;

    fn isl_union_map_to_str(umap: uintptr_t) -> *const c_char;

    fn isl_union_map_uncurry(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_union(umap1: uintptr_t, umap2: uintptr_t) -> uintptr_t;

    fn isl_union_map_universe(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_wrap(umap: uintptr_t) -> uintptr_t;

    fn isl_union_map_zip(umap: uintptr_t) -> uintptr_t;

}

impl UnionMap {
    /// Wraps `isl_union_map_add_map`.
    pub fn add_map(self, map: Map) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut map = map;
        map.do_not_free_on_drop();
        let map = map.ptr;
        let isl_rs_result = unsafe { isl_union_map_add_map(umap, map) };
        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_map_affine_hull`.
    pub fn affine_hull(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_affine_hull(umap) };
        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_map_align_params`.
    pub fn align_params(self, model: Space) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut model = model;
        model.do_not_free_on_drop();
        let model = model.ptr;
        let isl_rs_result = unsafe { isl_union_map_align_params(umap, model) };
        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_map_apply_domain`.
    pub fn apply_domain(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_apply_domain(umap1, umap2) };
        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_map_apply_range`.
    pub fn apply_range(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_apply_range(umap1, umap2) };
        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_map_as_map`.
    pub fn as_map(self) -> Result<Map, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_as_map(umap) };
        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_union_map_as_multi_union_pw_aff`.
    pub fn as_multi_union_pw_aff(self) -> Result<MultiUnionPwAff, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_as_multi_union_pw_aff(umap) };
        let isl_rs_result = MultiUnionPwAff { ptr: isl_rs_result,
                                              should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = 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_map_as_union_pw_multi_aff`.
    pub fn as_union_pw_multi_aff(self) -> Result<UnionPwMultiAff, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_as_union_pw_multi_aff(umap) };
        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_map_bind_range`.
    pub fn bind_range(self, tuple: MultiId) -> Result<UnionSet, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut tuple = tuple;
        tuple.do_not_free_on_drop();
        let tuple = tuple.ptr;
        let isl_rs_result = unsafe { isl_union_map_bind_range(umap, tuple) };
        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_map_coalesce`.
    pub fn coalesce(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_coalesce(umap) };
        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_map_compute_divs`.
    pub fn compute_divs(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_compute_divs(umap) };
        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_map_contains`.
    pub fn contains(&self, space: &Space) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_union_map_contains(umap, 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_map_copy`.
    pub fn copy(&self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_copy(umap) };
        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_map_curry`.
    pub fn curry(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_curry(umap) };
        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_map_deltas`.
    pub fn deltas(self) -> Result<UnionSet, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_deltas(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_map_deltas_map`.
    pub fn deltas_map(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_deltas_map(umap) };
        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_map_detect_equalities`.
    pub fn detect_equalities(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_detect_equalities(umap) };
        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_map_dim`.
    pub fn dim(&self, type_: DimType) -> Result<i32, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_union_map_dim(umap, 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_map_domain`.
    pub fn domain(self) -> Result<UnionSet, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_domain(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_map_domain_factor_domain`.
    pub fn domain_factor_domain(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_domain_factor_domain(umap) };
        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_map_domain_factor_range`.
    pub fn domain_factor_range(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_domain_factor_range(umap) };
        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_map_domain_map`.
    pub fn domain_map(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_domain_map(umap) };
        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_map_domain_map_union_pw_multi_aff`.
    pub fn domain_map_union_pw_multi_aff(self) -> Result<UnionPwMultiAff, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_domain_map_union_pw_multi_aff(umap) };
        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_map_domain_product`.
    pub fn domain_product(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_domain_product(umap1, umap2) };
        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_map_domain_reverse`.
    pub fn domain_reverse(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_domain_reverse(umap) };
        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_map_drop_unused_params`.
    pub fn drop_unused_params(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_drop_unused_params(umap) };
        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_map_dump`.
    pub fn dump(&self) -> Result<(), LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_dump(umap) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = 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_map_empty`.
    pub fn empty(space: Space) -> Result<UnionMap, 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_map_empty(space) };
        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_map_empty_ctx`.
    pub fn empty_ctx(ctx: &Context) -> Result<UnionMap, 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_map_empty_ctx(ctx) };
        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_map_empty_space`.
    pub fn empty_space(space: Space) -> Result<UnionMap, 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_map_empty_space(space) };
        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_map_eq_at_multi_union_pw_aff`.
    pub fn eq_at_multi_union_pw_aff(self, mupa: MultiUnionPwAff) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut mupa = mupa;
        mupa.do_not_free_on_drop();
        let mupa = mupa.ptr;
        let isl_rs_result = unsafe { isl_union_map_eq_at_multi_union_pw_aff(umap, mupa) };
        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_map_extract_map`.
    pub fn extract_map(&self, space: Space) -> Result<Map, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_union_map_extract_map(umap, space) };
        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_union_map_factor_domain`.
    pub fn factor_domain(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_factor_domain(umap) };
        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_map_factor_range`.
    pub fn factor_range(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_factor_range(umap) };
        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_map_find_dim_by_name`.
    pub fn find_dim_by_name(&self, type_: DimType, name: &str) -> Result<i32, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let type_ = type_.to_i32();
        let name = CString::new(name).unwrap();
        let name = name.as_ptr();
        let isl_rs_result = unsafe { isl_union_map_find_dim_by_name(umap, 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_union_map_fixed_power_val`.
    pub fn fixed_power_val(self, exp: Val) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut exp = exp;
        exp.do_not_free_on_drop();
        let exp = exp.ptr;
        let isl_rs_result = unsafe { isl_union_map_fixed_power_val(umap, exp) };
        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_map_flat_domain_product`.
    pub fn flat_domain_product(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_flat_domain_product(umap1, umap2) };
        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_map_flat_range_product`.
    pub fn flat_range_product(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_flat_range_product(umap1, umap2) };
        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_map_free`.
    pub fn free(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_free(umap) };
        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_map_from_basic_map`.
    pub fn from_basic_map(bmap: BasicMap) -> Result<UnionMap, LibISLError> {
        let isl_rs_ctx = bmap.get_ctx();
        let mut bmap = bmap;
        bmap.do_not_free_on_drop();
        let bmap = bmap.ptr;
        let isl_rs_result = unsafe { isl_union_map_from_basic_map(bmap) };
        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_map_from_domain`.
    pub fn from_domain(uset: UnionSet) -> Result<UnionMap, 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_union_map_from_domain(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_map_from_domain_and_range`.
    pub fn from_domain_and_range(domain: UnionSet, range: UnionSet)
                                 -> Result<UnionMap, LibISLError> {
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let mut range = range;
        range.do_not_free_on_drop();
        let range = range.ptr;
        let isl_rs_result = unsafe { isl_union_map_from_domain_and_range(domain, range) };
        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_map_from_map`.
    pub fn from_map(map: Map) -> Result<UnionMap, LibISLError> {
        let isl_rs_ctx = map.get_ctx();
        let mut map = map;
        map.do_not_free_on_drop();
        let map = map.ptr;
        let isl_rs_result = unsafe { isl_union_map_from_map(map) };
        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_map_from_multi_union_pw_aff`.
    pub fn from_multi_union_pw_aff(mupa: MultiUnionPwAff) -> Result<UnionMap, LibISLError> {
        let isl_rs_ctx = mupa.get_ctx();
        let mut mupa = mupa;
        mupa.do_not_free_on_drop();
        let mupa = mupa.ptr;
        let isl_rs_result = unsafe { isl_union_map_from_multi_union_pw_aff(mupa) };
        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_map_from_range`.
    pub fn from_range(uset: UnionSet) -> Result<UnionMap, 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_union_map_from_range(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_map_from_union_pw_aff`.
    pub fn from_union_pw_aff(upa: UnionPwAff) -> Result<UnionMap, LibISLError> {
        let isl_rs_ctx = upa.get_ctx();
        let mut upa = upa;
        upa.do_not_free_on_drop();
        let upa = upa.ptr;
        let isl_rs_result = unsafe { isl_union_map_from_union_pw_aff(upa) };
        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_map_from_union_pw_multi_aff`.
    pub fn from_union_pw_multi_aff(upma: UnionPwMultiAff) -> Result<UnionMap, LibISLError> {
        let isl_rs_ctx = upma.get_ctx();
        let mut upma = upma;
        upma.do_not_free_on_drop();
        let upma = upma.ptr;
        let isl_rs_result = unsafe { isl_union_map_from_union_pw_multi_aff(upma) };
        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_map_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let umap = self;
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_get_ctx(umap) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

    /// Wraps `isl_union_map_get_dim_id`.
    pub fn get_dim_id(&self, type_: DimType, pos: u32) -> Result<Id, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_union_map_get_dim_id(umap, 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_union_map_get_hash`.
    pub fn get_hash(&self) -> Result<u32, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_get_hash(umap) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = 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_map_get_map_list`.
    pub fn get_map_list(&self) -> Result<MapList, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_get_map_list(umap) };
        let isl_rs_result = MapList { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = 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_map_get_space`.
    pub fn get_space(&self) -> Result<Space, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_get_space(umap) };
        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_map_gist`.
    pub fn gist(self, context: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut context = context;
        context.do_not_free_on_drop();
        let context = context.ptr;
        let isl_rs_result = unsafe { isl_union_map_gist(umap, context) };
        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_map_gist_domain`.
    pub fn gist_domain(self, uset: UnionSet) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_map_gist_domain(umap, 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_map_gist_params`.
    pub fn gist_params(self, set: Set) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_union_map_gist_params(umap, set) };
        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_map_gist_range`.
    pub fn gist_range(self, uset: UnionSet) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_map_gist_range(umap, 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_map_intersect`.
    pub fn intersect(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect(umap1, umap2) };
        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_map_intersect_domain`.
    pub fn intersect_domain(self, uset: UnionSet) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_domain(umap, 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_map_intersect_domain_factor_domain`.
    pub fn intersect_domain_factor_domain(self, factor: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut factor = factor;
        factor.do_not_free_on_drop();
        let factor = factor.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_domain_factor_domain(umap, factor) };
        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_map_intersect_domain_factor_range`.
    pub fn intersect_domain_factor_range(self, factor: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut factor = factor;
        factor.do_not_free_on_drop();
        let factor = factor.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_domain_factor_range(umap, factor) };
        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_map_intersect_domain_space`.
    pub fn intersect_domain_space(self, space: Space) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_domain_space(umap, space) };
        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_map_intersect_domain_union_set`.
    pub fn intersect_domain_union_set(self, uset: UnionSet) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_domain_union_set(umap, 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_map_intersect_domain_wrapped_domain_union_set`.
    pub fn intersect_domain_wrapped_domain_union_set(self, domain: UnionSet)
                                                     -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result =
            unsafe { isl_union_map_intersect_domain_wrapped_domain_union_set(umap, domain) };
        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_map_intersect_params`.
    pub fn intersect_params(self, set: Set) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut set = set;
        set.do_not_free_on_drop();
        let set = set.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_params(umap, set) };
        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_map_intersect_range`.
    pub fn intersect_range(self, uset: UnionSet) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_range(umap, 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_map_intersect_range_factor_domain`.
    pub fn intersect_range_factor_domain(self, factor: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut factor = factor;
        factor.do_not_free_on_drop();
        let factor = factor.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_range_factor_domain(umap, factor) };
        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_map_intersect_range_factor_range`.
    pub fn intersect_range_factor_range(self, factor: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut factor = factor;
        factor.do_not_free_on_drop();
        let factor = factor.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_range_factor_range(umap, factor) };
        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_map_intersect_range_space`.
    pub fn intersect_range_space(self, space: Space) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut space = space;
        space.do_not_free_on_drop();
        let space = space.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_range_space(umap, space) };
        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_map_intersect_range_union_set`.
    pub fn intersect_range_union_set(self, uset: UnionSet) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut uset = uset;
        uset.do_not_free_on_drop();
        let uset = uset.ptr;
        let isl_rs_result = unsafe { isl_union_map_intersect_range_union_set(umap, 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_map_intersect_range_wrapped_domain_union_set`.
    pub fn intersect_range_wrapped_domain_union_set(self, domain: UnionSet)
                                                    -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result =
            unsafe { isl_union_map_intersect_range_wrapped_domain_union_set(umap, domain) };
        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_map_involves_dims`.
    pub fn involves_dims(&self, type_: DimType, first: u32, n: u32) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_union_map_involves_dims(umap, 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_union_map_is_bijective`.
    pub fn is_bijective(&self) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_bijective(umap) };
        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_map_is_disjoint`.
    pub fn is_disjoint(&self, umap2: &UnionMap) -> Result<bool, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let umap1 = umap1.ptr;
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_disjoint(umap1, umap2) };
        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_map_is_empty`.
    pub fn is_empty(&self) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_empty(umap) };
        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_map_is_equal`.
    pub fn is_equal(&self, umap2: &UnionMap) -> Result<bool, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let umap1 = umap1.ptr;
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_equal(umap1, umap2) };
        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_map_is_identity`.
    pub fn is_identity(&self) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_identity(umap) };
        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_map_is_injective`.
    pub fn is_injective(&self) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_injective(umap) };
        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_map_is_single_valued`.
    pub fn is_single_valued(&self) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_single_valued(umap) };
        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_map_is_strict_subset`.
    pub fn is_strict_subset(&self, umap2: &UnionMap) -> Result<bool, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let umap1 = umap1.ptr;
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_strict_subset(umap1, umap2) };
        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_map_is_subset`.
    pub fn is_subset(&self, umap2: &UnionMap) -> Result<bool, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let umap1 = umap1.ptr;
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_is_subset(umap1, umap2) };
        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_map_isa_map`.
    pub fn isa_map(&self) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_isa_map(umap) };
        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_map_lex_ge_at_multi_union_pw_aff`.
    pub fn lex_ge_at_multi_union_pw_aff(self, mupa: MultiUnionPwAff)
                                        -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut mupa = mupa;
        mupa.do_not_free_on_drop();
        let mupa = mupa.ptr;
        let isl_rs_result = unsafe { isl_union_map_lex_ge_at_multi_union_pw_aff(umap, mupa) };
        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_map_lex_ge_union_map`.
    pub fn lex_ge_union_map(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_lex_ge_union_map(umap1, umap2) };
        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_map_lex_gt_at_multi_union_pw_aff`.
    pub fn lex_gt_at_multi_union_pw_aff(self, mupa: MultiUnionPwAff)
                                        -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut mupa = mupa;
        mupa.do_not_free_on_drop();
        let mupa = mupa.ptr;
        let isl_rs_result = unsafe { isl_union_map_lex_gt_at_multi_union_pw_aff(umap, mupa) };
        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_map_lex_gt_union_map`.
    pub fn lex_gt_union_map(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_lex_gt_union_map(umap1, umap2) };
        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_map_lex_le_at_multi_union_pw_aff`.
    pub fn lex_le_at_multi_union_pw_aff(self, mupa: MultiUnionPwAff)
                                        -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut mupa = mupa;
        mupa.do_not_free_on_drop();
        let mupa = mupa.ptr;
        let isl_rs_result = unsafe { isl_union_map_lex_le_at_multi_union_pw_aff(umap, mupa) };
        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_map_lex_le_union_map`.
    pub fn lex_le_union_map(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_lex_le_union_map(umap1, umap2) };
        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_map_lex_lt_at_multi_union_pw_aff`.
    pub fn lex_lt_at_multi_union_pw_aff(self, mupa: MultiUnionPwAff)
                                        -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut mupa = mupa;
        mupa.do_not_free_on_drop();
        let mupa = mupa.ptr;
        let isl_rs_result = unsafe { isl_union_map_lex_lt_at_multi_union_pw_aff(umap, mupa) };
        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_map_lex_lt_union_map`.
    pub fn lex_lt_union_map(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_lex_lt_union_map(umap1, umap2) };
        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_map_lexmax`.
    pub fn lexmax(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_lexmax(umap) };
        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_map_lexmin`.
    pub fn lexmin(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_lexmin(umap) };
        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_map_n_map`.
    pub fn n_map(&self) -> Result<i32, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_n_map(umap) };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = 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_map_params`.
    pub fn params(self) -> Result<Set, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_params(umap) };
        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_map_plain_is_empty`.
    pub fn plain_is_empty(&self) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_plain_is_empty(umap) };
        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_map_plain_is_injective`.
    pub fn plain_is_injective(&self) -> Result<bool, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_plain_is_injective(umap) };
        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_map_plain_unshifted_simple_hull`.
    pub fn plain_unshifted_simple_hull(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_plain_unshifted_simple_hull(umap) };
        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_map_polyhedral_hull`.
    pub fn polyhedral_hull(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_polyhedral_hull(umap) };
        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_map_preimage_domain_multi_aff`.
    pub fn preimage_domain_multi_aff(self, ma: MultiAff) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut ma = ma;
        ma.do_not_free_on_drop();
        let ma = ma.ptr;
        let isl_rs_result = unsafe { isl_union_map_preimage_domain_multi_aff(umap, ma) };
        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_map_preimage_domain_multi_pw_aff`.
    pub fn preimage_domain_multi_pw_aff(self, mpa: MultiPwAff) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut mpa = mpa;
        mpa.do_not_free_on_drop();
        let mpa = mpa.ptr;
        let isl_rs_result = unsafe { isl_union_map_preimage_domain_multi_pw_aff(umap, mpa) };
        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_map_preimage_domain_pw_multi_aff`.
    pub fn preimage_domain_pw_multi_aff(self, pma: PwMultiAff) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut pma = pma;
        pma.do_not_free_on_drop();
        let pma = pma.ptr;
        let isl_rs_result = unsafe { isl_union_map_preimage_domain_pw_multi_aff(umap, pma) };
        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_map_preimage_domain_union_pw_multi_aff`.
    pub fn preimage_domain_union_pw_multi_aff(self, upma: UnionPwMultiAff)
                                              -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut upma = upma;
        upma.do_not_free_on_drop();
        let upma = upma.ptr;
        let isl_rs_result = unsafe { isl_union_map_preimage_domain_union_pw_multi_aff(umap, upma) };
        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_map_preimage_range_multi_aff`.
    pub fn preimage_range_multi_aff(self, ma: MultiAff) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut ma = ma;
        ma.do_not_free_on_drop();
        let ma = ma.ptr;
        let isl_rs_result = unsafe { isl_union_map_preimage_range_multi_aff(umap, ma) };
        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_map_preimage_range_pw_multi_aff`.
    pub fn preimage_range_pw_multi_aff(self, pma: PwMultiAff) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut pma = pma;
        pma.do_not_free_on_drop();
        let pma = pma.ptr;
        let isl_rs_result = unsafe { isl_union_map_preimage_range_pw_multi_aff(umap, pma) };
        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_map_preimage_range_union_pw_multi_aff`.
    pub fn preimage_range_union_pw_multi_aff(self, upma: UnionPwMultiAff)
                                             -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut upma = upma;
        upma.do_not_free_on_drop();
        let upma = upma.ptr;
        let isl_rs_result = unsafe { isl_union_map_preimage_range_union_pw_multi_aff(umap, upma) };
        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_map_product`.
    pub fn product(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_product(umap1, umap2) };
        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_map_project_out`.
    pub fn project_out(self, type_: DimType, first: u32, n: u32) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let type_ = type_.to_i32();
        let isl_rs_result = unsafe { isl_union_map_project_out(umap, type_, first, n) };
        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_map_project_out_all_params`.
    pub fn project_out_all_params(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_project_out_all_params(umap) };
        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_map_project_out_param_id`.
    pub fn project_out_param_id(self, id: Id) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut id = id;
        id.do_not_free_on_drop();
        let id = id.ptr;
        let isl_rs_result = unsafe { isl_union_map_project_out_param_id(umap, id) };
        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_map_project_out_param_id_list`.
    pub fn project_out_param_id_list(self, list: IdList) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut list = list;
        list.do_not_free_on_drop();
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_union_map_project_out_param_id_list(umap, list) };
        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_map_range`.
    pub fn range(self) -> Result<UnionSet, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_range(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_map_range_curry`.
    pub fn range_curry(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_range_curry(umap) };
        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_map_range_factor_domain`.
    pub fn range_factor_domain(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_range_factor_domain(umap) };
        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_map_range_factor_range`.
    pub fn range_factor_range(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_range_factor_range(umap) };
        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_map_range_map`.
    pub fn range_map(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_range_map(umap) };
        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_map_range_product`.
    pub fn range_product(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_range_product(umap1, umap2) };
        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_map_range_reverse`.
    pub fn range_reverse(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_range_reverse(umap) };
        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_map_read_from_str`.
    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<UnionMap, 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_map_read_from_str(ctx, str_) };
        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_map_remove_divs`.
    pub fn remove_divs(self) -> Result<UnionMap, LibISLError> {
        let bmap = self;
        let isl_rs_ctx = bmap.get_ctx();
        let mut bmap = bmap;
        bmap.do_not_free_on_drop();
        let bmap = bmap.ptr;
        let isl_rs_result = unsafe { isl_union_map_remove_divs(bmap) };
        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_map_remove_redundancies`.
    pub fn remove_redundancies(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_remove_redundancies(umap) };
        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_map_reset_user`.
    pub fn reset_user(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_reset_user(umap) };
        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_map_reverse`.
    pub fn reverse(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_reverse(umap) };
        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_map_sample`.
    pub fn sample(self) -> Result<BasicMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_sample(umap) };
        let isl_rs_result = BasicMap { ptr: isl_rs_result,
                                       should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = 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_map_simple_hull`.
    pub fn simple_hull(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_simple_hull(umap) };
        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_map_subtract`.
    pub fn subtract(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_subtract(umap1, umap2) };
        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_map_subtract_domain`.
    pub fn subtract_domain(self, dom: UnionSet) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut dom = dom;
        dom.do_not_free_on_drop();
        let dom = dom.ptr;
        let isl_rs_result = unsafe { isl_union_map_subtract_domain(umap, dom) };
        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_map_subtract_range`.
    pub fn subtract_range(self, dom: UnionSet) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let mut dom = dom;
        dom.do_not_free_on_drop();
        let dom = dom.ptr;
        let isl_rs_result = unsafe { isl_union_map_subtract_range(umap, dom) };
        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_map_to_list`.
    pub fn to_list(self) -> Result<UnionMapList, 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_map_to_list(el) };
        let isl_rs_result = UnionMapList { ptr: isl_rs_result,
                                           should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = 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_map_to_str`.
    pub fn to_str(&self) -> Result<&str, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_to_str(umap) };
        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_map_uncurry`.
    pub fn uncurry(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_uncurry(umap) };
        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_map_union`.
    pub fn union(self, umap2: UnionMap) -> Result<UnionMap, LibISLError> {
        let umap1 = self;
        let isl_rs_ctx = umap1.get_ctx();
        let mut umap1 = umap1;
        umap1.do_not_free_on_drop();
        let umap1 = umap1.ptr;
        let mut umap2 = umap2;
        umap2.do_not_free_on_drop();
        let umap2 = umap2.ptr;
        let isl_rs_result = unsafe { isl_union_map_union(umap1, umap2) };
        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_map_universe`.
    pub fn universe(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_universe(umap) };
        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_map_wrap`.
    pub fn wrap(self) -> Result<UnionSet, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_wrap(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_map_zip`.
    pub fn zip(self) -> Result<UnionMap, LibISLError> {
        let umap = self;
        let isl_rs_ctx = umap.get_ctx();
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_union_map_zip(umap) };
        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_map_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 UnionMap {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_union_map_free(self.ptr);
            }
        }
    }
}