react-native-nitro-modules 0.5.0 → 0.7.0

package/cpp/prototype/Prototype.hpp

@@ -38,8 +38,8 @@ using NativeInstanceId = std::type_index;
  */
 struct Prototype final {
 private:
-  std::shared_ptr<Prototype> _base = nullptr;
   NativeInstanceId _instanceTypeId;
+  std::shared_ptr<Prototype> _base = nullptr;
   std::unordered_map<std::string, HybridFunction> _methods;
   std::unordered_map<std::string, HybridFunction> _getters;
   std::unordered_map<std::string, HybridFunction> _setters;
@@ -102,25 +102,6 @@ public:
   }
 
 public:
-  /**
-   * Registers the given C++ method as a Hybrid Method that can be called from JS, through the object's Prototype.
-   * Example:
-   * ```cpp
-   * registerHybridMethod("sayHello", &MyObject::sayHello);
-   * ```
-   */
-  template <typename Derived, typename ReturnType, typename... Args>
-  inline void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...)) {
-    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
-    }
-    if (_methods.contains(name)) [[unlikely]] {
-      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
-    }
-
-    _methods.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::METHOD));
-  }
-
   /**
    * Registers the given C++ method as a property getter that can be called from JS, through the object's Prototype.
    * Example:
@@ -137,7 +118,7 @@ public:
       throw std::runtime_error("Cannot add Hybrid Property Getter \"" + name + "\" - a method with that name already exists!");
     }
 
-    _getters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::GETTER));
+    _getters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionKind::GETTER));
   }
 
   /**
@@ -156,7 +137,47 @@ public:
       throw std::runtime_error("Cannot add Hybrid Property Setter \"" + name + "\" - a method with that name already exists!");
     }
 
-    _setters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionType::SETTER));
+    _setters.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionKind::SETTER));
+  }
+
+  /**
+   * Registers the given C++ method as a Hybrid Method that can be called from JS, through the object's Prototype.
+   * Example:
+   * ```cpp
+   * registerHybridMethod("sayHello", &MyObject::sayHello);
+   * ```
+   */
+  template <typename Derived, typename ReturnType, typename... Args>
+  inline void registerHybridMethod(std::string name, ReturnType (Derived::*method)(Args...)) {
+    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _methods.emplace(name, HybridFunction::createHybridFunction(name, method, FunctionKind::METHOD));
+  }
+
+  /**
+   * Registers the given raw JSI C++ method as a Hybrid Method that can be called from JS, through the object's Prototype.
+   * Example:
+   * ```cpp
+   * registerRawHybridMethod("sayHello", &MyObject::sayHello);
+   * ```
+   */
+  template <typename Derived>
+  inline void registerRawHybridMethod(std::string name, size_t expectedArgumentsCount,
+                                      jsi::Value (Derived::*method)(jsi::Runtime& runtime, const jsi::Value& thisArg,
+                                                                    const jsi::Value* args, size_t count)) {
+    if (_getters.contains(name) || _setters.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a property with that name already exists!");
+    }
+    if (_methods.contains(name)) [[unlikely]] {
+      throw std::runtime_error("Cannot add Hybrid Method \"" + name + "\" - a method with that name already exists!");
+    }
+
+    _methods.emplace(name, HybridFunction::createRawHybridFunction(name, expectedArgumentsCount, method));
   }
 };
 

package/cpp/registry/HybridObjectRegistry.cpp

@@ -29,9 +29,9 @@ std::vector<std::string> HybridObjectRegistry::getAllHybridObjectNames() {
 }
 
 void HybridObjectRegistry::registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn) {
-  Logger::log(TAG, "Registering HybridObject \"%s\"...", hybridObjectName);
+  Logger::log(LogLevel::Info, TAG, "Registering HybridObject \"%s\"...", hybridObjectName.c_str());
   auto& map = HybridObjectRegistry::getRegistry();
-#if DEBUG
+#ifndef NDEBUG
   if (map.contains(hybridObjectName)) [[unlikely]] {
     auto message =
         "HybridObject \"" + std::string(hybridObjectName) +
@@ -43,7 +43,7 @@ void HybridObjectRegistry::registerHybridObjectConstructor(const std::string& hy
   }
 #endif
   map.insert({hybridObjectName, std::move(constructorFn)});
-  Logger::log(TAG, "Successfully registered HybridObject \"%s\"!", hybridObjectName);
+  Logger::log(LogLevel::Info, TAG, "Successfully registered HybridObject \"%s\"!", hybridObjectName.c_str());
 }
 
 std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std::string& hybridObjectName) {
@@ -57,7 +57,7 @@ std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std
   }
   std::shared_ptr<HybridObject> instance = fn->second();
 
