isl-rs 0.3.1

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

use super::{ASTExpr, Context, Error, LibISLError};
use libc::uintptr_t;
use std::ffi::CStr;
use std::os::raw::c_char;

/// Wraps `isl_ast_expr_list`.
pub struct ASTExprList {
    pub ptr: uintptr_t,
    pub should_free_on_drop: bool,
}

extern "C" {

    fn isl_ast_expr_list_add(list: uintptr_t, el: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_alloc(ctx: uintptr_t, n: i32) -> uintptr_t;

    fn isl_ast_expr_list_clear(list: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_concat(list1: uintptr_t, list2: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_copy(list: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_drop(list: uintptr_t, first: u32, n: u32) -> uintptr_t;

    fn isl_ast_expr_list_dump(list: uintptr_t) -> ();

    fn isl_ast_expr_list_free(list: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_from_ast_expr(el: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_get_ast_expr(list: uintptr_t, index: i32) -> uintptr_t;

    fn isl_ast_expr_list_get_at(list: uintptr_t, index: i32) -> uintptr_t;

    fn isl_ast_expr_list_get_ctx(list: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_insert(list: uintptr_t, pos: u32, el: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_n_ast_expr(list: uintptr_t) -> i32;

    fn isl_ast_expr_list_reverse(list: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_set_ast_expr(list: uintptr_t, index: i32, el: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_set_at(list: uintptr_t, index: i32, el: uintptr_t) -> uintptr_t;

    fn isl_ast_expr_list_size(list: uintptr_t) -> i32;

    fn isl_ast_expr_list_swap(list: uintptr_t, pos1: u32, pos2: u32) -> uintptr_t;

    fn isl_ast_expr_list_to_str(list: uintptr_t) -> *const c_char;

}

impl ASTExprList {
    /// Wraps `isl_ast_expr_list_add`.
    pub fn add(self, el: ASTExpr) -> Result<ASTExprList, LibISLError> {
        let list = self;
        let isl_rs_ctx = list.get_ctx();
        let mut list = list;
        list.do_not_free_on_drop();
        let list = list.ptr;
        let mut el = el;
        el.do_not_free_on_drop();
        let el = el.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_list_add(list, el) };
        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_list_alloc`.
    pub fn alloc(ctx: &Context, n: i32) -> Result<ASTExprList, LibISLError> {
        let isl_rs_ctx = Context { ptr: ctx.ptr,
                                   should_free_on_drop: false };
        let ctx = ctx.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_list_alloc(ctx, n) };
        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

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

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

    /// Wraps `isl_ast_expr_list_drop`.
    pub fn drop(self, first: u32, n: u32) -> Result<ASTExprList, LibISLError> {
        let list = self;
        let isl_rs_ctx = list.get_ctx();
        let mut list = list;
        list.do_not_free_on_drop();
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_list_drop(list, first, n) };
        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

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

    /// Wraps `isl_ast_expr_list_from_ast_expr`.
    pub fn from_ast_expr(el: ASTExpr) -> Result<ASTExprList, LibISLError> {
        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_ast_expr_list_from_ast_expr(el) };
        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

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

    /// Wraps `isl_ast_expr_list_get_ctx`.
    pub fn get_ctx(&self) -> Context {
        let list = self;
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_list_get_ctx(list) };
        let isl_rs_result = Context { ptr: isl_rs_result,
                                      should_free_on_drop: false };
        isl_rs_result
    }

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

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

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

    /// Wraps `isl_ast_expr_list_set_ast_expr`.
    pub fn set_ast_expr(self, index: i32, el: ASTExpr) -> Result<ASTExprList, LibISLError> {
        let list = self;
        let isl_rs_ctx = list.get_ctx();
        let mut list = list;
        list.do_not_free_on_drop();
        let list = list.ptr;
        let mut el = el;
        el.do_not_free_on_drop();
        let el = el.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_list_set_ast_expr(list, index, el) };
        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

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

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

    /// Wraps `isl_ast_expr_list_swap`.
    pub fn swap(self, pos1: u32, pos2: u32) -> Result<ASTExprList, LibISLError> {
        let list = self;
        let isl_rs_ctx = list.get_ctx();
        let mut list = list;
        list.do_not_free_on_drop();
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_list_swap(list, pos1, pos2) };
        let isl_rs_result = ASTExprList { ptr: isl_rs_result,
                                          should_free_on_drop: true };
        let err = isl_rs_ctx.last_error();
        if err != Error::None_ {
            let err_msg = isl_rs_ctx.last_error_msg();
            isl_rs_ctx.reset_error();
            return Err(LibISLError::new(err, err_msg));
        }
        Ok(isl_rs_result)
    }

    /// Wraps `isl_ast_expr_list_to_str`.
    pub fn to_str(&self) -> Result<&str, LibISLError> {
        let list = self;
        let isl_rs_ctx = list.get_ctx();
        let list = list.ptr;
        let isl_rs_result = unsafe { isl_ast_expr_list_to_str(list) };
        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_ast_expr_list_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 ASTExprList {
    fn drop(&mut self) {
        if self.should_free_on_drop {
            unsafe {
                isl_ast_expr_list_free(self.ptr);
            }
        }
    }
}