react-native-wgpu 0.1.0

package/cpp/rnwgpu/api/descriptors/GPUComputePipelineDescriptor.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUComputePipelineDescriptor {
+public:
+  wgpu::ComputePipelineDescriptor *getInstance() { return &_instance; }
+
+  wgpu::ComputePipelineDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUComputePipelineDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUComputePipelineDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUComputePipelineDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "compute")) {
+        auto compute = value.getProperty(runtime, "compute");
+
+        if (compute.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUComputePipelineDescriptor::compute is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUComputePipelineDescriptor::compute is not defined");
+      }
+      if (value.hasProperty(runtime, "layout")) {
+        auto layout = value.getProperty(runtime, "layout");
+
+        if (layout.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUComputePipelineDescriptor::layout is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUComputePipelineDescriptor::layout is not defined");
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUComputePipelineDescriptor::compute = %f",
+                                 result->_instance.compute);
+    rnwgpu::Logger::logToConsole("GPUComputePipelineDescriptor::layout = %f",
+                                 result->_instance.layout);
+    rnwgpu::Logger::logToConsole("GPUComputePipelineDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUComputePipelineDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUDepthStencilState.h

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUDepthStencilState {
+public:
+  wgpu::DepthStencilState *getInstance() { return &_instance; }
+
+  wgpu::DepthStencilState _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDepthStencilState>> {
+  static std::shared_ptr<rnwgpu::GPUDepthStencilState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDepthStencilState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "format")) {
+        auto format = value.getProperty(runtime, "format");
+
+        if (format.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUDepthStencilState::format is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUDepthStencilState::format is not defined");
+      }
+      if (value.hasProperty(runtime, "depthWriteEnabled")) {
+        auto depthWriteEnabled =
+            value.getProperty(runtime, "depthWriteEnabled");
+      }
+      if (value.hasProperty(runtime, "depthCompare")) {
+        auto depthCompare = value.getProperty(runtime, "depthCompare");
+      }
+      if (value.hasProperty(runtime, "stencilFront")) {
+        auto stencilFront = value.getProperty(runtime, "stencilFront");
+      }
+      if (value.hasProperty(runtime, "stencilBack")) {
+        auto stencilBack = value.getProperty(runtime, "stencilBack");
+      }
+      if (value.hasProperty(runtime, "stencilReadMask")) {
+        auto stencilReadMask = value.getProperty(runtime, "stencilReadMask");
+
+        if (stencilReadMask.isNumber()) {
+          result->_instance.stencilReadMask =
+              static_cast<wgpu::StencilValue>(stencilReadMask.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "stencilWriteMask")) {
+        auto stencilWriteMask = value.getProperty(runtime, "stencilWriteMask");
+
+        if (stencilWriteMask.isNumber()) {
+          result->_instance.stencilWriteMask =
+              static_cast<wgpu::StencilValue>(stencilWriteMask.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "depthBias")) {
+        auto depthBias = value.getProperty(runtime, "depthBias");
+
+        if (depthBias.isNumber()) {
+          result->_instance.depthBias =
+              static_cast<wgpu::DepthBias>(depthBias.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "depthBiasSlopeScale")) {
+        auto depthBiasSlopeScale =
+            value.getProperty(runtime, "depthBiasSlopeScale");
+
+        if (depthBiasSlopeScale.isNumber()) {
+          result->_instance.depthBiasSlopeScale =
+              depthBiasSlopeScale.getNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "depthBiasClamp")) {
+        auto depthBiasClamp = value.getProperty(runtime, "depthBiasClamp");
+
+        if (depthBiasClamp.isNumber()) {
+          result->_instance.depthBiasClamp = depthBiasClamp.getNumber();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::format = %f",
+                                 result->_instance.format);
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::depthWriteEnabled = %f",
+                                 result->_instance.depthWriteEnabled);
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::depthCompare = %f",
+                                 result->_instance.depthCompare);
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::stencilFront = %f",
+                                 result->_instance.stencilFront);
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::stencilBack = %f",
+                                 result->_instance.stencilBack);
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::stencilReadMask = %f",
+                                 result->_instance.stencilReadMask);
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::stencilWriteMask = %f",
+                                 result->_instance.stencilWriteMask);
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::depthBias = %f",
+                                 result->_instance.depthBias);
+    rnwgpu::Logger::logToConsole(
+        "GPUDepthStencilState::depthBiasSlopeScale = %f",
+        result->_instance.depthBiasSlopeScale);
+    rnwgpu::Logger::logToConsole("GPUDepthStencilState::depthBiasClamp = %f",
+                                 result->_instance.depthBiasClamp);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUDepthStencilState> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUDeviceDescriptor.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUDeviceDescriptor {
+public:
+  wgpu::DeviceDescriptor *getInstance() { return &_instance; }
+
+  wgpu::DeviceDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUDeviceDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDeviceDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "requiredFeatures")) {
+        auto requiredFeatures = value.getProperty(runtime, "requiredFeatures");
+      }
+      if (value.hasProperty(runtime, "requiredLimits")) {
+        auto requiredLimits = value.getProperty(runtime, "requiredLimits");
+      }
+      if (value.hasProperty(runtime, "defaultQueue")) {
+        auto defaultQueue = value.getProperty(runtime, "defaultQueue");
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUDeviceDescriptor::requiredFeatures = %f",
+                                 result->_instance.requiredFeatures);
+    rnwgpu::Logger::logToConsole("GPUDeviceDescriptor::requiredLimits = %f",
+                                 result->_instance.requiredLimits);
+    rnwgpu::Logger::logToConsole("GPUDeviceDescriptor::defaultQueue = %f",
+                                 result->_instance.defaultQueue);
+    rnwgpu::Logger::logToConsole("GPUDeviceDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUDeviceDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUExtent3DDict.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUExtent3DDict {
+public:
+  wgpu::Extent3DDict *getInstance() { return &_instance; }
+
+  wgpu::Extent3DDict _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUExtent3DDict>> {
+  static std::shared_ptr<rnwgpu::GPUExtent3DDict>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUExtent3DDict>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "width")) {
+        auto width = value.getProperty(runtime, "width");
+
+        if (width.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUExtent3DDict::width is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUExtent3DDict::width is not defined");
+      }
+      if (value.hasProperty(runtime, "height")) {
+        auto height = value.getProperty(runtime, "height");
+
+        if (height.isNumber()) {
+          result->_instance.height =
+              static_cast<wgpu::IntegerCoordinate>(height.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "depthOrArrayLayers")) {
+        auto depthOrArrayLayers =
+            value.getProperty(runtime, "depthOrArrayLayers");
+
+        if (depthOrArrayLayers.isNumber()) {
+          result->_instance.depthOrArrayLayers =
+              static_cast<wgpu::IntegerCoordinate>(
+                  depthOrArrayLayers.getNumber());
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUExtent3DDict::width = %f",
+                                 result->_instance.width);
+    rnwgpu::Logger::logToConsole("GPUExtent3DDict::height = %f",
+                                 result->_instance.height);
+    rnwgpu::Logger::logToConsole("GPUExtent3DDict::depthOrArrayLayers = %f",
+                                 result->_instance.depthOrArrayLayers);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUExtent3DDict> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUExtent3DDictStrict.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUExtent3DDictStrict {
+public:
+  wgpu::Extent3DDictStrict *getInstance() { return &_instance; }
+
+  wgpu::Extent3DDictStrict _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUExtent3DDictStrict>> {
+  static std::shared_ptr<rnwgpu::GPUExtent3DDictStrict>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUExtent3DDictStrict>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "depth")) {
+        auto depth = value.getProperty(runtime, "depth");
+
+        if (depth.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUExtent3DDictStrict::depth is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUExtent3DDictStrict::depth is not defined");
+      }
+      if (value.hasProperty(runtime, "width")) {
+        auto width = value.getProperty(runtime, "width");
+
+        if (width.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUExtent3DDictStrict::width is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUExtent3DDictStrict::width is not defined");
+      }
+      if (value.hasProperty(runtime, "height")) {
+        auto height = value.getProperty(runtime, "height");
+
+        if (height.isNumber()) {
+          result->_instance.height =
+              static_cast<wgpu::IntegerCoordinate>(height.getNumber());
+        }
+      }
+      if (value.hasProperty(runtime, "depthOrArrayLayers")) {
+        auto depthOrArrayLayers =
+            value.getProperty(runtime, "depthOrArrayLayers");
+
+        if (depthOrArrayLayers.isNumber()) {
+          result->_instance.depthOrArrayLayers =
+              static_cast<wgpu::IntegerCoordinate>(
+                  depthOrArrayLayers.getNumber());
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUExtent3DDictStrict::depth = %f",
+                                 result->_instance.depth);
+    rnwgpu::Logger::logToConsole("GPUExtent3DDictStrict::width = %f",
+                                 result->_instance.width);
+    rnwgpu::Logger::logToConsole("GPUExtent3DDictStrict::height = %f",
+                                 result->_instance.height);
+    rnwgpu::Logger::logToConsole(
+        "GPUExtent3DDictStrict::depthOrArrayLayers = %f",
+        result->_instance.depthOrArrayLayers);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUExtent3DDictStrict> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUExternalTextureBindingLayout.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUExternalTextureBindingLayout {
+public:
+  wgpu::ExternalTextureBindingLayout *getInstance() { return &_instance; }
+
+  wgpu::ExternalTextureBindingLayout _instance;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureBindingLayout>> {
+  static std::shared_ptr<rnwgpu::GPUExternalTextureBindingLayout>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUExternalTextureBindingLayout>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUExternalTextureBindingLayout> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUExternalTextureDescriptor.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUExternalTextureDescriptor {
+public:
+  wgpu::ExternalTextureDescriptor *getInstance() { return &_instance; }
+
+  wgpu::ExternalTextureDescriptor _instance;
+
+  std::string label;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUExternalTextureDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "source")) {
+        auto source = value.getProperty(runtime, "source");
+
+        if (source.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUExternalTextureDescriptor::source is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUExternalTextureDescriptor::source is not defined");
+      }
+      if (value.hasProperty(runtime, "colorSpace")) {
+        auto colorSpace = value.getProperty(runtime, "colorSpace");
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto label = value.getProperty(runtime, "label");
+
+        if (label.isString()) {
+          auto str = label.asString(runtime).utf8(runtime);
+          result->label = str;
+          result->_instance.label = result->label.c_str();
+        }
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUExternalTextureDescriptor::source = %f",
+                                 result->_instance.source);
+    rnwgpu::Logger::logToConsole(
+        "GPUExternalTextureDescriptor::colorSpace = %f",
+        result->_instance.colorSpace);
+    rnwgpu::Logger::logToConsole("GPUExternalTextureDescriptor::label = %f",
+                                 result->_instance.label);
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo

package/cpp/rnwgpu/api/descriptors/GPUFragmentState.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "Logger.h"
+#include "RNFJSIConverter.h"
+#include <RNFHybridObject.h>
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+class GPUFragmentState {
+public:
+  wgpu::FragmentState *getInstance() { return &_instance; }
+
+  wgpu::FragmentState _instance;
+
+  std::string entryPoint;
+};
+} // namespace rnwgpu
+
+namespace margelo {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUFragmentState>> {
+  static std::shared_ptr<rnwgpu::GPUFragmentState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUFragmentState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "targets")) {
+        auto targets = value.getProperty(runtime, "targets");
+
+        if (targets.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUFragmentState::targets is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUFragmentState::targets is not defined");
+      }
+      if (value.hasProperty(runtime, "module")) {
+        auto module = value.getProperty(runtime, "module");
+
+        if (module.isUndefined()) {
+          throw std::runtime_error(
+              "Property GPUFragmentState::module is required");
+        }
+      } else {
+        throw std::runtime_error(
+            "Property GPUFragmentState::module is not defined");
+      }
+      if (value.hasProperty(runtime, "entryPoint")) {
+        auto entryPoint = value.getProperty(runtime, "entryPoint");
+
+        if (entryPoint.isString()) {
+          auto str = entryPoint.asString(runtime).utf8(runtime);
+          result->entryPoint = str;
+          result->_instance.entryPoint = result->entryPoint.c_str();
+        }
+      }
+      if (value.hasProperty(runtime, "constants")) {
+        auto constants = value.getProperty(runtime, "constants");
+      }
+    }
+    rnwgpu::Logger::logToConsole("GPUFragmentState::targets = %f",
+                                 result->_instance.targets);
+    rnwgpu::Logger::logToConsole("GPUFragmentState::module = %f",
+                                 result->_instance.module);
+    rnwgpu::Logger::logToConsole("GPUFragmentState::entryPoint = %f",
+                                 result->_instance.entryPoint);
+    rnwgpu::Logger::logToConsole("GPUFragmentState::constants = %f",
+                                 result->_instance.constants);
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUFragmentState> arg) {
+    // No conversions here
+    return jsi::Value::null();
+  }
+};
+} // namespace margelo