rustduck-sys 1.1.0

Raw Rust FFI bindings to the C ABI used by TSDuck's Python API
Documentation
#include "rustduck-sys/native/bridge/memory_handler.h"

#include "rustduck-sys/native/bridge/test_hooks.h"
#include "rustduck-sys/native/tspy.h"
#include "rustduck-sys/src/bridge.rs.h"

#include <cstdint>
#include <memory>
#include <stdexcept>
#include <type_traits>

namespace {

bool memory_callback(std::uint32_t event_code, const tspy_uchar *plugin_name,
                     std::size_t plugin_name_size, std::size_t, std::size_t,
                     std::size_t, std::size_t, std::size_t,
                     const std::uint8_t *data, std::size_t data_size,
                     std::size_t data_max_size, bool data_read_only,
                     void *event_data) noexcept {
  try {
    const bool plugin_name_valid =
        plugin_name != nullptr || plugin_name_size == 0;
    const bool data_valid = data != nullptr || data_size == 0;
    const auto *plugin_name_bytes =
        reinterpret_cast<const std::uint8_t *>(plugin_name);
    const rust::Slice<const std::uint8_t> plugin_name_slice(
        plugin_name_bytes, plugin_name_valid ? plugin_name_size : 0);
    const rust::Slice<const std::uint8_t> data_slice(
        data, data_valid ? data_size : 0);
    const auto validity = static_cast<std::uint8_t>(
        (plugin_name_valid ? 0x01 : 0) | (data_valid ? 0x02 : 0) |
        (event_data != nullptr ? 0x04 : 0));
    auto result =
        rustduck_memory_callback(event_code, plugin_name_slice, data_slice,
                                 data_max_size, data_read_only, validity);
    if (!result.ok) {
      return false;
    }
    if (!data_read_only) {
      if (event_data == nullptr || result.data.size() > data_max_size) {
        rustduck_memory_callback_writeback_failure(event_code);
        return false;
      }
      rustduck_test_maybe_fail(RustDuckFailurePoint::MemoryWriteback);
      std::uint8_t empty = 0;
      void *writeback_data = result.data.empty()
                                 ? static_cast<void *>(&empty)
                                 : static_cast<void *>(result.data.data());
      tspyPyPluginEventHandlerUpdateData(event_data, writeback_data,
                                         result.data.size());
    }
    return true;
  } catch (...) {
    rustduck_memory_callback_writeback_failure(event_code);
    return false;
  }
}

static_assert(
    std::is_convertible_v<decltype(&memory_callback), tspy_plugin_callback>);

} // namespace

RustDuckMemoryHandler::RustDuckMemoryHandler()
    : handler_(tspyNewPyPluginEventHandler(memory_callback), [](void *pointer) {
        if (pointer != nullptr) {
          tspyDeletePyPluginEventHandler(pointer);
        }
      }) {
  if (!handler_) {
    throw std::runtime_error("native memory handler construction failed");
  }
}

RustDuckMemoryHandler::~RustDuckMemoryHandler() noexcept = default;

void *RustDuckMemoryHandler::raw() const noexcept { return handler_.get(); }

std::shared_ptr<void> RustDuckMemoryHandler::retain() const noexcept {
  return handler_;
}

std::unique_ptr<RustDuckMemoryHandler> rustduck_memory_handler_new() {
  return std::make_unique<RustDuckMemoryHandler>();
}