isl_rs/bindings/
stride_info.rs1use super::{Aff, Context, Error, LibISLError, Val};
5use libc::uintptr_t;
6
7pub struct StrideInfo {
9 pub ptr: uintptr_t,
10 pub should_free_on_drop: bool,
11}
12
13extern "C" {
14
15 fn isl_stride_info_copy(si: uintptr_t) -> uintptr_t;
16
17 fn isl_stride_info_free(si: uintptr_t) -> uintptr_t;
18
19 fn isl_stride_info_get_ctx(si: uintptr_t) -> uintptr_t;
20
21 fn isl_stride_info_get_offset(si: uintptr_t) -> uintptr_t;
22
23 fn isl_stride_info_get_stride(si: uintptr_t) -> uintptr_t;
24
25}
26
27impl StrideInfo {
28 pub fn copy(&self) -> Result<StrideInfo, LibISLError> {
30 let si = self;
31 let isl_rs_ctx = si.get_ctx();
32 let si = si.ptr;
33 let isl_rs_result = unsafe { isl_stride_info_copy(si) };
34 let isl_rs_result = StrideInfo { ptr: isl_rs_result,
35 should_free_on_drop: true };
36 let err = isl_rs_ctx.last_error();
37 if err != Error::None_ {
38 let err_msg = isl_rs_ctx.last_error_msg();
39 isl_rs_ctx.reset_error();
40 return Err(LibISLError::new(err, err_msg));
41 }
42 Ok(isl_rs_result)
43 }
44
45 pub fn free(self) -> Result<StrideInfo, LibISLError> {
47 let si = self;
48 let isl_rs_ctx = si.get_ctx();
49 let mut si = si;
50 si.do_not_free_on_drop();
51 let si = si.ptr;
52 let isl_rs_result = unsafe { isl_stride_info_free(si) };
53 let isl_rs_result = StrideInfo { ptr: isl_rs_result,
54 should_free_on_drop: true };
55 let err = isl_rs_ctx.last_error();
56 if err != Error::None_ {
57 let err_msg = isl_rs_ctx.last_error_msg();
58 isl_rs_ctx.reset_error();
59 return Err(LibISLError::new(err, err_msg));
60 }
61 Ok(isl_rs_result)
62 }
63
64 pub fn get_ctx(&self) -> Context {
66 let si = self;
67 let si = si.ptr;
68 let isl_rs_result = unsafe { isl_stride_info_get_ctx(si) };
69 let isl_rs_result = Context { ptr: isl_rs_result,
70 should_free_on_drop: false };
71 isl_rs_result
72 }
73
74 pub fn get_offset(&self) -> Result<Aff, LibISLError> {
76 let si = self;
77 let isl_rs_ctx = si.get_ctx();
78 let si = si.ptr;
79 let isl_rs_result = unsafe { isl_stride_info_get_offset(si) };
80 let isl_rs_result = Aff { ptr: isl_rs_result,
81 should_free_on_drop: true };
82 let err = isl_rs_ctx.last_error();
83 if err != Error::None_ {
84 let err_msg = isl_rs_ctx.last_error_msg();
85 isl_rs_ctx.reset_error();
86 return Err(LibISLError::new(err, err_msg));
87 }
88 Ok(isl_rs_result)
89 }
90
91 pub fn get_stride(&self) -> Result<Val, LibISLError> {
93 let si = self;
94 let isl_rs_ctx = si.get_ctx();
95 let si = si.ptr;
96 let isl_rs_result = unsafe { isl_stride_info_get_stride(si) };
97 let isl_rs_result = Val { ptr: isl_rs_result,
98 should_free_on_drop: true };
99 let err = isl_rs_ctx.last_error();
100 if err != Error::None_ {
101 let err_msg = isl_rs_ctx.last_error_msg();
102 isl_rs_ctx.reset_error();
103 return Err(LibISLError::new(err, err_msg));
104 }
105 Ok(isl_rs_result)
106 }
107
108 pub fn do_not_free_on_drop(&mut self) {
111 self.should_free_on_drop = false;
112 }
113}
114
115impl Drop for StrideInfo {
116 fn drop(&mut self) {
117 if self.should_free_on_drop {
118 unsafe {
119 isl_stride_info_free(self.ptr);
120 }
121 }
122 }
123}