// Array marshalling between Odin slices and Java arrays.
//
// GENERATED by jnigen. Do not edit.
//
// Every to_* returns a LOCAL ref the caller must free; every from_* allocates
// with the given allocator and the caller owns the result.
package jni

import "shared:android"

to_bool_array :: proc(e: Env, vals: []bool) -> android.jbooleanArray {
    arr := e^^.NewBooleanArray(e, android.jsize(len(vals)))
    if arr == nil || len(vals) == 0 {
        return arr
    }
    // Identical layout, so the slice can be handed over without a copy.
    e^^.SetBooleanArrayRegion(e, arr, 0, android.jsize(len(vals)), cast([^]android.jboolean)raw_data(vals))
    return arr
}

from_bool_array :: proc(e: Env, arr: android.jbooleanArray, allocator := context.allocator) -> []bool {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]bool, n, allocator)
    e^^.GetBooleanArrayRegion(e, arr, 0, android.jsize(n), cast([^]android.jboolean)raw_data(out))
    return out
}

to_i8_array :: proc(e: Env, vals: []i8) -> android.jbyteArray {
    arr := e^^.NewByteArray(e, android.jsize(len(vals)))
    if arr == nil || len(vals) == 0 {
        return arr
    }
    // Identical layout, so the slice can be handed over without a copy.
    e^^.SetByteArrayRegion(e, arr, 0, android.jsize(len(vals)), cast([^]android.jbyte)raw_data(vals))
    return arr
}

from_i8_array :: proc(e: Env, arr: android.jbyteArray, allocator := context.allocator) -> []i8 {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]i8, n, allocator)
    e^^.GetByteArrayRegion(e, arr, 0, android.jsize(n), cast([^]android.jbyte)raw_data(out))
    return out
}

to_u16_array :: proc(e: Env, vals: []u16) -> android.jcharArray {
    arr := e^^.NewCharArray(e, android.jsize(len(vals)))
    if arr == nil || len(vals) == 0 {
        return arr
    }
    // Identical layout, so the slice can be handed over without a copy.
    e^^.SetCharArrayRegion(e, arr, 0, android.jsize(len(vals)), cast([^]android.jchar)raw_data(vals))
    return arr
}

from_u16_array :: proc(e: Env, arr: android.jcharArray, allocator := context.allocator) -> []u16 {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]u16, n, allocator)
    e^^.GetCharArrayRegion(e, arr, 0, android.jsize(n), cast([^]android.jchar)raw_data(out))
    return out
}

to_i16_array :: proc(e: Env, vals: []i16) -> android.jshortArray {
    arr := e^^.NewShortArray(e, android.jsize(len(vals)))
    if arr == nil || len(vals) == 0 {
        return arr
    }
    // Identical layout, so the slice can be handed over without a copy.
    e^^.SetShortArrayRegion(e, arr, 0, android.jsize(len(vals)), cast([^]android.jshort)raw_data(vals))
    return arr
}

from_i16_array :: proc(e: Env, arr: android.jshortArray, allocator := context.allocator) -> []i16 {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]i16, n, allocator)
    e^^.GetShortArrayRegion(e, arr, 0, android.jsize(n), cast([^]android.jshort)raw_data(out))
    return out
}

to_i32_array :: proc(e: Env, vals: []i32) -> android.jintArray {
    arr := e^^.NewIntArray(e, android.jsize(len(vals)))
    if arr == nil || len(vals) == 0 {
        return arr
    }
    // Identical layout, so the slice can be handed over without a copy.
    e^^.SetIntArrayRegion(e, arr, 0, android.jsize(len(vals)), cast([^]android.jint)raw_data(vals))
    return arr
}

from_i32_array :: proc(e: Env, arr: android.jintArray, allocator := context.allocator) -> []i32 {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]i32, n, allocator)
    e^^.GetIntArrayRegion(e, arr, 0, android.jsize(n), cast([^]android.jint)raw_data(out))
    return out
}

