react-native-nitro-geolocation 1.1.4 → 1.2.0

package/nitrogen/generated/android/c++/JFunc_void_CompatGeolocationError.hpp

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_CompatGeolocationError.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "CompatGeolocationError.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JCompatGeolocationError.hpp"
+#include <string>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(error: CompatGeolocationError) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_CompatGeolocationError: public jni::JavaClass<JFunc_void_CompatGeolocationError> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_CompatGeolocationError;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_CompatGeolocationError` instance holds through JNI.
+     */
+    void invoke(const CompatGeolocationError& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCompatGeolocationError> /* error */)>("invoke");
+      method(self(), JCompatGeolocationError::fromCpp(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_CompatGeolocationError that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_CompatGeolocationError_cxx final: public jni::HybridClass<JFunc_void_CompatGeolocationError_cxx, JFunc_void_CompatGeolocationError> {
+  public:
+    static jni::local_ref<JFunc_void_CompatGeolocationError::javaobject> fromCpp(const std::function<void(const CompatGeolocationError& /* error */)>& func) {
+      return JFunc_void_CompatGeolocationError_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_CompatGeolocationError_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JCompatGeolocationError> error) {
+      _func(error->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const CompatGeolocationError& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_CompatGeolocationError_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_CompatGeolocationError_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_CompatGeolocationError_cxx(const std::function<void(const CompatGeolocationError& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const CompatGeolocationError& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/android/c++/JFunc_void_CompatGeolocationResponse.hpp

@@ -0,0 +1,84 @@
+///
+/// JFunc_void_CompatGeolocationResponse.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "CompatGeolocationResponse.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JCompatGeolocationResponse.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
+#include "JNullableDouble.hpp"
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(position: CompatGeolocationResponse) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_CompatGeolocationResponse: public jni::JavaClass<JFunc_void_CompatGeolocationResponse> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_CompatGeolocationResponse;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_CompatGeolocationResponse` instance holds through JNI.
+     */
+    void invoke(const CompatGeolocationResponse& position) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCompatGeolocationResponse> /* position */)>("invoke");
+      method(self(), JCompatGeolocationResponse::fromCpp(position));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_CompatGeolocationResponse that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_CompatGeolocationResponse_cxx final: public jni::HybridClass<JFunc_void_CompatGeolocationResponse_cxx, JFunc_void_CompatGeolocationResponse> {
+  public:
+    static jni::local_ref<JFunc_void_CompatGeolocationResponse::javaobject> fromCpp(const std::function<void(const CompatGeolocationResponse& /* position */)>& func) {
+      return JFunc_void_CompatGeolocationResponse_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_CompatGeolocationResponse_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JCompatGeolocationResponse> position) {
+      _func(position->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const CompatGeolocationResponse& /* position */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_CompatGeolocationResponse_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_CompatGeolocationResponse_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_CompatGeolocationResponse_cxx(const std::function<void(const CompatGeolocationResponse& /* position */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const CompatGeolocationResponse& /* position */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/android/c++/JFunc_void_GeolocationResponse.hpp

@@ -21,6 +21,8 @@
 #include <optional>
 #include "JNullableDouble.hpp"
 #include <NitroModules/JNull.hpp>
+#include "LocationProviderUsed.hpp"
+#include "JLocationProviderUsed.hpp"
 
 namespace margelo::nitro::nitrogeolocation {
 

package/nitrogen/generated/android/c++/JFunc_void_Heading.hpp

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_Heading.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "Heading.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JHeading.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(heading: Heading) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_Heading: public jni::JavaClass<JFunc_void_Heading> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_Heading;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_Heading` instance holds through JNI.
+     */
+    void invoke(const Heading& heading) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHeading> /* heading */)>("invoke");
+      method(self(), JHeading::fromCpp(heading));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_Heading that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_Heading_cxx final: public jni::HybridClass<JFunc_void_Heading_cxx, JFunc_void_Heading> {
+  public:
+    static jni::local_ref<JFunc_void_Heading::javaobject> fromCpp(const std::function<void(const Heading& /* heading */)>& func) {
+      return JFunc_void_Heading_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_Heading_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JHeading> heading) {
+      _func(heading->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const Heading& /* heading */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_Heading_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_Heading_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_Heading_cxx(const std::function<void(const Heading& /* heading */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const Heading& /* heading */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/android/c++/JFunc_void_LocationProviderStatus.hpp

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_LocationProviderStatus.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "LocationProviderStatus.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JLocationProviderStatus.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(status: LocationProviderStatus) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_LocationProviderStatus: public jni::JavaClass<JFunc_void_LocationProviderStatus> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_LocationProviderStatus;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_LocationProviderStatus` instance holds through JNI.
+     */
+    void invoke(const LocationProviderStatus& status) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JLocationProviderStatus> /* status */)>("invoke");
+      method(self(), JLocationProviderStatus::fromCpp(status));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_LocationProviderStatus that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_LocationProviderStatus_cxx final: public jni::HybridClass<JFunc_void_LocationProviderStatus_cxx, JFunc_void_LocationProviderStatus> {
+  public:
+    static jni::local_ref<JFunc_void_LocationProviderStatus::javaobject> fromCpp(const std::function<void(const LocationProviderStatus& /* status */)>& func) {
+      return JFunc_void_LocationProviderStatus_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_LocationProviderStatus_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JLocationProviderStatus> status) {
+      _func(status->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const LocationProviderStatus& /* status */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_LocationProviderStatus_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_LocationProviderStatus_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_LocationProviderStatus_cxx(const std::function<void(const LocationProviderStatus& /* status */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const LocationProviderStatus& /* status */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/android/c++/JFunc_void_PermissionStatus.hpp

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_PermissionStatus.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "PermissionStatus.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JPermissionStatus.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(status: PermissionStatus) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_PermissionStatus: public jni::JavaClass<JFunc_void_PermissionStatus> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_PermissionStatus;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_PermissionStatus` instance holds through JNI.
+     */
+    void invoke(PermissionStatus status) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPermissionStatus> /* status */)>("invoke");
+      method(self(), JPermissionStatus::fromCpp(status));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_PermissionStatus that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_PermissionStatus_cxx final: public jni::HybridClass<JFunc_void_PermissionStatus_cxx, JFunc_void_PermissionStatus> {
+  public:
+    static jni::local_ref<JFunc_void_PermissionStatus::javaobject> fromCpp(const std::function<void(PermissionStatus /* status */)>& func) {
+      return JFunc_void_PermissionStatus_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_PermissionStatus_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JPermissionStatus> status) {
+      _func(status->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(PermissionStatus /* status */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_PermissionStatus_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_PermissionStatus_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_PermissionStatus_cxx(const std::function<void(PermissionStatus /* status */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(PermissionStatus /* status */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/android/c++/JFunc_void_std__vector_GeocodedLocation_.hpp

@@ -0,0 +1,97 @@
+///
+/// JFunc_void_std__vector_GeocodedLocation_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "GeocodedLocation.hpp"
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JGeocodedLocation.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(locations: Array<GeocodedLocation>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_GeocodedLocation_: public jni::JavaClass<JFunc_void_std__vector_GeocodedLocation_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_std__vector_GeocodedLocation_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_GeocodedLocation_` instance holds through JNI.
+     */
+    void invoke(const std::vector<GeocodedLocation>& locations) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JGeocodedLocation>> /* locations */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = locations.size();
+        jni::local_ref<jni::JArrayClass<JGeocodedLocation>> __array = jni::JArrayClass<JGeocodedLocation>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = locations[__i];
+          auto __elementJni = JGeocodedLocation::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_GeocodedLocation_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_GeocodedLocation__cxx final: public jni::HybridClass<JFunc_void_std__vector_GeocodedLocation__cxx, JFunc_void_std__vector_GeocodedLocation_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_GeocodedLocation_::javaobject> fromCpp(const std::function<void(const std::vector<GeocodedLocation>& /* locations */)>& func) {
+      return JFunc_void_std__vector_GeocodedLocation__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_GeocodedLocation__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JGeocodedLocation>> locations) {
+      _func([&]() {
+              size_t __size = locations->size();
+              std::vector<GeocodedLocation> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = locations->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<GeocodedLocation>& /* locations */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_std__vector_GeocodedLocation__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_GeocodedLocation__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_GeocodedLocation__cxx(const std::function<void(const std::vector<GeocodedLocation>& /* locations */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<GeocodedLocation>& /* locations */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/android/c++/JFunc_void_std__vector_ReverseGeocodedAddress_.hpp

@@ -0,0 +1,98 @@
+///
+/// JFunc_void_std__vector_ReverseGeocodedAddress_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "ReverseGeocodedAddress.hpp"
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JReverseGeocodedAddress.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(addresses: Array<ReverseGeocodedAddress>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_ReverseGeocodedAddress_: public jni::JavaClass<JFunc_void_std__vector_ReverseGeocodedAddress_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_std__vector_ReverseGeocodedAddress_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_ReverseGeocodedAddress_` instance holds through JNI.
+     */
+    void invoke(const std::vector<ReverseGeocodedAddress>& addresses) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JReverseGeocodedAddress>> /* addresses */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = addresses.size();
+        jni::local_ref<jni::JArrayClass<JReverseGeocodedAddress>> __array = jni::JArrayClass<JReverseGeocodedAddress>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = addresses[__i];
+          auto __elementJni = JReverseGeocodedAddress::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_ReverseGeocodedAddress_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_ReverseGeocodedAddress__cxx final: public jni::HybridClass<JFunc_void_std__vector_ReverseGeocodedAddress__cxx, JFunc_void_std__vector_ReverseGeocodedAddress_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_ReverseGeocodedAddress_::javaobject> fromCpp(const std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>& func) {
+      return JFunc_void_std__vector_ReverseGeocodedAddress__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_ReverseGeocodedAddress__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JReverseGeocodedAddress>> addresses) {
+      _func([&]() {
+              size_t __size = addresses->size();
+              std::vector<ReverseGeocodedAddress> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = addresses->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_std__vector_ReverseGeocodedAddress__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_ReverseGeocodedAddress__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_ReverseGeocodedAddress__cxx(const std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

package/nitrogen/generated/android/c++/JGeocodedLocation.hpp

@@ -0,0 +1,65 @@
+///
+/// JGeocodedLocation.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "GeocodedLocation.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "GeocodedLocation" and the the Kotlin data class "GeocodedLocation".
+   */
+  struct JGeocodedLocation final: public jni::JavaClass<JGeocodedLocation> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/GeocodedLocation;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct GeocodedLocation by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GeocodedLocation toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLatitude = clazz->getField<double>("latitude");
+      double latitude = this->getFieldValue(fieldLatitude);
+      static const auto fieldLongitude = clazz->getField<double>("longitude");
+      double longitude = this->getFieldValue(fieldLongitude);
+      static const auto fieldAccuracy = clazz->getField<jni::JDouble>("accuracy");
+      jni::local_ref<jni::JDouble> accuracy = this->getFieldValue(fieldAccuracy);
+      return GeocodedLocation(
+        latitude,
+        longitude,
+        accuracy != nullptr ? std::make_optional(accuracy->value()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JGeocodedLocation::javaobject> fromCpp(const GeocodedLocation& value) {
+      using JSignature = JGeocodedLocation(double, double, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.latitude,
+        value.longitude,
+        value.accuracy.has_value() ? jni::JDouble::valueOf(value.accuracy.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation