generator/templates/art/kotlin_record_conversion.cpp

//* Copyright 2024 The Dawn & Tint Authors
//*
//* Redistribution and use in source and binary forms, with or without
//* modification, are permitted provided that the following conditions are met:
//*
//* 1. Redistributions of source code must retain the above copyright notice, this
//*    list of conditions and the following disclaimer.
//*
//* 2. Redistributions in binary form must reproduce the above copyright notice,
//*    this list of conditions and the following disclaimer in the documentation
//*    and/or other materials provided with the distribution.
//*
//* 3. Neither the name of the copyright holder nor the names of its
//*    contributors may be used to endorse or promote products derived from
//*    this software without specific prior written permission.
//*
//* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
//* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
//* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
//* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
//* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
//* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
//* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
{% from 'art/api_jni_types.kt' import arg_to_jni_type, convert_to_kotlin, jni_signature with context %}

{% macro define_kotlin_record_structure(struct_name, members) %}
    struct {{struct_name}} {
        {% for member in kotlin_record_members(members) %}
            //* HACK: Hardcode that ANativeWindow is a jlong instead of an actual pointer. Instead
            //* of this, we should have manually written method that directly creates the
            //* wgpu::Surface from the Java Surface.
            {% if member.name.get() == "window" and member.type.name.get() == "void *"%}
                jlong {{ as_varName(member.name) }};
            {% else %}
                {{ arg_to_jni_type(member) }} {{ as_varName(member.name) }};
            {% endif %}
        {% endfor%}
    };
{% endmacro %}

