Внешние компоненты Native API на языке Rust - Просто!

cargo install cargo-expand

cargo expand

   Checking test1c v0.1.0 (/home/aleksandr/rust_pro/test1c)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2021::*;
#[macro_use]
extern crate std;
use std::sync::Arc;
use native_api_1c::{
    native_api_1c_core::ffi::connection::Connection, native_api_1c_macro::AddIn,
};
pub struct Test {
    #[add_in_con]
    connection: Arc<Option<&'static Connection>>,
    #[add_in_func(name = "Test", name_ru = "ОбработатьДанные")]
    #[arg(Str)]
    #[arg(Str)]
    #[returns(Str, result)]
    read_bytes: fn(&Self, String, String) -> Result<String, Box<dyn std::error::Error>>,
}
impl native_api_1c::native_api_1c_core::interface::AddInWrapper for Test {
    fn init(
        &mut self,
        interface: &'static native_api_1c::native_api_1c_core::ffi::connection::Connection,
    ) -> bool {
        self.connection = std::sync::Arc::new(Some(interface));
        true
    }
    fn get_info(&self) -> u16 {
        2000
    }
    fn done(&mut self) {}
    fn register_extension_as(&mut self) -> &[u16] {
        &{
            const ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF8: &str = "Test";
            const ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_LEN: usize = ::utf16_lit::internals::length_as_utf16(
                ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF8,
            ) + 1;
            const ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF16­: [u16; ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_LEN] = {
                let mut buffer = [0u16; ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_LEN];
                let mut bytes = ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF8
                    .as_bytes();
                let mut i = 0;
                while let Some((ch, rest))
                    = ::utf16_lit::internals::next_code_point(bytes) {
                    bytes = rest;
                    if ch & 0xFFFF == ch {
                        buffer[i] = ch as u16;
                        i += 1;
                    } else {
                        let code = ch - 0x1_0000;
                        buffer[i] = 0xD800 | ((code >> 10) as u16);
                        buffer[i + 1] = 0xDC00 | ((code as u16) & 0x3FF);
                        i += 2;
                    }
                }
                buffer
            };
            ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF16­
        }
    }
    fn get_n_props(&self) -> usize {
        0usize
    }
    fn find_prop(&self, name: &[u16]) -> Option<usize> {
        None
    }
    fn get_prop_name(&self, num: usize, alias: usize) -> Option<Vec<u16>> {
        None
    }
    fn get_prop_val(
        &self,
        num: usize,
        val: native_api_1c::native_api_1c_core::ffi::types::ReturnValue,
    ) -> bool {
        false
    }
    fn set_prop_val(
        &mut self,
        num: usize,
        val: &native_api_1c::native_api_1c_core::ffi::types::ParamValue,
    ) -> bool {
        false
    }
    fn is_prop_readable(&self, num: usize) -> bool {
        false
    }
    fn is_prop_writable(&self, num: usize) -> bool {
        false
    }
    fn get_n_methods(&self) -> usize {
        1usize
    }
    fn find_method(&self, name: &[u16]) -> Option<usize> {
        if native_api_1c::native_api_1c_core::ffi::utils::os_string_nil("Test") == name {
            return Some(0usize);
        }
        if native_api_1c::native_api_1c_core::ffi::utils::os_string_nil(
            "ОбработатьДанные",
        ) == name
        {
            return Some(0usize);
        }
        None
    }
    fn get_method_name(&self, num: usize, alias: usize) -> Option<Vec<u16>> {
        if num == 0usize && alias == 0 {
            return Some(
                native_api_1c::native_api_1c_core::ffi::utils::os_string_nil("Test")
                    .into(),
            );
        }
        if num == 0usize {
            return Some(
                native_api_1c::native_api_1c_core::ffi::utils::os_string_nil(
                        "ОбработатьДанные",
                    )
                    .into(),
            );
        }
        None
    }
    fn get_n_params(&self, num: usize) -> usize {
        if num == 0usize {
            return 2usize;
        }
        0
    }
    fn get_param_def_value(
        &self,
        method_num: usize,
        param_num: usize,
        value: native_api_1c::native_api_1c_core::ffi::types::ReturnValue,
    ) -> bool {
        if method_num == 0usize {
            return false;
        }
        false
    }
    fn has_ret_val(&self, method_num: usize) -> bool {
        if method_num == 0usize {
            return true;
        }
        false
    }
    fn call_as_proc(
        &mut self,
        method_num: usize,
        params: &[native_api_1c::native_api_1c_core::ffi::types::ParamValue],
    ) -> bool {
        if method_num == 0usize {
            let Some(param_data) = params.get(0i32 as usize) else {
                return false;
            };
            let native_api_1c::native_api_1c_core::ffi::types::ParamValue::Str(
                param_1,
            ) = param_data else {
                return false;
            };
            let param_1 = native_api_1c::native_api_1c_core::ffi::utils::from_os_string(
                param_1,
            );
            let Some(param_data) = params.get(1i32 as usize) else {
                return false;
            };
            let native_api_1c::native_api_1c_core::ffi::types::ParamValue::Str(
                param_2,
            ) = param_data else {
                return false;
            };
            let param_2 = native_api_1c::native_api_1c_core::ffi::utils::from_os_string(
                param_2,
            );
            let call_result = self
                .read_bytes(param_1.clone().into(), param_2.clone().into());
            let Ok(call_result) = call_result else {
                return false;
            };
            return true;
        }
        false
    }
    fn call_as_func(
        &mut self,
        method_num: usize,
        params: &[native_api_1c::native_api_1c_core::ffi::types::ParamValue],
        val: native_api_1c::native_api_1c_core::ffi::types::ReturnValue,
    ) -> bool {
        if method_num == 0usize {
            let Some(param_data) = params.get(0i32 as usize) else {
                return false;
            };
            let native_api_1c::native_api_1c_core::ffi::types::ParamValue::Str(
                param_1,
            ) = param_data else {
                return false;
            };
            let param_1 = native_api_1c::native_api_1c_core::ffi::utils::from_os_string(
                param_1,
            );
            let Some(param_data) = params.get(1i32 as usize) else {
                return false;
            };
            let native_api_1c::native_api_1c_core::ffi::types::ParamValue::Str(
                param_2,
            ) = param_data else {
                return false;
            };
            let param_2 = native_api_1c::native_api_1c_core::ffi::utils::from_os_string(
                param_2,
            );
            let call_result = self
                .read_bytes(param_1.clone().into(), param_2.clone().into());
            let Ok(call_result) = call_result else {
                return false;
            };
            val.set_str(
                &native_api_1c::native_api_1c_core::ffi::utils::os_string_nil(
                    String::from(&call_result).as_str(),
                ),
            );
            return true;
        }
        false
    }
    fn set_locale(&mut self, loc: &[u16]) {}
    fn set_user_interface_language_code(&mut self, lang: &[u16]) {}
}
pub static mut PLATFORM_CAPABILITIES: std::sync::atomic::AtomicI32 = std::sync::atomic::AtomicI32::new(
    -1,
);
#[allow(non_snake_case)]
#[no_mangle]
pub extern "C" fn GetAttachType() -> native_api_1c::native_api_1c_core::ffi::AttachType {
    native_api_1c::native_api_1c_core::ffi::AttachType::Any
}
#[allow(non_snake_case)]
#[no_mangle]
pub unsafe extern "C" fn DestroyObject(
    component: *mut *mut std::ffi::c_void,
) -> std::ffi::c_long {
    native_api_1c::native_api_1c_core::ffi::destroy_component(component)
}
#[allow(non_snake_case)]
#[no_mangle]
pub unsafe extern "C" fn GetClassObject(
    name: *const u16,
    component: *mut *mut std::ffi::c_void,
) -> std::ffi::c_long {
    match *name as u8 {
        b'1' => {
            let add_in_1 = Test::new();
            native_api_1c::native_api_1c_core::ffi::create_component(component, add_in_1)
        }
        _ => 0,
    }
}
#[allow(non_snake_case)]
#[no_mangle]
pub extern "C" fn GetClassNames() -> *const u16 {
    {
        const ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF8: &str = "1";
        const ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_LEN: usize = ::utf16_lit::internals::length_as_utf16(
            ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF8,
        ) + 1;
        const ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF16­: [u16; ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_LEN] = {
            let mut buffer = [0u16; ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_LEN];
            let mut bytes = ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF8
                .as_bytes();
            let mut i = 0;
            while let Some((ch, rest)) = ::utf16_lit::internals::next_code_point(bytes) {
                bytes = rest;
                if ch & 0xFFFF == ch {
                    buffer[i] = ch as u16;
                    i += 1;
                } else {
                    let code = ch - 0x1_0000;
                    buffer[i] = 0xD800 | ((code >> 10) as u16);
                    buffer[i + 1] = 0xDC00 | ((code as u16) & 0x3FF);
                    i += 2;
                }
            }
            buffer
        };
        ABC678_PREFIX_THAT_SHOULD_NEVER_CLASH_WITH_OUTER_SCOPE_UTF16­
    }
        .as_ptr()
}
impl Test {
    pub fn new() -> Self {
        Self {
            connection: Arc::new(None),
            read_bytes: Self::read_bytes,
        }
    }
    pub fn read_bytes(
        &self,
        imya: String,
        telefon: String,
    ) -> Result<String, Box<dyn std::error::Error>> {
        let f = imya + &telefon;
        Ok(f)
    }
}