react-native-nitro-modules 0.24.0 → 0.25.0

package/NitroModules.podspec

@@ -48,7 +48,6 @@ Pod::Spec.new do |s|
     # Public iOS-specific headers that will be exposed in modulemap (for Swift)
     "ios/core/ArrayBufferHolder.hpp",
     "ios/core/AnyMapHolder.hpp",
-    "ios/core/HybridContext.hpp",
     "ios/core/PromiseHolder.hpp",
     "ios/utils/Result.hpp",
     "ios/utils/RuntimeError.hpp",

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.8.1"
+    classpath "com.android.tools.build:gradle:8.9.0"
   }
 }
 

package/android/src/main/cpp/JNIOnLoad.cpp

@@ -3,7 +3,6 @@
 #include "JAnyMap.hpp"
 #include "JAnyValue.hpp"
 #include "JArrayBuffer.hpp"
-#include "JHybridObjectRegistry.hpp"
 #include "JNitroModules.hpp"
 #include "JPromise.hpp"
 #include <fbjni/fbjni.h>
@@ -14,7 +13,6 @@ using namespace margelo::nitro;
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
   return facebook::jni::initialize(vm, [] {
     // 1. Initialize all core Nitro Java bindings
-    JHybridObjectRegistry::registerNatives();
     JArrayBuffer::registerNatives();
     JAnyMap::registerNatives();
     JAnyValue::registerNatives();

package/android/src/main/cpp/registry/JHybridObjectInitializer.hpp

@@ -18,7 +18,7 @@ using namespace facebook;
 struct JHybridObjectInitializer : public jni::JavaClass<JHybridObjectInitializer> {
 public:
   jni::local_ref<JHybridObject::javaobject> call() const {
-    const auto method = this->getClass()->getMethod<JHybridObject::javaobject()>("initialize");
+    const auto method = this->javaClassStatic()->getMethod<JHybridObject::javaobject()>("initialize");
     return method(self());
   }
 

package/android/src/main/cpp/utils/JNISharedPtr.hpp

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include "NitroDefines.hpp"
+#include "NitroTypeInfo.hpp"
 #include <fbjni/fbjni.h>
 #include <memory>
 
@@ -13,19 +15,21 @@ using namespace facebook;
 
 template <typename T>
 struct GlobalRefDeleter {
-  explicit GlobalRefDeleter(jni::global_ref<typename T::javaobject> ref) : _ref(ref) {}
+  explicit GlobalRefDeleter(const jni::global_ref<typename T::javaobject>& ref) : _ref(ref) {}
+
+  GlobalRefDeleter(const GlobalRefDeleter& copy) = delete;
+  GlobalRefDeleter(GlobalRefDeleter&& move) = default;
 
   void operator()(T* /* cthis */) {
-    if (_ref) {
-      _ref.release();
-    }
+    // It's RAII - once `GlobalRefDeleter` goes out of scope, `jni::global_ref` will too.
+    _ref = nullptr;
   }
 
 private:
   jni::global_ref<typename T::javaobject> _ref;
 };
 
-class JNISharedPtr {
+class JNISharedPtr final {
 private:
   template <typename T, template <typename, typename...> class Base>
   struct is_base_template_of {
@@ -39,9 +43,23 @@ private:
   };
 
 public:
+  JNISharedPtr() = delete;
+  ~JNISharedPtr() = delete;
+
+public:
+  /**
+   * Creates a new `std::shared_ptr<T>` from the given `jni::global_ref<T::javaobject>`.
+   */
   template <typename T, typename std::enable_if<is_base_template_of<T, jni::HybridClass>::value, int>::type = 0>
-  static std::shared_ptr<T> make_shared_from_jni(jni::global_ref<typename T::javaobject> ref) {
-    return std::shared_ptr<T>(ref->cthis(), GlobalRefDeleter<T>{ref});
+  static std::shared_ptr<T> make_shared_from_jni(const jni::global_ref<typename T::javaobject>& ref) {
+#ifdef NITRO_DEBUG
+    if (ref == nullptr || ref->cthis() == nullptr) [[unlikely]] {
+      std::string typeName = TypeInfo::getFriendlyTypename<T>(true);
+      throw std::runtime_error("Failed to wrap jni::global_ref<" + typeName + "::javaobject> in std::shared_ptr<" + typeName +
+                               "> - it's null!");
+    }
+#endif
+    return std::shared_ptr<T>(ref->cthis(), GlobalRefDeleter<T>(ref));
   }
 };
 

package/android/src/main/java/com/margelo/nitro/core/ArrayBuffer.kt

@@ -137,10 +137,5 @@ class ArrayBuffer {
             byteBuffer.rewind()
             return ArrayBuffer(byteBuffer)
         }
-
-        @Deprecated("Use copy(...) instead", level = DeprecationLevel.WARNING)
-        fun copyOf(other: ArrayBuffer): ArrayBuffer {
-            return copy(other)
-        }
     }
 }

package/cpp/core/ArrayBuffer.cpp

@@ -21,13 +21,13 @@ std::shared_ptr<ArrayBuffer> ArrayBuffer::wrap(uint8_t* data, size_t size, Delet
   return std::make_shared<NativeArrayBuffer>(data, size, std::move(deleteFunc));
 }
 
-std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(uint8_t* data, size_t size) {
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const uint8_t* data, size_t size) {
   uint8_t* copy = new uint8_t[size];
   std::memcpy(copy, data, size);
   return ArrayBuffer::wrap(copy, size, [=]() { delete[] copy; });
 }
 
-std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(std::vector<uint8_t>& data) {
+std::shared_ptr<ArrayBuffer> ArrayBuffer::copy(const std::vector<uint8_t>& data) {
   return ArrayBuffer::copy(data.data(), data.size());
 }
 

package/cpp/core/ArrayBuffer.hpp

@@ -58,20 +58,15 @@ public:
    * Create a new `NativeArrayBuffer` that copies the given data of the given size
    * into a newly allocated buffer.
    */
-  static std::shared_ptr<ArrayBuffer> copy(uint8_t* data, size_t size);
+  static std::shared_ptr<ArrayBuffer> copy(const uint8_t* data, size_t size);
   /**
    * Create a new `NativeArrayBuffer` that copies the given `std::vector`.
    */
-  static std::shared_ptr<ArrayBuffer> copy(std::vector<uint8_t>& data);
+  static std::shared_ptr<ArrayBuffer> copy(const std::vector<uint8_t>& data);
   /**
    * Create a new `NativeArrayBuffer` that allocates a new buffer of the given size.
    */
   static std::shared_ptr<ArrayBuffer> allocate(size_t size);
-
-  [[deprecated("Use wrapBuffer(...) instead.")]]
-  static std::shared_ptr<ArrayBuffer> makeBuffer(uint8_t* data, size_t size, DeleteFn&& deleteFunc) {
-    return ArrayBuffer::wrap(data, size, std::move(deleteFunc));
-  }
 };
 
 /**

package/cpp/core/HybridObject.cpp

@@ -79,11 +79,17 @@ jsi::Value HybridObject::toObject(jsi::Runtime& runtime) {
   object.setProperty(runtime, "__type", jsi::String::createFromUtf8(runtime, "NativeState<" + std::string(_name) + ">"));
 #endif
 
-  // 8. Throw a jsi::WeakObject pointing to our object into cache so subsequent calls can use it from cache
+#ifdef NITRO_DEBUG
+  // 8. Freeze the object to prevent accidentally setting wrong props on it that do nothing.
+  jsi::Function freeze = objectConstructor.getPropertyAsFunction(runtime, "freeze");
+  freeze.call(runtime, object);
+#endif
+
+  // 9. Throw a jsi::WeakObject pointing to our object into cache so subsequent calls can use it from cache
   JSICacheReference cache = JSICache::getOrCreateCache(runtime);
-  _objectCache.emplace(&runtime, cache.makeShared(jsi::WeakObject(runtime, object)));
+  _objectCache[&runtime] = cache.makeShared(jsi::WeakObject(runtime, object));
 
-  // 9. Return it!
+  // 10. Return it!
   return object;
 }
 

package/cpp/core/Promise.hpp

@@ -161,10 +161,6 @@ public:
       _onResolvedListeners.push_back(onResolved);
     }
   }
-  [[deprecated("Upgrade Nitro to use PromiseHolder<T> instead.")]]
-  void addOnResolvedListenerCopy(const std::function<void(TResult)>& onResolved) {
-    addOnResolvedListener([=](const TResult& value) { onResolved(value); });
-  }
 
   /**
    * Add a listener that will be called when the Promise gets rejected.

package/cpp/jsi/JSICache.cpp

@@ -57,7 +57,7 @@ JSICacheReference JSICache::getOrCreateCache(jsi::Runtime& runtime) {
   // Cache doesn't exist yet.
   Logger::log(LogLevel::Info, TAG, "Creating new JSICache<T> for runtime %s..", getRuntimeId(runtime).c_str());
   // Create new cache
-  auto nativeState = std::shared_ptr<JSICache>(new JSICache());
+  std::shared_ptr<JSICache> nativeState(new JSICache());
   // Wrap it in a jsi::Value using NativeState
   jsi::Object cache(runtime);
   cache.setNativeState(runtime, nativeState);

package/cpp/jsi/JSIConverter.hpp

@@ -185,7 +185,6 @@ struct JSIConverter<std::string> final {
 #include "JSIConverter+ArrayBuffer.hpp"
 #include "JSIConverter+Exception.hpp"
 #include "JSIConverter+Function.hpp"
-#include "JSIConverter+Future.hpp"
 #include "JSIConverter+HostObject.hpp"
 #include "JSIConverter+HybridObject.hpp"
 #include "JSIConverter+Optional.hpp"

package/cpp/prototype/HybridObjectPrototype.cpp

@@ -78,7 +78,8 @@ jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const s
   // 7. Throw it into our cache so the next lookup can be cached and therefore faster
   JSICacheReference jsiCache = JSICache::getOrCreateCache(runtime);
   BorrowingReference<jsi::Object> sharedObject = jsiCache.makeShared(std::move(object));
-  prototypeCache.emplace(prototype->getNativeInstanceId(), sharedObject);
+  auto instanceId = prototype->getNativeInstanceId();
+  prototypeCache[instanceId] = sharedObject;
 
   // 8. Return it!
   return jsi::Value(runtime, *sharedObject);

package/cpp/threading/Dispatcher.cpp

@@ -22,7 +22,7 @@ void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shar
   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);
+  _globalCache[&runtime] = dispatcher;
 
   // Inject the dispatcher into Runtime global (runtime will hold a strong reference)
   jsi::Object dispatcherHolder(runtime);
@@ -31,9 +31,10 @@ void Dispatcher::installRuntimeGlobalDispatcher(jsi::Runtime& runtime, std::shar
 }
 
 std::shared_ptr<Dispatcher> Dispatcher::getRuntimeGlobalDispatcher(jsi::Runtime& runtime) {
-  if (_globalCache.contains(&runtime)) [[likely]] {
+  auto found = _globalCache.find(&runtime);
+  if (found != _globalCache.end()) [[likely]] {
     // the runtime is known - we have something in cache
-    std::weak_ptr<Dispatcher> weakDispatcher = _globalCache[&runtime];
+    std::weak_ptr<Dispatcher> weakDispatcher = found->second;
     std::shared_ptr<Dispatcher> strongDispatcher = weakDispatcher.lock();
     if (strongDispatcher) {
       // the weak reference we cached is still valid - return it!

package/cpp/utils/NitroDefines.hpp

@@ -9,7 +9,7 @@
 #define NitroDefines_h
 
 // Sets the version of the native Nitro core library
-#define NITRO_VERSION "0.24.0"
+#define NITRO_VERSION "0.25.0"
 
 // Sets whether to use debug or optimized production build flags
 #ifdef DEBUG

package/ios/core/HybridObject.swift

@@ -33,13 +33,3 @@ public extension HybridObject {
   // By default, this returns `0`.
   var memorySize: Int { return 0 }
 }
-
-@available(*, deprecated, message: "HybridObjectSpec has been renamed to HybridObject. Update Nitrogen and re-generate your specs.")
-public typealias HybridObjectSpec = HybridObject
-
-public extension HybridObjectSpec {
-  @available(*, deprecated, message: "getSizeOf(...) will now be default-computed. Please remove getSizeOf() from your code.")
-  func getSizeOf<T: AnyObject>(_ instance: T) -> Int {
-    return 0
-  }
-}

package/ios/platform/ThreadUtils.mm

@@ -0,0 +1,46 @@
+//
+//  ThreadUtils.mm
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 14.07.24.
+//
+
+#include "ThreadUtils.hpp"
+#include <pthread.h>
+#include <sstream>
+#include <thread>
+
+// ObjC import
+#import <Foundation/Foundation.h>
+
+namespace margelo::nitro {
+
+std::string ThreadUtils::getThreadName() {
+  // Try using NSThread APIs
+  NSString* threadName = NSThread.currentThread.name;
+  if (threadName != nil && threadName.length > 0) {
+    return threadName.UTF8String;
+  }
+
+  // Try using DispatchQueue APIs as fallback
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+  dispatch_queue_t queue = dispatch_get_current_queue();
+#pragma clang diagnostic pop
+  const char* label = dispatch_queue_get_label(queue);
+  if (label != nullptr) {
+    return label;
+  }
+
+  // Fall back to this_thread ID
+  std::stringstream stream;
+  stream << std::this_thread::get_id();
+  std::string threadId = stream.str();
+  return "Thread #" + threadId;
+}
+
+void ThreadUtils::setThreadName(const std::string& name) {
+  pthread_setname_np(name.c_str());
+}
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-modules",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Insanely fast native C++, Swift or Kotlin modules with a statically compiled binding layer to JSI.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/android/src/main/cpp/registry/JHybridObjectRegistry.cpp

@@ -1,45 +0,0 @@
-//
-//  JHybridObjectRegistry.cpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 22.07.24.
-//
-
-#include "JHybridObjectRegistry.hpp"
-#include "HybridObjectRegistry.hpp"
-#include "JNISharedPtr.hpp"
-#include "NitroDefines.hpp"
-
-namespace margelo::nitro {
-
-void JHybridObjectRegistry::registerHybridObjectConstructor(jni::alias_ref<jni::JClass>, std::string hybridObjectName,
-                                                            jni::alias_ref<JHybridObjectInitializer> constructorFn) {
-  auto sharedInitializer = jni::make_global(constructorFn);
-  HybridObjectRegistry::registerHybridObjectConstructor(
-      hybridObjectName,
-      [sharedInitializer = std::move(sharedInitializer),
-       hybridObjectName = std::move(hybridObjectName)]() -> std::shared_ptr<HybridObject> {
-        // 1. Call the Java initializer function
-        jni::local_ref<JHybridObject::javaobject> hybridObject = sharedInitializer->call();
-#ifdef NITRO_DEBUG
-        if (hybridObject == nullptr) [[unlikely]] {
-          throw std::runtime_error("Failed to create HybridObject \"" + hybridObjectName + "\" - the constructor returned null!");
-        }
-#endif
-
-        // 2. Make the resulting HybridObject a global (shared) reference
-        jni::global_ref<JHybridObject::javaobject> globalHybridObject = jni::make_global(hybridObject);
-        // 3. Create a shared_ptr from the JNI global reference
-        std::shared_ptr<JHybridObject> sharedCppPart = JNISharedPtr::make_shared_from_jni<JHybridObject>(globalHybridObject);
-        // 4. Up-cast to a HybridObject (kinda unsafe)
-        std::shared_ptr<HybridObject> cast = std::static_pointer_cast<HybridObject>(sharedCppPart);
-        return cast;
-      });
-}
-
-void JHybridObjectRegistry::registerNatives() {
-  javaClassStatic()->registerNatives({
-      makeNativeMethod("registerHybridObjectConstructor", JHybridObjectRegistry::registerHybridObjectConstructor),
-  });
-}
-} // namespace margelo::nitro

package/android/src/main/cpp/registry/JHybridObjectRegistry.hpp

@@ -1,32 +0,0 @@
-//
-//  JHybridObjectRegistry.hpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 22.07.24.
-//
-
-#pragma once
-
-#include "HybridObject.hpp"
-#include "JHybridObjectInitializer.hpp"
-#include <fbjni/fbjni.h>
-
-namespace margelo::nitro {
-
-using namespace facebook;
-
-struct JHybridObjectRegistry : public jni::JavaClass<JHybridObjectRegistry> {
-public:
-  static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/core/HybridObjectRegistry;";
-
-public:
-  [[deprecated("HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, "
-               "or add them manually in the C++ HybridObjectRegistry.")]]
-  static void registerHybridObjectConstructor(jni::alias_ref<jni::JClass> clazz, std::string hybridObjectName,
-                                              jni::alias_ref<JHybridObjectInitializer> constructorFn);
-
-public:
-  static void registerNatives();
-};
-
-} // namespace margelo::nitro

package/android/src/main/java/com/margelo/nitro/core/HybridObjectInitializer.java

@@ -1,17 +0,0 @@
-package com.margelo.nitro.core;
-
-import androidx.annotation.Keep;
-
-import com.facebook.proguard.annotations.DoNotStrip;
-
-/**
- * @deprecated HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, or add them manually in the C++ `HybridObjectRegistry`.
- */
-@Keep
-@DoNotStrip
-@Deprecated(forRemoval = true)
-public interface HybridObjectInitializer {
-    @Keep
-    @DoNotStrip
-    HybridObject initialize();
-}

package/android/src/main/java/com/margelo/nitro/core/HybridObjectRegistry.java

@@ -1,27 +0,0 @@
-package com.margelo.nitro.core;
-
-import androidx.annotation.Keep;
-import com.facebook.proguard.annotations.DoNotStrip;
-import com.margelo.nitro.JNIOnLoad;
-
-/**
- * A registry that holds initializers for HybridObjects.
- * This will be used to initialize them from JS using `NitroModules.createHybridObject<T>(name)`.
- * @noinspection JavaJniMissingFunction
- */
-@Keep
-@DoNotStrip
-public class HybridObjectRegistry {
-    static {
-        JNIOnLoad.initializeNativeNitro();
-    }
-
-    /**
-     * Registers the given HybridObject in the `HybridObjectRegistry`.
-     * It will be uniquely identified via it's `hybridObjectName`, and can be initialized from
-     * JS using `NitroModules.createHybridObject<T>(name)` - which will call the `constructorFn` here.
-     * @deprecated HybridObjects should be registered from C++ instead. Either autolink them using `nitro.json`, or add them manually in the C++ `HybridObjectRegistry`.
-     */
-    @Deprecated(forRemoval = true)
-    public static native void registerHybridObjectConstructor(String hybridObjectName, HybridObjectInitializer initializer);
-}

package/cpp/jsi/JSIConverter+Future.hpp

@@ -1,46 +0,0 @@
-//
-// Created by Marc Rousavy on 21.02.24.
-//
-
-#pragma once
-
-// Forward declare a few of the common types that might have cyclic includes.
-namespace margelo::nitro {
-
-template <typename T, typename Enable>
-struct JSIConverter;
-} // namespace margelo::nitro
-
-#include "JSIConverter.hpp"
-
-#include "Promise.hpp"
-#include <future>
-#include <jsi/jsi.h>
-#include <memory>
-
-namespace margelo::nitro {
-
-using namespace facebook;
-
-// std::future<T> <> Promise<T>
-template <typename TResult>
-struct JSIConverter<std::future<TResult>> final {
-  [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
-  static inline std::future<TResult> fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
-    auto promise = JSIConverter<std::shared_ptr<Promise<TResult>>>::fromJSI(runtime, value);
-    return promise->await();
-  }
-
-  [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
-  static inline jsi::Value toJSI(jsi::Runtime& runtime, std::future<TResult>&& arg) {
-    auto promise = Promise<TResult>::awaitFuture(std::move(arg));
-    return JSIConverter<std::shared_ptr<Promise<TResult>>>::toJSI(runtime, promise);
-  }
-
-  [[deprecated("Use JSIConverter<std::shared_ptr<Promise<T>>> instead.")]]
-  static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
-    return JSIConverter<std::shared_ptr<Promise<TResult>>>::canConvert(runtime, value);
-  }
-};
-
-} // namespace margelo::nitro

package/ios/core/HybridContext.hpp

@@ -1,55 +0,0 @@
-//
-//  HybridContext.hpp
-//  NitroModules
-//
-//  Created by Marc Rousavy on 17.07.24.
-//
-
-#pragma once
-
-namespace margelo::nitro {
-class HybridObject;
-}
-
-#include "HybridObject.hpp"
-#include "NitroLogger.hpp"
-#include "NitroTypeInfo.hpp"
-#include <memory>
-
-namespace margelo::nitro {
-
-/**
- * Represents contextual state for a `HybridObject`.
- *
- * This can be used in remote implementations, e.g. in a Swift implementation
- * to properly (weak-)reference the `HybridObject` instead of re-creating it each time.
- */
-struct [[deprecated("Update Nitrogen and re-generate your specs.")]]
-HybridContext final {
-public:
-  std::weak_ptr<HybridObject> cppPart;
-
-public:
-  template <typename THybridObject, typename TSwiftPart>
-  static inline std::shared_ptr<THybridObject> getOrCreate(TSwiftPart swiftPart) noexcept {
-    auto hybridContext = swiftPart.getHybridContext();
-    auto hybridObject = std::dynamic_pointer_cast<THybridObject>(hybridContext.cppPart.lock());
-    if (hybridObject != nullptr) [[likely]] {
-      // Fast path - an existing HybridObject is still in cache! (HybridContext)
-      return hybridObject;
-    }
-
-    // Slow path - we need to create a new HybridObject that wraps our Swift implementation.
-    Logger::log(LogLevel::Info, TAG, "Creating new HybridObject<%s> for %s...", TypeInfo::getFriendlyTypename<THybridObject>().c_str(),
-                TypeInfo::getFriendlyTypename<TSwiftPart>().c_str());
-    hybridObject = std::make_shared<THybridObject>(std::forward<decltype(swiftPart)>(swiftPart));
-    hybridContext.cppPart = hybridObject;
-    swiftPart.setHybridContext(hybridContext);
-    return hybridObject;
-  }
-
-private:
-  static constexpr auto TAG = "HybridContext";
-};
-
-} // namespace margelo::nitro

package/ios/platform/ThreadUtils.cpp

@@ -1,33 +0,0 @@
-//
-//  ThreadUtils.cpp
-//  react-native-nitro
-//
-//  Created by Marc Rousavy on 14.07.24.
-//
-
-#include "ThreadUtils.hpp"
-#include <pthread.h>
-#include <sstream>
-#include <thread>
-
-namespace margelo::nitro {
-
-std::string ThreadUtils::getThreadName() {
-  // Try using pthread APIs
-  char name[256];
-  if (pthread_getname_np(pthread_self(), name, sizeof(name)) == 0) {
-    return std::string(name);
-  }
-
-  // Fall back to this_thread ID
-  std::stringstream stream;
-  stream << std::this_thread::get_id();
-  std::string threadId = stream.str();
-  return "Thread #" + threadId;
-}
-
-void ThreadUtils::setThreadName(const std::string& name) {
-  pthread_setname_np(name.c_str());
-}
-
-} // namespace margelo::nitro