uniffi_bindgen 0.32.0

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

{# Template to generate standard Rust trait method implementations for a Ruby classes.
# Expects `trait_methods` to be a bound in the including template's scope.
# (e.g. `{%- let trait_methods = obj.uniffi_trait_methods() %}`)
#}

{%- if let Some(display_fmt) = trait_methods.display_fmt %}
# The Rust `Display::fmt` implementation.
def to_s
  result = ::{{ ci.namespace()|class_name_rb }}.rust_call(
    :{{ display_fmt.ffi_func().name() }},
    {{ display_fmt|lower_method_self_rb(config) }}
  )
  {{ "result"|lift_rb(display_fmt.return_type().unwrap(), config) }}
end
{%- endif %}

{%- if let Some(debug_fmt) = trait_methods.debug_fmt %}
# The Rust `Debug::fmt` implementation.
def inspect
  result = ::{{ ci.namespace()|class_name_rb }}.rust_call(
    :{{ debug_fmt.ffi_func().name() }},
    {{ debug_fmt|lower_method_self_rb(config) }}
  )
  {{ "result"|lift_rb(debug_fmt.return_type().unwrap(), config) }}
end
{%- endif %}

{%- if let Some(eq) = trait_methods.eq_eq %}
# The Rust `Eq::eq` implementation.
def ==(other)
  return false unless other.is_a?(self.class)
  result = ::{{ ci.namespace()|class_name_rb }}.rust_call(
    :{{ eq.ffi_func().name() }},
    {{ eq|lower_method_self_rb(config) }},
    {{ "other"|lower_rb(eq.arguments()[0].as_type().borrow(), config) }}
  )
  {{ "result"|lift_rb(eq.return_type().unwrap(), config) }}
end
{%- endif %}

{%- if let Some(hash) = trait_methods.hash_hash %}
# The Rust `Hash::hash` implementation.
def hash
  result = ::{{ ci.namespace()|class_name_rb }}.rust_call(
    :{{ hash.ffi_func().name() }},
    {{ hash|lower_method_self_rb(config) }}
  )
  {{ "result"|lift_rb(hash.return_type().unwrap(), config) }}
end

def eql?(other)
  self == other
end
{%- endif %}

{%- if let Some(cmp) = trait_methods.ord_cmp %}
# The Rust `Ord::cmp` implementation.
include Comparable

def <=>(other)
  # do we need this?
  # return nil unless other.is_a?(self.class)
  result = ::{{ ci.namespace()|class_name_rb }}.rust_call(
    :{{ cmp.ffi_func().name() }},
    {{ cmp|lower_method_self_rb(config) }},
    {{ "other"|lower_rb(cmp.arguments()[0].as_type().borrow(), config) }}
  )
  {{ "result"|lift_rb(cmp.return_type().unwrap(), config) }}
rescue
  nil
end
{%- endif %}