isl_rs/bindings/
vec.rs

1// Automatically generated by isl_bindings_generator.
2// LICENSE: MIT
3
4use super::{Context, Error, LibISLError, Mat, Val};
5use libc::uintptr_t;
6
7/// Wraps `isl_vec`.
8pub struct Vec {
9    pub ptr: uintptr_t,
10    pub should_free_on_drop: bool,
11}
12
13extern "C" {
14
15    fn isl_vec_add(vec1: uintptr_t, vec2: uintptr_t) -> uintptr_t;
16
17    fn isl_vec_add_els(vec: uintptr_t, n: u32) -> uintptr_t;
18
19    fn isl_vec_alloc(ctx: uintptr_t, size: u32) -> uintptr_t;
20
21    fn isl_vec_ceil(vec: uintptr_t) -> uintptr_t;
22
23    fn isl_vec_clr(vec: uintptr_t) -> uintptr_t;
24
25    fn isl_vec_cmp_element(vec1: uintptr_t, vec2: uintptr_t, pos: i32) -> i32;
26
27    fn isl_vec_concat(vec1: uintptr_t, vec2: uintptr_t) -> uintptr_t;
28
29    fn isl_vec_copy(vec: uintptr_t) -> uintptr_t;
30
31    fn isl_vec_drop_els(vec: uintptr_t, pos: u32, n: u32) -> uintptr_t;
32
33    fn isl_vec_dump(vec: uintptr_t) -> ();
34
35    fn isl_vec_extend(vec: uintptr_t, size: u32) -> uintptr_t;
36
37    fn isl_vec_free(vec: uintptr_t) -> uintptr_t;
38
39    fn isl_vec_get_ctx(vec: uintptr_t) -> uintptr_t;
40
41    fn isl_vec_get_element_val(vec: uintptr_t, pos: i32) -> uintptr_t;
42
43    fn isl_vec_insert_els(vec: uintptr_t, pos: u32, n: u32) -> uintptr_t;
44
45    fn isl_vec_insert_zero_els(vec: uintptr_t, pos: u32, n: u32) -> uintptr_t;
46
47    fn isl_vec_is_equal(vec1: uintptr_t, vec2: uintptr_t) -> i32;
48
49    fn isl_vec_mat_product(vec: uintptr_t, mat: uintptr_t) -> uintptr_t;
50
51    fn isl_vec_move_els(vec: uintptr_t, dst_col: u32, src_col: u32, n: u32) -> uintptr_t;
52
53    fn isl_vec_neg(vec: uintptr_t) -> uintptr_t;
54
55    fn isl_vec_normalize(vec: uintptr_t) -> uintptr_t;
56
57    fn isl_vec_set_element_si(vec: uintptr_t, pos: i32, v: i32) -> uintptr_t;
58
59    fn isl_vec_set_element_val(vec: uintptr_t, pos: i32, v: uintptr_t) -> uintptr_t;
60
61    fn isl_vec_set_si(vec: uintptr_t, v: i32) -> uintptr_t;
62
63    fn isl_vec_set_val(vec: uintptr_t, v: uintptr_t) -> uintptr_t;
64
65    fn isl_vec_size(vec: uintptr_t) -> i32;
66
67    fn isl_vec_sort(vec: uintptr_t) -> uintptr_t;
68
69    fn isl_vec_zero(ctx: uintptr_t, size: u32) -> uintptr_t;
70
71    fn isl_vec_zero_extend(vec: uintptr_t, size: u32) -> uintptr_t;
72
73}
74
75impl Vec {
76    /// Wraps `isl_vec_add`.
77    pub fn add(self, vec2: Vec) -> Result<Vec, LibISLError> {
78        let vec1 = self;
79        let isl_rs_ctx = vec1.get_ctx();
80        let mut vec1 = vec1;
81        vec1.do_not_free_on_drop();
82        let vec1 = vec1.ptr;
83        let mut vec2 = vec2;
84        vec2.do_not_free_on_drop();
85        let vec2 = vec2.ptr;
86        let isl_rs_result = unsafe { isl_vec_add(vec1, vec2) };
87        let isl_rs_result = Vec { ptr: isl_rs_result,
88                                  should_free_on_drop: true };
89        let err = isl_rs_ctx.last_error();
90        if err != Error::None_ {
91            let err_msg = isl_rs_ctx.last_error_msg();
92            isl_rs_ctx.reset_error();
93            return Err(LibISLError::new(err, err_msg));
94        }
95        Ok(isl_rs_result)
96    }
97
98    /// Wraps `isl_vec_add_els`.
99    pub fn add_els(self, n: u32) -> Result<Vec, LibISLError> {
100        let vec = self;
101        let isl_rs_ctx = vec.get_ctx();
102        let mut vec = vec;
103        vec.do_not_free_on_drop();
104        let vec = vec.ptr;
105        let isl_rs_result = unsafe { isl_vec_add_els(vec, n) };
106        let isl_rs_result = Vec { ptr: isl_rs_result,
107                                  should_free_on_drop: true };
108        let err = isl_rs_ctx.last_error();
109        if err != Error::None_ {
110            let err_msg = isl_rs_ctx.last_error_msg();
111            isl_rs_ctx.reset_error();
112            return Err(LibISLError::new(err, err_msg));
113        }
114        Ok(isl_rs_result)
115    }
116
117    /// Wraps `isl_vec_alloc`.
118    pub fn alloc(ctx: &Context, size: u32) -> Result<Vec, LibISLError> {
119        let isl_rs_ctx = Context { ptr: ctx.ptr,
120                                   should_free_on_drop: false };
121        let ctx = ctx.ptr;
122        let isl_rs_result = unsafe { isl_vec_alloc(ctx, size) };
123        let isl_rs_result = Vec { ptr: isl_rs_result,
124                                  should_free_on_drop: true };
125        let err = isl_rs_ctx.last_error();
126        if err != Error::None_ {
127            let err_msg = isl_rs_ctx.last_error_msg();
128            isl_rs_ctx.reset_error();
129            return Err(LibISLError::new(err, err_msg));
130        }
131        Ok(isl_rs_result)
132    }
133
134    /// Wraps `isl_vec_ceil`.
135    pub fn ceil(self) -> Result<Vec, LibISLError> {
136        let vec = self;
137        let isl_rs_ctx = vec.get_ctx();
138        let mut vec = vec;
139        vec.do_not_free_on_drop();
140        let vec = vec.ptr;
141        let isl_rs_result = unsafe { isl_vec_ceil(vec) };
142        let isl_rs_result = Vec { ptr: isl_rs_result,
143                                  should_free_on_drop: true };
144        let err = isl_rs_ctx.last_error();
145        if err != Error::None_ {
146            let err_msg = isl_rs_ctx.last_error_msg();
147            isl_rs_ctx.reset_error();
148            return Err(LibISLError::new(err, err_msg));
149        }
150        Ok(isl_rs_result)
151    }
152
153    /// Wraps `isl_vec_clr`.
154    pub fn clr(self) -> Result<Vec, LibISLError> {
155        let vec = self;
156        let isl_rs_ctx = vec.get_ctx();
157        let mut vec = vec;
158        vec.do_not_free_on_drop();
159        let vec = vec.ptr;
160        let isl_rs_result = unsafe { isl_vec_clr(vec) };
161        let isl_rs_result = Vec { ptr: isl_rs_result,
162                                  should_free_on_drop: true };
163        let err = isl_rs_ctx.last_error();
164        if err != Error::None_ {
165            let err_msg = isl_rs_ctx.last_error_msg();
166            isl_rs_ctx.reset_error();
167            return Err(LibISLError::new(err, err_msg));
168        }
169        Ok(isl_rs_result)
170    }
171
172    /// Wraps `isl_vec_cmp_element`.
173    pub fn cmp_element(&self, vec2: &Vec, pos: i32) -> Result<i32, LibISLError> {
174        let vec1 = self;
175        let isl_rs_ctx = vec1.get_ctx();
176        let vec1 = vec1.ptr;
177        let vec2 = vec2.ptr;
178        let isl_rs_result = unsafe { isl_vec_cmp_element(vec1, vec2, pos) };
179        let err = isl_rs_ctx.last_error();
180        if err != Error::None_ {
181            let err_msg = isl_rs_ctx.last_error_msg();
182            isl_rs_ctx.reset_error();
183            return Err(LibISLError::new(err, err_msg));
184        }
185        Ok(isl_rs_result)
186    }
187
188    /// Wraps `isl_vec_concat`.
189    pub fn concat(self, vec2: Vec) -> Result<Vec, LibISLError> {
190        let vec1 = self;
191        let isl_rs_ctx = vec1.get_ctx();
192        let mut vec1 = vec1;
193        vec1.do_not_free_on_drop();
194        let vec1 = vec1.ptr;
195        let mut vec2 = vec2;
196        vec2.do_not_free_on_drop();
197        let vec2 = vec2.ptr;
198        let isl_rs_result = unsafe { isl_vec_concat(vec1, vec2) };
199        let isl_rs_result = Vec { ptr: isl_rs_result,
200                                  should_free_on_drop: true };
201        let err = isl_rs_ctx.last_error();
202        if err != Error::None_ {
203            let err_msg = isl_rs_ctx.last_error_msg();
204            isl_rs_ctx.reset_error();
205            return Err(LibISLError::new(err, err_msg));
206        }
207        Ok(isl_rs_result)
208    }
209
210    /// Wraps `isl_vec_copy`.
211    pub fn copy(&self) -> Result<Vec, LibISLError> {
212        let vec = self;
213        let isl_rs_ctx = vec.get_ctx();
214        let vec = vec.ptr;
215        let isl_rs_result = unsafe { isl_vec_copy(vec) };
216        let isl_rs_result = Vec { ptr: isl_rs_result,
217                                  should_free_on_drop: true };
218        let err = isl_rs_ctx.last_error();
219        if err != Error::None_ {
220            let err_msg = isl_rs_ctx.last_error_msg();
221            isl_rs_ctx.reset_error();
222            return Err(LibISLError::new(err, err_msg));
223        }
224        Ok(isl_rs_result)
225    }
226
227    /// Wraps `isl_vec_drop_els`.
228    pub fn drop_els(self, pos: u32, n: u32) -> Result<Vec, LibISLError> {
229        let vec = self;
230        let isl_rs_ctx = vec.get_ctx();
231        let mut vec = vec;
232        vec.do_not_free_on_drop();
233        let vec = vec.ptr;
234        let isl_rs_result = unsafe { isl_vec_drop_els(vec, pos, n) };
235        let isl_rs_result = Vec { ptr: isl_rs_result,
236                                  should_free_on_drop: true };
237        let err = isl_rs_ctx.last_error();
238        if err != Error::None_ {
239            let err_msg = isl_rs_ctx.last_error_msg();
240            isl_rs_ctx.reset_error();
241            return Err(LibISLError::new(err, err_msg));
242        }
243        Ok(isl_rs_result)
244    }
245
246    /// Wraps `isl_vec_dump`.
247    pub fn dump(&self) -> Result<(), LibISLError> {
248        let vec = self;
249        let isl_rs_ctx = vec.get_ctx();
250        let vec = vec.ptr;
251        let isl_rs_result = unsafe { isl_vec_dump(vec) };
252        let err = isl_rs_ctx.last_error();
253        if err != Error::None_ {
254            let err_msg = isl_rs_ctx.last_error_msg();
255            isl_rs_ctx.reset_error();
256            return Err(LibISLError::new(err, err_msg));
257        }
258        Ok(isl_rs_result)
259    }
260
261    /// Wraps `isl_vec_extend`.
262    pub fn extend(self, size: u32) -> Result<Vec, LibISLError> {
263        let vec = self;
264        let isl_rs_ctx = vec.get_ctx();
265        let mut vec = vec;
266        vec.do_not_free_on_drop();
267        let vec = vec.ptr;
268        let isl_rs_result = unsafe { isl_vec_extend(vec, size) };
269        let isl_rs_result = Vec { ptr: isl_rs_result,
270                                  should_free_on_drop: true };
271        let err = isl_rs_ctx.last_error();
272        if err != Error::None_ {
273            let err_msg = isl_rs_ctx.last_error_msg();
274            isl_rs_ctx.reset_error();
275            return Err(LibISLError::new(err, err_msg));
276        }
277        Ok(isl_rs_result)
278    }
279
280    /// Wraps `isl_vec_free`.
281    pub fn free(self) -> Result<Vec, LibISLError> {
282        let vec = self;
283        let isl_rs_ctx = vec.get_ctx();
284        let mut vec = vec;
285        vec.do_not_free_on_drop();
286        let vec = vec.ptr;
287        let isl_rs_result = unsafe { isl_vec_free(vec) };
288        let isl_rs_result = Vec { ptr: isl_rs_result,
289                                  should_free_on_drop: true };
290        let err = isl_rs_ctx.last_error();
291        if err != Error::None_ {
292            let err_msg = isl_rs_ctx.last_error_msg();
293            isl_rs_ctx.reset_error();
294            return Err(LibISLError::new(err, err_msg));
295        }
296        Ok(isl_rs_result)
297    }
298
299    /// Wraps `isl_vec_get_ctx`.
300    pub fn get_ctx(&self) -> Context {
301        let vec = self;
302        let vec = vec.ptr;
303        let isl_rs_result = unsafe { isl_vec_get_ctx(vec) };
304        let isl_rs_result = Context { ptr: isl_rs_result,
305                                      should_free_on_drop: false };
306        isl_rs_result
307    }
308
309    /// Wraps `isl_vec_get_element_val`.
310    pub fn get_element_val(&self, pos: i32) -> Result<Val, LibISLError> {
311        let vec = self;
312        let isl_rs_ctx = vec.get_ctx();
313        let vec = vec.ptr;
314        let isl_rs_result = unsafe { isl_vec_get_element_val(vec, pos) };
315        let isl_rs_result = Val { ptr: isl_rs_result,
316                                  should_free_on_drop: true };
317        let err = isl_rs_ctx.last_error();
318        if err != Error::None_ {
319            let err_msg = isl_rs_ctx.last_error_msg();
320            isl_rs_ctx.reset_error();
321            return Err(LibISLError::new(err, err_msg));
322        }
323        Ok(isl_rs_result)
324    }
325
326    /// Wraps `isl_vec_insert_els`.
327    pub fn insert_els(self, pos: u32, n: u32) -> Result<Vec, LibISLError> {
328        let vec = self;
329        let isl_rs_ctx = vec.get_ctx();
330        let mut vec = vec;
331        vec.do_not_free_on_drop();
332        let vec = vec.ptr;
333        let isl_rs_result = unsafe { isl_vec_insert_els(vec, pos, n) };
334        let isl_rs_result = Vec { ptr: isl_rs_result,
335                                  should_free_on_drop: true };
336        let err = isl_rs_ctx.last_error();
337        if err != Error::None_ {
338            let err_msg = isl_rs_ctx.last_error_msg();
339            isl_rs_ctx.reset_error();
340            return Err(LibISLError::new(err, err_msg));
341        }
342        Ok(isl_rs_result)
343    }
344
345    /// Wraps `isl_vec_insert_zero_els`.
346    pub fn insert_zero_els(self, pos: u32, n: u32) -> Result<Vec, LibISLError> {
347        let vec = self;
348        let isl_rs_ctx = vec.get_ctx();
349        let mut vec = vec;
350        vec.do_not_free_on_drop();
351        let vec = vec.ptr;
352        let isl_rs_result = unsafe { isl_vec_insert_zero_els(vec, pos, n) };
353        let isl_rs_result = Vec { ptr: isl_rs_result,
354                                  should_free_on_drop: true };
355        let err = isl_rs_ctx.last_error();
356        if err != Error::None_ {
357            let err_msg = isl_rs_ctx.last_error_msg();
358            isl_rs_ctx.reset_error();
359            return Err(LibISLError::new(err, err_msg));
360        }
361        Ok(isl_rs_result)
362    }
363
364    /// Wraps `isl_vec_is_equal`.
365    pub fn is_equal(&self, vec2: &Vec) -> Result<bool, LibISLError> {
366        let vec1 = self;
367        let isl_rs_ctx = vec1.get_ctx();
368        let vec1 = vec1.ptr;
369        let vec2 = vec2.ptr;
370        let isl_rs_result = unsafe { isl_vec_is_equal(vec1, vec2) };
371        let isl_rs_result = match isl_rs_result {
372            0 => false,
373            1 => true,
374            _ => {
375                return Err(LibISLError::new(Error::Unknown, "Got isl_bool = -1"));
376            }
377        };
378        let err = isl_rs_ctx.last_error();
379        if err != Error::None_ {
380            let err_msg = isl_rs_ctx.last_error_msg();
381            isl_rs_ctx.reset_error();
382            return Err(LibISLError::new(err, err_msg));
383        }
384        Ok(isl_rs_result)
385    }
386
387    /// Wraps `isl_vec_mat_product`.
388    pub fn mat_product(self, mat: Mat) -> Result<Vec, LibISLError> {
389        let vec = self;
390        let isl_rs_ctx = vec.get_ctx();
391        let mut vec = vec;
392        vec.do_not_free_on_drop();
393        let vec = vec.ptr;
394        let mut mat = mat;
395        mat.do_not_free_on_drop();
396        let mat = mat.ptr;
397        let isl_rs_result = unsafe { isl_vec_mat_product(vec, mat) };
398        let isl_rs_result = Vec { ptr: isl_rs_result,
399                                  should_free_on_drop: true };
400        let err = isl_rs_ctx.last_error();
401        if err != Error::None_ {
402            let err_msg = isl_rs_ctx.last_error_msg();
403            isl_rs_ctx.reset_error();
404            return Err(LibISLError::new(err, err_msg));
405        }
406        Ok(isl_rs_result)
407    }
408
409    /// Wraps `isl_vec_move_els`.
410    pub fn move_els(self, dst_col: u32, src_col: u32, n: u32) -> Result<Vec, LibISLError> {
411        let vec = self;
412        let isl_rs_ctx = vec.get_ctx();
413        let mut vec = vec;
414        vec.do_not_free_on_drop();
415        let vec = vec.ptr;
416        let isl_rs_result = unsafe { isl_vec_move_els(vec, dst_col, src_col, n) };
417        let isl_rs_result = Vec { ptr: isl_rs_result,
418                                  should_free_on_drop: true };
419        let err = isl_rs_ctx.last_error();
420        if err != Error::None_ {
421            let err_msg = isl_rs_ctx.last_error_msg();
422            isl_rs_ctx.reset_error();
423            return Err(LibISLError::new(err, err_msg));
424        }
425        Ok(isl_rs_result)
426    }
427
428    /// Wraps `isl_vec_neg`.
429    pub fn neg(self) -> Result<Vec, LibISLError> {
430        let vec = self;
431        let isl_rs_ctx = vec.get_ctx();
432        let mut vec = vec;
433        vec.do_not_free_on_drop();
434        let vec = vec.ptr;
435        let isl_rs_result = unsafe { isl_vec_neg(vec) };
436        let isl_rs_result = Vec { ptr: isl_rs_result,
437                                  should_free_on_drop: true };
438        let err = isl_rs_ctx.last_error();
439        if err != Error::None_ {
440            let err_msg = isl_rs_ctx.last_error_msg();
441            isl_rs_ctx.reset_error();
442            return Err(LibISLError::new(err, err_msg));
443        }
444        Ok(isl_rs_result)
445    }
446
447    /// Wraps `isl_vec_normalize`.
448    pub fn normalize(self) -> Result<Vec, LibISLError> {
449        let vec = self;
450        let isl_rs_ctx = vec.get_ctx();
451        let mut vec = vec;
452        vec.do_not_free_on_drop();
453        let vec = vec.ptr;
454        let isl_rs_result = unsafe { isl_vec_normalize(vec) };
455        let isl_rs_result = Vec { ptr: isl_rs_result,
456                                  should_free_on_drop: true };
457        let err = isl_rs_ctx.last_error();
458        if err != Error::None_ {
459            let err_msg = isl_rs_ctx.last_error_msg();
460            isl_rs_ctx.reset_error();
461            return Err(LibISLError::new(err, err_msg));
462        }
463        Ok(isl_rs_result)
464    }
465
466    /// Wraps `isl_vec_set_element_si`.
467    pub fn set_element_si(self, pos: i32, v: i32) -> Result<Vec, LibISLError> {
468        let vec = self;
469        let isl_rs_ctx = vec.get_ctx();
470        let mut vec = vec;
471        vec.do_not_free_on_drop();
472        let vec = vec.ptr;
473        let isl_rs_result = unsafe { isl_vec_set_element_si(vec, pos, v) };
474        let isl_rs_result = Vec { ptr: isl_rs_result,
475                                  should_free_on_drop: true };
476        let err = isl_rs_ctx.last_error();
477        if err != Error::None_ {
478            let err_msg = isl_rs_ctx.last_error_msg();
479            isl_rs_ctx.reset_error();
480            return Err(LibISLError::new(err, err_msg));
481        }
482        Ok(isl_rs_result)
483    }
484
485    /// Wraps `isl_vec_set_element_val`.
486    pub fn set_element_val(self, pos: i32, v: Val) -> Result<Vec, LibISLError> {
487        let vec = self;
488        let isl_rs_ctx = vec.get_ctx();
489        let mut vec = vec;
490        vec.do_not_free_on_drop();
491        let vec = vec.ptr;
492        let mut v = v;
493        v.do_not_free_on_drop();
494        let v = v.ptr;
495        let isl_rs_result = unsafe { isl_vec_set_element_val(vec, pos, v) };
496        let isl_rs_result = Vec { ptr: isl_rs_result,
497                                  should_free_on_drop: true };
498        let err = isl_rs_ctx.last_error();
499        if err != Error::None_ {
500            let err_msg = isl_rs_ctx.last_error_msg();
501            isl_rs_ctx.reset_error();
502            return Err(LibISLError::new(err, err_msg));
503        }
504        Ok(isl_rs_result)
505    }
506
507    /// Wraps `isl_vec_set_si`.
508    pub fn set_si(self, v: i32) -> Result<Vec, LibISLError> {
509        let vec = self;
510        let isl_rs_ctx = vec.get_ctx();
511        let mut vec = vec;
512        vec.do_not_free_on_drop();
513        let vec = vec.ptr;
514        let isl_rs_result = unsafe { isl_vec_set_si(vec, v) };
515        let isl_rs_result = Vec { ptr: isl_rs_result,
516                                  should_free_on_drop: true };
517        let err = isl_rs_ctx.last_error();
518        if err != Error::None_ {
519            let err_msg = isl_rs_ctx.last_error_msg();
520            isl_rs_ctx.reset_error();
521            return Err(LibISLError::new(err, err_msg));
522        }
523        Ok(isl_rs_result)
524    }
525
526    /// Wraps `isl_vec_set_val`.
527    pub fn set_val(self, v: Val) -> Result<Vec, LibISLError> {
528        let vec = self;
529        let isl_rs_ctx = vec.get_ctx();
530        let mut vec = vec;
531        vec.do_not_free_on_drop();
532        let vec = vec.ptr;
533        let mut v = v;
534        v.do_not_free_on_drop();
535        let v = v.ptr;
536        let isl_rs_result = unsafe { isl_vec_set_val(vec, v) };
537        let isl_rs_result = Vec { ptr: isl_rs_result,
538                                  should_free_on_drop: true };
539        let err = isl_rs_ctx.last_error();
540        if err != Error::None_ {
541            let err_msg = isl_rs_ctx.last_error_msg();
542            isl_rs_ctx.reset_error();
543            return Err(LibISLError::new(err, err_msg));
544        }
545        Ok(isl_rs_result)
546    }
547
548    /// Wraps `isl_vec_size`.
549    pub fn size(&self) -> Result<i32, LibISLError> {
550        let vec = self;
551        let isl_rs_ctx = vec.get_ctx();
552        let vec = vec.ptr;
553        let isl_rs_result = unsafe { isl_vec_size(vec) };
554        let err = isl_rs_ctx.last_error();
555        if err != Error::None_ {
556            let err_msg = isl_rs_ctx.last_error_msg();
557            isl_rs_ctx.reset_error();
558            return Err(LibISLError::new(err, err_msg));
559        }
560        Ok(isl_rs_result)
561    }
562
563    /// Wraps `isl_vec_sort`.
564    pub fn sort(self) -> Result<Vec, LibISLError> {
565        let vec = self;
566        let isl_rs_ctx = vec.get_ctx();
567        let mut vec = vec;
568        vec.do_not_free_on_drop();
569        let vec = vec.ptr;
570        let isl_rs_result = unsafe { isl_vec_sort(vec) };
571        let isl_rs_result = Vec { ptr: isl_rs_result,
572                                  should_free_on_drop: true };
573        let err = isl_rs_ctx.last_error();
574        if err != Error::None_ {
575            let err_msg = isl_rs_ctx.last_error_msg();
576            isl_rs_ctx.reset_error();
577            return Err(LibISLError::new(err, err_msg));
578        }
579        Ok(isl_rs_result)
580    }
581
582    /// Wraps `isl_vec_zero`.
583    pub fn zero(ctx: &Context, size: u32) -> Result<Vec, LibISLError> {
584        let isl_rs_ctx = Context { ptr: ctx.ptr,
585                                   should_free_on_drop: false };
586        let ctx = ctx.ptr;
587        let isl_rs_result = unsafe { isl_vec_zero(ctx, size) };
588        let isl_rs_result = Vec { ptr: isl_rs_result,
589                                  should_free_on_drop: true };
590        let err = isl_rs_ctx.last_error();
591        if err != Error::None_ {
592            let err_msg = isl_rs_ctx.last_error_msg();
593            isl_rs_ctx.reset_error();
594            return Err(LibISLError::new(err, err_msg));
595        }
596        Ok(isl_rs_result)
597    }
598
599    /// Wraps `isl_vec_zero_extend`.
600    pub fn zero_extend(self, size: u32) -> Result<Vec, LibISLError> {
601        let vec = self;
602        let isl_rs_ctx = vec.get_ctx();
603        let mut vec = vec;
604        vec.do_not_free_on_drop();
605        let vec = vec.ptr;
606        let isl_rs_result = unsafe { isl_vec_zero_extend(vec, size) };
607        let isl_rs_result = Vec { ptr: isl_rs_result,
608                                  should_free_on_drop: true };
609        let err = isl_rs_ctx.last_error();
610        if err != Error::None_ {
611            let err_msg = isl_rs_ctx.last_error_msg();
612            isl_rs_ctx.reset_error();
613            return Err(LibISLError::new(err, err_msg));
614        }
615        Ok(isl_rs_result)
616    }
617
618    /// Does not call isl_vec_free() on being dropped. (For internal use only.)
619    pub fn do_not_free_on_drop(&mut self) {
620        self.should_free_on_drop = false;
621    }
622}
623
624impl Drop for Vec {
625    fn drop(&mut self) {
626        if self.should_free_on_drop {
627            unsafe {
628                isl_vec_free(self.ptr);
629            }
630        }
631    }
632}
isl_rs/bindings/vec.rs

isl_rs/bindings/
vec.rs
