react-native-nitro-background-geolocation 0.1.0

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

@@ -0,0 +1,71 @@
+///
+/// JVariant_NullType_AnyMap.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/JAnyMap.hpp>
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_AnyMap".
+   */
+  class JVariant_NullType_AnyMap: public jni::JavaClass<JVariant_NullType_AnyMap> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_AnyMap;";
+
+    static jni::local_ref<JVariant_NullType_AnyMap> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_AnyMap(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_AnyMap> create_1(jni::alias_ref<JAnyMap::javaobject> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_AnyMap(jni::alias_ref<JAnyMap::javaobject>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_AnyMap> fromCpp(const std::variant<nitro::NullType, std::shared_ptr<AnyMap>>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(JAnyMap::create(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, std::shared_ptr<AnyMap>> toCpp() const;
+  };
+
+  namespace JVariant_NullType_AnyMap_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_AnyMap> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_AnyMap$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_AnyMap> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_AnyMap$Second;";
+    
+      [[nodiscard]] jni::local_ref<JAnyMap::javaobject> getValue() const {
+        static const auto field = javaClassStatic()->getField<JAnyMap::javaobject>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_AnyMap_impl
+} // namespace margelo::nitro::nitrobackgroundgeolocation

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

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

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

@@ -0,0 +1,69 @@
+///
+/// JVariant_NullType_Boolean.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Boolean".
+   */
+  class JVariant_NullType_Boolean: public jni::JavaClass<JVariant_NullType_Boolean> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Boolean;";
+
+    static jni::local_ref<JVariant_NullType_Boolean> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Boolean(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_Boolean> create_1(jboolean value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Boolean(jboolean)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_Boolean> fromCpp(const std::variant<nitro::NullType, bool>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(std::get<1>(variant));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, bool> toCpp() const;
+  };
+
+  namespace JVariant_NullType_Boolean_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_Boolean> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Boolean$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_Boolean> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Boolean$Second;";
+    
+      [[nodiscard]] jboolean getValue() const {
+        static const auto field = javaClassStatic()->getField<jboolean>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_Boolean_impl
+} // namespace margelo::nitro::nitrobackgroundgeolocation

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

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

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

@@ -0,0 +1,69 @@
+///
+/// JVariant_NullType_Double.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Double".
+   */
+  class JVariant_NullType_Double: public jni::JavaClass<JVariant_NullType_Double> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Double;";
+
+    static jni::local_ref<JVariant_NullType_Double> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Double(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_Double> create_1(double value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Double(double)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_Double> fromCpp(const std::variant<nitro::NullType, double>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(std::get<1>(variant));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, double> toCpp() const;
+  };
+
+  namespace JVariant_NullType_Double_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_Double> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Double$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_Double> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Double$Second;";
+    
+      [[nodiscard]] double getValue() const {
+        static const auto field = javaClassStatic()->getField<double>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_Double_impl
+} // namespace margelo::nitro::nitrobackgroundgeolocation

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

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

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

@@ -0,0 +1,71 @@
+///
+/// JVariant_NullType_LocationAccuracy.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include "LocationAccuracy.hpp"
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include "JLocationAccuracy.hpp"
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_LocationAccuracy".
+   */
+  class JVariant_NullType_LocationAccuracy: public jni::JavaClass<JVariant_NullType_LocationAccuracy> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_LocationAccuracy;";
+
+    static jni::local_ref<JVariant_NullType_LocationAccuracy> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_LocationAccuracy(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_LocationAccuracy> create_1(jni::alias_ref<JLocationAccuracy> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_LocationAccuracy(jni::alias_ref<JLocationAccuracy>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_LocationAccuracy> fromCpp(const std::variant<nitro::NullType, LocationAccuracy>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(JLocationAccuracy::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, LocationAccuracy> toCpp() const;
+  };
+
+  namespace JVariant_NullType_LocationAccuracy_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_LocationAccuracy> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_LocationAccuracy$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_LocationAccuracy> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_LocationAccuracy$Second;";
+    
+      [[nodiscard]] jni::local_ref<JLocationAccuracy> getValue() const {
+        static const auto field = javaClassStatic()->getField<JLocationAccuracy>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_LocationAccuracy_impl
+} // namespace margelo::nitro::nitrobackgroundgeolocation

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

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

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

@@ -0,0 +1,71 @@
+///
+/// JVariant_NullType_LocationProvider.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include "LocationProvider.hpp"
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include "JLocationProvider.hpp"
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_LocationProvider".
+   */
+  class JVariant_NullType_LocationProvider: public jni::JavaClass<JVariant_NullType_LocationProvider> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_LocationProvider;";
+
+    static jni::local_ref<JVariant_NullType_LocationProvider> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_LocationProvider(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_LocationProvider> create_1(jni::alias_ref<JLocationProvider> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_LocationProvider(jni::alias_ref<JLocationProvider>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_LocationProvider> fromCpp(const std::variant<nitro::NullType, LocationProvider>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(JLocationProvider::fromCpp(std::get<1>(variant)));
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, LocationProvider> toCpp() const;
+  };
+
+  namespace JVariant_NullType_LocationProvider_impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_LocationProvider> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_LocationProvider$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_LocationProvider> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_LocationProvider$Second;";
+    
+      [[nodiscard]] jni::local_ref<JLocationProvider> getValue() const {
+        static const auto field = javaClassStatic()->getField<JLocationProvider>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_LocationProvider_impl
+} // namespace margelo::nitro::nitrobackgroundgeolocation

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

@@ -0,0 +1,33 @@
+///
+/// JVariant_NullType_Map_String__String_.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JVariant_NullType_Map_String__String_.hpp"
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+  /**
+   * Converts JVariant_NullType_Map_String__String_ to std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>
+   */
+  std::variant<nitro::NullType, std::unordered_map<std::string, std::string>> JVariant_NullType_Map_String__String_::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_Map_String__String__impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_Map_String__String__impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_Map_String__String__impl::Second::javaClassStatic())) {
+      // It's a `std::unordered_map<std::string, std::string>`
+      auto jniValue = static_cast<const JVariant_NullType_Map_String__String__impl::Second*>(this)->getValue();
+      return [&]() {
+        std::unordered_map<std::string, std::string> __map;
+        __map.reserve(jniValue->size());
+        for (const auto& __entry : *jniValue) {
+          __map.emplace(__entry.first->toStdString(), __entry.second->toStdString());
+        }
+        return __map;
+      }();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitrobackgroundgeolocation

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

@@ -0,0 +1,77 @@
+///
+/// JVariant_NullType_Map_String__String_.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 <variant>
+
+#include <NitroModules/Null.hpp>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitrobackgroundgeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_Map_String__String_".
+   */
+  class JVariant_NullType_Map_String__String_: public jni::JavaClass<JVariant_NullType_Map_String__String_> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Map_String__String_;";
+
+    static jni::local_ref<JVariant_NullType_Map_String__String_> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Map_String__String_(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_Map_String__String_> create_1(jni::alias_ref<jni::JMap<jni::JString, jni::JString>> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_Map_String__String_(jni::alias_ref<jni::JMap<jni::JString, jni::JString>>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_Map_String__String_> fromCpp(const std::variant<nitro::NullType, std::unordered_map<std::string, std::string>>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1([&]() -> jni::local_ref<jni::JMap<jni::JString, jni::JString>> {
+          auto __map = jni::JHashMap<jni::JString, jni::JString>::create(std::get<1>(variant).size());
+          for (const auto& __entry : std::get<1>(variant)) {
+            __map->put(jni::make_jstring(__entry.first), jni::make_jstring(__entry.second));
+          }
+          return __map;
+        }());
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, std::unordered_map<std::string, std::string>> toCpp() const;
+  };
+
+  namespace JVariant_NullType_Map_String__String__impl {
+    class First final: public jni::JavaClass<First, JVariant_NullType_Map_String__String_> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Map_String__String_$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second final: public jni::JavaClass<Second, JVariant_NullType_Map_String__String_> {
+    public:
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrobackgroundgeolocation/Variant_NullType_Map_String__String_$Second;";
+    
+      [[nodiscard]] jni::local_ref<jni::JMap<jni::JString, jni::JString>> getValue() const {
+        static const auto field = javaClassStatic()->getField<jni::JMap<jni::JString, jni::JString>>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_Map_String__String__impl
+} // namespace margelo::nitro::nitrobackgroundgeolocation

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

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