-#if DEBUG
+#ifndef NDEBUG
   if (instance == nullptr) [[unlikely]] {
     throw std::runtime_error("Failed to create HybridObject \"" + hybridObjectName +
                              "\" - "

package/cpp/threading/Dispatcher.cpp

@@ -11,7 +11,7 @@ static constexpr auto GLOBAL_DISPATCHER_HOLDER_NAME = "__nitroDispatcher";
 std::unordered_map<jsi::Runtime*, std::weak_ptr<Dispatcher>> Dispatcher::_globalCache;
 
 void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher) {
-  Logger::log(TAG, "Installing global Dispatcher Holder into Runtime \"%s\"...", getRuntimeId(runtime));
+  Logger::log(LogLevel::Info, TAG, "Installing global Dispatcher Holder into Runtime \"%s\"...", getRuntimeId(runtime).c_str());
 
   // Store a weak reference in global cache
   _globalCache[&runtime] = std::weak_ptr(dispatcher);
@@ -33,14 +33,15 @@ std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime&
     }
   }
 
-  Logger::log(TAG, "Unknown Runtime (%s), looking for Dispatcher through JSI global lookup...", getRuntimeId(runtime));
+  Logger::log(LogLevel::Warning, TAG, "Unknown Runtime (%s), looking for Dispatcher through JSI global lookup...",
+              getRuntimeId(runtime).c_str());
   jsi::Value dispatcherHolderValue = getRuntimeGlobalDispatcherHolder(runtime);
   jsi::Object dispatcherHolder = dispatcherHolderValue.getObject(runtime);
   return dispatcherHolder.getNativeState<Dispatcher>(runtime);
 }
 
 jsi::Value Dispatcher::getRuntimeGlobalDispatcherHolder(jsi::Runtime& runtime) {
-#if DEBUG
+#ifndef NDEBUG
   if (!runtime.global().hasProperty(runtime, GLOBAL_DISPATCHER_HOLDER_NAME)) {
     throw std::runtime_error("Failed to get current Dispatcher - the global Dispatcher "
                              "holder (global." +

package/cpp/threading/ThreadPool.cpp

@@ -12,7 +12,7 @@
 namespace margelo::nitro {
 
 ThreadPool::ThreadPool(const char* name, size_t numThreads) : _isAlive(true), _name(name) {
-  Logger::log(TAG, "Creating ThreadPool \"%s\" with %i threads...", name, numThreads);
+  Logger::log(LogLevel::Info, TAG, "Creating ThreadPool \"%s\" with %i threads...", name, numThreads);
 
   for (size_t i = 0; i < numThreads; ++i) {
     std::string threadName = std::string(name) + "-" + std::to_string(i + 1);
@@ -56,7 +56,7 @@ void ThreadPool::run(std::function<void()>&& task) {
 }
 
 ThreadPool::~ThreadPool() {
-  Logger::log(TAG, "Destroying ThreadPool \"%s\"...", _name);
+  Logger::log(LogLevel::Info, TAG, "Destroying ThreadPool \"%s\"...", _name);
 
   {
     // Lock and set `_isAlive` to false.

package/cpp/turbomodule/NativeNitroModules.cpp

@@ -25,7 +25,7 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   if (name == "install") {
     return jsi::Function::createFromHostFunction(
         runtime, jsi::PropNameID::forUtf8(runtime, "install"), 0,
-        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
           install(runtime);
           return jsi::Value::undefined();
         });
@@ -33,8 +33,8 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   if (name == "createHybridObject") {
     return jsi::Function::createFromHostFunction(
         runtime, jsi::PropNameID::forUtf8(runtime, "createHybridObject"), 2,
-        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-#if DEBUG
+        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+#ifndef NDEBUG
           if (count != 1 && count != 2) [[unlikely]] {
             throw jsi::JSError(runtime, "NitroModules.createHybridObject(..) expects 1 or 2 arguments, but " + std::to_string(count) +
                                             " were supplied!");
@@ -52,8 +52,8 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   if (name == "hasHybridObject") {
     return jsi::Function::createFromHostFunction(
         runtime, jsi::PropNameID::forUtf8(runtime, "hasHybridObject"), 1,
-        [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
-#if DEBUG
+        [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+#ifndef NDEBUG
           if (count != 1) [[unlikely]] {
             throw jsi::JSError(runtime,
                                "NitroModules.hasHybridObject(..) expects 1 argument (name), but received " + std::to_string(count) + "!");
@@ -65,8 +65,26 @@ jsi::Value NativeNitroModules::get(jsi::Runtime& runtime, const jsi::PropNameID&
   }
   if (name == "getAllHybridObjectNames") {
     return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, "getAllHybridObjectNames"), 0,
-                                                 [=](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args,
-                                                     size_t count) -> jsi::Value { return getAllHybridObjectNames(runtime); });
+                                                 [this](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args,
+                                                        size_t count) -> jsi::Value { return getAllHybridObjectNames(runtime); });
+  }
+  if (name == "hasNativeState") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "hasNativeState"), 1,
+        [](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+          jsi::Object object = args[0].asObject(runtime);
+          bool has = object.hasNativeState(runtime) && object.getNativeState(runtime) != nullptr;
+          return jsi::Value(has);
+        });
+  }
+  if (name == "removeNativeState") {
+    return jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "removeNativeState"), 1,
+        [](jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* args, size_t count) -> jsi::Value {
+          jsi::Object object = args[0].asObject(runtime);
+          object.setNativeState(runtime, nullptr);
+          return jsi::Value::undefined();
+        });
   }
 
   return jsi::Value::undefined();
@@ -80,7 +98,7 @@ void NativeNitroModules::install(jsi::Runtime& runtime) {
 }
 
 jsi::Value NativeNitroModules::createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName,
-                                                  const std::optional<jsi::Object>& args) {
+                                                  const std::optional<jsi::Object>&) {
   auto name = hybridObjectName.utf8(runtime);
   // TODO: Pass args? Do we need that?
   auto hybridObject = HybridObjectRegistry::createHybridObject(name.c_str());

package/cpp/turbomodule/NativeNitroModules.h

@@ -4,4 +4,5 @@
 
 #pragma once
 
+// Forward include, because in react-native they use `.h` instead of `.hpp`
 #include "NativeNitroModules.hpp"

package/cpp/turbomodule/NativeNitroModules.hpp

@@ -22,7 +22,9 @@ public:
 public:
   jsi::Value get(jsi::Runtime& runtime, const jsi::PropNameID& propName) override;
 
+  // Setup
   void install(jsi::Runtime& runtime);
+  // Hybrid Objects stuff
   jsi::Value createHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName, const std::optional<jsi::Object>& args);
   jsi::Value hasHybridObject(jsi::Runtime& runtime, const jsi::String& hybridObjectName);
   jsi::Value getAllHybridObjectNames(jsi::Runtime& runtime);

package/cpp/utils/TypeInfo.hpp

@@ -71,6 +71,20 @@ public:
     return name;
   }
 
+  /**
+   * Get a friendly name of the type `T` (if possible, demangled), without any namespaces
+   */
+  template <typename T>
+  static inline std::string getFriendlyTypenameNoNamespace() {
+    std::string friendly = getFriendlyTypename<T>();
+    size_t lastColon = friendly.rfind(':');
+    if (lastColon == std::string::npos) {
+      // Type does not have any namespace (:), just return as is.
+      return friendly;
+    }
+    return friendly.substr(lastColon + 1);
+  }
+
   template <typename... Types>
   static inline std::string getFriendlyTypenames() {
     std::ostringstream stream;

package/ios/core/AnyMapHolder.hpp

@@ -0,0 +1,91 @@
+//
+//  AnyMapHolder.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.08.24.
+//
+
+#pragma once
+
+#include "AnyMap.hpp"
+
+namespace margelo::nitro {
+
+using TSharedMap = std::shared_ptr<AnyMap>;
+
+inline AnyValue create_AnyValue() {
+  return AnyValue{std::monostate{}};
+}
+inline AnyValue create_AnyValue(bool boolValue) {
+  return AnyValue{boolValue};
+}
+inline AnyValue create_AnyValue(double doubleValue) {
+  return AnyValue{doubleValue};
+}
+inline AnyValue create_AnyValue(int64_t bigintValue) {
+  return AnyValue{bigintValue};
+}
+inline AnyValue create_AnyValue(const std::string& stringValue) {
+  return AnyValue{stringValue};
+}
+inline AnyValue create_AnyValue(const AnyArray& arrayValue) {
+  return AnyValue{arrayValue};
+}
+inline AnyValue create_AnyValue(const AnyObject& objectValue) {
+  return AnyValue{objectValue};
+}
+
+inline bool is_AnyValue_null(const AnyValue& value) {
+  return std::holds_alternative<std::monostate>(value);
+}
+inline bool is_AnyValue_bool(const AnyValue& value) {
+  return std::holds_alternative<bool>(value);
+}
+inline bool is_AnyValue_number(const AnyValue& value) {
+  return std::holds_alternative<double>(value);
+}
+inline bool is_AnyValue_bigint(const AnyValue& value) {
+  return std::holds_alternative<int64_t>(value);
+}
+inline bool is_AnyValue_string(const AnyValue& value) {
+  return std::holds_alternative<std::string>(value);
+}
+inline bool is_AnyValue_AnyArray(const AnyValue& value) {
+  return std::holds_alternative<AnyArray>(value);
+}
+inline bool is_AnyValue_AnyObject(const AnyValue& value) {
+  return std::holds_alternative<AnyObject>(value);
+}
+
+inline std::monostate get_AnyValue_null(const AnyValue& value) {
+  return std::get<std::monostate>(value);
+}
+inline bool get_AnyValue_bool(const AnyValue& value) {
+  return std::get<bool>(value);
+}
+inline double get_AnyValue_number(const AnyValue& value) {
+  return std::get<double>(value);
+}
+inline int64_t get_AnyValue_bigint(const AnyValue& value) {
+  return std::get<int64_t>(value);
+}
+inline std::string get_AnyValue_string(const AnyValue& value) {
+  return std::get<std::string>(value);
+}
+inline AnyArray get_AnyValue_AnyArray(const AnyValue& value) {
+  return std::get<AnyArray>(value);
+}
+inline AnyObject get_AnyValue_AnyObject(const AnyValue& value) {
+  return std::get<AnyObject>(value);
+}
+
+inline std::vector<std::string> getAnyObjectKeys(const AnyObject& object) {
+  std::vector<std::string> keys;
+  keys.reserve(object.size());
+  for (const auto& entry : object) {
+    keys.push_back(entry.first);
+  }
+  return keys;
+}
+
+} // namespace margelo::nitro

package/ios/core/AnyMapHolder.swift

@@ -0,0 +1,316 @@
+//
+//  AnyMapHolder.swift
+//  NitroModules
+//
+//  Created by Marc Rousavy on 20.08.24.
+//
+
+import Foundation
+
+/**
+ * Represents any value representable by the `AnyMap`.
+ * Note: Arrays are currently not implemented due to a Swift compiler bug https://github.com/swiftlang/swift/issues/75994
+ */
+public enum AnyValue {
+  case null
+  case number(Double)
+  case bool(Bool)
+  case bigint(Int64)
+  case string(String)
+  case object(Dictionary<String, AnyValue>)
+
+  static func create(_ value: margelo.nitro.AnyValue) -> AnyValue {
+    if margelo.nitro.is_AnyValue_null(value) {
+      return .null
+    } else if margelo.nitro.is_AnyValue_bool(value) {
+      return .bool(margelo.nitro.get_AnyValue_bool(value))
+    } else if margelo.nitro.is_AnyValue_number(value) {
+      return .number(margelo.nitro.get_AnyValue_number(value))
+    } else if margelo.nitro.is_AnyValue_bigint(value) {
+      return .bigint(margelo.nitro.get_AnyValue_bigint(value))
+    } else if margelo.nitro.is_AnyValue_string(value) {
+      return .string(margelo.nitro.get_AnyValue_string(value).toSwift())
+    } else if margelo.nitro.is_AnyValue_AnyObject(value) {
+      return .object(margelo.nitro.get_AnyValue_AnyObject(value).toSwift())
+    } else {
+      fatalError("AnyValue has unknown type!")
+    }
+  }
+}
+
+/**
+ * Represents an `AnyMap` that can be passed to Swift.
+ */
+public class AnyMapHolder {
+  let _cppPart: margelo.nitro.TSharedMap
+  
+  public var cppPart: margelo.nitro.TSharedMap {
+    return _cppPart
+  }
+
+  public init() {
+    _cppPart = margelo.nitro.AnyMap.make()
+  }
+
+  public init(withPreallocatedSize size: Int) {
+    _cppPart = margelo.nitro.AnyMap.make(size)
+  }
+  
+  public init(withCppPart cppPart: margelo.nitro.TSharedMap) {
+    _cppPart = cppPart
+  }
+
+  // pragma MARK: Common Operations
+
+  /**
+   * Returns whether the given key exists in the map.
+   */
+  public func contains(key: String) -> Bool {
+    return _cppPart.pointee.contains(std.string(key))
+  }
+
+  /**
+   * Removes the given key from the map.
+   */
+  public func remove(key: String) {
+    _cppPart.pointee.remove(std.string(key))
+  }
+
+  /**
+   * Removes all keys in this map.
+   */
+  public func clear() {
+    _cppPart.pointee.clear()
+  }
+
+  // pragma MARK: Getters
+
+  /**
+   * Gets the double value at the given key.
+   * If no value exists at the given key, or if it is not a double,
+   * this function throws.
+   */
+  public func getDouble(key: String) -> Double {
+    return _cppPart.pointee.getDouble(std.string(key))
+  }
+
+  /**
+   * Gets the double value at the given key.
+   * If no value exists at the given key, or if it is not a double,
+   * this function throws.
+   */
+  public func getBoolean(key: String) -> Bool {
+    return _cppPart.pointee.getBoolean(std.string(key))
+  }
+
+  /**
+   * Gets the double value at the given key.
+   * If no value exists at the given key, or if it is not a double,
+   * this function throws.
+   */
+  public func getBigInt(key: String) -> Int64 {
+    return _cppPart.pointee.getBigInt(std.string(key))
+  }
+
+  /**
+   * Gets the double value at the given key.
+   * If no value exists at the given key, or if it is not a double,
+   * this function throws.
+   */
+  public func getString(key: String) -> String {
+    let value = _cppPart.pointee.getString(std.string(key))
+    return String(value)
+  }
+
+  /**
+   * Gets the double value at the given key.
+   * If no value exists at the given key, or if it is not a double,
+   * this function throws.
+   */
+  public func getObject(key: String) -> Dictionary<String, AnyValue> {
+    let value = _cppPart.pointee.getObject(std.string(key))
+    return value.toSwift()
+  }
+
+  // pragma MARK: Setters
+
+  /**
+   * Set the given key to `null`.
+   */
+  public func setNull(key: String) {
+    _cppPart.pointee.setNull(std.string(key))
+  }
+
+  /**
+   * Set the given key to the given double value.
+   */
+  public func setDouble(key: String, value: Double) {
+    _cppPart.pointee.setDouble(std.string(key), value)
+  }
+
+  /**
+   * Set the given key to the given boolean value.
+   */
+  public func setBoolean(key: String, value: Bool) {
+    _cppPart.pointee.setBoolean(std.string(key), value)
+  }
+
+  /**
+   * Set the given key to the given bigint value.
+   */
+  public func setBigInt(key: String, value: Int64) {
+    _cppPart.pointee.setBigInt(std.string(key), value)
+  }
+
+  /**
+   * Set the given key to the given string value.
+   */
+  public func setString(key: String, value: String) {
+    _cppPart.pointee.setString(std.string(key), std.string(value))
+  }
+
+  /**
+   * Set the given key to the given object value.
+   */
+  public func setObject(key: String, value: Dictionary<String, AnyValue>) {
+    _cppPart.pointee.setObject(std.string(key), margelo.nitro.AnyObject.create(value))
+  }
+
+  // pragma MARK: Is Getters
+
+  /**
+   * Gets whether the given `key` is holding a null value, or not.
+   */
+  public func isNull(key: String) -> Bool {
+    return _cppPart.pointee.isNull(std.string(key))
+  }
+
+  /**
+   * Gets whether the given `key` is holding a double value, or not.
+   */
+  public func isDouble(key: String) -> Bool {
+    return _cppPart.pointee.isDouble(std.string(key))
+  }
+
+  /**
+   * Gets whether the given `key` is holding a boolean value, or not.
+   */
+  public func isBool(key: String) -> Bool {
+    return _cppPart.pointee.isBoolean(std.string(key))
+  }
+
+  /**
+   * Gets whether the given `key` is holding a bigint value, or not.
+   */
+  public func isBigInt(key: String) -> Bool {
+    return _cppPart.pointee.isBigInt(std.string(key))
+  }
+
+  /**
+   * Gets whether the given `key` is holding a string value, or not.
+   */
+  public func isString(key: String) -> Bool {
+    return _cppPart.pointee.isString(std.string(key))
+  }
+
+  /**
+   * Gets whether the given `key` is holding a object value, or not.
+   */
+  public func isObject(key: String) -> Bool {
+    return _cppPart.pointee.isObject(std.string(key))
+  }
+}
+
+// pragma MARK: margelo.nitro.AnyValue extension
+
+extension margelo.nitro.AnyValue {
+  static func create(_ value: AnyValue) -> margelo.nitro.AnyValue {
+    switch value {
+    case .null:
+      return create()
+    case .bool(let bool):
+      return create(bool)
+    case .number(let number):
+      return create(number)
+    case .bigint(let bigint):
+      return create(bigint)
+    case .string(let string):
+      return create(string)
+    case .object(let object):
+      return create(object)
+    }
+  }
+  static func create() -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue()
+  }
+  static func create(_ value: Bool) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(value)
+  }
+  static func create(_ value: Double) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(value)
+  }
+  static func create(_ value: Int64) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(value)
+  }
+  static func create(_ value: String) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(std.string(value))
+  }
+  static func create(_ value: [AnyValue]) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(margelo.nitro.AnyArray.create(value))
+  }
+  static func create(_ value: Dictionary<String, AnyValue>) -> margelo.nitro.AnyValue {
+    return margelo.nitro.create_AnyValue(margelo.nitro.AnyObject.create(value))
+  }
+}
+
+// pragma MARK: std.string extension
+
+extension std.string {
+  func toSwift() -> String {
+    return String(self)
+  }
+}
+
+// pragma MARK: margelo.nitro.AnyArray extension
+
+extension margelo.nitro.AnyArray {
+  static func create(_ array: [AnyValue]) -> margelo.nitro.AnyArray {
+    var vector = margelo.nitro.AnyArray()
+    vector.reserve(array.count)
+    for value in array {
+      vector.push_back(margelo.nitro.AnyValue.create(value))
+    }
+    return vector
+  }
+
+  func toSwift() -> [AnyValue] {
+    var array: [AnyValue] = []
+    array.reserveCapacity(self.size())
+    for value in self {
+      array.append(AnyValue.create(value))
+    }
+    return array
+  }
+}
+
+// pragma MARK: margelo.nitro.AnyObject extension
+
+extension margelo.nitro.AnyObject {
+  static func create(_ dictionary: Dictionary<String, AnyValue>) -> margelo.nitro.AnyObject {
+    var object = margelo.nitro.AnyObject()
+    object.reserve(dictionary.count)
+    for (key, value) in dictionary {
+      object[std.string(key)] = margelo.nitro.AnyValue.create(value)
+    }
+    return object
+  }
+
+  func toSwift() -> Dictionary<String, AnyValue> {
+    let keys = margelo.nitro.getAnyObjectKeys(self)
+    var dictionary = Dictionary<String, AnyValue>(minimumCapacity: keys.size())
+    for key in keys {
+
+    }
+    return dictionary
+  }
+}