@maydon_tech/react-native-nitro-maps 0.1.0

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

@@ -0,0 +1,86 @@
+///
+/// JClusterPressEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ClusterPressEvent.hpp"
+
+#include "Coordinate.hpp"
+#include "JCoordinate.hpp"
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ClusterPressEvent" and the the Kotlin data class "ClusterPressEvent".
+   */
+  struct JClusterPressEvent final: public jni::JavaClass<JClusterPressEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/ClusterPressEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ClusterPressEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ClusterPressEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCoordinate = clazz->getField<JCoordinate>("coordinate");
+      jni::local_ref<JCoordinate> coordinate = this->getFieldValue(fieldCoordinate);
+      static const auto fieldMarkerIds = clazz->getField<jni::JArrayClass<jni::JString>>("markerIds");
+      jni::local_ref<jni::JArrayClass<jni::JString>> markerIds = this->getFieldValue(fieldMarkerIds);
+      static const auto fieldCount = clazz->getField<double>("count");
+      double count = this->getFieldValue(fieldCount);
+      return ClusterPressEvent(
+        coordinate->toCpp(),
+        [&]() {
+          size_t __size = markerIds->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = markerIds->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }(),
+        count
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JClusterPressEvent::javaobject> fromCpp(const ClusterPressEvent& value) {
+      using JSignature = JClusterPressEvent(jni::alias_ref<JCoordinate>, jni::alias_ref<jni::JArrayClass<jni::JString>>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JCoordinate::fromCpp(value.coordinate),
+        [&]() {
+          size_t __size = value.markerIds.size();
+          jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.markerIds[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        value.count
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,59 @@
+///
+/// JClusterStrategy.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ClusterStrategy.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "ClusterStrategy" and the the Kotlin enum "ClusterStrategy".
+   */
+  struct JClusterStrategy final: public jni::JavaClass<JClusterStrategy> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/ClusterStrategy;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum ClusterStrategy.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ClusterStrategy toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<ClusterStrategy>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JClusterStrategy> fromCpp(ClusterStrategy value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSUPERCLUSTER = clazz->getStaticField<JClusterStrategy>("SUPERCLUSTER");
+      static const auto fieldHIDEONOVERLAP = clazz->getStaticField<JClusterStrategy>("HIDEONOVERLAP");
+      
+      switch (value) {
+        case ClusterStrategy::SUPERCLUSTER:
+          return clazz->getStaticFieldValue(fieldSUPERCLUSTER);
+        case ClusterStrategy::HIDEONOVERLAP:
+          return clazz->getStaticFieldValue(fieldHIDEONOVERLAP);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

package/nitrogen/generated/android/c++/JColorValue.cpp

@@ -0,0 +1,26 @@
+///
+/// JColorValue.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JColorValue.hpp"
+
+namespace margelo::nitro::nitromap {
+  /**
+   * Converts JColorValue to std::variant<std::string, MarkerColor>
+   */
+  std::variant<std::string, MarkerColor> JColorValue::toCpp() const {
+    if (isInstanceOf(JColorValue_impl::First::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JColorValue_impl::First*>(this)->getValue();
+      return jniValue->toStdString();
+    } else if (isInstanceOf(JColorValue_impl::Second::javaClassStatic())) {
+      // It's a `MarkerColor`
+      auto jniValue = static_cast<const JColorValue_impl::Second*>(this)->getValue();
+      return jniValue->toCpp();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,70 @@
+///
+/// JColorValue.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <variant>
+
+#include <string>
+#include "MarkerColor.hpp"
+#include <variant>
+#include "JMarkerColor.hpp"
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "ColorValue".
+   */
+  class JColorValue: public jni::JavaClass<JColorValue> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/ColorValue;";
+
+    static jni::local_ref<JColorValue> create_0(jni::alias_ref<jni::JString> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JColorValue(jni::alias_ref<jni::JString>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JColorValue> create_1(jni::alias_ref<JMarkerColor> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JColorValue(jni::alias_ref<JMarkerColor>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JColorValue> fromCpp(const std::variant<std::string, MarkerColor>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(jni::make_jstring(std::get<0>(variant)));
+        case 1: return create_1(JMarkerColor::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<std::string, MarkerColor> toCpp() const;
+  };
+
+  namespace JColorValue_impl {
+    class First: public jni::JavaClass<First, JColorValue> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/ColorValue$First;";
+    
+      [[nodiscard]] jni::local_ref<jni::JString> getValue() const {
+        static const auto field = javaClassStatic()->getField<jni::JString>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second: public jni::JavaClass<Second, JColorValue> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/ColorValue$Second;";
+    
+      [[nodiscard]] jni::local_ref<JMarkerColor> getValue() const {
+        static const auto field = javaClassStatic()->getField<JMarkerColor>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JColorValue_impl
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,61 @@
+///
+/// JCoordinate.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Coordinate.hpp"
+
+
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Coordinate" and the the Kotlin data class "Coordinate".
+   */
+  struct JCoordinate final: public jni::JavaClass<JCoordinate> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/Coordinate;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Coordinate by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Coordinate 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);
+      return Coordinate(
+        latitude,
+        longitude
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JCoordinate::javaobject> fromCpp(const Coordinate& value) {
+      using JSignature = JCoordinate(double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.latitude,
+        value.longitude
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

@@ -0,0 +1,69 @@
+///
+/// JEdgePadding.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "EdgePadding.hpp"
+
+
+
+namespace margelo::nitro::nitromap {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "EdgePadding" and the the Kotlin data class "EdgePadding".
+   */
+  struct JEdgePadding final: public jni::JavaClass<JEdgePadding> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitromap/EdgePadding;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct EdgePadding by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    EdgePadding toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTop = clazz->getField<double>("top");
+      double top = this->getFieldValue(fieldTop);
+      static const auto fieldRight = clazz->getField<double>("right");
+      double right = this->getFieldValue(fieldRight);
+      static const auto fieldBottom = clazz->getField<double>("bottom");
+      double bottom = this->getFieldValue(fieldBottom);
+      static const auto fieldLeft = clazz->getField<double>("left");
+      double left = this->getFieldValue(fieldLeft);
+      return EdgePadding(
+        top,
+        right,
+        bottom,
+        left
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JEdgePadding::javaobject> fromCpp(const EdgePadding& value) {
+      using JSignature = JEdgePadding(double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.top,
+        value.right,
+        value.bottom,
+        value.left
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitromap

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

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

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

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

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

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

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

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