cglue 0.3.5

FFI safe abstractions for making plugins and C-compatible libraries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use super::super::simple::structs::*;
use cglue_macro::*;

#[cglue_trait]
pub trait GenericTrait<T> {
    fn gt_1(&self) -> T;
}

impl GenericTrait<usize> for SA {
    fn gt_1(&self) -> usize {
        27
    }
}

#[cglue_trait]
pub trait GenWithWhereClause<T>
where
    T: Eq,
{
    fn gww_1(&self, input: &T) -> bool;
}

impl GenWithWhereClause<usize> for SA {
    fn gww_1(&self, input: &usize) -> bool {
        self.gt_1().eq(input)
    }
}

#[cglue_trait]
pub trait GenWithInlineClause<T: Eq> {
    fn gwi_1(&self, input: &T) -> bool;
}

impl GenWithInlineClause<usize> for SA {
    fn gwi_1(&self, input: &usize) -> bool {
        self.gt_1().eq(input)
    }
}

#[cglue_trait]
pub trait GenWithLifetime<'a, T: Eq + 'a> {
    fn gwl_1(&self) -> &T;
    fn gwl_2(&self) {}
}

impl<'a> GenWithLifetime<'a, usize> for SA {
    fn gwl_1(&self) -> &usize {
        &60
    }
}

#[test]
fn use_gen_infer() {
    let sa = SA {};

    let obj = trait_obj!(sa as GenericTrait);

    println!("{}", obj.gt_1());
}

#[test]
fn use_gen_explicit() {
    let sa = SA {};

    let obj = trait_obj!(sa as GenericTrait<usize>);

    println!("{}", obj.gt_1());
}

#[test]
fn use_lifetime() {
    let sa = SA {};

    let obj = trait_obj!(sa as GenWithLifetime);

    println!("{}", obj.gwl_1());
}

#[test]
fn use_lifetime_explicit_t() {
    let sa = SA {};

    let obj = trait_obj!(sa as GenWithLifetime<usize>);

    println!("{}", obj.gwl_1());
}

#[test]
fn use_lifetime_explicit() {
    let sa = SA {};

    let obj = trait_obj!(sa as GenWithLifetime<'static, usize>);

    println!("{}", obj.gwl_1());
}