@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/src/main/cpp/nitro/shared/HybridObject.hpp

@@ -0,0 +1,152 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+#include "HybridObjectPrototype.hpp"
+
+#include "NitroDefines.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a C++ object that is exposed to JS.
+ * `HybridObject`s can have native getters and setters, and normal methods.
+ *
+ * To implement a `HybridObject`, simply inherit from this class and override `loadHybridMethods`
+ * to register the given getters, setters or methods.
+ *
+ * The new class can then be passed to JS using the `JSIConverter<HybridObject>`.
+ */
+class HybridObject : public virtual jsi::NativeState, public HybridObjectPrototype, public std::enable_shared_from_this<HybridObject> {
+public:
+  /**
+   * Create a new instance of a `HybridObject`.
+   * The given `name` will be used for logging and stringifying.
+   */
+  explicit HybridObject(const char* NON_NULL name);
+  /**
+   * Called when no more references to the given `HybridObject` exist in both C++ and JS.
+   * JS might keep references for longer, as it is a garbage collected language.
+   */
+  ~HybridObject() override = default;
+  /**
+   * HybridObjects cannot be copied.
+   */
+  HybridObject(const HybridObject& copy) = delete;
+  /**
+   * HybridObjects cannot be moved.
+   */
+  HybridObject(HybridObject&& move) = delete;
+  /**
+   * HybridObjects cannot be default-constructed!
+   * Use this instead;
+   * ```cpp
+   * MyHybridObject(): HybridObject(TAG) {}
+   * ```
+   */
+  HybridObject() {
+    throw std::runtime_error("Cannot default-construct HybridObject! "
+                             "Did you forget to add the `HybridObject(TAG)` base-constructor call to your Hybrid Object's constructor?");
+  }
+
+public:
+  /**
+   * Return the `jsi::Object` that holds this `HybridObject`. (boxed in a `jsi::Value`)
+   * This properly assigns (or creates) the base prototype for this type,
+   * and assigns it's NativeState.
+   * Additionally, this sets the external memory pressure for proper GC memory management.
+   */
+  jsi::Value toObject(jsi::Runtime& runtime);
+
+public:
+  /**
+   * Get the `std::shared_ptr` instance of this HybridObject as it's concrete type.
+   * The HybridObject must be managed inside a `shared_ptr` already, otherwise this will fail.
+   */
+  template <typename Derived>
+  std::shared_ptr<Derived> shared_cast() {
+    return std::dynamic_pointer_cast<Derived>(shared());
+  }
+  /**
+   * Get the `std::shared_ptr` instance of this HybridObject.
+   */
+  virtual std::shared_ptr<HybridObject> shared();
+
+public:
+  /**
+   * Get the HybridObject's name
+   */
+  std::string getName();
+  /**
+   * Compare this HybridObject for reference equality to the other HybridObject.
+   *
+   * While two `jsi::Object`s of the same `HybridObject` might not be equal when compared with `==`,
+   * they might still be the same `HybridObject` - in this case `equals(other)` will return true.
+   */
+  bool equals(const std::shared_ptr<HybridObject>& other);
+  /**
+   * Get a string representation of this `HybridObject` - useful for logging or debugging.
+   */
+  virtual std::string toString();
+  /**
+   * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
+   * This method can only be manually called from JS using `dispose()`.
+   *
+   * If this method is never manually called, a `HybridObject` is expected to disposes it's
+   * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
+   *
+   * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup
+   * if required.
+   */
+  virtual void dispose() {}
+
+private:
+  /**
+   * The actual `dispose()` function from JS.
+   * This needs to be a raw JSI function as we remove the NativeState here.
+   */
+  jsi::Value disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* NON_NULL args, size_t count);
+
+protected:
+  /**
+   * Get the size of any external (heap) allocations this `HybridObject` has made, in bytes.
+   * This will be used to notify the JS GC about memory pressure.
+   */
+  virtual inline size_t getExternalMemorySize() noexcept {
+    return 0;
+  }
+
+protected:
+  /**
+   * Loads all native methods of this `HybridObject` to be exposed to JavaScript.
+   * The base implementation registers a `toString()` method and `name` property.
+   *
+   * Example:
+   *
+   * ```cpp
+   * int User::getAge() {
+   *   return 23;
+   * }
+   *
+   * void User::loadHybridMethods() {
+   *   HybridObject::loadHybridMethods();
+   *   registerHybridMethod("getAge", &User::getAge);
+   * }
+   * ```
+   */
+  virtual void loadHybridMethods() override;
+
+private:
+  static constexpr auto TAG = "HybridObject";
+  const char* NON_NULL _name = TAG;
+  std::unordered_map<jsi::Runtime*, BorrowingReference<jsi::WeakObject>> _objectCache;
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/HybridObjectPrototype.cpp

