aes_externalobj 0.1.2

ExtendScript external object library implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


use crate::bindings;
use aes_types::TaggedData;
use libc::{c_char, c_long};

// Public type aliases with better names
pub type ESGetVersionFn = extern "C" fn () -> c_long;
pub type ESInitializeFn = extern "C" fn (data: *mut ExtendScriptData, count: c_long) -> *mut c_char;
pub type ESTerminateFn = extern "C" fn ();

// Wrapper around TaggedData for safer interface
#[repr(transparent)]
#[derive(Debug)]
pub struct ExtendScriptData(TaggedData);

impl ExtendScriptData {
    pub fn new_undefined() -> Self {
        Self(bindings::TaggedData::new_undefined())
    }

    pub fn new_string(s: &str) -> Self {
        Self(bindings::TaggedData::new_string(s))
    }

    pub fn new_integer(val: i32) -> Self {
        Self(bindings::TaggedData::new_integer(val))
    }

    pub fn new_bool(val: bool) -> Self {
        Self(bindings::TaggedData::new_bool(val))
    }

    // Add other conversion methods as needed
}

// Internal conversion traits
impl From<bindings::TaggedData> for ExtendScriptData {
    fn from(data: bindings::TaggedData) -> Self {
        Self(data)
    }
}

impl From<ExtendScriptData> for bindings::TaggedData {
    fn from(data: ExtendScriptData) -> Self {
        data.0
    }
}

// Internal helper functions
pub(crate) fn to_raw_tagged_data(data: &ExtendScriptData) -> *mut bindings::TaggedData {
    &data.0 as *const _ as *mut _
}

pub(crate) fn from_raw_tagged_data(ptr: *mut bindings::TaggedData) -> Option<&'static ExtendScriptData> {
    if ptr.is_null() {
        None
    } else {
        unsafe {
            Some(&*(ptr as *const ExtendScriptData))
        }
    }
}

#[derive(Debug)]
pub enum Error {
    InitializationFailed,
    InvalidArguments,
    ExecutionFailed,
    // Add other error types
}

pub type Result<T> = std::result::Result<T, Error>;