@dittolive/ditto 4.5.1-experimental.aarch64-linux.1.aarch64 → 4.5.2-rc.2

package/react-native/cpp/include/Arc.hpp

@@ -0,0 +1,141 @@
+#ifndef _ARC_
+#define _ARC_
+
+#include <atomic>
+#include <cassert>
+#include <utility>
+
+namespace sharedjsi {
+
+template <typename T> struct ArcPointee {
+  T value;
+  mutable std::atomic<size_t> strong_count;
+
+  ArcPointee(T &&value, size_t strong_count)
+      : value /* = */ (std::move(value)), strong_count /* = */ (strong_count) {}
+};
+
+template <typename T> class Arc {
+public:
+  // Post-condition: refcount = 1.
+  Arc(T value) noexcept
+      : ptr /* = */ (new ArcPointee<T>(std::move(value), 1)) {}
+
+  // Post-condition: refcount ±= 0; schedules dtor glue to `-= 1`.
+  // There has to be a 1-to-1 relation between `into_raw()` and `from_raw()`.
+  static Arc<T> from_raw(void *ptr) noexcept {
+    return Arc(static_cast<ArcPointee<T> *>(ptr));
+  }
+
+  // The equivalent of boost's `detach()`.
+  // Post-condition: refcount ±= 0; disables the `-= 1` eventual dtor glue.
+  // There has to be a 1-to-1 relation between `into_raw()` and `from_raw()`.
+  static void *into_raw(ArcPointee<T> &&self) noexcept {
+    auto ptr = self.ptr;
+    self.ptr = nullptr;
+    return static_cast<void *>(ptr);
+  }
+
+  // The equivalent of boost's `get()`.
+  // Post-condition: refcount ±= 0; dtor untouched.
+  static void *as_raw(Arc<T> const &arc) noexcept { return arc.ptr; }
+
+  // Borrow a `void *` as a `Arc<T>`, *temporarily*.
+  // (i.e., without touching the refcount nor setting up any ownership).
+  //   - You could then use the copy (clone) ctor to get back an owned `Arc<T>`,
+  //     via the retain therein.
+  // Post-condition: refcount ±= 0; dtor not enabled.
+  static Arc<T> &borrow_from_raw(void *&ptr) noexcept {
+    return *reinterpret_cast<Arc<T> *>(&ptr);
+  }
+
+  // Copy (clone) constructor
+  // Post-condition: refcount += 1; schedules new `-= 1` dtor glue.
+  Arc(Arc<T> const &other) noexcept : ptr /* = */ (other.ptr) {
+    ++(ptr->strong_count);
+  }
+
+  // Destructor / dtor.
+  // Post-condition: refcount = -1.
+  ~Arc() {
+    if (ptr != nullptr) { // <- if not moved from.
+      size_t count = --(ptr->strong_count);
+      if (count == 0) {
+        delete ptr;
+      }
+    }
+  }
+
+  // Move constructor
+  // Post-condition: refcount ±= 0 (and `rhs.ptr == nullptr`); moves dtor glue
+  // from `rhs` to `this`.
+  Arc(Arc<T> &&rhs) noexcept : ptr /* = */ (rhs.ptr) { rhs.ptr = nullptr; }
+
+  // Using `swap()`, we can use temporaries to derive the tricky assignments
+  // semantics off the above constructor & destructor operations, thanks to the
+  // C++ RAII semantics of the temporary. Post-condition: refcount ±= 0.
+  void swap(Arc<T> &rhs) noexcept {
+    ArcPointee<T> *rhs_ptr = rhs.ptr;
+    rhs.ptr = this->ptr;
+    this->ptr = rhs_ptr;
+  }
+
+  // Copy (clone) assignment.
+  // Post-condition: rhs refcount += 1; orig `*this` destroyed; schedules new
+  // `-= 1` dtor glue.
+  Arc<T> &operator=(Arc<T> const &rhs) noexcept {
+    {
+      Arc temporary{rhs}; // copy ctor: +1 of rhs
+      temporary.swap(*this);
+    } // dtor: -1 on what used to be `*this`.
+    return *this;
+  }
+
+  // Move assignment
+  // Post-condition: rhs refcount ±= 0; `rhs.ptr == nullptr`; orig `*this`
+  // destroyed. Moved dtor.
+  Arc<T> &operator=(Arc<T> &&rhs) noexcept {
+    {
+      Arc<T> temporary{
+          std::move(rhs)}; // move ctor: +0 of rhs; `rhs` is now `nullptr`.
+      temporary.swap(*this);
+    } // dtor: -1 on what used to be `*this`.
+    return *this;
+  }
+
+  // Deref
+  // Post-condition: rhs refcount ±= 0; dtor untouched.
+  T &operator*() const noexcept {
+    assert(ptr != nullptr);
+    return ptr->value;
+  }
+
+  // Post-condition: rhs refcount ±= 0; dtor untouched.
+  T *operator->() const noexcept {
+    assert(ptr != nullptr);
+    return &ptr->value;
+  }
+
+private:
+  ArcPointee<T> *ptr;
+
+  // from raw
+  Arc<T>(ArcPointee<T> *ptr) : ptr(ptr) {}
+};
+
+#define DEFINE_RETAIN_RELEASE_FOR(T, retain, release)                          \
+  extern "C" {                                                                 \
+  /* Post-condition: refcount += 1; dtor untouched. */                         \
+  static void retain(void *ptr) {                                              \
+    ++(static_cast<ArcPointee<T> *>(ptr)->strong_count);                \
+  }                                                                            \
+                                                                               \
+  /* Post-condition: refcount -= 1; dtor untouched. */                         \
+  static void release(void *ptr) { Arc<T>::from_raw(ptr); }             \
+  }                                                                            \
+  static_assert(true,                                                          \
+                "") // <- to require a semi-colon when the macro is invoked.
+
+} // namespace sharedjsi
+
+#endif // _ARC_

