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            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
92        }
93        Ok(isl_rs_result)
94    }
95
96    /// Wraps `isl_vec_add_els`.
97    pub fn add_els(self, n: u32) -> Result<Vec, LibISLError> {
98        let vec = self;
99        let isl_rs_ctx = vec.get_ctx();
100        let mut vec = vec;
101        vec.do_not_free_on_drop();
102        let vec = vec.ptr;
103        let isl_rs_result = unsafe { isl_vec_add_els(vec, n) };
104        let isl_rs_result = Vec { ptr: isl_rs_result,
105                                  should_free_on_drop: true };
106        let err = isl_rs_ctx.last_error();
107        if err != Error::None_ {
108            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
109        }
110        Ok(isl_rs_result)
111    }
112
113    /// Wraps `isl_vec_alloc`.
114    pub fn alloc(ctx: &Context, size: u32) -> Result<Vec, LibISLError> {
115        let isl_rs_ctx = Context { ptr: ctx.ptr,
116                                   should_free_on_drop: false };
117        let ctx = ctx.ptr;
118        let isl_rs_result = unsafe { isl_vec_alloc(ctx, size) };
119        let isl_rs_result = Vec { ptr: isl_rs_result,
120                                  should_free_on_drop: true };
121        let err = isl_rs_ctx.last_error();
122        if err != Error::None_ {
123            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
124        }
125        Ok(isl_rs_result)
126    }
127
128    /// Wraps `isl_vec_ceil`.
129    pub fn ceil(self) -> Result<Vec, LibISLError> {
130        let vec = self;
131        let isl_rs_ctx = vec.get_ctx();
132        let mut vec = vec;
133        vec.do_not_free_on_drop();
134        let vec = vec.ptr;
135        let isl_rs_result = unsafe { isl_vec_ceil(vec) };
136        let isl_rs_result = Vec { ptr: isl_rs_result,
137                                  should_free_on_drop: true };
138        let err = isl_rs_ctx.last_error();
139        if err != Error::None_ {
140            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
141        }
142        Ok(isl_rs_result)
143    }
144
145    /// Wraps `isl_vec_clr`.
146    pub fn clr(self) -> Result<Vec, LibISLError> {
147        let vec = self;
148        let isl_rs_ctx = vec.get_ctx();
149        let mut vec = vec;
150        vec.do_not_free_on_drop();
151        let vec = vec.ptr;
152        let isl_rs_result = unsafe { isl_vec_clr(vec) };
153        let isl_rs_result = Vec { ptr: isl_rs_result,
154                                  should_free_on_drop: true };
155        let err = isl_rs_ctx.last_error();
156        if err != Error::None_ {
157            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
158        }
159        Ok(isl_rs_result)
160    }
161
162    /// Wraps `isl_vec_cmp_element`.
163    pub fn cmp_element(&self, vec2: &Vec, pos: i32) -> Result<i32, LibISLError> {
164        let vec1 = self;
165        let isl_rs_ctx = vec1.get_ctx();
166        let vec1 = vec1.ptr;
167        let vec2 = vec2.ptr;
168        let isl_rs_result = unsafe { isl_vec_cmp_element(vec1, vec2, pos) };
169        let err = isl_rs_ctx.last_error();
170        if err != Error::None_ {
171            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
172        }
173        Ok(isl_rs_result)
174    }
175
176    /// Wraps `isl_vec_concat`.
177    pub fn concat(self, vec2: Vec) -> Result<Vec, LibISLError> {
178        let vec1 = self;
179        let isl_rs_ctx = vec1.get_ctx();
180        let mut vec1 = vec1;
181        vec1.do_not_free_on_drop();
182        let vec1 = vec1.ptr;
183        let mut vec2 = vec2;
184        vec2.do_not_free_on_drop();
185        let vec2 = vec2.ptr;
186        let isl_rs_result = unsafe { isl_vec_concat(vec1, vec2) };
187        let isl_rs_result = Vec { ptr: isl_rs_result,
188                                  should_free_on_drop: true };
189        let err = isl_rs_ctx.last_error();
190        if err != Error::None_ {
191            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
192        }
193        Ok(isl_rs_result)
194    }
195
196    /// Wraps `isl_vec_copy`.
197    pub fn copy(&self) -> Result<Vec, LibISLError> {
198        let vec = self;
199        let isl_rs_ctx = vec.get_ctx();
200        let vec = vec.ptr;
201        let isl_rs_result = unsafe { isl_vec_copy(vec) };
202        let isl_rs_result = Vec { ptr: isl_rs_result,
203                                  should_free_on_drop: true };
204        let err = isl_rs_ctx.last_error();
205        if err != Error::None_ {
206            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
207        }
208        Ok(isl_rs_result)
209    }
210
211    /// Wraps `isl_vec_drop_els`.
212    pub fn drop_els(self, pos: u32, n: u32) -> Result<Vec, LibISLError> {
213        let vec = self;
214        let isl_rs_ctx = vec.get_ctx();
215        let mut vec = vec;
216        vec.do_not_free_on_drop();
217        let vec = vec.ptr;
218        let isl_rs_result = unsafe { isl_vec_drop_els(vec, pos, n) };
219        let isl_rs_result = Vec { ptr: isl_rs_result,
220                                  should_free_on_drop: true };
221        let err = isl_rs_ctx.last_error();
222        if err != Error::None_ {
223            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
224        }
225        Ok(isl_rs_result)
226    }
227
228    /// Wraps `isl_vec_dump`.
229    pub fn dump(&self) -> Result<(), LibISLError> {
230        let vec = self;
231        let isl_rs_ctx = vec.get_ctx();
232        let vec = vec.ptr;
233        let isl_rs_result = unsafe { isl_vec_dump(vec) };
234        let err = isl_rs_ctx.last_error();
235        if err != Error::None_ {
236            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
237        }
238        Ok(isl_rs_result)
239    }
240
241    /// Wraps `isl_vec_extend`.
242    pub fn extend(self, size: u32) -> Result<Vec, LibISLError> {
243        let vec = self;
244        let isl_rs_ctx = vec.get_ctx();
245        let mut vec = vec;
246        vec.do_not_free_on_drop();
247        let vec = vec.ptr;
248        let isl_rs_result = unsafe { isl_vec_extend(vec, size) };
249        let isl_rs_result = Vec { ptr: isl_rs_result,
250                                  should_free_on_drop: true };
251        let err = isl_rs_ctx.last_error();
252        if err != Error::None_ {
253            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
254        }
255        Ok(isl_rs_result)
256    }
257
258    /// Wraps `isl_vec_free`.
259    pub fn free(self) -> Result<Vec, LibISLError> {
260        let vec = self;
261        let isl_rs_ctx = vec.get_ctx();
262        let mut vec = vec;
263        vec.do_not_free_on_drop();
264        let vec = vec.ptr;
265        let isl_rs_result = unsafe { isl_vec_free(vec) };
266        let isl_rs_result = Vec { ptr: isl_rs_result,
267                                  should_free_on_drop: true };
268        let err = isl_rs_ctx.last_error();
269        if err != Error::None_ {
270            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
271        }
272        Ok(isl_rs_result)
273    }
274
275    /// Wraps `isl_vec_get_ctx`.
276    pub fn get_ctx(&self) -> Context {
277        let vec = self;
278        let vec = vec.ptr;
279        let isl_rs_result = unsafe { isl_vec_get_ctx(vec) };
280        let isl_rs_result = Context { ptr: isl_rs_result,
281                                      should_free_on_drop: false };
282        isl_rs_result
283    }
284
285    /// Wraps `isl_vec_get_element_val`.
286    pub fn get_element_val(&self, pos: i32) -> Result<Val, LibISLError> {
287        let vec = self;
288        let isl_rs_ctx = vec.get_ctx();
289        let vec = vec.ptr;
290        let isl_rs_result = unsafe { isl_vec_get_element_val(vec, pos) };
291        let isl_rs_result = Val { ptr: isl_rs_result,
292                                  should_free_on_drop: true };
293        let err = isl_rs_ctx.last_error();
294        if err != Error::None_ {
295            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
296        }
297        Ok(isl_rs_result)
298    }
299
300    /// Wraps `isl_vec_insert_els`.
301    pub fn insert_els(self, pos: u32, n: u32) -> Result<Vec, LibISLError> {
302        let vec = self;
303        let isl_rs_ctx = vec.get_ctx();
304        let mut vec = vec;
305        vec.do_not_free_on_drop();
306        let vec = vec.ptr;
307        let isl_rs_result = unsafe { isl_vec_insert_els(vec, pos, n) };
308        let isl_rs_result = Vec { ptr: isl_rs_result,
309                                  should_free_on_drop: true };
310        let err = isl_rs_ctx.last_error();
311        if err != Error::None_ {
312            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
313        }
314        Ok(isl_rs_result)
315    }
316
317    /// Wraps `isl_vec_insert_zero_els`.
318    pub fn insert_zero_els(self, pos: u32, n: u32) -> Result<Vec, LibISLError> {
319        let vec = self;
320        let isl_rs_ctx = vec.get_ctx();
321        let mut vec = vec;
322        vec.do_not_free_on_drop();
323        let vec = vec.ptr;
324        let isl_rs_result = unsafe { isl_vec_insert_zero_els(vec, pos, n) };
325        let isl_rs_result = Vec { ptr: isl_rs_result,
326                                  should_free_on_drop: true };
327        let err = isl_rs_ctx.last_error();
328        if err != Error::None_ {
329            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
330        }
331        Ok(isl_rs_result)
332    }
333
334    /// Wraps `isl_vec_is_equal`.
335    pub fn is_equal(&self, vec2: &Vec) -> Result<bool, LibISLError> {
336        let vec1 = self;
337        let isl_rs_ctx = vec1.get_ctx();
338        let vec1 = vec1.ptr;
339        let vec2 = vec2.ptr;
340        let isl_rs_result = unsafe { isl_vec_is_equal(vec1, vec2) };
341        let isl_rs_result = match isl_rs_result {
342            0 => false,
343            1 => true,
344            _ => panic!("Got isl_bool = -1"),
345        };
346        let err = isl_rs_ctx.last_error();
347        if err != Error::None_ {
348            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
349        }
350        Ok(isl_rs_result)
351    }
352
353    /// Wraps `isl_vec_mat_product`.
354    pub fn mat_product(self, mat: Mat) -> Result<Vec, LibISLError> {
355        let vec = self;
356        let isl_rs_ctx = vec.get_ctx();
357        let mut vec = vec;
358        vec.do_not_free_on_drop();
359        let vec = vec.ptr;
360        let mut mat = mat;
361        mat.do_not_free_on_drop();
362        let mat = mat.ptr;
363        let isl_rs_result = unsafe { isl_vec_mat_product(vec, mat) };
364        let isl_rs_result = Vec { ptr: isl_rs_result,
365                                  should_free_on_drop: true };
366        let err = isl_rs_ctx.last_error();
367        if err != Error::None_ {
368            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
369        }
370        Ok(isl_rs_result)
371    }
372
373    /// Wraps `isl_vec_move_els`.
374    pub fn move_els(self, dst_col: u32, src_col: u32, n: u32) -> Result<Vec, LibISLError> {
375        let vec = self;
376        let isl_rs_ctx = vec.get_ctx();
377        let mut vec = vec;
378        vec.do_not_free_on_drop();
379        let vec = vec.ptr;
380        let isl_rs_result = unsafe { isl_vec_move_els(vec, dst_col, src_col, n) };
381        let isl_rs_result = Vec { ptr: isl_rs_result,
382                                  should_free_on_drop: true };
383        let err = isl_rs_ctx.last_error();
384        if err != Error::None_ {
385            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
386        }
387        Ok(isl_rs_result)
388    }
389
390    /// Wraps `isl_vec_neg`.
391    pub fn neg(self) -> Result<Vec, LibISLError> {
392        let vec = self;
393        let isl_rs_ctx = vec.get_ctx();
394        let mut vec = vec;
395        vec.do_not_free_on_drop();
396        let vec = vec.ptr;
397        let isl_rs_result = unsafe { isl_vec_neg(vec) };
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            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
403        }
404        Ok(isl_rs_result)
405    }
406
407    /// Wraps `isl_vec_normalize`.
408    pub fn normalize(self) -> Result<Vec, LibISLError> {
409        let vec = self;
410        let isl_rs_ctx = vec.get_ctx();
411        let mut vec = vec;
412        vec.do_not_free_on_drop();
413        let vec = vec.ptr;
414        let isl_rs_result = unsafe { isl_vec_normalize(vec) };
415        let isl_rs_result = Vec { ptr: isl_rs_result,
416                                  should_free_on_drop: true };
417        let err = isl_rs_ctx.last_error();
418        if err != Error::None_ {
419            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
420        }
421        Ok(isl_rs_result)
422    }
423
424    /// Wraps `isl_vec_set_element_si`.
425    pub fn set_element_si(self, pos: i32, v: i32) -> Result<Vec, LibISLError> {
426        let vec = self;
427        let isl_rs_ctx = vec.get_ctx();
428        let mut vec = vec;
429        vec.do_not_free_on_drop();
430        let vec = vec.ptr;
431        let isl_rs_result = unsafe { isl_vec_set_element_si(vec, pos, v) };
432        let isl_rs_result = Vec { ptr: isl_rs_result,
433                                  should_free_on_drop: true };
434        let err = isl_rs_ctx.last_error();
435        if err != Error::None_ {
436            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
437        }
438        Ok(isl_rs_result)
439    }
440
441    /// Wraps `isl_vec_set_element_val`.
442    pub fn set_element_val(self, pos: i32, v: Val) -> Result<Vec, LibISLError> {
443        let vec = self;
444        let isl_rs_ctx = vec.get_ctx();
445        let mut vec = vec;
446        vec.do_not_free_on_drop();
447        let vec = vec.ptr;
448        let mut v = v;
449        v.do_not_free_on_drop();
450        let v = v.ptr;
451        let isl_rs_result = unsafe { isl_vec_set_element_val(vec, pos, v) };
452        let isl_rs_result = Vec { ptr: isl_rs_result,
453                                  should_free_on_drop: true };
454        let err = isl_rs_ctx.last_error();
455        if err != Error::None_ {
456            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
457        }
458        Ok(isl_rs_result)
459    }
460
461    /// Wraps `isl_vec_set_si`.
462    pub fn set_si(self, v: i32) -> Result<Vec, LibISLError> {
463        let vec = self;
464        let isl_rs_ctx = vec.get_ctx();
465        let mut vec = vec;
466        vec.do_not_free_on_drop();
467        let vec = vec.ptr;
468        let isl_rs_result = unsafe { isl_vec_set_si(vec, v) };
469        let isl_rs_result = Vec { ptr: isl_rs_result,
470                                  should_free_on_drop: true };
471        let err = isl_rs_ctx.last_error();
472        if err != Error::None_ {
473            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
474        }
475        Ok(isl_rs_result)
476    }
477
478    /// Wraps `isl_vec_set_val`.
479    pub fn set_val(self, v: Val) -> Result<Vec, LibISLError> {
480        let vec = self;
481        let isl_rs_ctx = vec.get_ctx();
482        let mut vec = vec;
483        vec.do_not_free_on_drop();
484        let vec = vec.ptr;
485        let mut v = v;
486        v.do_not_free_on_drop();
487        let v = v.ptr;
488        let isl_rs_result = unsafe { isl_vec_set_val(vec, v) };
489        let isl_rs_result = Vec { ptr: isl_rs_result,
490                                  should_free_on_drop: true };
491        let err = isl_rs_ctx.last_error();
492        if err != Error::None_ {
493            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
494        }
495        Ok(isl_rs_result)
496    }
497
498    /// Wraps `isl_vec_size`.
499    pub fn size(&self) -> Result<i32, LibISLError> {
500        let vec = self;
501        let isl_rs_ctx = vec.get_ctx();
502        let vec = vec.ptr;
503        let isl_rs_result = unsafe { isl_vec_size(vec) };
504        let err = isl_rs_ctx.last_error();
505        if err != Error::None_ {
506            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
507        }
508        Ok(isl_rs_result)
509    }
510
511    /// Wraps `isl_vec_sort`.
512    pub fn sort(self) -> Result<Vec, LibISLError> {
513        let vec = self;
514        let isl_rs_ctx = vec.get_ctx();
515        let mut vec = vec;
516        vec.do_not_free_on_drop();
517        let vec = vec.ptr;
518        let isl_rs_result = unsafe { isl_vec_sort(vec) };
519        let isl_rs_result = Vec { ptr: isl_rs_result,
520                                  should_free_on_drop: true };
521        let err = isl_rs_ctx.last_error();
522        if err != Error::None_ {
523            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
524        }
525        Ok(isl_rs_result)
526    }
527
528    /// Wraps `isl_vec_zero`.
529    pub fn zero(ctx: &Context, size: u32) -> Result<Vec, LibISLError> {
530        let isl_rs_ctx = Context { ptr: ctx.ptr,
531                                   should_free_on_drop: false };
532        let ctx = ctx.ptr;
533        let isl_rs_result = unsafe { isl_vec_zero(ctx, size) };
534        let isl_rs_result = Vec { ptr: isl_rs_result,
535                                  should_free_on_drop: true };
536        let err = isl_rs_ctx.last_error();
537        if err != Error::None_ {
538            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
539        }
540        Ok(isl_rs_result)
541    }
542
543    /// Wraps `isl_vec_zero_extend`.
544    pub fn zero_extend(self, size: u32) -> Result<Vec, LibISLError> {
545        let vec = self;
546        let isl_rs_ctx = vec.get_ctx();
547        let mut vec = vec;
548        vec.do_not_free_on_drop();
549        let vec = vec.ptr;
550        let isl_rs_result = unsafe { isl_vec_zero_extend(vec, size) };
551        let isl_rs_result = Vec { ptr: isl_rs_result,
552                                  should_free_on_drop: true };
553        let err = isl_rs_ctx.last_error();
554        if err != Error::None_ {
555            return Err(LibISLError::new(err, isl_rs_ctx.last_error_msg()));
556        }
557        Ok(isl_rs_result)
558    }
559
560    /// Does not call isl_vec_free() on being dropped. (For internal use only.)
561    pub fn do_not_free_on_drop(&mut self) {
562        self.should_free_on_drop = false;
563    }
564}
565
566impl Drop for Vec {
567    fn drop(&mut self) {
568        if self.should_free_on_drop {
569            unsafe {
570                isl_vec_free(self.ptr);
571            }
572        }
573    }
574}
isl_rs/bindings/vec.rs

isl_rs/bindings/
vec.rs
