isl-rs 0.3.1

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

use super::{Context, Error, Id, IdList, LibISLError, Space};
use libc::uintptr_t;
use std::ffi::{CStr, CString};
use std::os::raw::c_char;

/// Wraps `isl_multi_id`.
pub struct MultiId {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_multi_id_align_params(multi: uintptr_t, model: uintptr_t) -> uintptr_t;

    fn isl_multi_id_copy(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_dump(mi: uintptr_t) -> ();

    fn isl_multi_id_factor_range(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_flat_range_product(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;

    fn isl_multi_id_flatten_range(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_free(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_from_id_list(space: uintptr_t, list: uintptr_t) -> uintptr_t;

    fn isl_multi_id_from_range(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_get_at(multi: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_multi_id_get_ctx(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_get_domain_space(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_get_id(multi: uintptr_t, pos: i32) -> uintptr_t;

    fn isl_multi_id_get_list(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_get_space(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_plain_is_equal(multi1: uintptr_t, multi2: uintptr_t) -> i32;

    fn isl_multi_id_range_factor_domain(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_range_factor_range(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_range_is_wrapping(multi: uintptr_t) -> i32;

    fn isl_multi_id_range_product(multi1: uintptr_t, multi2: uintptr_t) -> uintptr_t;

    fn isl_multi_id_range_splice(multi1: uintptr_t, pos: u32, multi2: uintptr_t) -> uintptr_t;

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

    fn isl_multi_id_reset_user(multi: uintptr_t) -> uintptr_t;

    fn isl_multi_id_set_at(multi: uintptr_t, pos: i32, el: uintptr_t) -> uintptr_t;

    fn isl_multi_id_set_id(multi: uintptr_t, pos: i32, el: uintptr_t) -> uintptr_t;

    fn isl_multi_id_size(multi: uintptr_t) -> i32;

    fn isl_multi_id_to_str(mi: uintptr_t) -> *const c_char;

}

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

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

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

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

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

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

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

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

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

    /// Wraps `isl_multi_id_get_at`.
    pub fn get_at(&self, pos: i32) -> Result<Id, LibISLError> {
        let multi = self;
        let isl_rs_ctx = multi.get_ctx();
        let multi = multi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_get_at(multi, 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_multi_id_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let multi = self;
        let multi = multi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_get_ctx(multi) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

    /// Wraps `isl_multi_id_get_domain_space`.
    pub fn get_domain_space(&self) -> Result<Space, LibISLError> {
        let multi = self;
        let isl_rs_ctx = multi.get_ctx();
        let multi = multi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_get_domain_space(multi) };
        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_multi_id_get_id`.
    pub fn get_id(&self, pos: i32) -> Result<Id, LibISLError> {
        let multi = self;
        let isl_rs_ctx = multi.get_ctx();
        let multi = multi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_get_id(multi, 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_multi_id_get_list`.
    pub fn get_list(&self) -> Result<IdList, LibISLError> {
        let multi = self;
        let isl_rs_ctx = multi.get_ctx();
        let multi = multi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_get_list(multi) };
        let isl_rs_result = IdList { ptr: isl_rs_result,
                                     should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_multi_id_get_space`.
    pub fn get_space(&self) -> Result<Space, LibISLError> {
        let multi = self;
        let isl_rs_ctx = multi.get_ctx();
        let multi = multi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_get_space(multi) };
        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_multi_id_plain_is_equal`.
    pub fn plain_is_equal(&self, multi2: &MultiId) -> Result<bool, LibISLError> {
        let multi1 = self;
        let isl_rs_ctx = multi1.get_ctx();
        let multi1 = multi1.ptr;
        let multi2 = multi2.ptr;
        let isl_rs_result = unsafe { isl_multi_id_plain_is_equal(multi1, multi2) };
        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_multi_id_range_factor_domain`.
    pub fn range_factor_domain(self) -> Result<MultiId, LibISLError> {
        let multi = self;
        let isl_rs_ctx = multi.get_ctx();
        let mut multi = multi;
        multi.do_not_free_on_drop();
        let multi = multi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_range_factor_domain(multi) };
        let isl_rs_result = MultiId { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

    /// Wraps `isl_multi_id_range_is_wrapping`.
    pub fn range_is_wrapping(&self) -> Result<bool, LibISLError> {
        let multi = self;
        let isl_rs_ctx = multi.get_ctx();
        let multi = multi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_range_is_wrapping(multi) };
        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_multi_id_range_product`.
    pub fn range_product(self, multi2: MultiId) -> Result<MultiId, LibISLError> {
        let multi1 = self;
        let isl_rs_ctx = multi1.get_ctx();
        let mut multi1 = multi1;
        multi1.do_not_free_on_drop();
        let multi1 = multi1.ptr;
        let mut multi2 = multi2;
        multi2.do_not_free_on_drop();
        let multi2 = multi2.ptr;
        let isl_rs_result = unsafe { isl_multi_id_range_product(multi1, multi2) };
        let isl_rs_result = MultiId { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_multi_id_range_splice`.
    pub fn range_splice(self, pos: u32, multi2: MultiId) -> Result<MultiId, LibISLError> {
        let multi1 = self;
        let isl_rs_ctx = multi1.get_ctx();
        let mut multi1 = multi1;
        multi1.do_not_free_on_drop();
        let multi1 = multi1.ptr;
        let mut multi2 = multi2;
        multi2.do_not_free_on_drop();
        let multi2 = multi2.ptr;
        let isl_rs_result = unsafe { isl_multi_id_range_splice(multi1, pos, multi2) };
        let isl_rs_result = MultiId { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_multi_id_read_from_str`.
    pub fn read_from_str(ctx: &Context, str_: &str) -> Result<MultiId, 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_multi_id_read_from_str(ctx, str_) };
        let isl_rs_result = MultiId { ptr: isl_rs_result,
                                      should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

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

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

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

    /// Wraps `isl_multi_id_to_str`.
    pub fn to_str(&self) -> Result<&str, LibISLError> {
        let mi = self;
        let isl_rs_ctx = mi.get_ctx();
        let mi = mi.ptr;
        let isl_rs_result = unsafe { isl_multi_id_to_str(mi) };
        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)
    }

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