package/react-native/cpp/include/Attachment.h

@@ -0,0 +1,16 @@
+#ifndef Attachment_H
+#define Attachment_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_cancel_resolve_attachment(Runtime &runtime);
+Function ditto_free_attachment_handle(Runtime &runtime);
+Function ditto_get_complete_attachment_path(Runtime &runtime);
+Function ditto_new_attachment_from_bytes(Runtime &runtime);
+}
+
+#endif /* Attachment_H */

package/react-native/cpp/include/Authentication.h

@@ -0,0 +1,23 @@
+#ifndef Authentication_H
+#define Authentication_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_auth_client_set_validity_listener(Runtime &runtime);
+Function ditto_auth_client_is_web_valid(Runtime &runtime);
+Function ditto_auth_client_is_x509_valid(Runtime &runtime);
+Function ditto_auth_client_get_app_id(Runtime &runtime);
+Function ditto_auth_client_get_site_id(Runtime &runtime);
+Function ditto_auth_client_make_login_provider(Runtime &runtime);
+Function ditto_auth_set_login_provider(Runtime &runtime);
+Function ditto_auth_client_login_with_token(Runtime &runtime);
+Function ditto_auth_client_login_with_credentials(Runtime &runtime);
+Function ditto_auth_client_logout(Runtime &runtime);
+Function ditto_auth_client_user_id(Runtime &runtime);
+}
+
+#endif /* Authentication_H */

package/react-native/cpp/include/Collection.h

@@ -0,0 +1,13 @@
+#ifndef Collection_H
+#define Collection_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_collection_insert_value(Runtime &runtime);
+}
+
+#endif /* Collection_H */

package/react-native/cpp/include/DQL.h

@@ -0,0 +1,21 @@
+#ifndef DQL_H
+#define DQL_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi {
+Function dittoffi_try_experimental_register_change_observer_str_detached(Runtime &runtime);
+Function dittoffi_try_experimental_add_dql_subscription(Runtime &runtime);
+Function dittoffi_try_experimental_remove_dql_subscription(Runtime &runtime);
+Function dittoffi_try_experimental_exec_statement_str(Runtime &runtime);
+Function ditto_dql_response_result_count(Runtime &runtime);
+Function ditto_dql_response_result_at(Runtime &runtime);
+Function ditto_dql_response_affected_document_id_count(Runtime &runtime);
+Function ditto_dql_response_affected_document_id_at(Runtime &runtime);
+Function ditto_result_cbor(Runtime &runtime);
+Function ditto_result_json(Runtime &runtime);
+}
+
+#endif /* DQL_H */

package/react-native/cpp/include/Document.h

@@ -0,0 +1,17 @@
+#ifndef Document_H
+#define Document_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_document_id_query_compatible(Runtime &runtime);
+Function ditto_document_id(Runtime &runtime);
+Function ditto_document_free(Runtime &runtime);
+Function ditto_document_get_cbor_with_path_type(Runtime &runtime);
+Function ditto_validate_document_id(Runtime &runtime);
+}
+
+#endif /* Document_H */

package/react-native/cpp/include/Identity.h

