uniffi_bindgen 0.31.1

a multi-language bindings generator for rust (codegen and cli tooling)
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

{# expects var `uniffi_trait_methods` #}
{%- if let Some(fmt) = uniffi_trait_methods.debug_fmt %}
{%-    let callable = fmt.callable %}
# The Rust `Debug::fmt` implementation.
def __repr__(self) -> {{ callable.return_type.type_name }}:
    {% filter indent(4) -%}
    {% include "CallableBody.py" -%}
    {% endfilter -%}
{%- endif %}

{%- if let Some(fmt) = uniffi_trait_methods.display_fmt %}
{%-    let callable = fmt.callable %}
# The Rust `Display::fmt` implementation.
def __str__(self) -> {{ callable.return_type.type_name }}:
    {% filter indent(4) -%}
    {% include "CallableBody.py" -%}
    {% endfilter -%}
{%- endif %}

{%- if let Some(eq) = uniffi_trait_methods.eq_eq %}
{%-    let callable = eq.callable %}
# The Rust `Eq::eq` implementation.
def __eq__(self, other: object) -> {{ callable.return_type.type_name }}:
    if not isinstance(other, {{ callable.self_type().unwrap().type_name }}):
        return NotImplemented

    {% filter indent(4) -%}
    {% include "CallableBody.py" -%}
    {% endfilter -%}
{%- endif %}
{%- if let Some(ne) = uniffi_trait_methods.eq_ne %}
{%-    let callable = ne.callable %}
# The Rust `Eq::ne` implementation.
def __ne__(self, other: object) -> {{ callable.return_type.type_name }}:
    if not isinstance(other, {{ callable.self_type().unwrap().type_name }}):
        return NotImplemented
    {% filter indent(4) -%}
    {% include "CallableBody.py" -%}
    {% endfilter -%}
{%- endif %}

{%- if let Some(hash) = uniffi_trait_methods.hash_hash %}
{%-    let callable = hash.callable %}
# The Rust `Hash::hash` implementation.
def __hash__(self) -> {{ callable.return_type.type_name }}:
    {% filter indent(4) -%}
    {% include "CallableBody.py" -%}
    {% endfilter -%}

{%- endif %}

{%- if let Some(cmp) = uniffi_trait_methods.ord_cmp %}
{%-    let callable = cmp.callable %}
# The Rust `Ord::cmp` implementation.
# lol/sob, python3 got rid of the perfect python2 `.__cmp__()` :(
def __rust_cmp__(self, other) -> {{ callable.return_type.type_name }}:
    {% filter indent(4) -%}
    {% include "CallableBody.py" -%}
    {% endfilter %}

def __lt__(self, other) -> bool:
    return self.__rust_cmp__(other) < 0

def __le__(self, other) -> bool:
    return self.__rust_cmp__(other) <= 0

def __gt__(self, other) -> bool:
    return self.__rust_cmp__(other) > 0

def __ge__(self, other) -> bool:
    return self.__rust_cmp__(other) >= 0
{%- endif %}