1
pub mod bindings {
2
    #![allow(warnings)]
3
    include!(concat!(env!("OUT_DIR"), "/chuffed_bindings.rs"));
4
}
5

            
6
pub mod wrappers {
7
    use core::ptr;
8

            
9
    use crate::bindings::{
10
        all_different, branch_IntVar, createVar, createVars, int_plus, make_vec_intvar,
11
        output_vars1, var_sym_break, vec, ConLevel, IntVar, ValBranch, VarBranch,
12
    };
13

            
14
    // The signature of createVar is below for reference.
15
    // createVar(x: *mut *mut IntVar, min: ::std::os::raw::c_int, max: ::std::os::raw::c_int, el: bool)
16
    pub fn create_var(min: i32, max: i32, el: bool) -> *mut IntVar {
17
        let mut ptr: *mut IntVar = ptr::null_mut();
18

            
19
        unsafe {
20
            createVar(&mut ptr, min, max, el);
21
            ptr
22
        }
23
    }
24

            
25
    // createVars void createVars(vec<IntVar*>& x, int n, int min, int max, bool el)
26
    pub fn create_vars(n: i32, min: i32, max: i32, el: bool) -> *mut vec<*mut IntVar> {
27
        let ptr: *mut vec<*mut IntVar> = unsafe { make_vec_intvar() };
28

            
29
        unsafe {
30
            createVars(ptr, n, min, max, el);
31
            ptr
32
        }
33
    }
34

            
35
    // void all_different(vec<IntVar*>& x, ConLevel cl)
36
    pub unsafe fn all_different_wrapper(x: *mut vec<*mut IntVar>, cl: ConLevel) {
37
        unsafe {
38
            all_different(x, cl);
39
        }
40
    }
41

            
42
    // void branch(vec<Branching*> x, VarBranch var_branch, ValBranch val_branch);
43
    pub unsafe fn branch_wrapper(
44
        x: *mut vec<*mut IntVar>,
45
        var_branch: VarBranch,
46
        val_branch: ValBranch,
47
    ) {
48
        unsafe {
49
            branch_IntVar(x, var_branch, val_branch);
50
        }
51
    }
52

            
53
    pub unsafe fn output_vars_wrapper(x: *mut vec<*mut IntVar>) {
54
        unsafe {
55
            // output_vars1 takes in an vec<IntVar*> instead of branching
56
            output_vars1(x);
57
        }
58
    }
59

            
60
    pub unsafe fn var_sym_break_wrapper(x: *mut vec<*mut IntVar>) {
61
        unsafe {
62
            var_sym_break(x);
63
        }
64
    }
65

            
66
    pub unsafe fn int_plus_wrapper(x: *mut IntVar, y: *mut IntVar, z: *mut IntVar) {
67
        unsafe {
68
            int_plus(x, y, z);
69
        }
70
    }
71
}