isl-rs 0.3.1

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

use super::{Context, Error, LibISLError, Schedule, Set, UnionMap, UnionSet};
use libc::uintptr_t;
use std::ffi::{CStr, CString};
use std::os::raw::c_char;

/// Wraps `isl_schedule_constraints`.
pub struct ScheduleConstraints {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_schedule_constraints_apply(sc: uintptr_t, umap: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_compute_schedule(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_copy(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_dump(sc: uintptr_t) -> ();

    fn isl_schedule_constraints_free(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_get_coincidence(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_get_conditional_validity(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_get_conditional_validity_condition(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_get_context(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_get_ctx(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_get_domain(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_get_proximity(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_get_validity(sc: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_on_domain(domain: uintptr_t) -> uintptr_t;

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

    fn isl_schedule_constraints_set_coincidence(sc: uintptr_t, coincidence: uintptr_t)
                                                -> uintptr_t;

    fn isl_schedule_constraints_set_conditional_validity(sc: uintptr_t, condition: uintptr_t,
                                                         validity: uintptr_t)
                                                         -> uintptr_t;

    fn isl_schedule_constraints_set_context(sc: uintptr_t, context: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_set_proximity(sc: uintptr_t, proximity: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_set_validity(sc: uintptr_t, validity: uintptr_t) -> uintptr_t;

    fn isl_schedule_constraints_to_str(sc: uintptr_t) -> *const c_char;

}

impl ScheduleConstraints {
    /// Wraps `isl_schedule_constraints_apply`.
    pub fn apply(self, umap: UnionMap) -> Result<ScheduleConstraints, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let mut sc = sc;
        sc.do_not_free_on_drop();
        let sc = sc.ptr;
        let mut umap = umap;
        umap.do_not_free_on_drop();
        let umap = umap.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_apply(sc, umap) };
        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
                                                  should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

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

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

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

    /// Wraps `isl_schedule_constraints_get_coincidence`.
    pub fn get_coincidence(&self) -> Result<UnionMap, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_get_coincidence(sc) };
        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_schedule_constraints_get_conditional_validity`.
    pub fn get_conditional_validity(&self) -> Result<UnionMap, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_get_conditional_validity(sc) };
        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_schedule_constraints_get_conditional_validity_condition`.
    pub fn get_conditional_validity_condition(&self) -> Result<UnionMap, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let sc = sc.ptr;
        let isl_rs_result =
            unsafe { isl_schedule_constraints_get_conditional_validity_condition(sc) };
        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_schedule_constraints_get_context`.
    pub fn get_context(&self) -> Result<Set, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_get_context(sc) };
        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_schedule_constraints_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let sc = self;
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_get_ctx(sc) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

    /// Wraps `isl_schedule_constraints_get_domain`.
    pub fn get_domain(&self) -> Result<UnionSet, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_get_domain(sc) };
        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_schedule_constraints_get_proximity`.
    pub fn get_proximity(&self) -> Result<UnionMap, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_get_proximity(sc) };
        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_schedule_constraints_get_validity`.
    pub fn get_validity(&self) -> Result<UnionMap, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_get_validity(sc) };
        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_schedule_constraints_on_domain`.
    pub fn on_domain(domain: UnionSet) -> Result<ScheduleConstraints, LibISLError> {
        let isl_rs_ctx = domain.get_ctx();
        let mut domain = domain;
        domain.do_not_free_on_drop();
        let domain = domain.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_on_domain(domain) };
        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
                                                  should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

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

    /// Wraps `isl_schedule_constraints_set_conditional_validity`.
    pub fn set_conditional_validity(self, condition: UnionMap, validity: UnionMap)
                                    -> Result<ScheduleConstraints, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let mut sc = sc;
        sc.do_not_free_on_drop();
        let sc = sc.ptr;
        let mut condition = condition;
        condition.do_not_free_on_drop();
        let condition = condition.ptr;
        let mut validity = validity;
        validity.do_not_free_on_drop();
        let validity = validity.ptr;
        let isl_rs_result =
            unsafe { isl_schedule_constraints_set_conditional_validity(sc, condition, validity) };
        let isl_rs_result = ScheduleConstraints { ptr: isl_rs_result,
                                                  should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

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

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

    /// Wraps `isl_schedule_constraints_to_str`.
    pub fn to_str(&self) -> Result<&str, LibISLError> {
        let sc = self;
        let isl_rs_ctx = sc.get_ctx();
        let sc = sc.ptr;
        let isl_rs_result = unsafe { isl_schedule_constraints_to_str(sc) };
        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_schedule_constraints_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 ScheduleConstraints {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_schedule_constraints_free(self.ptr);
            }
        }
    }
}