@@ -0,0 +1,17 @@
+#ifndef Identity_H
+#define Identity_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_identity_config_make_online_playground(Runtime &runtime);
+Function ditto_identity_config_make_offline_playground(Runtime &runtime);
+Function ditto_identity_config_make_manual_v0(Runtime &runtime);
+Function ditto_identity_config_make_shared_key(Runtime &runtime);
+Function ditto_identity_config_make_online_with_authentication(Runtime &runtime);
+}
+
+#endif /* Identity_H */

package/react-native/cpp/include/Lifecycle.h

@@ -0,0 +1,17 @@
+#ifndef Lifecycle_H
+#define Lifecycle_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_init_sdk_version(Runtime &runtime);
+Function ditto_uninitialized_ditto_make(Runtime &runtime);
+Function ditto_shutdown(Runtime &runtime);
+Function ditto_free(Runtime &runtime);
+Function ditto_make(Runtime &runtime);
+}
+
+#endif /* Document_H */

package/react-native/cpp/include/LiveQuery.h

@@ -0,0 +1,17 @@
+#ifndef LiveQuery_H
+#define LiveQuery_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_live_query_signal_available_next(Runtime &runtime);
+Function ditto_live_query_start(Runtime &runtime);
+Function ditto_live_query_stop(Runtime &runtime);
+Function ditto_live_query_register_str_detached(Runtime &runtime);
+void v_live_query_update(void *ctx, c_cb_params_t params);
+}
+
+#endif /* LiveQuery_H */

package/react-native/cpp/include/Logger.h

@@ -0,0 +1,22 @@
+
+
+#ifndef Logger_H
+#define Logger_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_log(Runtime &runtime);
+Function ditto_logger_set_log_file(Runtime &runtime);
+Function ditto_logger_minimum_log_level_get(Runtime &runtime);
+Function ditto_logger_minimum_log_level(Runtime &runtime);
+Function ditto_logger_emoji_headings_enabled_get(Runtime &runtime);
+Function ditto_logger_emoji_headings_enabled(Runtime &runtime);
+Function ditto_logger_enabled_get(Runtime &runtime);
+Function ditto_logger_enabled(Runtime &runtime);
+
+}
+#endif /* Logger_H */

package/react-native/cpp/include/Misc.h

@@ -0,0 +1,27 @@
+#ifndef Misc_H
+#define Misc_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_tick(Runtime &runtime);
+Function ditto_set_device_name(Runtime &runtime);
+Function ditto_error_message(Runtime &runtime);
+Function dittoffi_error_code(Runtime &runtime);
+Function dittoffi_error_description(Runtime &runtime);
+Function dittoffi_error_free(Runtime &runtime);
+Function ditto_set_connect_retry_interval(Runtime &runtime);
+Function ditto_get_sdk_version(Runtime &runtime);
+Function dittoffi_get_sdk_semver(Runtime &runtime);
+Function ditto_small_peer_info_set_transport_config_data(Runtime &runtime);
+Function ditto_verify_license(Runtime &runtime);
+Function ditto_run_garbage_collection(Runtime &runtime);
+Function ditto_set_static_websocket_clients(Runtime &runtime);
+Function ditto_set_sync_group(Runtime &runtime);
+Function refCStringToString(Runtime &runtime);
+}
+
+#endif /* Misc_H */

package/react-native/cpp/include/Presence.h

@@ -0,0 +1,14 @@
+#ifndef Presence_H
+#define Presence_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_presence_v3(Runtime &runtime);
+Function ditto_register_presence_v3_callback(Runtime &runtime);
+Function ditto_clear_presence_v3_callback(Runtime &runtime);
+}
+#endif /* Presence_H */

package/react-native/cpp/include/SmallPeerInfo.h

@@ -0,0 +1,19 @@
+#ifndef SmallPeerInfo_H
+#define SmallPeerInfo_H
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+Function ditto_small_peer_info_set_transport_config_data(Runtime &runtime);
+Function ditto_small_peer_info_get_is_enabled(Runtime &runtime);
+Function ditto_small_peer_info_set_enabled(Runtime &runtime);
+Function ditto_small_peer_info_get_sync_scope(Runtime &runtime);
+Function ditto_small_peer_info_set_sync_scope(Runtime &runtime);
+Function ditto_small_peer_info_get_metadata(Runtime &runtime);
+Function ditto_small_peer_info_set_metadata(Runtime &runtime);
+}
+
+#endif /* SmallPeerInfo_H */

package/react-native/cpp/include/Transports.h

