// This file was generated by
//     //third_party/jni_zero/jni_zero.py
// For
//     org.jni_zero.SampleForAnnotationProcessor

#ifndef org_jni_zero_SampleForAnnotationProcessor_JNI
#define org_jni_zero_SampleForAnnotationProcessor_JNI

#include <jni.h>

#include "third_party/jni_zero/jni_export.h"
#include "third_party/jni_zero/jni_zero_helper.h"
// Class Accessors.
#ifndef org_jni_1zero_SampleForAnnotationProcessor_clazz_defined
#define org_jni_1zero_SampleForAnnotationProcessor_clazz_defined
inline jclass org_jni_1zero_SampleForAnnotationProcessor_clazz(JNIEnv* env) {
  static const char kClassName[] = "org/jni_zero/SampleForAnnotationProcessor";
  static std::atomic<jclass> cached_class;
  return jni_zero::internal::LazyGetClass(env, kClassName, &cached_class);
}
#endif

// Forward declare used conversion functions to avoid a compiler warning that
// triggers if a conversion specialization exists within the including .cc file.
namespace jni_zero {
template<> jni_zero::ScopedJavaLocalRef<jstring> ToJniType<std::string, jstring>(JNIEnv*, std::string const&);
template<> jni_zero::tests::CPPClass FromJniType<jni_zero::tests::CPPClass, jobject>(JNIEnv*, const JavaRef<jobject>&);
template<> std::optional<std::string> FromJniType<std::optional<std::string>, jstring>(JNIEnv*, const JavaRef<jstring>&);
template<> std::string FromJniType<std::string, jstring>(JNIEnv*, const JavaRef<jstring>&);
}  // namespace jni_zero
// Java to native functions
// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobject> JNI_SampleForAnnotationProcessor_Bar(
    JNIEnv* env,
    const jni_zero::JavaParamRef<jobject>& sample);