@@ -0,0 +1,113 @@
+//
+//  HybridObjectPrototype.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#include "HybridObjectPrototype.hpp"
+#include "NitroDefines.hpp"
+#include "NitroLogger.hpp"
+#include "NitroTypeInfo.hpp"
+#include "ObjectUtils.hpp"
+
+namespace margelo::nitro {
+
+std::unordered_map<jsi::Runtime*, HybridObjectPrototype::PrototypeCache> HybridObjectPrototype::_prototypeCache;
+
+jsi::Value HybridObjectPrototype::createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype) {
+  // 0. Check if we're at the highest level of our prototype chain
+  if (prototype == nullptr) {
+    // There is no prototype - we just have an empty Object base - so `Object.create({})`
+    return jsi::Object(runtime);
+  }
+
+  // 1. Try looking for the given prototype in cache.
+  //    If we find it in cache, we can create instances faster and skip creating the prototype from scratch!
+  auto& prototypeCache = _prototypeCache[&runtime];
+  auto cachedPrototype = prototypeCache.find(prototype->getNativeInstanceId());
+  if (cachedPrototype != prototypeCache.end()) {
+    const BorrowingReference<jsi::Object>& cachedObject = cachedPrototype->second;
+    if (cachedObject != nullptr) {
+      // 1.1. Found it in cache! Copy & return it.
+      return jsi::Value(runtime, *cachedObject);
+    }
+  }
+
+  // 2. Get the base prototype of this prototype (recursively), then create the individual prototypes downwards
+  //    until we reach our current prototype.
+  std::string typeName = TypeInfo::getFriendlyTypename(prototype->getNativeInstanceId(), true);
+  Logger::log(LogLevel::Info, TAG, "Creating new JS prototype for C++ instance type \"%s\"...", typeName.c_str());
+  jsi::Value basePrototype = createPrototype(runtime, prototype->getBase());
+  jsi::Object object = ObjectUtils::create(runtime, basePrototype);
+
+  // 4. Add all Hybrid Methods to it
+  for (const auto& method : prototype->getMethods()) {
+    // method()
+    const std::string& name = method.first;
+    ObjectUtils::defineProperty(runtime, object, name.c_str(),
+                                PlainPropertyDescriptor{
+                                    .configurable = false,
+                                    .enumerable = true,
+                                    .value = method.second.toJSFunction(runtime),
+                                    .writable = false,
+                                });
+  }
+
+  // 5. Add all properties (getter + setter) to it using defineProperty
+  for (const auto& getter : prototype->getGetters()) {
+    const auto& setter = prototype->getSetters().find(getter.first);
+    bool isReadonly = setter == prototype->getSetters().end();
+    const std::string& name = getter.first;
+    if (isReadonly) {
+      // get
+      ObjectUtils::defineProperty(runtime, object, name.c_str(),
+                                  ComputedReadonlyPropertyDescriptor{// readonly
+                                                                     .configurable = false,
+                                                                     .enumerable = true,
+                                                                     .get = getter.second.toJSFunction(runtime)});
+    } else {
+      // get + set
+      ObjectUtils::defineProperty(runtime, object, name.c_str(),
+                                  ComputedPropertyDescriptor{// readonly with setter
+                                                             .configurable = false,
+                                                             .enumerable = false,
+                                                             .get = getter.second.toJSFunction(runtime),
+                                                             .set = setter->second.toJSFunction(runtime)});
+    }
+  }
+
+  // 6. In DEBUG, add a __type info to the prototype object.
+#ifdef NITRO_DEBUG
+  std::string prototypeName = "Prototype<" + typeName + ">";
+  ObjectUtils::defineProperty(runtime, object, "__type",
+                              PlainPropertyDescriptor{
+                                  .configurable = false,
+                                  .enumerable = true,
+                                  .value = jsi::String::createFromUtf8(runtime, prototypeName),
+                                  .writable = false,
+                              });
+#endif
+
+  // 7. In DEBUG, freeze the prototype.
+#ifdef NITRO_DEBUG
+  ObjectUtils::freeze(runtime, object);
+#endif
+
+  // 8. 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));
+  auto instanceId = prototype->getNativeInstanceId();
+  prototypeCache[instanceId] = sharedObject;
+
+  // 9. Return it!
+  return jsi::Value(runtime, *sharedObject);
+}
+
+jsi::Value HybridObjectPrototype::getPrototype(jsi::Runtime& runtime) {
+  ensureInitialized();
+
+  return createPrototype(runtime, _prototypeChain.getPrototype());
+}
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/HybridObjectPrototype.hpp