@@ -0,0 +1,25 @@
+#ifndef Transports_h
+#define Transports_h
+
+#include <jsi/jsi.h>
+
+using namespace facebook::jsi;
+
+namespace sharedjsi {
+Function ditto_sdk_transports_error_new(Runtime &runtime);
+Function ditto_sdk_transports_init(Runtime &runtime);
+Function ditto_sdk_transports_error_value(Runtime &runtime);
+Function ditto_sdk_transports_error_free(Runtime &runtime);
+Function ditto_sdk_transports_ble_is_available(Runtime &runtime);
+Function ditto_sdk_transports_ble_create(Runtime &runtime);
+Function ditto_sdk_transports_ble_destroy(Runtime &runtime);
+Function ditto_sdk_transports_lan_is_available(Runtime &runtime);
+Function ditto_sdk_transports_lan_create(Runtime &runtime);
+Function ditto_sdk_transports_lan_destroy(Runtime &runtime);
+Function ditto_sdk_transports_awdl_is_available(Runtime &runtime);
+Function ditto_sdk_transports_awdl_create(Runtime &runtime);
+Function ditto_sdk_transports_awdl_destroy(Runtime &runtime);
+Function ditto_add_multicast_transport(Runtime &runtime);
+Function ditto_remove_multicast_transport(Runtime &runtime);
+}
+#endif /* Transports_h */

package/react-native/cpp/include/TypedArray.hpp