{% macro define_kotlin_to_struct_conversion(function_name, kotlin_name, struct_name, members) %}
    inline void {{function_name}}(JNIContext* c, const {{kotlin_name}}& inStruct, {{struct_name}}* outStruct) {
        JNIEnv* env = c->env;
        *outStruct = {};
        {% for member in kotlin_record_members(members) %} {
            auto& in = inStruct.{{member.name.camelCase()}};
            auto& out = outStruct->{{member.name.camelCase()}};
            {% if member.length == 'strlen' %}
                if (in != nullptr) {
                    out = c->GetStringUTFChars(in);
                } else {
                    out = nullptr;
                }

            {% elif member.constant_length == 1 %}
                {% if member.type.category == 'structure' %}
                    if (in != nullptr) {
                        auto converted = c->Alloc<{{as_cType(member.type.name)}}>();
                        ToNative(c, env, in, converted);
                        out = converted;
                    }
                {% elif member.type.name.get() == 'void' %}
                    out = reinterpret_cast<void*>(in);
                {% else %}
                    {{ unreachable_code() }}
                {% endif %}

            {% elif member.length %}
                auto& outLength = outStruct->{{member.length.name.camelCase()}};

                {% if member.constant_length %}
                    {{ unreachable_code() }}
                {% endif %}

                //* Convert container, including the length field.
                {% if member.type.name.get() == 'uint32_t' %}
                    //* This container type is represented in Kotlin as a primitive array.
                    out = reinterpret_cast<const uint32_t*>(c->GetIntArrayElements(in));
                    outLength = env->GetArrayLength(in);

                {% elif member.type.name.get() == 'void' %}
                    out = env->GetDirectBufferAddress(in);
                    outLength = env->GetDirectBufferCapacity(in);

                {% else %}
                    //* These container types are represented in Kotlin as arrays of objects.
                    outLength = env->GetArrayLength(in);
                    auto array = c->AllocArray<{{ as_cType(member.type.name) }}>(outLength);
                    out = array;

                    {% if member.type.category in ['bitmask', 'enum'] %}
                        jclass memberClass = env->FindClass("{{ jni_name(member.type) }}");
                        jmethodID getValue = env->GetMethodID(memberClass, "getValue", "()I");
                        for (int idx = 0; idx != outLength; idx++) {
                            jobject element = env->GetObjectArrayElement(in, idx);
                            array[idx] = static_cast<{{ as_cType(member.type.name) }}>(
                                    env->CallIntMethod(element, getValue));
                        }
                    {% elif member.type.category == 'object' %}
                        jclass memberClass = env->FindClass("{{ jni_name(member.type) }}");
                        jmethodID getHandle = env->GetMethodID(memberClass, "getHandle", "()J");
                        for (int idx = 0; idx != outLength; idx++) {
                            jobject element = env->GetObjectArrayElement(in, idx);
                            array[idx] = reinterpret_cast<{{ as_cType(member.type.name) }}>(
                                    env->CallLongMethod(element, getHandle));
                        }
                    {% elif member.type.category == 'structure' %}
                        for (int idx = 0; idx != outLength; idx++) {
                            ToNative(c, env, env->GetObjectArrayElement(in, idx), &array[idx]);
                        }
                    {% else %}
                        {{ unreachable_code() }}
                    {% endif %}
                {% endif %}

            //* From here members are single values.
            {% elif member.type.category == 'object' %}
                if (in != nullptr) {
                    jclass memberClass = env->FindClass("{{ jni_name(member.type) }}");
                    jmethodID getHandle = env->GetMethodID(memberClass, "getHandle", "()J");
                    out = reinterpret_cast<{{as_cType(member.type.name)}}>(
                            env->CallLongMethod(in, getHandle));
                } else {
                    out = nullptr;
                }
            {% elif member.type.category == 'structure' %}
                //* Mandatory structure.
                ToNative(c, env, in, &out);

            {% elif member.name.get() == "window" and member.type.name.get() == "void *" %}
                //* HACK: Hardcode that ANativeWindow is a jlong instead of an actual pointer. Instead
                //* of this, we should have manually written method that directly creates the
                //* wgpu::Surface from the Java Surface.
                out = reinterpret_cast<{{as_cType(member.type.name)}}>(static_cast<uintptr_t>(in));

            {% elif member.type.category in ["native", "enum", "bitmask"] %}
                out = static_cast<{{as_cType(member.type.name)}}>(in);

            {% elif member.type.category == 'function pointer' %}
                //* Function pointers themselves require each argument converting.
                //* A custom native callback is generated to wrap the Kotlin callback.
                out = [](
                    {%- for callbackArg in member.type.arguments %}
                        {{ as_annotated_cType(callbackArg) }}{{ ',' if not loop.last }}
                    {%- endfor %}) {
                    UserData* userData1 = static_cast<UserData *>(userdata);
                    JNIEnv *env = userData1->env;
                    if (env->ExceptionCheck()) {
                        return;
                    }

                    {%- for callbackArg in kotlin_record_members(member.type.arguments) -%}
                        {{ convert_to_kotlin(callbackArg.name.camelCase(),
                                             '_' + callbackArg.name.camelCase(),
                                             'input->' + callbackArg.length.name.camelCase() if callbackArg.length.name,
                                             callbackArg) }}
                    {% endfor %}

                    //* Get the client (Kotlin) callback so we can call it.
                    jmethodID callbackMethod = env->GetMethodID(
                            env->FindClass("{{ jni_name(member.type) }}"), "callback", "(
                        {%- for callbackArg in kotlin_record_members(member.type.arguments) -%}
                            {{- jni_signature(callbackArg) -}}
                        {%- endfor %})V");

                    //* Call the callback with all converted parameters.
                    env->CallVoidMethod(userData1->callback, callbackMethod
                    {%- for callbackArg in kotlin_record_members(member.type.arguments) %}
                         ,_{{ callbackArg.name.camelCase() }}
                    {%- endfor %});
                };
                //* TODO(b/330293719): free associated resources.
                outStruct->userdata = new UserData(
                        {.env = env, .callback = env->NewGlobalRef(in)});

            {% else %}
                {{ unreachable_code() }}
            {% endif %}
        } {% endfor %}
    }
{% endmacro %}