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/context.h"

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

#include <memory>
#include <stdexcept>
#include <utility>

#include <tsDuckContext.h>

RustDuckDuckContext::RustDuckDuckContext(std::shared_ptr<void> context) noexcept
    : context_(std::move(context)) {}

RustDuckDuckContext::~RustDuckDuckContext() noexcept = default;

void *RustDuckDuckContext::raw() const noexcept { return context_.get(); }

std::shared_ptr<void> RustDuckDuckContext::retain() const noexcept {
  return context_;
}

ts::DuckContext &RustDuckDuckContext::native() const {
  if (context_ == nullptr) {
    throw std::runtime_error("native context is null");
  }
  return *static_cast<ts::DuckContext *>(context_.get());
}

std::unique_ptr<RustDuckDuckContext>
rustduck_context_new(const RustDuckReport &report) {
  rustduck_test_maybe_fail(RustDuckFailurePoint::ContextConstruct);
  auto context =
      std::shared_ptr<void>(tspyNewDuckContext(report.raw()),
                            [report = report.retain()](void *pointer) {
                              if (pointer != nullptr) {
                                tspyDeleteDuckContext(pointer);
                              }
                            });
  if (!context) {
    throw std::runtime_error("native context construction failed");
  }
  return std::make_unique<RustDuckDuckContext>(std::move(context));
}

bool rustduck_context_set_default_charset(
    RustDuckDuckContext &context, rust::Slice<const std::uint8_t> charset) {
  return tspyDuckContextSetDefaultCharset(context.raw(),
                                          rustduck::utf16_data(charset),
                                          rustduck::utf16_size(charset));
}

void rustduck_context_set_default_cas_id(RustDuckDuckContext &context,
                                         std::uint16_t cas_id) {
  tspyDuckContextSetDefaultCASId(context.raw(), cas_id);
}

void rustduck_context_set_default_pds(RustDuckDuckContext &context,
                                      std::uint32_t pds) {
  tspyDuckContextSetDefaultPDS(context.raw(), pds);
}

void rustduck_context_add_standards(RustDuckDuckContext &context,
                                    std::uint32_t standards) {
  tspyDuckContextAddStandards(context.raw(), standards);
}

std::uint32_t rustduck_context_standards(const RustDuckDuckContext &context) {
  return tspyDuckContextStandards(context.raw());
}

void rustduck_context_reset_standards(RustDuckDuckContext &context,
                                      std::uint32_t standards) {
  tspyDuckContextResetStandards(context.raw(), standards);
}

void rustduck_context_set_time_reference_offset(RustDuckDuckContext &context,
                                                std::int64_t offset_millis) {
  tspyDuckContextSetTimeReferenceOffset(context.raw(), offset_millis);
}

bool rustduck_context_set_time_reference(RustDuckDuckContext &context,
                                         rust::Slice<const std::uint8_t> name) {
  return tspyDuckContextSetTimeReference(
      context.raw(), rustduck::utf16_data(name), rustduck::utf16_size(name));
}