interoptopus_csharp 0.16.0-alpha.13

The C# backend for Interoptopus.
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

public partial class {{ name }}
{
    {{ _fns_decorators_all | indent }}
    private {{ name }}() { }

    /// Creates an empty Rust-owned vector.
    {{ _fns_decorators_all | indent }}
    public static unsafe {{ name }} Empty()
    {
        InteropHelper.interoptopus_vec_create(IntPtr.Zero, 0, out var _out);
        return _out.IntoManaged();
    }

    /// The number of elements in this vector.
    public int Count
    {
        {{ _fns_decorators_all | indent(prefix="        ") }}
        get { if (_ptr == IntPtr.Zero) { throw new NullReferenceException(); } else { return (int) _len; } }
    }

    {{ _fns_decorators_all | indent }}
    {{ _fns_decorators_internal | indent }}
    internal Unmanaged IntoUnmanaged()
    {
        if (_ptr == IntPtr.Zero) throw new NullReferenceException();
        var rval = new Unmanaged();
        rval._len = _len;
        rval._capacity = _capacity;
        rval._ptr = _ptr;
        _ptr = IntPtr.Zero;
        return rval;
    }

    {{ _fns_decorators_all | indent }}
    {{ _fns_decorators_internal | indent }}
    internal Unmanaged AsUnmanaged()
    {
        if (_ptr == IntPtr.Zero) throw new NullReferenceException();
        var rval = new Unmanaged();
        rval._len = _len;
        rval._capacity = _capacity;
        rval._ptr = _ptr;
        return rval;
    }

    /// Frees the underlying Rust allocation. Safe to call multiple times.
    {{ _fns_decorators_all | indent }}
    public void Dispose()
    {
        if (_ptr == IntPtr.Zero) return;
        var _unmanaged = new Unmanaged();
        _unmanaged._ptr = _ptr;
        _unmanaged._len = _len;
        _unmanaged._capacity = _capacity;
        InteropHelper.interoptopus_vec_destroy(_unmanaged);
        _ptr = IntPtr.Zero;
        _len = 0;
        _capacity = 0;
    }

    {{ _fns_decorators_all | indent }}
    public override string ToString()
    {
        return "{{ name }} { ... }";
    }

    internal partial class InteropHelper
    {
        [LibraryImport(Interop.NativeLib, EntryPoint = "{{ create_entry_point }}")]
        internal static partial long interoptopus_vec_create(IntPtr vec, ulong len, out Unmanaged rval);
        [LibraryImport(Interop.NativeLib, EntryPoint = "{{ destroy_entry_point }}")]
        internal static partial long interoptopus_vec_destroy(Unmanaged vec);
    }

    [CustomMarshaller(typeof({{ name }}), MarshalMode.Default, typeof(Marshaller))]
    private struct MarshallerMeta { }

    [StructLayout(LayoutKind.Sequential)]
    internal struct Unmanaged
    {
        internal IntPtr _ptr;
        internal ulong _len;
        internal ulong _capacity;

        {{ _fns_decorators_all | indent(prefix="        ") }}
        {{ _fns_decorators_internal | indent(prefix="        ") }}
        internal {{ name }} IntoManaged()
        {
            var rval = new {{ name }}();
            rval._len = _len;
            rval._capacity = _capacity;
            rval._ptr = _ptr;
            return rval;
        }
    }

    internal ref struct Marshaller
    {
        private {{ name }} _managed;
        private Unmanaged _unmanaged;

        {{ _fns_decorators_all | indent(prefix="        ") }}
        public Marshaller({{ name }} managed) { _managed = managed; }

        {{ _fns_decorators_all | indent(prefix="        ") }}
        public Marshaller(Unmanaged unmanaged) { _unmanaged = unmanaged; }

        {{ _fns_decorators_all | indent(prefix="        ") }}
        public void FromManaged({{ name }} managed) { _managed = managed; }

        {{ _fns_decorators_all | indent(prefix="        ") }}
        public void FromUnmanaged(Unmanaged unmanaged) { _unmanaged = unmanaged; }

        {{ _fns_decorators_all | indent(prefix="        ") }}
        public Unmanaged ToUnmanaged() { return _managed.IntoUnmanaged(); }

        {{ _fns_decorators_all | indent(prefix="        ") }}
        public {{ name }} ToManaged() { return _unmanaged.IntoManaged(); }

        {{ _fns_decorators_all | indent(prefix="        ") }}
        public void Free() {}
    }
}