to_i64_array :: proc(e: Env, vals: []i64) -> android.jlongArray {
    arr := e^^.NewLongArray(e, android.jsize(len(vals)))
    if arr == nil || len(vals) == 0 {
        return arr
    }
    // Identical layout, so the slice can be handed over without a copy.
    e^^.SetLongArrayRegion(e, arr, 0, android.jsize(len(vals)), cast([^]android.jlong)raw_data(vals))
    return arr
}

from_i64_array :: proc(e: Env, arr: android.jlongArray, allocator := context.allocator) -> []i64 {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]i64, n, allocator)
    e^^.GetLongArrayRegion(e, arr, 0, android.jsize(n), cast([^]android.jlong)raw_data(out))
    return out
}

to_f32_array :: proc(e: Env, vals: []f32) -> android.jfloatArray {
    arr := e^^.NewFloatArray(e, android.jsize(len(vals)))
    if arr == nil || len(vals) == 0 {
        return arr
    }
    // Identical layout, so the slice can be handed over without a copy.
    e^^.SetFloatArrayRegion(e, arr, 0, android.jsize(len(vals)), cast([^]android.jfloat)raw_data(vals))
    return arr
}

from_f32_array :: proc(e: Env, arr: android.jfloatArray, allocator := context.allocator) -> []f32 {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]f32, n, allocator)
    e^^.GetFloatArrayRegion(e, arr, 0, android.jsize(n), cast([^]android.jfloat)raw_data(out))
    return out
}

to_f64_array :: proc(e: Env, vals: []f64) -> android.jdoubleArray {
    arr := e^^.NewDoubleArray(e, android.jsize(len(vals)))
    if arr == nil || len(vals) == 0 {
        return arr
    }
    // Identical layout, so the slice can be handed over without a copy.
    e^^.SetDoubleArrayRegion(e, arr, 0, android.jsize(len(vals)), cast([^]android.jdouble)raw_data(vals))
    return arr
}

from_f64_array :: proc(e: Env, arr: android.jdoubleArray, allocator := context.allocator) -> []f64 {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]f64, n, allocator)
    e^^.GetDoubleArrayRegion(e, arr, 0, android.jsize(n), cast([^]android.jdouble)raw_data(out))
    return out
}

// Object arrays. `elem_class` is the array's component type.
to_object_array :: proc(e: Env, vals: []android.jobject, elem_class: android.jclass) -> android.jobjectArray {
    arr := e^^.NewObjectArray(e, android.jsize(len(vals)), elem_class, nil)
    if arr == nil {
        return nil
    }
    for v, i in vals {
        e^^.SetObjectArrayElement(e, arr, android.jsize(i), v)
    }
    return arr
}

from_object_array :: proc(e: Env, arr: android.jobjectArray, allocator := context.allocator) -> []android.jobject {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]android.jobject, n, allocator)
    for i in 0 ..< n {
        out[i] = e^^.GetObjectArrayElement(e, arr, android.jsize(i))
    }
    return out
}

// String arrays need per-element conversion in both directions.
to_string_array :: proc(e: Env, vals: []string) -> android.jobjectArray {
    cls := class_ref(e, "java/lang/String")
    if cls == nil {
        return nil
    }
    arr := e^^.NewObjectArray(e, android.jsize(len(vals)), cls, nil)
    if arr == nil {
        return nil
    }
    for v, i in vals {
        s := to_jstring(e, v)
        e^^.SetObjectArrayElement(e, arr, android.jsize(i), android.jobject(s))
        free_local(e, android.jobject(s))
    }
    return arr
}

from_string_array :: proc(e: Env, arr: android.jobjectArray, allocator := context.allocator) -> []string {
    if arr == nil {
        return nil
    }
    n := int(e^^.GetArrayLength(e, android.jarray(arr)))
    if n == 0 {
        return nil
    }
    out := make([]string, n, allocator)
    for i in 0 ..< n {
        el := e^^.GetObjectArrayElement(e, arr, android.jsize(i))
        out[i] = from_jstring(e, android.jstring(el), allocator)
        free_local(e, el)
    }
    return out
}