@@ -0,0 +1,93 @@
+//
+//  HybridObjectPrototype.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include "HybridFunction.hpp"
+#include "NitroDefines.hpp"
+#include "Prototype.hpp"
+#include "PrototypeChain.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a Hybrid Object's prototype.
+ * The prototype should be cached per Runtime, and can be assigned to multiple jsi::Objects.
+ * When assigned to a jsi::Object, all methods of this prototype can be called on that jsi::Object,
+ * as long as it has a valid NativeState (`this`).
+ */
+class HybridObjectPrototype {
+private:
+  PrototypeChain _prototypeChain;
+  bool _didLoadMethods = false;
+  static constexpr auto TAG = "HybridObjectPrototype";
+
+public:
+  HybridObjectPrototype() {}
+
+public:
+  /**
+   * Get a fully initialized jsi::Object that represents this prototype to JS.
+   * The result of this value will be cached per Runtime, so it's safe to call this often.
+   */
+  jsi::Value getPrototype(jsi::Runtime& runtime);
+
+private:
+  static jsi::Value createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype);
+  using PrototypeCache = std::unordered_map<NativeInstanceId, BorrowingReference<jsi::Object>>;
+  static std::unordered_map<jsi::Runtime * NON_NULL, PrototypeCache> _prototypeCache;
+
+protected:
+  /**
+   * Loads all Hybrid Methods that will be initialized in this Prototype.
+   * This will only be called once for the first time the Prototype will be created,
+   * so don't conditionally register methods.
+   */
+  virtual void loadHybridMethods() = 0;
+
+private:
+  /**
+   * Ensures that all Hybrid Methods, Getters and Setters are initialized by calling loadHybridMethods().
+   */
+  inline void ensureInitialized() {
+    if (!_didLoadMethods) [[unlikely]] {
+      // lazy-load all exposed methods
+      loadHybridMethods();
+      _didLoadMethods = true;
+    }
+  }
+
+protected:
+  using RegisterFn = void (*NON_NULL)(Prototype&);
+  /**
+   * Registers the given methods inside the Hybrid Object's prototype.
+   *
+   * For subsequent HybridObjects of the same type, `registerFunc` will not be called again, as the
+   * prototype will already be known and cached.
+   * **Do not conditionally register hybrid methods, getters or setter!**
+   */
+  template <typename Derived>
+  inline void registerHybrids(Derived* NON_NULL /* this */, RegisterFn registerFunc) {
+    const std::shared_ptr<Prototype>& prototype = _prototypeChain.extendPrototype<Derived>();
+
+    if (!prototype->hasHybrids()) {
+      // The `Prototype` does not have any methods or properties registered yet - so do it now
+      registerFunc(*prototype);
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/HybridObjectRegistry.cpp

@@ -0,0 +1,105 @@
+//
+//  HybridObjectRegistry.cpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#include "HybridObjectRegistry.hpp"
+#include "NitroDefines.hpp"
+#include "NitroLogger.hpp"
+#include <numeric>
+
+namespace margelo::nitro {
+
+std::unordered_map<std::string, HybridObjectRegistry::HybridObjectConstructorFn>& HybridObjectRegistry::getRegistry() {
+  static std::unordered_map<std::string, HybridObjectRegistry::HybridObjectConstructorFn> _constructorsMap;
+  return _constructorsMap;
+}
+
+bool HybridObjectRegistry::hasHybridObject(const std::string& name) {
+  return getRegistry().contains(name);
+}
+
+std::vector<std::string> HybridObjectRegistry::getAllHybridObjectNames() {
+  std::vector<std::string> keys;
+  keys.reserve(getRegistry().size());
+  for (const auto& entry : getRegistry()) {
+    keys.push_back(entry.first);
+  }
+  return keys;
+}
+
+std::string HybridObjectRegistry::getAllRegisteredHybridObjectNamesToString() {
+  std::vector<std::string> names = getAllHybridObjectNames();
+  if (names.empty()) {
+    return "";
+  }
+  return std::accumulate(std::next(names.begin()), names.end(), names[0], [](std::string a, std::string b) { return a + ", " + b; });
+}
+
+void HybridObjectRegistry::registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn) {
+  Logger::log(LogLevel::Info, TAG, "Registering HybridObject \"%s\"...", hybridObjectName.c_str());
+  auto& map = HybridObjectRegistry::getRegistry();
+#ifdef NITRO_DEBUG
+  if (map.contains(hybridObjectName)) [[unlikely]] {
+    auto allObjectNames = getAllRegisteredHybridObjectNamesToString();
+    auto message =
+        "HybridObject \"" + hybridObjectName +
+        "\" has already been "
+        "registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
+        "- If you just installed another library, maybe both libraries are using the same name?\n"
+        "- If you just registered your own HybridObject, maybe you accidentally called `registerHybridObjectConstructor(...)` twice?\n"
+        "- All registered HybridObjects: [" +
+        allObjectNames + "]";
+    throw std::runtime_error(message);
+  }
+#endif
+  map.insert({hybridObjectName, std::move(constructorFn)});
+  Logger::log(LogLevel::Info, TAG, "Successfully registered HybridObject \"%s\"!", hybridObjectName.c_str());
+}
+
+void HybridObjectRegistry::unregisterHybridObjectConstructor(const std::string& hybridObjectName) {
+  Logger::log(LogLevel::Info, TAG, "Unregistering HybridObject \"%s\"...", hybridObjectName.c_str());
+  auto& map = HybridObjectRegistry::getRegistry();
+  map.erase(hybridObjectName);
+}
+
+std::shared_ptr<HybridObject> HybridObjectRegistry::createHybridObject(const std::string& hybridObjectName) {
+  auto& map = HybridObjectRegistry::getRegistry();
+  auto fn = map.find(hybridObjectName);
+  if (fn == map.end()) [[unlikely]] {
+    auto allObjectNames = getAllRegisteredHybridObjectNamesToString();
+    auto message =
+        "Cannot create an instance of HybridObject \"" + hybridObjectName +
+        "\" - It has not yet been registered in the Nitro Modules HybridObjectRegistry! Suggestions:\n"
+        "- If you use Nitrogen, make sure your `nitro.json` contains `" +
+        hybridObjectName +
+        "` on this platform.\n"
+        "- If you use Nitrogen, make sure your library (*Package.kt)/app (MainApplication.kt) calls "
+        "`$$androidCxxLibName$$OnLoad.initializeNative()` somewhere on app-startup.\n"
+        "- If you use Nitrogen, make sure your `cpp-adapter.cpp`/`OnLoad.cpp` calls `margelo::nitro::$$cxxNamespace$$::initialize(vm)`.\n"
+        "- If you use Nitrogen, inspect the generated `$$androidCxxLibName$$OnLoad.cpp` file.\n"
+        "- If you don't use Nitrogen, make sure you called `HybridObjectRegistry.registerHybridObject(...)`."
+        "- All registered HybridObjects: [" +
+        allObjectNames + "]";
+    throw std::runtime_error(message);
+  }
+  std::shared_ptr<HybridObject> instance = fn->second();
+
+#ifdef NITRO_DEBUG
+  if (instance == nullptr) [[unlikely]] {
+    throw std::runtime_error("Failed to create HybridObject \"" + hybridObjectName + "\" - The constructor returned null!");
+  }
+  if (instance->getName() != hybridObjectName) [[unlikely]] {
+    throw std::runtime_error("HybridObject's name (\"" + instance->getName() +
+                             "\") "
+                             "does not match the name it was registered with (\"" +
+                             hybridObjectName + "\")!");
+  }
+#endif
+
+  return instance;
+}
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/HybridObjectRegistry.hpp

@@ -0,0 +1,53 @@
+//
+//  HybridObjectRegistry.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include <functional>
+#include <string>
+
+namespace margelo::nitro {
+
+/**
+ * A registry that holds initializers for HybridObjects.
+ * This will be used to initialize them from JS using `NitroModules.createHybridObject<T>(name)`.
+ */
+class HybridObjectRegistry {
+public:
+  HybridObjectRegistry() = delete;
+
+public:
+  using HybridObjectConstructorFn = std::function<std::shared_ptr<HybridObject>()>;
+
+public:
+  /**
+   * 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.
+   */
+  static void registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn);
+
+  /**
+   * Unregisters a Hybrid Object with the given `hybridObjectName`.
+   * It is recommended to not use this method, as this makes HybridObject constructors unpredictable from JS.
+   */
+  static void unregisterHybridObjectConstructor(const std::string& hybridObjectName);
+
+  static std::shared_ptr<HybridObject> createHybridObject(const std::string& hybridObjectName);
+  static bool hasHybridObject(const std::string& hybridObjectName);
+  static std::vector<std::string> getAllHybridObjectNames();
+
+private:
+  static std::unordered_map<std::string, HybridObjectConstructorFn>& getRegistry();
+  static std::string getAllRegisteredHybridObjectNamesToString();
+
+private:
+  static constexpr auto TAG = "HybridObjectRegistry";
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/InstallNitro.cpp

@@ -0,0 +1,29 @@
+//
+//  InstallNitro.cpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 05.10.24
+//
+
+#include "InstallNitro.hpp"
+#include "HybridNitroModulesProxy.hpp"
+#include "ObjectUtils.hpp"
+
+namespace margelo::nitro {
+
+void install(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher) {
+  // Registers a Dispatcher for Nitro to call back into the JS Runtime.
+  // This allows creating Promises and calling back to JS.
+  Dispatcher::installRuntimeGlobalDispatcher(runtime, dispatcher);
+
+  // Installs NitroModulesProxy itself into the Runtime's global.
+  install(runtime);
+}
+
+void install(jsi::Runtime& runtime) {
+  // Installs global.NitroModulesProxy
+  auto proxy = std::make_shared<HybridNitroModulesProxy>();
+  ObjectUtils::defineGlobal(runtime, KnownGlobalPropertyName::NITRO_MODULES_PROXY, proxy->toObject(runtime));
+}
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/InstallNitro.hpp

@@ -0,0 +1,41 @@
+//
+//  InstallNitro.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 05.10.24
+//
+
+#pragma once
+
+#include "Dispatcher.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+/**
+ * Installs Nitro into the given JS `runtime`.
+ * This will create `global.NitroModulesProxy`, Nitro's entry-point,
+ * which can be used to create all registered HybridObjects from JS.
+ *
+ * Also registers the given `dispatcher` which allows using callbacks,
+ * and async code (Promises).
+ * The `dispatcher` needs to implement `runAsync`/`runSync` to run
+ * methods on whatever Thread can safely access `runtime`.
+ * In a non-thread-safe Runtime, it needs to be a single Thread (e.g.
+ * React's `CallInvoker`), but in a thread-safe Runtime it might just be
+ * an implementation that runs the method directly.
+ */
+void install(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher);
+
+/**
+ * Installs Nitro into the given JS `runtime`.
+ * This will create `global.NitroModulesProxy`, Nitro's entry-point,
+ * which can be used to create all registered HybridObjects from JS.
+ *
+ * No `Dispatcher` will be installed, meaning Nitro can only use synchronous
+ * methods.
+ */
+void install(jsi::Runtime& runtime);
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/InstanceMethod.hpp

@@ -0,0 +1,23 @@
+//
+//  InstanceMethod.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 25.09.25.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+
+namespace margelo::nitro {
+
+/**
+ * Represents a Function pointer to an instance method of the given class.
+ * For example:
+ * `InstanceMethod<std::string, size_t>` could point to `size_t std::string::length()`
+ * `InstanceMethod<std::vector<int>, void, int>` could point to `void std::vector<int>::push_back(int)`
+ */
+template <typename T, typename ReturnType, typename... Args>
+using InstanceMethod = ReturnType (T::*NON_NULL)(Args...);
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/shared/IsSharedPtrTo.hpp

@@ -0,0 +1,27 @@
+//
+//  IsSharedPtrTo.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 21.06.24.
+//
+
+#pragma once
+
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+// Returns whether the given type T is a shared_ptr to type P.
+template <typename T, typename P>
+struct is_shared_ptr_to : std::false_type {};
+
+template <typename T, typename P>
+struct is_shared_ptr_to<std::shared_ptr<T>, P> : std::is_base_of<typename std::remove_cv<typename std::remove_reference<P>::type>::type,
+                                                                 typename std::remove_cv<typename std::remove_reference<T>::type>::type> {};
+
+template <typename T, typename P>
+constexpr bool is_shared_ptr_to_v = is_shared_ptr_to<T, P>::value;
+
+} // namespace margelo::nitro