react-native-fast-html-parser 0.1.0

package/nitrogen/generated/shared/c++/HybridFastHtmlParserSpec.cpp

@@ -0,0 +1,21 @@
+///
+/// HybridFastHtmlParserSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridFastHtmlParserSpec.hpp"
+
+namespace margelo::nitro::fasthtmlparser {
+
+  void HybridFastHtmlParserSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("parse", &HybridFastHtmlParserSpec::parse);
+    });
+  }
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridFastHtmlParserSpec.hpp

@@ -0,0 +1,67 @@
+///
+/// HybridFastHtmlParserSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridParsedArticleSpec` to properly resolve imports.
+namespace margelo::nitro::fasthtmlparser { class HybridParsedArticleSpec; }
+
+#include <memory>
+#include "HybridParsedArticleSpec.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <string>
+
+namespace margelo::nitro::fasthtmlparser {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `FastHtmlParser`
+   * Inherit this class to create instances of `HybridFastHtmlParserSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridFastHtmlParser: public HybridFastHtmlParserSpec {
+   * public:
+   *   HybridFastHtmlParser(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridFastHtmlParserSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridFastHtmlParserSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridFastHtmlParserSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::variant<std::shared_ptr<HybridParsedArticleSpec>, nitro::NullType> parse(const std::string& html) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "FastHtmlParser";
+  };
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridInlineNodeSpec.cpp

@@ -0,0 +1,25 @@
+///
+/// HybridInlineNodeSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridInlineNodeSpec.hpp"
+
+namespace margelo::nitro::fasthtmlparser {
+
+  void HybridInlineNodeSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("type", &HybridInlineNodeSpec::getType);
+      prototype.registerHybridGetter("text", &HybridInlineNodeSpec::getText);
+      prototype.registerHybridGetter("url", &HybridInlineNodeSpec::getUrl);
+      prototype.registerHybridGetter("childCount", &HybridInlineNodeSpec::getChildCount);
+      prototype.registerHybridMethod("getChild", &HybridInlineNodeSpec::getChild);
+    });
+  }
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridInlineNodeSpec.hpp

@@ -0,0 +1,70 @@
+///
+/// HybridInlineNodeSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridInlineNodeSpec` to properly resolve imports.
+namespace margelo::nitro::fasthtmlparser { class HybridInlineNodeSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridInlineNodeSpec.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+
+namespace margelo::nitro::fasthtmlparser {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `InlineNode`
+   * Inherit this class to create instances of `HybridInlineNodeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridInlineNode: public HybridInlineNodeSpec {
+   * public:
+   *   HybridInlineNode(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridInlineNodeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridInlineNodeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridInlineNodeSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getType() = 0;
+      virtual std::string getText() = 0;
+      virtual std::string getUrl() = 0;
+      virtual double getChildCount() = 0;
+
+    public:
+      // Methods
+      virtual std::variant<std::shared_ptr<HybridInlineNodeSpec>, nitro::NullType> getChild(double index) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "InlineNode";
+  };
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridListItemSpec.cpp

@@ -0,0 +1,24 @@
+///
+/// HybridListItemSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridListItemSpec.hpp"
+
+namespace margelo::nitro::fasthtmlparser {
+
+  void HybridListItemSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("childCount", &HybridListItemSpec::getChildCount);
+      prototype.registerHybridGetter("nestedCount", &HybridListItemSpec::getNestedCount);
+      prototype.registerHybridMethod("getChild", &HybridListItemSpec::getChild);
+      prototype.registerHybridMethod("getNested", &HybridListItemSpec::getNested);
+    });
+  }
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridListItemSpec.hpp

@@ -0,0 +1,71 @@
+///
+/// HybridListItemSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridInlineNodeSpec` to properly resolve imports.
+namespace margelo::nitro::fasthtmlparser { class HybridInlineNodeSpec; }
+// Forward declaration of `HybridContentBlockSpec` to properly resolve imports.
+namespace margelo::nitro::fasthtmlparser { class HybridContentBlockSpec; }
+
+#include <memory>
+#include "HybridInlineNodeSpec.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "HybridContentBlockSpec.hpp"
+
+namespace margelo::nitro::fasthtmlparser {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ListItem`
+   * Inherit this class to create instances of `HybridListItemSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridListItem: public HybridListItemSpec {
+   * public:
+   *   HybridListItem(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridListItemSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridListItemSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridListItemSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getChildCount() = 0;
+      virtual double getNestedCount() = 0;
+
+    public:
+      // Methods
+      virtual std::variant<std::shared_ptr<HybridInlineNodeSpec>, nitro::NullType> getChild(double index) = 0;
+      virtual std::variant<std::shared_ptr<HybridContentBlockSpec>, nitro::NullType> getNested(double index) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ListItem";
+  };
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridParsedArticleSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridParsedArticleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridParsedArticleSpec.hpp"
+
+namespace margelo::nitro::fasthtmlparser {
+
+  void HybridParsedArticleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("length", &HybridParsedArticleSpec::getLength);
+      prototype.registerHybridMethod("getBlock", &HybridParsedArticleSpec::getBlock);
+    });
+  }
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridParsedArticleSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridParsedArticleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridContentBlockSpec` to properly resolve imports.
+namespace margelo::nitro::fasthtmlparser { class HybridContentBlockSpec; }
+
+#include <memory>
+#include "HybridContentBlockSpec.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+
+namespace margelo::nitro::fasthtmlparser {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ParsedArticle`
+   * Inherit this class to create instances of `HybridParsedArticleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridParsedArticle: public HybridParsedArticleSpec {
+   * public:
+   *   HybridParsedArticle(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridParsedArticleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridParsedArticleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridParsedArticleSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getLength() = 0;
+
+    public:
+      // Methods
+      virtual std::variant<std::shared_ptr<HybridContentBlockSpec>, nitro::NullType> getBlock(double index) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ParsedArticle";
+  };
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridTableCellSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridTableCellSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridTableCellSpec.hpp"
+
+namespace margelo::nitro::fasthtmlparser {
+
+  void HybridTableCellSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("childCount", &HybridTableCellSpec::getChildCount);
+      prototype.registerHybridMethod("getChild", &HybridTableCellSpec::getChild);
+    });
+  }
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridTableCellSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridTableCellSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridInlineNodeSpec` to properly resolve imports.
+namespace margelo::nitro::fasthtmlparser { class HybridInlineNodeSpec; }
+
+#include <memory>
+#include "HybridInlineNodeSpec.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+
+namespace margelo::nitro::fasthtmlparser {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `TableCell`
+   * Inherit this class to create instances of `HybridTableCellSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridTableCell: public HybridTableCellSpec {
+   * public:
+   *   HybridTableCell(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridTableCellSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridTableCellSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridTableCellSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getChildCount() = 0;
+
+    public:
+      // Methods
+      virtual std::variant<std::shared_ptr<HybridInlineNodeSpec>, nitro::NullType> getChild(double index) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "TableCell";
+  };
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridTableRowSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridTableRowSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridTableRowSpec.hpp"
+
+namespace margelo::nitro::fasthtmlparser {
+
+  void HybridTableRowSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("cellCount", &HybridTableRowSpec::getCellCount);
+      prototype.registerHybridMethod("getCell", &HybridTableRowSpec::getCell);
+    });
+  }
+
+} // namespace margelo::nitro::fasthtmlparser

package/nitrogen/generated/shared/c++/HybridTableRowSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridTableRowSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridTableCellSpec` to properly resolve imports.
+namespace margelo::nitro::fasthtmlparser { class HybridTableCellSpec; }
+
+#include <memory>
+#include "HybridTableCellSpec.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+
+namespace margelo::nitro::fasthtmlparser {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `TableRow`
+   * Inherit this class to create instances of `HybridTableRowSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridTableRow: public HybridTableRowSpec {
+   * public:
+   *   HybridTableRow(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridTableRowSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridTableRowSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridTableRowSpec() override = default;
+
+    public:
+      // Properties
+      virtual double getCellCount() = 0;
+
+    public:
+      // Methods
+      virtual std::variant<std::shared_ptr<HybridTableCellSpec>, nitro::NullType> getCell(double index) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "TableRow";
+  };
+
+} // namespace margelo::nitro::fasthtmlparser