generator/templates/art/kotlin_record_conversion.cpp - dawn - Git at Google

 //* 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.cpp' 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 %}
	//* 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.cpp' 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 %}