#![allow(non_camel_case_types)]
use std::cell::RefCell;
use std::collections::{BTreeMap, HashSet};
use std::ffi::{CStr, CString, c_char};
use std::panic::{AssertUnwindSafe, catch_unwind};
use std::sync::{Mutex, MutexGuard, OnceLock};
use cadkit::{Document, DxfVersion, Error, Format, Limits, ReadOptions, SvgOptions};
pub use cadkit;
static VERSION: &CStr =
match CStr::from_bytes_with_nul(concat!(env!("CARGO_PKG_VERSION"), "\0").as_bytes()) {
Ok(v) => v,
Err(_) => c"unknown",
};
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum cadkit_status {
Ok = 0,
NullPointer = 1,
InvalidArgument = 2,
Io = 3,
Truncated = 4,
InvalidData = 5,
Unsupported = 6,
LimitExceeded = 7,
UnknownFormat = 8,
Panic = 9,
Internal = 10,
InvalidHandle = 11,
}
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum cadkit_format {
Unknown = 0,
Dwg = 1,
Dxf = 2,
DgnV7 = 3,
DgnV8 = 4,
CityGml = 5,
}
#[repr(C)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum cadkit_dxf_version {
R12 = 0,
R2000 = 1,
R2004 = 2,
R2007 = 3,
R2010 = 4,
R2013 = 5,
R2018 = 6,
}
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct cadkit_options {
pub max_input_bytes: u64,
pub max_decompressed_bytes: u64,
pub max_objects: u64,
pub max_depth: u32,
pub max_string_bytes: u32,
pub max_vertices: u32,
pub keep_raw: i32,
pub fallback_codepage: *const c_char,
}
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct cadkit_svg_options {
pub model_index: u32,
pub width_px: f64,
pub stroke_px: f64,
pub background: *const c_char,
pub text: i32,
pub expand_blocks: i32,
}
#[repr(C)]
#[derive(Debug, Clone, Copy)]
pub struct cadkit_info {
pub format: cadkit_format,
pub model_count: u64,
pub layer_count: u64,
pub block_count: u64,
pub entity_count: u64,
pub warning_count: u64,
}
pub struct cadkit_document {
doc: Document,
}
thread_local! {
static LAST_ERROR: RefCell<CString> = RefCell::new(CString::default());
}
fn live_handles() -> MutexGuard<'static, HashSet<usize>> {
static LIVE: OnceLock<Mutex<HashSet<usize>>> = OnceLock::new();
LIVE.get_or_init(|| Mutex::new(HashSet::new()))
.lock()
.unwrap_or_else(|p| p.into_inner())
}
fn set_error(message: &str) {
let cleaned: Vec<u8> = message.bytes().filter(|b| *b != 0).collect();
let c = CString::new(cleaned).unwrap_or_default();
LAST_ERROR.with(|e| *e.borrow_mut() = c);
}
fn clear_error() {
LAST_ERROR.with(|e| *e.borrow_mut() = CString::default());
}
fn fail(status: cadkit_status, message: &str) -> cadkit_status {
set_error(message);
status
}
fn map_error(err: &Error) -> cadkit_status {
let status = match err {
Error::Truncated { .. } => cadkit_status::Truncated,
Error::Invalid { .. } => cadkit_status::InvalidData,
Error::Unsupported(_) => cadkit_status::Unsupported,
Error::LimitExceeded { .. } => cadkit_status::LimitExceeded,
Error::UnknownFormat => cadkit_status::UnknownFormat,
Error::Io(_) => cadkit_status::Io,
_ => cadkit_status::Internal,
};
fail(status, &err.to_string())
}
fn guarded(f: impl FnOnce() -> cadkit_status) -> cadkit_status {
clear_error();
match catch_unwind(AssertUnwindSafe(f)) {
Ok(status) => status,
Err(_) => fail(
cadkit_status::Panic,
"internal panic caught at the FFI boundary",
),
}
}
fn into_c_string(s: String) -> CString {
CString::new(s).unwrap_or_else(|e| {
let cleaned: Vec<u8> = e.into_vec().into_iter().filter(|b| *b != 0).collect();
CString::new(cleaned).unwrap_or_default()
})
}
unsafe fn opt_str<'a>(p: *const c_char, what: &str) -> Result<Option<&'a str>, cadkit_status> {
if p.is_null() {
return Ok(None);
}
let c = unsafe { CStr::from_ptr(p) };
match c.to_str() {
Ok(s) => Ok(Some(s)),
Err(_) => Err(fail(
cadkit_status::InvalidArgument,
&format!("{what} is not valid UTF-8"),
)),
}
}
unsafe fn convert_options(opts: *const cadkit_options) -> Result<ReadOptions, cadkit_status> {
let mut out = ReadOptions::default();
let Some(o) = (unsafe { opts.as_ref() }) else {
return Ok(out);
};
let d = Limits::default();
out.limits = Limits::default()
.with_max_input_bytes(if o.max_input_bytes == 0 {
d.max_input_bytes
} else {
o.max_input_bytes
})
.with_max_decompressed_bytes(if o.max_decompressed_bytes == 0 {
d.max_decompressed_bytes
} else {
o.max_decompressed_bytes
})
.with_max_objects(if o.max_objects == 0 {
d.max_objects
} else {
o.max_objects
})
.with_max_depth(if o.max_depth == 0 {
d.max_depth
} else {
o.max_depth
})
.with_max_string_bytes(if o.max_string_bytes == 0 {
d.max_string_bytes
} else {
o.max_string_bytes
})
.with_max_vertices(if o.max_vertices == 0 {
d.max_vertices
} else {
o.max_vertices
})
.with_max_total_vertices(d.max_total_vertices);
out.keep_raw = o.keep_raw != 0;
out.fallback_codepage =
unsafe { opt_str(o.fallback_codepage, "fallback_codepage") }?.map(str::to_owned);
Ok(out)
}
fn to_c_format(f: Option<Format>) -> cadkit_format {
match f {
Some(Format::Dwg) => cadkit_format::Dwg,
Some(Format::Dxf) => cadkit_format::Dxf,
Some(Format::DgnV7) => cadkit_format::DgnV7,
Some(Format::DgnV8) => cadkit_format::DgnV8,
Some(Format::CityGml) => cadkit_format::CityGml,
_ => cadkit_format::Unknown,
}
}
unsafe fn register(doc: Document, out: *mut *mut cadkit_document) {
let ptr = Box::into_raw(Box::new(cadkit_document { doc }));
live_handles().insert(ptr as usize);
unsafe { *out = ptr };
}
unsafe fn doc_ref<'a>(doc: *const cadkit_document) -> Result<&'a Document, cadkit_status> {
if doc.is_null() {
return Err(fail(cadkit_status::NullPointer, "document is NULL"));
}
if !live_handles().contains(&(doc as usize)) {
return Err(fail(
cadkit_status::InvalidHandle,
"document handle is not live (already freed or never created)",
));
}
Ok(unsafe { &(*doc).doc })
}
unsafe fn string_getter(
doc: *const cadkit_document,
out: *mut *mut c_char,
f: impl FnOnce(&Document) -> Result<String, Error>,
) -> cadkit_status {
if !out.is_null() {
unsafe { *out = std::ptr::null_mut() };
}
guarded(|| {
if out.is_null() {
return fail(cadkit_status::NullPointer, "out pointer is NULL");
}
let d = match unsafe { doc_ref(doc) } {
Ok(d) => d,
Err(s) => return s,
};
match f(d) {
Ok(s) => {
unsafe { *out = into_c_string(s).into_raw() };
cadkit_status::Ok
}
Err(e) => map_error(&e),
}
})
}
#[unsafe(no_mangle)]
pub extern "C" fn cadkit_version() -> *const c_char {
VERSION.as_ptr()
}
#[unsafe(no_mangle)]
pub extern "C" fn cadkit_status_string(status: i32) -> *const c_char {
let s: &CStr = match status {
0 => c"ok",
1 => c"null pointer argument",
2 => c"invalid argument",
3 => c"I/O error",
4 => c"truncated input",
5 => c"invalid data",
6 => c"unsupported feature",
7 => c"limit exceeded",
8 => c"unrecognized file format",
9 => c"internal panic",
10 => c"internal error",
11 => c"invalid document handle",
_ => c"unknown status",
};
s.as_ptr()
}
#[unsafe(no_mangle)]
pub extern "C" fn cadkit_last_error_message() -> *const c_char {
LAST_ERROR.with(|e| e.borrow().as_ptr())
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_options_init(options: *mut cadkit_options) {
if let Some(o) = unsafe { options.as_mut() } {
*o = cadkit_options {
max_input_bytes: 0,
max_decompressed_bytes: 0,
max_objects: 0,
max_depth: 0,
max_string_bytes: 0,
max_vertices: 0,
keep_raw: 0,
fallback_codepage: std::ptr::null(),
};
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_svg_options_init(options: *mut cadkit_svg_options) {
let d = SvgOptions::default();
if let Some(o) = unsafe { options.as_mut() } {
*o = cadkit_svg_options {
model_index: 0,
width_px: d.width_px,
stroke_px: d.stroke_px,
background: c"#ffffff".as_ptr(),
text: 1,
expand_blocks: 1,
};
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_detect(data: *const u8, len: usize) -> cadkit_format {
if data.is_null() {
return cadkit_format::Unknown;
}
let bytes = unsafe { std::slice::from_raw_parts(data, len) };
catch_unwind(|| to_c_format(cadkit::detect(bytes))).unwrap_or(cadkit_format::Unknown)
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_read_file(
utf8_path: *const c_char,
options: *const cadkit_options,
out: *mut *mut cadkit_document,
) -> cadkit_status {
if !out.is_null() {
unsafe { *out = std::ptr::null_mut() };
}
guarded(|| {
if out.is_null() || utf8_path.is_null() {
return fail(cadkit_status::NullPointer, "path or out pointer is NULL");
}
let path = match unsafe { opt_str(utf8_path, "path") } {
Ok(Some(p)) => p,
Ok(None) => return fail(cadkit_status::NullPointer, "path is NULL"),
Err(s) => return s,
};
let opts = match unsafe { convert_options(options) } {
Ok(o) => o,
Err(s) => return s,
};
match cadkit::open_with(path, &opts) {
Ok(doc) => {
unsafe { register(doc, out) };
cadkit_status::Ok
}
Err(e) => map_error(&e),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_read_bytes(
data: *const u8,
len: usize,
options: *const cadkit_options,
out: *mut *mut cadkit_document,
) -> cadkit_status {
if !out.is_null() {
unsafe { *out = std::ptr::null_mut() };
}
guarded(|| {
if out.is_null() {
return fail(cadkit_status::NullPointer, "out pointer is NULL");
}
let bytes: &[u8] = if data.is_null() {
if len != 0 {
return fail(cadkit_status::NullPointer, "data is NULL but len is not 0");
}
&[]
} else {
unsafe { std::slice::from_raw_parts(data, len) }
};
let opts = match unsafe { convert_options(options) } {
Ok(o) => o,
Err(s) => return s,
};
match cadkit::read_with(bytes, &opts) {
Ok(doc) => {
unsafe { register(doc, out) };
cadkit_status::Ok
}
Err(e) => map_error(&e),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_free(doc: *mut cadkit_document) -> cadkit_status {
if doc.is_null() {
return cadkit_status::Ok;
}
guarded(|| {
if !live_handles().remove(&(doc as usize)) {
return fail(
cadkit_status::InvalidHandle,
"document handle is not live (double free?)",
);
}
drop(unsafe { Box::from_raw(doc) });
cadkit_status::Ok
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_info(
doc: *const cadkit_document,
out: *mut cadkit_info,
) -> cadkit_status {
guarded(|| {
if out.is_null() {
return fail(cadkit_status::NullPointer, "out pointer is NULL");
}
let d = match unsafe { doc_ref(doc) } {
Ok(d) => d,
Err(s) => return s,
};
let info = cadkit_info {
format: to_c_format(Some(d.source.format)),
model_count: d.models.len() as u64,
layer_count: d.layers.len() as u64,
block_count: d.blocks.len() as u64,
entity_count: d.models.iter().map(|m| m.entities.len() as u64).sum(),
warning_count: d.warnings.len() as u64,
};
unsafe { *out = info };
cadkit_status::Ok
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_info_json(
doc: *const cadkit_document,
out: *mut *mut c_char,
) -> cadkit_status {
unsafe {
string_getter(doc, out, |d| {
let mut kinds: BTreeMap<String, u64> = BTreeMap::new();
for e in d.models.iter().flat_map(|m| m.entities.iter()) {
let name = e.kind.type_name().to_owned();
*kinds.entry(name).or_insert(0) += 1;
}
let v = serde_json::json!({
"format": d.source.format,
"version": d.source.version,
"application": d.source.application,
"models": d.models.len(),
"layers": d.layers.len(),
"blocks": d.blocks.len(),
"entities": d.models.iter().map(|m| m.entities.len()).sum::<usize>(),
"warnings": d.warnings.len(),
"entity_kinds": kinds,
});
Ok(v.to_string())
})
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_to_json(
doc: *const cadkit_document,
pretty: i32,
out: *mut *mut c_char,
) -> cadkit_status {
unsafe { string_getter(doc, out, |d| cadkit::to_json(d, pretty != 0)) }
}
unsafe fn convert_svg_options(
options: *const cadkit_svg_options,
) -> Result<SvgOptions, cadkit_status> {
let Some(o) = (unsafe { options.as_ref() }) else {
return Ok(SvgOptions::default());
};
let bg = unsafe { opt_str(o.background, "background") }?;
if !(o.width_px.is_finite() && o.width_px > 0.0 && o.stroke_px.is_finite() && o.stroke_px > 0.0)
{
return Err(fail(
cadkit_status::InvalidArgument,
"width_px and stroke_px must be finite and > 0",
));
}
Ok({
let mut options = SvgOptions::default()
.with_model(o.model_index as usize)
.with_width_px(o.width_px)
.with_stroke_px(o.stroke_px)
.with_text(o.text != 0)
.with_expand_blocks(o.expand_blocks != 0);
options.background = bg.map(str::to_owned);
options
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_to_svg(
doc: *const cadkit_document,
options: *const cadkit_svg_options,
out: *mut *mut c_char,
) -> cadkit_status {
clear_error();
match unsafe { convert_svg_options(options) } {
Ok(opts) => unsafe { string_getter(doc, out, |d| Ok(cadkit::to_svg(d, &opts))) },
Err(status) => {
if !out.is_null() {
unsafe { *out = std::ptr::null_mut() };
}
status
}
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_to_dxf(
doc: *const cadkit_document,
version: i32,
out: *mut *mut c_char,
) -> cadkit_status {
let v = match version {
0 => DxfVersion::R12,
1 => DxfVersion::R2000,
2 => DxfVersion::R2004,
3 => DxfVersion::R2007,
4 => DxfVersion::R2010,
5 => DxfVersion::R2013,
6 => DxfVersion::R2018,
_ => {
if !out.is_null() {
unsafe { *out = std::ptr::null_mut() };
}
return fail(cadkit_status::InvalidArgument, "unknown DXF version");
}
};
unsafe { string_getter(doc, out, |d| cadkit::to_dxf(d, v)) }
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_string_free(s: *mut c_char) {
if s.is_null() {
return;
}
drop(unsafe { CString::from_raw(s) });
}
fn live_buffers() -> MutexGuard<'static, std::collections::HashMap<usize, Vec<u8>>> {
static BUFFERS: OnceLock<Mutex<std::collections::HashMap<usize, Vec<u8>>>> = OnceLock::new();
BUFFERS
.get_or_init(|| Mutex::new(std::collections::HashMap::new()))
.lock()
.unwrap_or_else(|p| p.into_inner())
}
#[unsafe(no_mangle)]
pub extern "C" fn cadkit_bytes_free(data: *mut u8) {
live_buffers().remove(&(data as usize));
}
unsafe fn options_json<T: serde::de::DeserializeOwned + Default>(
text: *const c_char,
) -> Result<T, cadkit_status> {
match unsafe { opt_str(text, "options_json") }? {
None => Ok(T::default()),
Some(s) => serde_json::from_str(s)
.map_err(|e| fail(cadkit_status::InvalidArgument, &e.to_string())),
}
}
fn register_live_buffer(mut bytes: Vec<u8>) -> (*mut u8, usize) {
let len = bytes.len();
if bytes.capacity() == 0 {
bytes.reserve_exact(1);
}
let ptr = bytes.as_mut_ptr();
live_buffers().insert(ptr as usize, bytes);
(ptr, len)
}
unsafe fn binary_getter(
doc: *const cadkit_document,
out: *mut *mut u8,
out_len: *mut usize,
f: impl FnOnce(&Document) -> Result<Vec<u8>, Error>,
) -> cadkit_status {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
if !out_len.is_null() {
*out_len = 0;
}
}
guarded(|| {
if out.is_null() || out_len.is_null() {
return fail(cadkit_status::NullPointer, "binary output pointer is NULL");
}
let d = match unsafe { doc_ref(doc) } {
Ok(d) => d,
Err(s) => return s,
};
match f(d) {
Ok(bytes) => {
let (ptr, len) = register_live_buffer(bytes);
unsafe {
*out = ptr;
*out_len = len;
}
cadkit_status::Ok
}
Err(e) => map_error(&e),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_from_json(
json: *const c_char,
out: *mut *mut cadkit_document,
) -> cadkit_status {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
}
guarded(|| {
if out.is_null() {
return fail(cadkit_status::NullPointer, "out is NULL");
}
let text = match unsafe { opt_str(json, "json") } {
Ok(Some(s)) => s,
Ok(None) => return fail(cadkit_status::NullPointer, "json is NULL"),
Err(s) => return s,
};
match cadkit::export::document_from_json(text, &cadkit::Limits::default()) {
Ok(doc) => {
unsafe {
register(doc, out);
}
cadkit_status::Ok
}
Err(e) => map_error(&e),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_to_dgn(
doc: *const cadkit_document,
seed: *const u8,
seed_len: usize,
options_json_text: *const c_char,
out: *mut *mut u8,
out_len: *mut usize,
) -> cadkit_status {
guarded(|| {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
if !out_len.is_null() {
*out_len = 0;
}
}
if seed.is_null() || seed_len > isize::MAX as usize {
return fail(cadkit_status::InvalidArgument, "invalid DGN seed buffer");
}
let options = match unsafe { options_json::<cadkit::dgn::WriteOptions>(options_json_text) }
{
Ok(o) => o,
Err(s) => return s,
};
let bytes = unsafe { std::slice::from_raw_parts(seed, seed_len) };
unsafe { binary_getter(doc, out, out_len, |d| cadkit::to_dgn(d, bytes, &options)) }
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_dgn_strip_seed(
seed: *const u8,
seed_len: usize,
options_json_text: *const c_char,
options: *const cadkit_options,
out: *mut *mut u8,
out_len: *mut usize,
report_json: *mut *mut c_char,
) -> cadkit_status {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
if !out_len.is_null() {
*out_len = 0;
}
if !report_json.is_null() {
*report_json = std::ptr::null_mut();
}
}
guarded(|| {
if out.is_null() || out_len.is_null() || report_json.is_null() {
return fail(cadkit_status::NullPointer, "output pointer is NULL");
}
if seed.is_null() || seed_len > isize::MAX as usize {
return fail(cadkit_status::InvalidArgument, "invalid DGN seed buffer");
}
let strip =
match unsafe { options_json::<cadkit::dgn::StripSeedOptions>(options_json_text) } {
Ok(o) => o,
Err(s) => return s,
};
let read = match unsafe { convert_options(options) } {
Ok(o) => o,
Err(s) => return s,
};
let bytes = unsafe { std::slice::from_raw_parts(seed, seed_len) };
let stripped = match cadkit::strip_dgn_seed(bytes, &strip, &read) {
Ok(s) => s,
Err(e) => return map_error(&e),
};
let report = match serde_json::to_string(&stripped.report) {
Ok(r) => r,
Err(e) => return fail(cadkit_status::Internal, &e.to_string()),
};
let (ptr, len) = register_live_buffer(stripped.bytes);
unsafe {
*out = ptr;
*out_len = len;
*report_json = into_c_string(report).into_raw();
}
cadkit_status::Ok
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_to_citygml(
doc: *const cadkit_document,
srs_name: *const c_char,
lod: u8,
out: *mut *mut c_char,
) -> cadkit_status {
guarded(|| {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
}
let srs = match unsafe { opt_str(srs_name, "srs_name") } {
Ok(Some(s)) => s.to_owned(),
Ok(None) => return fail(cadkit_status::InvalidArgument, "srs_name is required"),
Err(s) => return s,
};
unsafe {
string_getter(doc, out, |d| {
String::from_utf8(cadkit::to_citygml(
d,
&cadkit::gml::ExportOptions::new(srs, lod)
.with_limits(cadkit::Limits::default()),
)?)
.map_err(|e| Error::invalid(0, e.to_string()))
})
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_to_citygml_with_report(
doc: *const cadkit_document,
srs_name: *const c_char,
lod: u8,
metadata_only: i32,
out: *mut *mut c_char,
) -> cadkit_status {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
}
guarded(|| {
let policy = match metadata_only {
0 => cadkit::gml::UnsupportedGeometry::Reject,
1 => cadkit::gml::UnsupportedGeometry::MetadataOnly,
_ => {
return fail(
cadkit_status::InvalidArgument,
"metadata_only must be 0 or 1",
);
}
};
let srs = match unsafe { opt_str(srs_name, "srs_name") } {
Ok(Some(s)) => s.to_owned(),
Ok(None) => return fail(cadkit_status::InvalidArgument, "srs_name is required"),
Err(s) => return s,
};
unsafe {
string_getter(doc, out, |d| {
let (bytes, report) = cadkit::gml::write_document_with_report(
d,
&cadkit::gml::ExportOptions::new(srs, lod)
.with_limits(cadkit::Limits::default()),
policy,
)?;
let xml = String::from_utf8(bytes).map_err(|e| Error::invalid(0, e.to_string()))?;
serde_json::to_string(&serde_json::json!({"xml": xml, "report": report}))
.map_err(|e| Error::invalid(0, e.to_string()))
})
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_citygml_read_json(
data: *const u8,
len: usize,
options: *const cadkit_options,
out: *mut *mut c_char,
) -> cadkit_status {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
}
guarded(|| {
if data.is_null() || out.is_null() || len > isize::MAX as usize {
return fail(
cadkit_status::InvalidArgument,
"invalid CityGML input/output buffer",
);
}
let opts = match unsafe { convert_options(options) } {
Ok(o) => o,
Err(s) => return s,
};
let bytes = unsafe { std::slice::from_raw_parts(data, len) };
let result = cadkit::gml::read_native(bytes, &opts)
.and_then(|d| serde_json::to_string(&d).map_err(|e| Error::invalid(0, e.to_string())));
match result {
Ok(s) => {
unsafe {
*out = into_c_string(s).into_raw();
}
cadkit_status::Ok
}
Err(e) => map_error(&e),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_citygml_write_json(
json: *const c_char,
validation_options: *const c_char,
out: *mut *mut c_char,
) -> cadkit_status {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
}
guarded(|| {
if out.is_null() {
return fail(cadkit_status::NullPointer, "out is NULL");
}
let text = match unsafe { opt_str(json, "json") } {
Ok(Some(s)) => s,
Ok(None) => return fail(cadkit_status::NullPointer, "json is NULL"),
Err(s) => return s,
};
let options =
match unsafe { options_json::<cadkit::gml::ValidationOptions>(validation_options) } {
Ok(o) => o,
Err(s) => return s,
};
let result = cadkit::gml::read_native_json(
text,
&ReadOptions::default().with_limits(options.limits),
)
.and_then(|doc| cadkit::gml::write(&doc, &options))
.and_then(|bytes| String::from_utf8(bytes).map_err(|e| Error::invalid(0, e.to_string())));
match result {
Ok(s) => {
unsafe {
*out = into_c_string(s).into_raw();
}
cadkit_status::Ok
}
Err(e) => map_error(&e),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_citygml_preflight_tkgm(
json: *const c_char,
profile: *const c_char,
out: *mut *mut c_char,
) -> cadkit_status {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
}
guarded(|| {
if out.is_null() {
return fail(cadkit_status::NullPointer, "out is NULL");
}
let text = match unsafe { opt_str(json, "json") } {
Ok(Some(s)) => s,
Ok(None) => return fail(cadkit_status::NullPointer, "json is NULL"),
Err(s) => return s,
};
let profile = match unsafe { opt_str(profile, "profile") } {
Ok(Some(s)) => match s.parse::<cadkit::gml::tkgm::Profile>() {
Ok(p) => p,
Err(e) => return map_error(&e),
},
Ok(None) => return fail(cadkit_status::NullPointer, "profile is NULL"),
Err(s) => return s,
};
let options = ReadOptions::default();
let result = cadkit::gml::read_native_json(text, &options)
.and_then(|d| cadkit::gml::tkgm::preflight(&d, profile, &options.limits))
.and_then(|report| {
serde_json::to_string(&report).map_err(|e| Error::invalid(0, e.to_string()))
});
match result {
Ok(s) => {
unsafe {
*out = into_c_string(s).into_raw();
}
cadkit_status::Ok
}
Err(e) => map_error(&e),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_inspect_file(
path: *const c_char,
options: *const cadkit_options,
out: *mut *mut c_char,
) -> cadkit_status {
if !out.is_null() {
unsafe { *out = std::ptr::null_mut() };
}
guarded(|| {
if out.is_null() {
return fail(cadkit_status::NullPointer, "out pointer is NULL");
}
let path = match unsafe { opt_str(path, "path") } {
Ok(Some(p)) => p,
Ok(None) => return fail(cadkit_status::NullPointer, "path is NULL"),
Err(s) => return s,
};
let opts = match unsafe { convert_options(options) } {
Ok(o) => o,
Err(s) => return s,
};
let summary = match cadkit::inspect_file_with(path, &opts) {
Ok(s) => s,
Err(e) => return map_error(&e),
};
match serde_json::to_string(&summary) {
Ok(s) => {
unsafe { *out = into_c_string(s).into_raw() };
cadkit_status::Ok
}
Err(e) => fail(cadkit_status::Internal, &e.to_string()),
}
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_inspect_bytes(
data: *const u8,
len: usize,
options: *const cadkit_options,
out: *mut *mut c_char,
) -> cadkit_status {
if !out.is_null() {
unsafe { *out = std::ptr::null_mut() };
}
guarded(|| {
if out.is_null() || (data.is_null() && len != 0) {
return fail(cadkit_status::NullPointer, "invalid data or output pointer");
}
let bytes = if len == 0 {
&[]
} else {
unsafe { std::slice::from_raw_parts(data, len) }
};
let opts = match unsafe { convert_options(options) } {
Ok(o) => o,
Err(s) => return s,
};
let summary = match cadkit::inspect_with(bytes, &opts) {
Ok(s) => s,
Err(e) => return map_error(&e),
};
match serde_json::to_string(&summary) {
Ok(s) => {
unsafe { *out = into_c_string(s).into_raw() };
cadkit_status::Ok
}
Err(e) => fail(cadkit_status::Internal, &e.to_string()),
}
})
}
unsafe fn transformed_document(
doc: *const cadkit_document,
out: *mut *mut cadkit_document,
transform: impl FnOnce(&mut Document) -> Result<(), cadkit_status>,
) -> cadkit_status {
if !out.is_null() {
unsafe { *out = std::ptr::null_mut() };
}
guarded(|| {
if out.is_null() {
return fail(cadkit_status::NullPointer, "out pointer is NULL");
}
let source = match unsafe { doc_ref(doc) } {
Ok(d) => d,
Err(s) => return s,
};
let mut copy = source.clone();
if let Err(status) = transform(&mut copy) {
return status;
}
unsafe { register(copy, out) };
cadkit_status::Ok
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_explode_inserts(
doc: *const cadkit_document,
max_depth: u32,
out: *mut *mut cadkit_document,
) -> cadkit_status {
unsafe {
transformed_document(doc, out, |d| {
if d.explode_inserts(max_depth).truncated {
return Err(fail(
cadkit_status::LimitExceeded,
"block expansion work limit exceeded",
));
}
Ok(())
})
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_convert_units(
doc: *const cadkit_document,
unit: *const c_char,
out: *mut *mut cadkit_document,
) -> cadkit_status {
unsafe {
transformed_document(doc, out, |d| {
let name = opt_str(unit, "unit")?
.ok_or_else(|| fail(cadkit_status::NullPointer, "unit is NULL"))?;
let target = cadkit::LengthUnit::from_name(name)
.ok_or_else(|| fail(cadkit_status::InvalidArgument, "unknown length unit"))?;
d.convert_units(target)
.map(|_| ())
.map_err(|e| map_error(&e))
})
}
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn cadkit_document_to_dxf_bytes(
doc: *const cadkit_document,
version: i32,
codepage: *const c_char,
out: *mut *mut u8,
out_len: *mut usize,
) -> cadkit_status {
unsafe {
if !out.is_null() {
*out = std::ptr::null_mut();
}
if !out_len.is_null() {
*out_len = 0;
}
}
guarded(|| {
let version = match version {
0 => DxfVersion::R12,
1 => DxfVersion::R2000,
2 => DxfVersion::R2004,
3 => DxfVersion::R2007,
4 => DxfVersion::R2010,
5 => DxfVersion::R2013,
6 => DxfVersion::R2018,
_ => return fail(cadkit_status::InvalidArgument, "unknown DXF version"),
};
let codepage = match unsafe { opt_str(codepage, "codepage") } {
Ok(c) => c,
Err(s) => return s,
};
let options =
cadkit::dxf::WriteOptions::new(version).with_codepage(codepage.map(str::to_owned));
unsafe { binary_getter(doc, out, out_len, |d| cadkit::to_dxf_bytes(d, &options)) }
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn empty_buffers_get_distinct_addresses_in_live_buffers() {
let (p1, l1) = register_live_buffer(Vec::new());
let (p2, l2) = register_live_buffer(Vec::new());
assert_eq!((l1, l2), (0, 0));
assert_ne!(p1, p2);
assert!(live_buffers().contains_key(&(p1 as usize)));
assert!(live_buffers().contains_key(&(p2 as usize)));
cadkit_bytes_free(p1);
assert!(!live_buffers().contains_key(&(p1 as usize)));
assert!(live_buffers().contains_key(&(p2 as usize)));
cadkit_bytes_free(p2);
assert!(!live_buffers().contains_key(&(p2 as usize)));
}
}