@rive-app/react-native 0.1.1-beta.0

package/nitrogen/generated/ios/c++/HybridRiveFileSpecSwift.hpp

@@ -0,0 +1,121 @@
+///
+/// HybridRiveFileSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridRiveFileSpec.hpp"
+
+// Forward declaration of `HybridRiveFileSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveFileSpec_cxx; }
+
+// Forward declaration of `HybridViewModelSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridViewModelSpec; }
+// Forward declaration of `ArtboardBy` to properly resolve imports.
+namespace margelo::nitro::rive { struct ArtboardBy; }
+// Forward declaration of `ArtboardByTypes` to properly resolve imports.
+namespace margelo::nitro::rive { enum class ArtboardByTypes; }
+// Forward declaration of `ReferencedAssetsType` to properly resolve imports.
+namespace margelo::nitro::rive { struct ReferencedAssetsType; }
+// Forward declaration of `ResolvedReferencedAsset` to properly resolve imports.
+namespace margelo::nitro::rive { struct ResolvedReferencedAsset; }
+// Forward declaration of `HybridRiveImageSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveImageSpec; }
+
+#include <optional>
+#include <memory>
+#include "HybridViewModelSpec.hpp"
+#include <string>
+#include "ArtboardBy.hpp"
+#include "ArtboardByTypes.hpp"
+#include "ReferencedAssetsType.hpp"
+#include "ResolvedReferencedAsset.hpp"
+#include <unordered_map>
+#include "HybridRiveImageSpec.hpp"
+
+#include "RNRive-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::rive {
+
+  /**
+   * The C++ part of HybridRiveFileSpec_cxx.swift.
+   *
+   * HybridRiveFileSpecSwift (C++) accesses HybridRiveFileSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridRiveFileSpec_cxx can directly inherit from the C++ class HybridRiveFileSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridRiveFileSpecSwift: public virtual HybridRiveFileSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridRiveFileSpecSwift(const RNRive::HybridRiveFileSpec_cxx& swiftPart):
+      HybridObject(HybridRiveFileSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline RNRive::HybridRiveFileSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::optional<double> getViewModelCount() noexcept override {
+      auto __result = _swiftPart.getViewModelCount();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::optional<std::shared_ptr<HybridViewModelSpec>> viewModelByIndex(double index) override {
+      auto __result = _swiftPart.viewModelByIndex(std::forward<decltype(index)>(index));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::shared_ptr<HybridViewModelSpec>> viewModelByName(const std::string& name) override {
+      auto __result = _swiftPart.viewModelByName(name);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::shared_ptr<HybridViewModelSpec>> defaultArtboardViewModel(const std::optional<ArtboardBy>& artboardBy) override {
+      auto __result = _swiftPart.defaultArtboardViewModel(artboardBy);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void updateReferencedAssets(const ReferencedAssetsType& referencedAssets) override {
+      auto __result = _swiftPart.updateReferencedAssets(std::forward<decltype(referencedAssets)>(referencedAssets));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    RNRive::HybridRiveFileSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/ios/c++/HybridRiveImageFactorySpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridRiveImageFactorySpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRiveImageFactorySpecSwift.hpp"
+
+namespace margelo::nitro::rive {
+} // namespace margelo::nitro::rive

package/nitrogen/generated/ios/c++/HybridRiveImageFactorySpecSwift.hpp

@@ -0,0 +1,100 @@
+///
+/// HybridRiveImageFactorySpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridRiveImageFactorySpec.hpp"
+
+// Forward declaration of `HybridRiveImageFactorySpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveImageFactorySpec_cxx; }
+
+// Forward declaration of `HybridRiveImageSpec` to properly resolve imports.
+namespace margelo::nitro::rive { class HybridRiveImageSpec; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+
+#include <memory>
+#include "HybridRiveImageSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+
+#include "RNRive-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::rive {
+
+  /**
+   * The C++ part of HybridRiveImageFactorySpec_cxx.swift.
+   *
+   * HybridRiveImageFactorySpecSwift (C++) accesses HybridRiveImageFactorySpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridRiveImageFactorySpec_cxx can directly inherit from the C++ class HybridRiveImageFactorySpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridRiveImageFactorySpecSwift: public virtual HybridRiveImageFactorySpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridRiveImageFactorySpecSwift(const RNRive::HybridRiveImageFactorySpec_cxx& swiftPart):
+      HybridObject(HybridRiveImageFactorySpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline RNRive::HybridRiveImageFactorySpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>> loadFromURLAsync(const std::string& url) override {
+      auto __result = _swiftPart.loadFromURLAsync(url);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>> loadFromResourceAsync(const std::string& resource) override {
+      auto __result = _swiftPart.loadFromResourceAsync(resource);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<HybridRiveImageSpec>>> loadFromBytesAsync(const std::shared_ptr<ArrayBuffer>& bytes) override {
+      auto __result = _swiftPart.loadFromBytesAsync(ArrayBufferHolder(bytes));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    RNRive::HybridRiveImageFactorySpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/ios/c++/HybridRiveImageSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridRiveImageSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRiveImageSpecSwift.hpp"
+
+namespace margelo::nitro::rive {
+} // namespace margelo::nitro::rive

package/nitrogen/generated/ios/c++/HybridRiveImageSpecSwift.hpp

@@ -0,0 +1,71 @@
+///
+/// HybridRiveImageSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridRiveImageSpec.hpp"
+
+// Forward declaration of `HybridRiveImageSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveImageSpec_cxx; }
+
+
+
+
+
+#include "RNRive-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::rive {
+
+  /**
+   * The C++ part of HybridRiveImageSpec_cxx.swift.
+   *
+   * HybridRiveImageSpecSwift (C++) accesses HybridRiveImageSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridRiveImageSpec_cxx can directly inherit from the C++ class HybridRiveImageSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridRiveImageSpecSwift: public virtual HybridRiveImageSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridRiveImageSpecSwift(const RNRive::HybridRiveImageSpec_cxx& swiftPart):
+      HybridObject(HybridRiveImageSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline RNRive::HybridRiveImageSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline double getByteSize() noexcept override {
+      return _swiftPart.getByteSize();
+    }
+
+  public:
+    // Methods
+    
+
+  private:
+    RNRive::HybridRiveImageSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/ios/c++/HybridRiveSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridRiveSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRiveSpecSwift.hpp"
+
+namespace margelo::nitro::rive {
+} // namespace margelo::nitro::rive

package/nitrogen/generated/ios/c++/HybridRiveSpecSwift.hpp

@@ -0,0 +1,76 @@
+///
+/// HybridRiveSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridRiveSpec.hpp"
+
+// Forward declaration of `HybridRiveSpec_cxx` to properly resolve imports.
+namespace RNRive { class HybridRiveSpec_cxx; }
+
+
+
+
+
+#include "RNRive-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::rive {
+
+  /**
+   * The C++ part of HybridRiveSpec_cxx.swift.
+   *
+   * HybridRiveSpecSwift (C++) accesses HybridRiveSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridRiveSpec_cxx can directly inherit from the C++ class HybridRiveSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridRiveSpecSwift: public virtual HybridRiveSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridRiveSpecSwift(const RNRive::HybridRiveSpec_cxx& swiftPart):
+      HybridObject(HybridRiveSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline RNRive::HybridRiveSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline double multiply(double a, double b) override {
+      auto __result = _swiftPart.multiply(std::forward<decltype(a)>(a), std::forward<decltype(b)>(b));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    RNRive::HybridRiveSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::rive

package/nitrogen/generated/ios/c++/HybridRiveViewSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridRiveViewSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRiveViewSpecSwift.hpp"
+
+namespace margelo::nitro::rive {
+} // namespace margelo::nitro::rive