JNI_BOUNDARY_EXPORT jobject Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeBar(
    JNIEnv* env,
    jclass jcaller,
    jobject sample) {
  auto ret = JNI_SampleForAnnotationProcessor_Bar(
      env,
      jni_zero::JavaParamRef<jobject>(env, sample));
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static void JNI_SampleForAnnotationProcessor_Foo(JNIEnv* env);

JNI_BOUNDARY_EXPORT void Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeFoo(
    JNIEnv* env,
    jclass jcaller) {
  JNI_SampleForAnnotationProcessor_Foo(env);
}

// Forward declaration. To be implemented by the including .cc file.
static jboolean JNI_SampleForAnnotationProcessor_HasPhalange(JNIEnv* env);

JNI_BOUNDARY_EXPORT jboolean Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeHasPhalange(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_HasPhalange(env);
  return ret;
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jclass> JNI_SampleForAnnotationProcessor_ReturnClass(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jclass Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnClass(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnClass(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobjectArray> JNI_SampleForAnnotationProcessor_ReturnClasses(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnClasses(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnClasses(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static std::vector<jni_zero::ScopedJavaLocalRef<jobject>> JNI_SampleForAnnotationProcessor_ReturnConvertedAppObjects(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnConvertedAppObjects(
    JNIEnv* env,
    jclass jcaller,
    jclass __arrayClazz) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnConvertedAppObjects(env);
  return jni_zero::ConvertArray<std::vector<jni_zero::ScopedJavaLocalRef<jobject>>>::ToJniType<jobject>(
      env,
      ret,
      __arrayClazz).Release();
}

// Forward declaration. To be implemented by the including .cc file.
static std::vector<jint> JNI_SampleForAnnotationProcessor_ReturnConvertedInts(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jintArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnConvertedInts(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnConvertedInts(env);
  return jni_zero::ConvertArray<std::vector<jint>>::ToJniType(env, ret).Release();
}

// Forward declaration. To be implemented by the including .cc file.
static std::string JNI_SampleForAnnotationProcessor_ReturnConvertedString(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jstring Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnConvertedString(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnConvertedString(env);
  return jni_zero::ToJniType<std::string, jstring>(env, ret).Release();
}

// Forward declaration. To be implemented by the including .cc file.
static std::vector<std::string> JNI_SampleForAnnotationProcessor_ReturnConvertedStrings(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnConvertedStrings(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnConvertedStrings(env);
  return jni_zero::ConvertArray<std::vector<std::string>>::ToJniType<jstring>(
      env,
      ret,
      jni_zero::g_string_class).Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobject> JNI_SampleForAnnotationProcessor_ReturnObject(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobject Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnObject(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnObject(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobjectArray> JNI_SampleForAnnotationProcessor_ReturnObjects(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnObjects(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnObjects(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jstring> JNI_SampleForAnnotationProcessor_ReturnString(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jstring Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnString(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnString(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobjectArray> JNI_SampleForAnnotationProcessor_ReturnStrings(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnStrings(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnStrings(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobject> JNI_SampleForAnnotationProcessor_ReturnStruct(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobject Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnStruct(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnStruct(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobjectArray> JNI_SampleForAnnotationProcessor_ReturnStructs(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnStructs(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnStructs(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jthrowable> JNI_SampleForAnnotationProcessor_ReturnThrowable(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jthrowable Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnThrowable(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnThrowable(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobjectArray> JNI_SampleForAnnotationProcessor_ReturnThrowables(
    JNIEnv* env);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeReturnThrowables(
    JNIEnv* env,
    jclass jcaller) {
  auto ret = JNI_SampleForAnnotationProcessor_ReturnThrowables(env);
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jstring> JNI_SampleForAnnotationProcessor_RevString(
    JNIEnv* env,
    const jni_zero::JavaParamRef<jstring>& stringToReverse);

JNI_BOUNDARY_EXPORT jstring Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeRevString(
    JNIEnv* env,
    jclass jcaller,
    jstring stringToReverse) {
  auto ret = JNI_SampleForAnnotationProcessor_RevString(
      env,
      jni_zero::JavaParamRef<jstring>(env, stringToReverse));
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobjectArray> JNI_SampleForAnnotationProcessor_SendSamplesToNative(
    JNIEnv* env,
    const jni_zero::JavaParamRef<jobjectArray>& strs);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeSendSamplesToNative(
    JNIEnv* env,
    jclass jcaller,
    jobjectArray strs) {
  auto ret = JNI_SampleForAnnotationProcessor_SendSamplesToNative(
      env,
      jni_zero::JavaParamRef<jobjectArray>(env, strs));
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static jni_zero::ScopedJavaLocalRef<jobjectArray> JNI_SampleForAnnotationProcessor_SendToNative(
    JNIEnv* env,
    const jni_zero::JavaParamRef<jobjectArray>& strs);

JNI_BOUNDARY_EXPORT jobjectArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeSendToNative(
    JNIEnv* env,
    jclass jcaller,
    jobjectArray strs) {
  auto ret = JNI_SampleForAnnotationProcessor_SendToNative(
      env,
      jni_zero::JavaParamRef<jobjectArray>(env, strs));
  return ret.Release();
}

// Forward declaration. To be implemented by the including .cc file.
static std::vector<int32_t> JNI_SampleForAnnotationProcessor_TestAllPrimitives(
    JNIEnv* env,
    int zint,
    std::vector<int32_t>& ints,
    jlong zlong,
    const jni_zero::JavaParamRef<jlongArray>& longs,
    jshort zshort,
    const jni_zero::JavaParamRef<jshortArray>& shorts,
    int zchar,
    const jni_zero::JavaParamRef<jcharArray>& chars,
    jbyte zbyte,
    const jni_zero::JavaParamRef<jbyteArray>& bytes,
    jdouble zdouble,
    const jni_zero::JavaParamRef<jdoubleArray>& doubles,
    jfloat zfloat,
    const jni_zero::JavaParamRef<jfloatArray>& floats,
    jboolean zbool,
    const jni_zero::JavaParamRef<jbooleanArray>& bools);

JNI_BOUNDARY_EXPORT jintArray Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeTestAllPrimitives(
    JNIEnv* env,
    jclass jcaller,
    jint zint,
    jintArray ints,
    jlong zlong,
    jlongArray longs,
    jshort zshort,
    jshortArray shorts,
    jchar zchar,
    jcharArray chars,
    jbyte zbyte,
    jbyteArray bytes,
    jdouble zdouble,
    jdoubleArray doubles,
    jfloat zfloat,
    jfloatArray floats,
    jboolean zbool,
    jbooleanArray bools) {
  int zint_converted = static_cast<int>(zint);
  std::vector<int32_t> ints_converted = jni_zero::ConvertArray<std::vector<int32_t>>::FromJniType(
      env,
      jni_zero::JavaParamRef<jintArray>(env, ints));
  int zchar_converted = static_cast<int>(zchar);
  auto ret = JNI_SampleForAnnotationProcessor_TestAllPrimitives(
      env,
      zint_converted,
      ints_converted,
      zlong,
      jni_zero::JavaParamRef<jlongArray>(env, longs),
      zshort,
      jni_zero::JavaParamRef<jshortArray>(env, shorts),
      zchar_converted,
      jni_zero::JavaParamRef<jcharArray>(env, chars),
      zbyte,
      jni_zero::JavaParamRef<jbyteArray>(env, bytes),
      zdouble,
      jni_zero::JavaParamRef<jdoubleArray>(env, doubles),
      zfloat,
      jni_zero::JavaParamRef<jfloatArray>(env, floats),
      zbool,
      jni_zero::JavaParamRef<jbooleanArray>(env, bools));
  return jni_zero::ConvertArray<std::vector<int32_t>>::ToJniType(env, ret).Release();
}

// Forward declaration. To be implemented by the including .cc file.
static void JNI_SampleForAnnotationProcessor_TestSpecialTypes(
    JNIEnv* env,
    const jni_zero::JavaParamRef<jclass>& clazz,
    const jni_zero::JavaParamRef<jobjectArray>& classes,
    const jni_zero::JavaParamRef<jthrowable>& throwable,
    const jni_zero::JavaParamRef<jobjectArray>& throwables,
    const jni_zero::JavaParamRef<jstring>& string,
    const jni_zero::JavaParamRef<jobjectArray>& strings,
    std::string& convertedString,
    std::vector<std::string>& convertedStrings,
    std::optional<std::string>& optionalString,
    const jni_zero::JavaParamRef<jobject>& tStruct,
    const jni_zero::JavaParamRef<jobjectArray>& structs,
    const jni_zero::JavaParamRef<jobject>& obj,
    jni_zero::tests::CPPClass& convertedObj,
    const jni_zero::JavaParamRef<jobjectArray>& objects,
    const jni_zero::JavaParamRef<jobject>& nestedInterface,
    const jni_zero::JavaParamRef<jobject>& view,
    const jni_zero::JavaParamRef<jobject>& context,
    std::vector<jni_zero::tests::CPPClass>& convertedObjects);

JNI_BOUNDARY_EXPORT void Java_org_jni_1zero_SampleForAnnotationProcessorJni_nativeTestSpecialTypes(
    JNIEnv* env,
    jclass jcaller,
    jclass clazz,
    jobjectArray classes,
    jthrowable throwable,
    jobjectArray throwables,
    jstring string,
    jobjectArray strings,
    jstring convertedString,
    jobjectArray convertedStrings,
    jstring optionalString,
    jobject tStruct,
    jobjectArray structs,
    jobject obj,
    jobject convertedObj,
    jobjectArray objects,
    jobject nestedInterface,
    jobject view,
    jobject context,
    jobjectArray convertedObjects) {
  std::string convertedString_converted = jni_zero::FromJniType<std::string, jstring>(
      env,
      jni_zero::JavaParamRef<jstring>(env, convertedString));
  std::vector<std::string> convertedStrings_converted = jni_zero::ConvertArray<std::vector<std::string>>::FromJniType<jstring>(
      env,
      jni_zero::JavaParamRef<jobjectArray>(env, convertedStrings));
  std::optional<std::string> optionalString_converted = jni_zero::FromJniType<std::optional<std::string>, jstring>(
      env,
      jni_zero::JavaParamRef<jstring>(env, optionalString));
  jni_zero::tests::CPPClass convertedObj_converted = jni_zero::FromJniType<jni_zero::tests::CPPClass, jobject>(
      env,
      jni_zero::JavaParamRef<jobject>(env, convertedObj));
  std::vector<jni_zero::tests::CPPClass> convertedObjects_converted = jni_zero::ConvertArray<std::vector<jni_zero::tests::CPPClass>>::FromJniType<jobject>(
      env,
      jni_zero::JavaParamRef<jobjectArray>(env, convertedObjects));
  JNI_SampleForAnnotationProcessor_TestSpecialTypes(
      env,
      jni_zero::JavaParamRef<jclass>(env, clazz),
      jni_zero::JavaParamRef<jobjectArray>(env, classes),
      jni_zero::JavaParamRef<jthrowable>(env, throwable),
      jni_zero::JavaParamRef<jobjectArray>(env, throwables),
      jni_zero::JavaParamRef<jstring>(env, string),
      jni_zero::JavaParamRef<jobjectArray>(env, strings),
      convertedString_converted,
      convertedStrings_converted,
      optionalString_converted,
      jni_zero::JavaParamRef<jobject>(env, tStruct),
      jni_zero::JavaParamRef<jobjectArray>(env, structs),
      jni_zero::JavaParamRef<jobject>(env, obj),
      convertedObj_converted,
      jni_zero::JavaParamRef<jobjectArray>(env, objects),
      jni_zero::JavaParamRef<jobject>(env, nestedInterface),
      jni_zero::JavaParamRef<jobject>(env, view),
      jni_zero::JavaParamRef<jobject>(env, context),
      convertedObjects_converted);
}


#endif  // org_jni_zero_SampleForAnnotationProcessor_JNI