@@ -0,0 +1,167 @@
+
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace jsi = facebook::jsi;
+
+enum class TypedArrayKind {
+  Int8Array,
+  Int16Array,
+  Int32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Uint16Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+};
+
+template <TypedArrayKind T>
+class TypedArray;
+
+template <TypedArrayKind T>
+struct typedArrayTypeMap;
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Int8Array> {
+  typedef int8_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Int16Array> {
+  typedef int16_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Int32Array> {
+  typedef int32_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Uint8Array> {
+  typedef uint8_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Uint8ClampedArray> {
+  typedef uint8_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Uint16Array> {
+  typedef uint16_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Uint32Array> {
+  typedef uint32_t type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Float32Array> {
+  typedef float type;
+};
+template <>
+struct typedArrayTypeMap<TypedArrayKind::Float64Array> {
+  typedef double type;
+};
+
+// Instance of this class will invalidate PropNameIDCache when destructor is called.
+// Attach this object to global in specific jsi::Runtime to make sure lifecycle of
+// the cache object is connected to the lifecycle of the js runtime
+class InvalidateCacheOnDestroy : public jsi::HostObject {
+public:
+  InvalidateCacheOnDestroy(jsi::Runtime &runtime);
+  virtual ~InvalidateCacheOnDestroy();
+  virtual jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) {
+    return jsi::Value::null();
+  }
+  virtual void set(jsi::Runtime &, const jsi::PropNameID &name, const jsi::Value &value) {}
+  virtual std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) {
+    return {};
+  }
+
+private:
+  uintptr_t key;
+};
+
+class TypedArrayBase : public jsi::Object {
+public:
+  template <TypedArrayKind T>
+  using ContentType = typename typedArrayTypeMap<T>::type;
+
+  TypedArrayBase(jsi::Runtime &, size_t, TypedArrayKind);
+  TypedArrayBase(jsi::Runtime &, const jsi::Object &);
+  TypedArrayBase(TypedArrayBase &&) = default;
+  TypedArrayBase &operator=(TypedArrayBase &&) = default;
+
+  TypedArrayKind getKind(jsi::Runtime &runtime) const;
+
+  template <TypedArrayKind T>
+  TypedArray<T> get(jsi::Runtime &runtime) const &;
+  template <TypedArrayKind T>
+  TypedArray<T> get(jsi::Runtime &runtime) &&;
+  template <TypedArrayKind T>
+  TypedArray<T> as(jsi::Runtime &runtime) const &;
+  template <TypedArrayKind T>
+  TypedArray<T> as(jsi::Runtime &runtime) &&;
+
+  size_t size(jsi::Runtime &runtime) const;
+  size_t length(jsi::Runtime &runtime) const;
+  size_t byteLength(jsi::Runtime &runtime) const;
+  size_t byteOffset(jsi::Runtime &runtime) const;
+  bool hasBuffer(jsi::Runtime &runtime) const;
+
+  std::vector<uint8_t> toVector(jsi::Runtime &runtime);
+  jsi::ArrayBuffer getBuffer(jsi::Runtime &runtime) const;
+
+private:
+  template <TypedArrayKind>
+  friend class TypedArray;
+};
+
+bool isTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj);
+TypedArrayBase getTypedArray(jsi::Runtime &runtime, const jsi::Object &jsObj);
+
+std::vector<uint8_t> arrayBufferToVector(jsi::Runtime &runtime, jsi::Object &jsObj);
+void arrayBufferUpdate(
+                       jsi::Runtime &runtime,
+                       jsi::ArrayBuffer &buffer,
+                       std::vector<uint8_t> data,
+                       size_t offset);
+
+template <TypedArrayKind T>
+class TypedArray : public TypedArrayBase {
+public:
+  TypedArray(jsi::Runtime &runtime, size_t size);
+  TypedArray(jsi::Runtime &runtime, std::vector<ContentType<T>> data);
+  TypedArray(TypedArrayBase &&base);
+  TypedArray(TypedArray &&) = default;
+  TypedArray &operator=(TypedArray &&) = default;
+
+  std::vector<ContentType<T>> toVector(jsi::Runtime &runtime);
+  void update(jsi::Runtime &runtime, const std::vector<ContentType<T>> &data);
+};
+
+template <TypedArrayKind T>
+TypedArray<T> TypedArrayBase::get(jsi::Runtime &runtime) const & {
+  assert(getKind(runtime) == T);
+  (void)runtime; // when assert is disabled we need to mark this as used
+  return TypedArray<T>(jsi::Value(runtime, jsi::Value(runtime, *this).asObject(runtime)));
+}
+
+template <TypedArrayKind T>
+TypedArray<T> TypedArrayBase::get(jsi::Runtime &runtime) && {
+  assert(getKind(runtime) == T);
+  (void)runtime; // when assert is disabled we need to mark this as used
+  return TypedArray<T>(std::move(*this));
+}
+
+template <TypedArrayKind T>
+TypedArray<T> TypedArrayBase::as(jsi::Runtime &runtime) const & {
+  if (getKind(runtime) != T) {
+    throw jsi::JSError(runtime, "Object is not a TypedArray");
+  }
+  return get<T>(runtime);
+}
+
+template <TypedArrayKind T>
+TypedArray<T> TypedArrayBase::as(jsi::Runtime &runtime) && {
+  if (getKind(runtime) != T) {
+    throw jsi::JSError(runtime, "Object is not a TypedArray");
+  }
+  return std::move(*this).get<T>(runtime);
+}

package/react-native/cpp/include/Utils.h

@@ -0,0 +1,61 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <vector>
+#include <jsi/jsi.h>
+#include "TypedArray.hpp"
+#include <dittoffi.h>
+
+#define STRINGIFY(it) #it
+
+#define STRINGIFIED_FUNC_NAME() STRINGIFY(__function)
+#define STRINGIFY_TYPE(T) #T
+
+using namespace facebook::jsi;
+
+namespace sharedjsi
+{
+
+std::string pointerToHexString(void const *ptr);
+
+template <typename T>
+Value cPointerToJSPointerObject(Runtime &runtime, const T *pointer) {
+  if (pointer == nullptr) {
+    return Value::null();
+  }
+
+  Object obj(runtime);
+  obj.setProperty(runtime, "type", STRINGIFY_TYPE(T));
+  obj.setProperty(runtime, "addr", pointerToHexString(pointer));
+  return obj;
+}
+
+template <typename T>
+T *jsPointerObjectToCPointer(Runtime &runtime, const Value &arg)
+{
+  if (arg.isNull() || arg.isUndefined()) {
+    return nullptr;
+  }
+  Object obj = arg.getObject(runtime);
+  std::string str = obj.getProperty(runtime, "addr").toString(runtime).utf8(runtime);
+  T *ptr;
+  sscanf(str.c_str(), "%p", &ptr);
+  return ptr;
+}
+
+std::vector<uint8_t> jsTypedArrayToCVector(Runtime &runtime, const Value &arg);
+std::string jsTypedArrayToCString(Runtime &runtime, const Value &arg);
+
+slice_ref_uint8_t borrowVecAsOptRefSlice(std::vector<uint8_t> const& v);
+slice_ref_uint8_t borrowVecAsRefSlice(std::vector<uint8_t> const& v);
+
+Value cSlicedBoxToJSSlicedBox(Runtime &runtime, slice_boxed_uint8 box_c_bytes);
+Function sliceBoxedToUInt8Array(Runtime &runtime);
+
+Function withOutBoxCBytes(Runtime &runtime);
+
+void ditto_tick(Runtime* jsi);
+void ditto_enqueue_call(std::function<void(Runtime *)> && task);
+}
+
+#endif /* UTILS_H */

package/react-native/cpp/include/main.h

@@ -0,0 +1,10 @@
+#ifndef EXAMPLE_H
+#define EXAMPLE_H
+
+namespace sharedjsi 
+{
+void install(facebook::jsi::Runtime &jsiRuntime);
+}
+
+
+#endif /* EXAMPLE_H */