react-native-carrot-quest 0.1.0

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

@@ -0,0 +1,64 @@
+///
+/// JCarrotQuestTheme.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 "CarrotQuestTheme.hpp"
+
+namespace margelo::nitro::carrotquest {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "CarrotQuestTheme" and the Kotlin enum "CarrotQuestTheme".
+   */
+  struct JCarrotQuestTheme final: public jni::JavaClass<JCarrotQuestTheme> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/CarrotQuestTheme;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum CarrotQuestTheme.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CarrotQuestTheme toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<CarrotQuestTheme>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JCarrotQuestTheme> fromCpp(CarrotQuestTheme value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case CarrotQuestTheme::LIGHT:
+          static const auto fieldLIGHT = clazz->getStaticField<JCarrotQuestTheme>("LIGHT");
+          return clazz->getStaticFieldValue(fieldLIGHT);
+        case CarrotQuestTheme::DARK:
+          static const auto fieldDARK = clazz->getStaticField<JCarrotQuestTheme>("DARK");
+          return clazz->getStaticFieldValue(fieldDARK);
+        case CarrotQuestTheme::FROMDEVICE:
+          static const auto fieldFROMDEVICE = clazz->getStaticField<JCarrotQuestTheme>("FROMDEVICE");
+          return clazz->getStaticFieldValue(fieldFROMDEVICE);
+        case CarrotQuestTheme::FROMWEB:
+          static const auto fieldFROMWEB = clazz->getStaticField<JCarrotQuestTheme>("FROMWEB");
+          return clazz->getStaticFieldValue(fieldFROMWEB);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::carrotquest

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

@@ -0,0 +1,64 @@
+///
+/// JCarrotQuestUrlSource.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 "CarrotQuestUrlSource.hpp"
+
+namespace margelo::nitro::carrotquest {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "CarrotQuestUrlSource" and the Kotlin enum "CarrotQuestUrlSource".
+   */
+  struct JCarrotQuestUrlSource final: public jni::JavaClass<JCarrotQuestUrlSource> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/CarrotQuestUrlSource;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum CarrotQuestUrlSource.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CarrotQuestUrlSource toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<CarrotQuestUrlSource>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JCarrotQuestUrlSource> fromCpp(CarrotQuestUrlSource value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case CarrotQuestUrlSource::PUSH:
+          static const auto fieldPUSH = clazz->getStaticField<JCarrotQuestUrlSource>("PUSH");
+          return clazz->getStaticFieldValue(fieldPUSH);
+        case CarrotQuestUrlSource::CHAT:
+          static const auto fieldCHAT = clazz->getStaticField<JCarrotQuestUrlSource>("CHAT");
+          return clazz->getStaticFieldValue(fieldCHAT);
+        case CarrotQuestUrlSource::POPUP:
+          static const auto fieldPOPUP = clazz->getStaticField<JCarrotQuestUrlSource>("POPUP");
+          return clazz->getStaticFieldValue(fieldPOPUP);
+        case CarrotQuestUrlSource::ALL:
+          static const auto fieldALL = clazz->getStaticField<JCarrotQuestUrlSource>("ALL");
+          return clazz->getStaticFieldValue(fieldALL);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::carrotquest

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

@@ -0,0 +1,84 @@
+///
+/// JCarrotQuestUserProperties.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 "CarrotQuestUserProperties.hpp"
+
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace margelo::nitro::carrotquest {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "CarrotQuestUserProperties" and the Kotlin data class "CarrotQuestUserProperties".
+   */
+  struct JCarrotQuestUserProperties final: public jni::JavaClass<JCarrotQuestUserProperties> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/CarrotQuestUserProperties;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct CarrotQuestUserProperties by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CarrotQuestUserProperties toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldPhone = clazz->getField<jni::JString>("phone");
+      jni::local_ref<jni::JString> phone = this->getFieldValue(fieldPhone);
+      static const auto fieldEmail = clazz->getField<jni::JString>("email");
+      jni::local_ref<jni::JString> email = this->getFieldValue(fieldEmail);
+      static const auto fieldCustom = clazz->getField<jni::JMap<jni::JString, jni::JString>>("custom");
+      jni::local_ref<jni::JMap<jni::JString, jni::JString>> custom = this->getFieldValue(fieldCustom);
+      return CarrotQuestUserProperties(
+        name != nullptr ? std::make_optional(name->toStdString()) : std::nullopt,
+        phone != nullptr ? std::make_optional(phone->toStdString()) : std::nullopt,
+        email != nullptr ? std::make_optional(email->toStdString()) : std::nullopt,
+        custom != nullptr ? std::make_optional([&]() {
+          std::unordered_map<std::string, std::string> __map;
+          __map.reserve(custom->size());
+          for (const auto& __entry : *custom) {
+            __map.emplace(__entry.first->toStdString(), __entry.second->toStdString());
+          }
+          return __map;
+        }()) : 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<JCarrotQuestUserProperties::javaobject> fromCpp(const CarrotQuestUserProperties& value) {
+      using JSignature = JCarrotQuestUserProperties(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JMap<jni::JString, jni::JString>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.name.has_value() ? jni::make_jstring(value.name.value()) : nullptr,
+        value.phone.has_value() ? jni::make_jstring(value.phone.value()) : nullptr,
+        value.email.has_value() ? jni::make_jstring(value.email.value()) : nullptr,
+        value.custom.has_value() ? [&]() -> jni::local_ref<jni::JMap<jni::JString, jni::JString>> {
+          auto __map = jni::JHashMap<jni::JString, jni::JString>::create(value.custom.value().size());
+          for (const auto& __entry : value.custom.value()) {
+            __map->put(jni::make_jstring(__entry.first), jni::make_jstring(__entry.second));
+          }
+          return __map;
+        }() : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::carrotquest

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

@@ -0,0 +1,84 @@
+///
+/// JFunc_void_CarrotQuestLogEntry.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 "CarrotQuestLogEntry.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JCarrotQuestLogEntry.hpp"
+#include "CarrotQuestLogLevel.hpp"
+#include "JCarrotQuestLogLevel.hpp"
+#include "CarrotQuestLogCategory.hpp"
+#include "JCarrotQuestLogCategory.hpp"
+#include <string>
+#include <unordered_map>
+#include <optional>
+
+namespace margelo::nitro::carrotquest {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(entry: CarrotQuestLogEntry) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_CarrotQuestLogEntry: public jni::JavaClass<JFunc_void_CarrotQuestLogEntry> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/Func_void_CarrotQuestLogEntry;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_CarrotQuestLogEntry` instance holds through JNI.
+     */
+    void invoke(const CarrotQuestLogEntry& entry) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JCarrotQuestLogEntry> /* entry */)>("invoke");
+      method(self(), JCarrotQuestLogEntry::fromCpp(entry));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_CarrotQuestLogEntry that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_CarrotQuestLogEntry_cxx final: public jni::HybridClass<JFunc_void_CarrotQuestLogEntry_cxx, JFunc_void_CarrotQuestLogEntry> {
+  public:
+    static jni::local_ref<JFunc_void_CarrotQuestLogEntry::javaobject> fromCpp(const std::function<void(const CarrotQuestLogEntry& /* entry */)>& func) {
+      return JFunc_void_CarrotQuestLogEntry_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_CarrotQuestLogEntry_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JCarrotQuestLogEntry> entry) {
+      _func(entry->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const CarrotQuestLogEntry& /* entry */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/Func_void_CarrotQuestLogEntry_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_CarrotQuestLogEntry_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_CarrotQuestLogEntry_cxx(const std::function<void(const CarrotQuestLogEntry& /* entry */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const CarrotQuestLogEntry& /* entry */)> _func;
+  };
+
+} // namespace margelo::nitro::carrotquest

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool.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 <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::carrotquest {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(visible: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool visible) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* visible */)>("invoke");
+      method(self(), visible);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  public:
+    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* visible */)>& func) {
+      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean visible) {
+      _func(static_cast<bool>(visible));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* visible */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/Func_void_bool_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_cxx(const std::function<void(bool /* visible */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* visible */)> _func;
+  };
+
+} // namespace margelo::nitro::carrotquest

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_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 <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::carrotquest {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(count: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double: public jni::JavaClass<JFunc_void_double> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/Func_void_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double` instance holds through JNI.
+     */
+    void invoke(double count) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* count */)>("invoke");
+      method(self(), count);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_cxx final: public jni::HybridClass<JFunc_void_double_cxx, JFunc_void_double> {
+  public:
+    static jni::local_ref<JFunc_void_double::javaobject> fromCpp(const std::function<void(double /* count */)>& func) {
+      return JFunc_void_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_cxx` instance holds.
+     */
+    void invoke_cxx(double count) {
+      _func(count);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* count */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/Func_void_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_cxx(const std::function<void(double /* count */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* count */)> _func;
+  };
+
+} // namespace margelo::nitro::carrotquest

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

@@ -0,0 +1,76 @@
+///
+/// JFunc_void_std__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 <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::carrotquest {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(url: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& url) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* url */)>("invoke");
+      method(self(), jni::make_jstring(url));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* url */)>& func) {
+      return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> url) {
+      _func(url->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* url */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/carrotquest/Func_void_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* url */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* url */)> _func;
+  };
+
+} // namespace margelo::nitro::carrotquest