aam-rs 2.0.3

A Rust implementation of the Abstract Alias Mapping (AAM) framework for aliasing and maping aam files.
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

using System;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.Win32.SafeHandles;

namespace AamCsharp;

internal sealed unsafe class SafeAamHandle : SafeHandleZeroOrMinusOneIsInvalid
{
    public SafeAamHandle() : base(true)
    {
        SetHandle((IntPtr)AamNative.aam_new());
        if (IsInvalid)
        {
            throw new InvalidOperationException("Failed to allocate native AAM handle");
        }
    }

    protected override bool ReleaseHandle()
    {
        AamNative.aam_free((AamHandle*)handle);
        return true;
    }
}

internal static unsafe partial class AamNative
{
    internal static int aam_parse(SafeAamHandle handle, string content)
    {
        var utf8 = ToNullTerminatedUtf8(content);
        fixed (byte* ptr = utf8)
        {
            return aam_parse((AamHandle*)handle.DangerousGetHandle(), ptr);
        }
    }

    internal static int aam_load(SafeAamHandle handle, string path)
    {
        var utf8 = ToNullTerminatedUtf8(path);
        fixed (byte* ptr = utf8)
        {
            return aam_load((AamHandle*)handle.DangerousGetHandle(), ptr);
        }
    }

    internal static byte* aam_format(SafeAamHandle handle, string content)
    {
        var utf8 = ToNullTerminatedUtf8(content);
        fixed (byte* ptr = utf8)
        {
            return aam_format((AamHandle*)handle.DangerousGetHandle(), ptr);
        }
    }

    internal static byte* aam_get(SafeAamHandle handle, string key)
    {
        var utf8 = ToNullTerminatedUtf8(key);
        fixed (byte* ptr = utf8)
        {
            return aam_get((AamHandle*)handle.DangerousGetHandle(), ptr);
        }
    }

    internal static byte* aam_find(SafeAamHandle handle, string query)
    {
        var utf8 = ToNullTerminatedUtf8(query);
        fixed (byte* ptr = utf8)
        {
            return aam_find((AamHandle*)handle.DangerousGetHandle(), ptr);
        }
    }

    internal static byte* aam_deep_search(SafeAamHandle handle, string pattern)
    {
        var utf8 = ToNullTerminatedUtf8(pattern);
        fixed (byte* ptr = utf8)
        {
            return aam_deep_search((AamHandle*)handle.DangerousGetHandle(), ptr);
        }
    }

    internal static byte* aam_reverse_search(SafeAamHandle handle, string value)
    {
        var utf8 = ToNullTerminatedUtf8(value);
        fixed (byte* ptr = utf8)
        {
            return aam_reverse_search((AamHandle*)handle.DangerousGetHandle(), ptr);
        }
    }

    internal static byte* aam_schema_names(SafeAamHandle handle)
    {
        return aam_schema_names((AamHandle*)handle.DangerousGetHandle());
    }

    internal static byte* aam_type_names(SafeAamHandle handle)
    {
        return aam_type_names((AamHandle*)handle.DangerousGetHandle());
    }

    internal static byte* aam_last_error(SafeAamHandle handle)
    {
        return aam_last_error((AamHandle*)handle.DangerousGetHandle());
    }


    internal static string? BorrowUtf8String(byte* ptr)
    {
        if (ptr == null)
        {
            return null;
        }

        return Marshal.PtrToStringUTF8((IntPtr)ptr);
    }

    internal static string? TakeOwnedUtf8String(byte* ptr)
    {
        if (ptr == null)
        {
            return null;
        }

        try
        {
            return Marshal.PtrToStringUTF8((IntPtr)ptr);
        }
        finally
        {
            aam_string_free(ptr);
        }
    }

    private static byte[] ToNullTerminatedUtf8(string value)
    {
        var utf8 = Encoding.UTF8.GetBytes(value);
        var nullTerminated = new byte[utf8.Length + 1];
        Buffer.BlockCopy(utf8, 0, nullTerminated, 0, utf8.Length);
        return nullTerminated;
    }
}