diff --git a/.cargo/config.toml b/.cargo/config.toml new file mode 100644 index 0000000..855a7a9 --- /dev/null +++ b/.cargo/config.toml @@ -0,0 +1,2 @@ +[registries.cbsk] +index = "https://git.cbsk-tech.de/api/packages/Christoph/cargo/index" \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index 11a1c39..9abba97 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,31 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "libloading" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + [[package]] name = "xMVMOpenApiWrapper" version = "0.1.0" +dependencies = [ + "libloading", +] diff --git a/Cargo.toml b/Cargo.toml index 204c8d1..74caeeb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,8 @@ [package] name = "xMVMOpenApiWrapper" version = "0.1.0" -edition = "2024" +edition = "2021" +publish = ["cbsk"] [dependencies] +libloading = "0.9.0" \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index b93cf3f..88c2f51 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,14 +1,1134 @@ -pub fn add(left: u64, right: u64) -> u64 { - left + right +#![allow(non_snake_case)] +use libloading::{Library, Symbol}; +use std::path::Path; + +/// Pointer to a UTF-16 string (wide char) terminated with `0`. +pub type PCWSTR = *const u16; +/// Mutable pointer to a UTF-16 buffer. +pub type PWSTR = *mut u16; +/// Pointer to an array of UTF-16 string pointers. +pub type PPWSTR = *mut PWSTR; +/// 32-bit boolean, mirrors the Win32 `BOOL` layout used by the C API. +pub type Bool32 = i32; + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenReturnCodes { + Ok = 0, + // --------- Application control and Connection --------- + ErrorInternal = -1001, + ErrorVcNotFound = -1002, + ErrorCreateProcess = -1003, + ErrorAlreadyRunning = -1004, + ErrorCloseFailed = -1005, + ErrorInstanceNotFound = -1006, + ErrorInstanceBusy = -1007, + ErrorNoConnection = -1008, + ErrorVcNotReady = -1009, + ErrorInvalidParameter = -1010, + ErrorNoLicenseDeprecated = -1011, + ErrorConnectionClosed = -1012, + ErrorS7DosSimulationActive = -1013, + ErrorVersionIncompatible = -1014, + ErrorNotSupportedByBackend = -1015, + WarningWindowEmbedding = 1002, + WarningVersionClientOld = 1003, + WarningVersionMiddlewareOld = 1004, + WarningConnectionCorrupted = 1005, + // --------- File handling (VCPs, startprofiles, etc.) --------- + ErrorFileNotFound = -2001, + ErrorProjectOpen = -2002, + ErrorLoadFailed = -2003, + ErrorNoProjectOpen = -2004, + ErrorWriteProtected = -2005, + ErrorSimRunning = -2006, + ErrorWriteFailed = -2007, + ErrorVcpCloseFailed = -2008, + ErrorInvalidFile = -2009, + ErrorCncSwUnavailable = -2010, + ErrorFileCreationFailed = -2011, + ErrorFrontendNotInstalled = -2012, + ErrorFrontendNotLicensedDeprecated = -2013, + ErrorFilePathTooLong = -2014, + ErrorInvalidNckscaling = -2015, + ErrorInvalidNcunumber = -2016, + // --------- Simulation Control --------- + ErrorStartSimFailed = -3001, + ErrorStopSimFailed = -3002, + ErrorResetSimFailed = -3004, + ErrorSimSpeedInvalid = -3005, + ErrorSimNotAvailable = -3006, + ErrorSimNotRunning = -3007, + SimRunning = 3001, + SimNotRunning = 3002, + // --------- Synchronized Operation --------- + ErrorEventUnknown = -4001, + ErrorNoEventsRegistered = -4002, + ErrorSimInterrupted = -4003, + // --------- Data Access --------- + ErrorUnknownElement = -5001, + ErrorInvalidDictId = -5002, + ErrorInsufficientMemory = -5003, + ErrorNoarray = -5004, + ErrorWrongType = -5005, + ErrorInsufficientRights = -5006, + ErrorNotInWait = -5007, + NoMoreData = 5001, + // --------- File Operations --------- + ErrorFileOpInvalidDomain = -6001, + ErrorFileOpSourcePathNotAbsolute = -6002, + ErrorFileOpSourceFileNotExists = -6003, + ErrorFileOpDestinationPathNotAbsolute = -6004, + ErrorFileOpDestinationAlreadyExists = -6005, + ErrorFileOpDestinationDirectoryNotExists = -6006, + ErrorFileOpDirectoryNotExists = -6007, + ErrorFileOpDirectoryNotEmpty = -6008, + ErrorFileSelectNotPossible = -6009, + ErrorChannelNotExists = -6010, + ErrorFileUsed = -6011, + // --------- License handling --------- + ErrorLicenseNoLicense = -7001, + ErrorLicenseUnknownApplication = -7002, + ErrorLicenseUnknownFrontend = -7003, + ErrorLicenseNoConnection = -7004, + ErrorLicenseNoLicenseHandler = -7005, + ErrorLicenseErrorAtServerSite = -7006, + ErrorLicenseOptionalLicenseKeyNotAvailable = -7007, + ErrorLicenseOptionalLicenseKeyNotGranted = -7008, + ErrorLicenseOptionalLicenseNotAqcuired = -7009, + ErrorLicenseOptionalLicenseCheckFailed = -7010, + ErrorLicenseKeyNotAvailable = -7011, + ErrorLicenseKeyGrantFailed = -7012, + ErrorLicenseKeyReleaseFailed = -7013, + ErrorLicenseInvalid = -7014, + ErrorLicenseAlreadyInUse = -7015, + ErrorLicenseCheckFailed = -7016, + ErrorLicenseAllLicensesInUse = -7017, + ErrorLicenseUnknownLicense = -7018, } -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn it_works() { - let result = add(2, 2); - assert_eq!(result, 4); +impl OpenReturnCodes { + /// Convenience helper that mirrors the old `Ok` check in the C# wrapper. + pub fn is_ok(self) -> bool { + matches!(self, OpenReturnCodes::Ok) + } +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenDictionaryElementType { + Bool = 1, + Integer8Bit = 2, + UInteger8Bit = 3, + Integer16Bit = 4, + UInteger16Bit = 5, + Integer32Bit = 6, + UInteger32Bit = 7, + Integer64Bit = 8, + UInteger64Bit = 9, + Double = 10, + String = 11, + IntegerArray32Bit = 12, + UIntegerArray64Bit = 13, + BoolArray = 14, + DoubleArray = 15, + StringArray = 16, + UIntegerArray32Bit = 17, + UIntegerArray16Bit = 18, + UIntegerArray8Bit = 19, +} + +#[repr(u64)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenEventMaskDefinition { + Unknown = 0x0000000000000000, + NckFirstIpo = 0x0000000000000008, + NckBootReady = 0x0000000000000004, + NckIpo = 0x0000000000000001, + NckChannelNewMotion = 0x0000000000000100, + NckChannelNewBlock = 0x0000000000000200, + NckChannelConfigChanged = 0x0000000000000400, + NckChannelStartPositioningMotion = 0x0000000000000800, + NckChannelEndPositioningMotion = 0x0000000000001000, + NckChannelLengthSlicePath = 0x0000000000001001, + NckChannelLengthSlicePositioning = 0x0000000000001002, + NckChannelAngleSlicePositioning = 0x0000000000001003, + NckChannelAngleSliceOrientation = 0x0000000000001004, + NckChannelStateChanged = 0x0000000000001005, + NckChannelProgramFinished = 0x0000000000001006, + PlcOb1 = 0x0000000000010000, + PlcHwConfigChanged = 0x0000000000020000, + PlcAcyclicCommunication = 0x0000000000040000, + ContentChanged = 0x0001000000000000, + ResetStarted = 0x0002000000000000, + ResetFinished = 0x0004000000000000, +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenAxisMode { + None = 0, + Interpolation = 1, + Positioning = 2, + SpeedLeft = 3, + SpeedRight = 4, + SpeedStop = 5, + Following = 6, +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenAxisReferenceState { + None = 0, + NotReferenced = 1, + Referenced = 2, + ReferenceNotRequired = 3, +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenMotionType { + None = 0, + Rapid = 1, + Linear = 2, + Circle = 3, + Spline = 4, + Thread = 5, + Involute = 6, +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenCircleDirection { + None = 0, + Cw = 1, + Ccw = 2, +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenOperatingMode { + None = 0, + Auto = 1, + Jog = 2, + Mda = 3, +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenChannelState { + None = 0, + Activated = 1, + Stopped = 2, + Reseted = 3, +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenAxisType { + None = 0, + Linear = 1, + Rotatory = 2, + Modulo = 3, + Spindle = 4, +} + +#[repr(i32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq)] +pub enum OpenProjectStates { + Closed = 1, + Opening = 2, + Open = 3, + Booting = 4, + RunningOrPaused = 5, + ShuttingDown = 6, + Closing = 7, + Resetting = 8, + Saving = 9, + Error = 10, +} + +// Helper type aliases for function signatures +type StartApplicationFn = unsafe extern "C" fn(PCWSTR) -> OpenReturnCodes; +type StopApplicationFn = unsafe extern "C" fn() -> OpenReturnCodes; +type ConnectFn = unsafe extern "C" fn() -> OpenReturnCodes; +type DisconnectFn = unsafe extern "C" fn() -> OpenReturnCodes; +type OpenProjectFn = unsafe extern "C" fn(PCWSTR) -> OpenReturnCodes; +type CreateProjectFn = unsafe extern "C" fn(PCWSTR, PCWSTR) -> OpenReturnCodes; +type CreateProjectWithScalingFn = unsafe extern "C" fn(PCWSTR, PCWSTR, PCWSTR) -> OpenReturnCodes; +type CreateProjectWithScalingNcuNumberFn = + unsafe extern "C" fn(PCWSTR, PCWSTR, PCWSTR, u32) -> OpenReturnCodes; +type SaveProjectFn = unsafe extern "C" fn() -> OpenReturnCodes; +type CloseProjectFn = unsafe extern "C" fn() -> OpenReturnCodes; +type BootControllerFn = unsafe extern "C" fn() -> OpenReturnCodes; +type ShutdownControllerFn = unsafe extern "C" fn() -> OpenReturnCodes; +type ResetControllerFn = unsafe extern "C" fn() -> OpenReturnCodes; +type RegisterForEventsFn = + unsafe extern "C" fn(u32, *const OpenEventMaskDefinition) -> OpenReturnCodes; +type UnregisterEventsFn = unsafe extern "C" fn() -> OpenReturnCodes; +type WaitForEventsFn = unsafe extern "C" fn() -> OpenReturnCodes; +type ContinueSimulationFn = unsafe extern "C" fn() -> OpenReturnCodes; +type GetDictionaryIdFn = unsafe extern "C" fn(PCWSTR, *mut u32) -> OpenReturnCodes; +type RegisterWatchFn = unsafe extern "C" fn(u32, *const u32) -> OpenReturnCodes; +type UnregisterWatchFn = unsafe extern "C" fn() -> OpenReturnCodes; +type GetDictionaryElementTypeFn = unsafe extern "C" fn(u32, *mut u8) -> OpenReturnCodes; +type ReadUnsignedInteger64BitArrayFn = unsafe extern "C" fn(u32, u32, *mut u64) -> OpenReturnCodes; +type ReadSignedInteger32BitArrayFn = unsafe extern "C" fn(u32, u32, *mut i32) -> OpenReturnCodes; +type ReadUnsignedInteger32BitArrayFn = unsafe extern "C" fn(u32, u32, *mut u32) -> OpenReturnCodes; +type ReadUnsignedInteger16BitArrayFn = unsafe extern "C" fn(u32, u32, *mut u16) -> OpenReturnCodes; +type ReadUnsignedInteger8BitArrayFn = unsafe extern "C" fn(u32, u32, *mut u8) -> OpenReturnCodes; +type ReadBoolArrayFn = unsafe extern "C" fn(u32, u32, *mut bool) -> OpenReturnCodes; +type ReadDoubleArrayFn = unsafe extern "C" fn(u32, u32, *mut f64) -> OpenReturnCodes; +type ReadStringFn = unsafe extern "C" fn(u32, u32, PWSTR) -> OpenReturnCodes; +type ReadStringArrayFn = unsafe extern "C" fn(u32, u32, u32, PPWSTR) -> OpenReturnCodes; +type ReadUnsignedInteger16BitFn = unsafe extern "C" fn(u32, *mut u16) -> OpenReturnCodes; +type ReadSignedInteger16BitFn = unsafe extern "C" fn(u32, *mut i16) -> OpenReturnCodes; +type ReadUnsignedInteger32BitFn = unsafe extern "C" fn(u32, *mut u32) -> OpenReturnCodes; +type ReadSignedInteger32BitFn = unsafe extern "C" fn(u32, *mut i32) -> OpenReturnCodes; +type ReadUnsignedInteger64BitFn = unsafe extern "C" fn(u32, *mut u64) -> OpenReturnCodes; +type ReadSignedInteger64BitFn = unsafe extern "C" fn(u32, *mut i64) -> OpenReturnCodes; +type GetNumArrayElementsFn = unsafe extern "C" fn(u32, *mut u32) -> OpenReturnCodes; +type ReadBitFn = unsafe extern "C" fn(u32, *mut Bool32) -> OpenReturnCodes; +type ReadBoolFn = unsafe extern "C" fn(u32, *mut Bool32) -> OpenReturnCodes; +type ReadByteFn = unsafe extern "C" fn(u32, *mut u8) -> OpenReturnCodes; +type ReadDoubleFn = unsafe extern "C" fn(u32, *mut f64) -> OpenReturnCodes; +type ReadWordFn = unsafe extern "C" fn(u32, *mut u16) -> OpenReturnCodes; +type ReadDoubleWordFn = unsafe extern "C" fn(u32, *mut u32) -> OpenReturnCodes; +type ReadLongWordFn = unsafe extern "C" fn(u32, *mut u64) -> OpenReturnCodes; +type ReadNextEventFn = unsafe extern "C" fn(*mut u64) -> OpenReturnCodes; +type ReadNextEventWithNcuIndexFn = unsafe extern "C" fn(*mut u64, *mut i32) -> OpenReturnCodes; +type WriteBitFn = unsafe extern "C" fn(u32, Bool32) -> OpenReturnCodes; +type WriteBoolFn = unsafe extern "C" fn(u32, Bool32) -> OpenReturnCodes; +type WriteByteFn = unsafe extern "C" fn(u32, u8) -> OpenReturnCodes; +type WriteDoubleFn = unsafe extern "C" fn(u32, f64) -> OpenReturnCodes; +type WriteWordFn = unsafe extern "C" fn(u32, u16) -> OpenReturnCodes; +type WriteDoubleWordFn = unsafe extern "C" fn(u32, u32) -> OpenReturnCodes; +type WriteLongWordFn = unsafe extern "C" fn(u32, u64) -> OpenReturnCodes; +type WriteBoolArrayFn = unsafe extern "C" fn(u32, u32, *const bool) -> OpenReturnCodes; +type GetSimulationSpeedFn = unsafe extern "C" fn(*mut u32) -> OpenReturnCodes; +type SetSimulationSpeedFn = unsafe extern "C" fn(u32) -> OpenReturnCodes; +type GetCardPathFn = unsafe extern "C" fn(u32, PWSTR) -> OpenReturnCodes; +type GetCardPathsFn = unsafe extern "C" fn(u32, u32, PPWSTR) -> OpenReturnCodes; +type GetFileFn = unsafe extern "C" fn(PCWSTR, PCWSTR) -> OpenReturnCodes; +type PutFileFn = unsafe extern "C" fn(PCWSTR, PCWSTR) -> OpenReturnCodes; +type SelectFileFn = unsafe extern "C" fn(PCWSTR, PCWSTR) -> OpenReturnCodes; +type DeleteFileFn = unsafe extern "C" fn(PCWSTR) -> OpenReturnCodes; +type DeleteDirectoryFn = unsafe extern "C" fn(PCWSTR) -> OpenReturnCodes; +type CreateDirectoryFn = unsafe extern "C" fn(PCWSTR) -> OpenReturnCodes; +type ListDirectoryFn = unsafe extern "C" fn(PCWSTR, PCWSTR) -> OpenReturnCodes; +type GetVersionInformationFn = unsafe extern "C" fn(PCWSTR) -> OpenReturnCodes; +type GetProjectInformationFn = unsafe extern "C" fn(PCWSTR, PCWSTR) -> OpenReturnCodes; +type GetCurrentProjectInformationFn = unsafe extern "C" fn(PCWSTR) -> OpenReturnCodes; +type GetCurrentProjectStateFn = unsafe extern "C" fn(*mut OpenProjectStates) -> OpenReturnCodes; +type ImportProjectSettingsFn = unsafe extern "C" fn(PCWSTR, PCWSTR) -> OpenReturnCodes; +type ExportProjectSettingsFn = unsafe extern "C" fn(PCWSTR) -> OpenReturnCodes; +type WriteUnsignedInteger8BitArrayFn = unsafe extern "C" fn(u32, u32, *const u8) -> OpenReturnCodes; +type GetNumberOfNcusFn = unsafe extern "C" fn(*mut u32) -> OpenReturnCodes; + +fn load_symbol(lib: &'static Library, name: &[u8]) -> Result { + unsafe { + let symbol: Symbol = lib.get(name)?; + Ok(*symbol) + } +} + +pub struct OpenApi { + _lib: &'static Library, // keep leaked library alive so function pointers remain valid + start_application: StartApplicationFn, + stop_application: StopApplicationFn, + connect: ConnectFn, + disconnect: DisconnectFn, + open_project: OpenProjectFn, + create_project: CreateProjectFn, + create_project_with_scaling: CreateProjectWithScalingFn, + create_project_with_scaling_ncu_number: CreateProjectWithScalingNcuNumberFn, + save_project: SaveProjectFn, + close_project: CloseProjectFn, + boot_controller: BootControllerFn, + shutdown_controller: ShutdownControllerFn, + reset_controller: ResetControllerFn, + register_for_events: RegisterForEventsFn, + unregister_events: UnregisterEventsFn, + wait_for_events: WaitForEventsFn, + continue_simulation: ContinueSimulationFn, + get_dictionary_id: GetDictionaryIdFn, + register_watch: RegisterWatchFn, + unregister_watch: UnregisterWatchFn, + get_dictionary_element_type: GetDictionaryElementTypeFn, + read_unsigned_integer_64_bit_array: ReadUnsignedInteger64BitArrayFn, + read_signed_integer_32_bit_array: ReadSignedInteger32BitArrayFn, + read_unsigned_integer_32_bit_array: ReadUnsignedInteger32BitArrayFn, + read_unsigned_integer_16_bit_array: ReadUnsignedInteger16BitArrayFn, + read_unsigned_integer_8_bit_array: ReadUnsignedInteger8BitArrayFn, + read_bool_array: ReadBoolArrayFn, + read_double_array: ReadDoubleArrayFn, + read_string: ReadStringFn, + read_string_array: ReadStringArrayFn, + read_unsigned_integer_16_bit: ReadUnsignedInteger16BitFn, + read_signed_integer_16_bit: ReadSignedInteger16BitFn, + read_unsigned_integer_32_bit: ReadUnsignedInteger32BitFn, + read_signed_integer_32_bit: ReadSignedInteger32BitFn, + read_unsigned_integer_64_bit: ReadUnsignedInteger64BitFn, + read_signed_integer_64_bit: ReadSignedInteger64BitFn, + get_num_array_elements: GetNumArrayElementsFn, + read_bit: ReadBitFn, + read_bool: ReadBoolFn, + read_byte: ReadByteFn, + read_double: ReadDoubleFn, + read_word: ReadWordFn, + read_double_word: ReadDoubleWordFn, + read_long_word: ReadLongWordFn, + read_next_event: ReadNextEventFn, + read_next_event_with_ncu_index: ReadNextEventWithNcuIndexFn, + write_bit: WriteBitFn, + write_bool: WriteBoolFn, + write_byte: WriteByteFn, + write_double: WriteDoubleFn, + write_word: WriteWordFn, + write_double_word: WriteDoubleWordFn, + write_long_word: WriteLongWordFn, + write_bool_array: WriteBoolArrayFn, + get_simulation_speed: GetSimulationSpeedFn, + set_simulation_speed: SetSimulationSpeedFn, + get_card_path: GetCardPathFn, + get_card_paths: GetCardPathsFn, + get_file: GetFileFn, + put_file: PutFileFn, + select_file: SelectFileFn, + delete_file: DeleteFileFn, + delete_directory: DeleteDirectoryFn, + create_directory: CreateDirectoryFn, + list_directory: ListDirectoryFn, + get_version_information: GetVersionInformationFn, + get_project_information: GetProjectInformationFn, + get_current_project_information: GetCurrentProjectInformationFn, + get_current_project_state: GetCurrentProjectStateFn, + import_project_settings: ImportProjectSettingsFn, + export_project_settings: ExportProjectSettingsFn, + write_unsigned_integer_8_bit_array: WriteUnsignedInteger8BitArrayFn, + get_number_of_ncus: GetNumberOfNcusFn, +} + +impl OpenApi { + /// Load DLL from a path, binding required symbols. + pub unsafe fn load>(path: P) -> Result { + // Load the DLL + let lib = Library::new(path.as_ref())?; + // Extend the library's lifetime to 'static by leaking it. + // (Alternatively: design OpenApi with lifetimes and avoid leaking.) + let lib: &'static Library = Box::leak(Box::new(lib)); + + let start_application = load_symbol::(lib, b"startApplication")?; + let stop_application = load_symbol::(lib, b"stopApplication")?; + let connect = load_symbol::(lib, b"connect")?; + let disconnect = load_symbol::(lib, b"disconnect")?; + let open_project = load_symbol::(lib, b"openProject")?; + let create_project = load_symbol::(lib, b"createProject")?; + let create_project_with_scaling = + load_symbol::(lib, b"createProjectWithScaling")?; + let create_project_with_scaling_ncu_number = load_symbol::< + CreateProjectWithScalingNcuNumberFn, + >( + lib, b"createProjectWithScalingNCUNumber" + )?; + let save_project = load_symbol::(lib, b"saveProject")?; + let close_project = load_symbol::(lib, b"closeProject")?; + let boot_controller = load_symbol::(lib, b"bootController")?; + let shutdown_controller = load_symbol::(lib, b"shutdownController")?; + let reset_controller = load_symbol::(lib, b"resetController")?; + let register_for_events = load_symbol::(lib, b"registerForEvents")?; + let unregister_events = load_symbol::(lib, b"unregisterEvents")?; + let wait_for_events = load_symbol::(lib, b"waitForEvents")?; + let continue_simulation = load_symbol::(lib, b"continueSimulation")?; + let get_dictionary_id = load_symbol::(lib, b"getDictionaryId")?; + let register_watch = load_symbol::(lib, b"registerWatch")?; + let unregister_watch = load_symbol::(lib, b"unregisterWatch")?; + let get_dictionary_element_type = + load_symbol::(lib, b"getDictionaryElementType")?; + let read_unsigned_integer_64_bit_array = + load_symbol::(lib, b"readUnsignedInteger64BitArray")?; + let read_signed_integer_32_bit_array = + load_symbol::(lib, b"readSignedInteger32BitArray")?; + let read_unsigned_integer_32_bit_array = + load_symbol::(lib, b"readUnsignedInteger32BitArray")?; + let read_unsigned_integer_16_bit_array = + load_symbol::(lib, b"readUnsignedInteger16BitArray")?; + let read_unsigned_integer_8_bit_array = + load_symbol::(lib, b"readUnsignedInteger8BitArray")?; + let read_bool_array = load_symbol::(lib, b"readBoolArray")?; + let read_double_array = load_symbol::(lib, b"readDoubleArray")?; + let read_string = load_symbol::(lib, b"readString")?; + let read_string_array = load_symbol::(lib, b"readStringArray")?; + let read_unsigned_integer_16_bit = + load_symbol::(lib, b"readUnsignedInteger16Bit")?; + let read_signed_integer_16_bit = + load_symbol::(lib, b"readSignedInteger16Bit")?; + let read_unsigned_integer_32_bit = + load_symbol::(lib, b"readUnsignedInteger32Bit")?; + let read_signed_integer_32_bit = + load_symbol::(lib, b"readSignedInteger32Bit")?; + let read_unsigned_integer_64_bit = + load_symbol::(lib, b"readUnsignedInteger64Bit")?; + let read_signed_integer_64_bit = + load_symbol::(lib, b"readSignedInteger64Bit")?; + let get_num_array_elements = + load_symbol::(lib, b"getNumArrayElements")?; + let read_bit = load_symbol::(lib, b"readBit")?; + let read_bool = load_symbol::(lib, b"readBool")?; + let read_byte = load_symbol::(lib, b"readByte")?; + let read_double = load_symbol::(lib, b"readDouble")?; + let read_word = load_symbol::(lib, b"readWord")?; + let read_double_word = load_symbol::(lib, b"readDoubleWord")?; + let read_long_word = load_symbol::(lib, b"readLongWord")?; + let read_next_event = load_symbol::(lib, b"readNextEvent")?; + let read_next_event_with_ncu_index = + load_symbol::(lib, b"readNextEventWithNcuIndex")?; + let write_bit = load_symbol::(lib, b"writeBit")?; + let write_bool = load_symbol::(lib, b"writeBool")?; + let write_byte = load_symbol::(lib, b"writeByte")?; + let write_double = load_symbol::(lib, b"writeDouble")?; + let write_word = load_symbol::(lib, b"writeWord")?; + let write_double_word = load_symbol::(lib, b"writeDoubleWord")?; + let write_long_word = load_symbol::(lib, b"writeLongWord")?; + let write_bool_array = load_symbol::(lib, b"writeBoolArray")?; + let get_simulation_speed = load_symbol::(lib, b"getSimulationSpeed")?; + let set_simulation_speed = load_symbol::(lib, b"setSimulationSpeed")?; + let get_card_path = load_symbol::(lib, b"getCardPath")?; + let get_card_paths = load_symbol::(lib, b"getCardPaths")?; + let get_file = load_symbol::(lib, b"getFile")?; + let put_file = load_symbol::(lib, b"putFile")?; + let select_file = load_symbol::(lib, b"selectFile")?; + let delete_file = load_symbol::(lib, b"deleteFile")?; + let delete_directory = load_symbol::(lib, b"deleteDirectory")?; + let create_directory = load_symbol::(lib, b"createDirectory")?; + let list_directory = load_symbol::(lib, b"listDirectory")?; + let get_version_information = + load_symbol::(lib, b"getVersionInformation")?; + let get_project_information = + load_symbol::(lib, b"getProjectInformation")?; + let get_current_project_information = + load_symbol::(lib, b"getCurrentProjectInformation")?; + let get_current_project_state = + load_symbol::(lib, b"getCurrentProjectState")?; + let import_project_settings = + load_symbol::(lib, b"importProjectSettings")?; + let export_project_settings = + load_symbol::(lib, b"exportProjectSettings")?; + let write_unsigned_integer_8_bit_array = + load_symbol::(lib, b"writeUnsignedInteger8BitArray")?; + let get_number_of_ncus = load_symbol::(lib, b"getNumberOfNCUs")?; + + Ok(Self { + _lib: lib, + start_application, + stop_application, + connect, + disconnect, + open_project, + create_project, + create_project_with_scaling, + create_project_with_scaling_ncu_number, + save_project, + close_project, + boot_controller, + shutdown_controller, + reset_controller, + register_for_events, + unregister_events, + wait_for_events, + continue_simulation, + get_dictionary_id, + register_watch, + unregister_watch, + get_dictionary_element_type, + read_unsigned_integer_64_bit_array, + read_signed_integer_32_bit_array, + read_unsigned_integer_32_bit_array, + read_unsigned_integer_16_bit_array, + read_unsigned_integer_8_bit_array, + read_bool_array, + read_double_array, + read_string, + read_string_array, + read_unsigned_integer_16_bit, + read_signed_integer_16_bit, + read_unsigned_integer_32_bit, + read_signed_integer_32_bit, + read_unsigned_integer_64_bit, + read_signed_integer_64_bit, + get_num_array_elements, + read_bit, + read_bool, + read_byte, + read_double, + read_word, + read_double_word, + read_long_word, + read_next_event, + read_next_event_with_ncu_index, + write_bit, + write_bool, + write_byte, + write_double, + write_word, + write_double_word, + write_long_word, + write_bool_array, + get_simulation_speed, + set_simulation_speed, + get_card_path, + get_card_paths, + get_file, + put_file, + select_file, + delete_file, + delete_directory, + create_directory, + list_directory, + get_version_information, + get_project_information, + get_current_project_information, + get_current_project_state, + import_project_settings, + export_project_settings, + write_unsigned_integer_8_bit_array, + get_number_of_ncus, + }) + } + #[inline] + pub unsafe fn start_application(&self, str_profile_file_name: PCWSTR) -> OpenReturnCodes { + (self.start_application)(str_profile_file_name) + } + + #[inline] + pub unsafe fn stop_application(&self) -> OpenReturnCodes { + (self.stop_application)() + } + + #[inline] + pub unsafe fn connect(&self) -> OpenReturnCodes { + (self.connect)() + } + + #[inline] + pub unsafe fn disconnect(&self) -> OpenReturnCodes { + (self.disconnect)() + } + + #[inline] + pub unsafe fn open_project(&self, str_file_name: PCWSTR) -> OpenReturnCodes { + (self.open_project)(str_file_name) + } + + #[inline] + pub unsafe fn create_project( + &self, + str_file_name: PCWSTR, + str_version: PCWSTR, + ) -> OpenReturnCodes { + (self.create_project)(str_file_name, str_version) + } + + #[inline] + pub unsafe fn create_project_with_scaling( + &self, + str_file_name: PCWSTR, + str_version: PCWSTR, + str_nck_scaling: PCWSTR, + ) -> OpenReturnCodes { + (self.create_project_with_scaling)(str_file_name, str_version, str_nck_scaling) + } + + #[inline] + pub unsafe fn create_project_with_scaling_ncu_number( + &self, + str_file_name: PCWSTR, + str_version: PCWSTR, + str_nck_scaling: PCWSTR, + ncu_number: u32, + ) -> OpenReturnCodes { + (self.create_project_with_scaling_ncu_number)( + str_file_name, + str_version, + str_nck_scaling, + ncu_number, + ) + } + + #[inline] + pub unsafe fn save_project(&self) -> OpenReturnCodes { + (self.save_project)() + } + + #[inline] + pub unsafe fn close_project(&self) -> OpenReturnCodes { + (self.close_project)() + } + + #[inline] + pub unsafe fn boot_controller(&self) -> OpenReturnCodes { + (self.boot_controller)() + } + + #[inline] + pub unsafe fn shutdown_controller(&self) -> OpenReturnCodes { + (self.shutdown_controller)() + } + + #[inline] + pub unsafe fn reset_controller(&self) -> OpenReturnCodes { + (self.reset_controller)() + } + + #[inline] + pub unsafe fn register_for_events( + &self, + event_list_length: u32, + event_list: *const OpenEventMaskDefinition, + ) -> OpenReturnCodes { + (self.register_for_events)(event_list_length, event_list) + } + + #[inline] + pub unsafe fn unregister_events(&self) -> OpenReturnCodes { + (self.unregister_events)() + } + + #[inline] + pub unsafe fn wait_for_events(&self) -> OpenReturnCodes { + (self.wait_for_events)() + } + + #[inline] + pub unsafe fn continue_simulation(&self) -> OpenReturnCodes { + (self.continue_simulation)() + } + + #[inline] + pub unsafe fn get_dictionary_id( + &self, + dictionary_element: PCWSTR, + dictionary_id: *mut u32, + ) -> OpenReturnCodes { + (self.get_dictionary_id)(dictionary_element, dictionary_id) + } + + #[inline] + pub unsafe fn register_watch( + &self, + watch_list_length: u32, + dictionary_id_list: *const u32, + ) -> OpenReturnCodes { + (self.register_watch)(watch_list_length, dictionary_id_list) + } + + #[inline] + pub unsafe fn unregister_watch(&self) -> OpenReturnCodes { + (self.unregister_watch)() + } + + #[inline] + pub unsafe fn get_dictionary_element_type( + &self, + dictionary_id: u32, + value: *mut u8, + ) -> OpenReturnCodes { + (self.get_dictionary_element_type)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_unsigned_integer_64_bit_array( + &self, + dictionary_id: u32, + value_list_max_length: u32, + value_list: *mut u64, + ) -> OpenReturnCodes { + (self.read_unsigned_integer_64_bit_array)(dictionary_id, value_list_max_length, value_list) + } + + #[inline] + pub unsafe fn read_signed_integer_32_bit_array( + &self, + dictionary_id: u32, + value_list_max_length: u32, + value_list: *mut i32, + ) -> OpenReturnCodes { + (self.read_signed_integer_32_bit_array)(dictionary_id, value_list_max_length, value_list) + } + + #[inline] + pub unsafe fn read_unsigned_integer_32_bit_array( + &self, + dictionary_id: u32, + value_list_max_length: u32, + value_list: *mut u32, + ) -> OpenReturnCodes { + (self.read_unsigned_integer_32_bit_array)(dictionary_id, value_list_max_length, value_list) + } + + #[inline] + pub unsafe fn read_unsigned_integer_16_bit_array( + &self, + dictionary_id: u32, + value_list_max_length: u32, + value_list: *mut u16, + ) -> OpenReturnCodes { + (self.read_unsigned_integer_16_bit_array)(dictionary_id, value_list_max_length, value_list) + } + + #[inline] + pub unsafe fn read_unsigned_integer_8_bit_array( + &self, + dictionary_id: u32, + value_list_max_length: u32, + value_list: *mut u8, + ) -> OpenReturnCodes { + (self.read_unsigned_integer_8_bit_array)(dictionary_id, value_list_max_length, value_list) + } + + #[inline] + pub unsafe fn read_bool_array( + &self, + dictionary_id: u32, + value_list_max_length: u32, + value_list: *mut bool, + ) -> OpenReturnCodes { + (self.read_bool_array)(dictionary_id, value_list_max_length, value_list) + } + + #[inline] + pub unsafe fn read_double_array( + &self, + dictionary_id: u32, + value_list_max_length: u32, + value_list: *mut f64, + ) -> OpenReturnCodes { + (self.read_double_array)(dictionary_id, value_list_max_length, value_list) + } + + #[inline] + pub unsafe fn read_string( + &self, + dictionary_id: u32, + string_max_length: u32, + string_buffer: PWSTR, + ) -> OpenReturnCodes { + (self.read_string)(dictionary_id, string_max_length, string_buffer) + } + + #[inline] + pub unsafe fn read_string_array( + &self, + dictionary_id: u32, + string_array_max_length: u32, + string_max_length: u32, + string_array: PPWSTR, + ) -> OpenReturnCodes { + (self.read_string_array)( + dictionary_id, + string_array_max_length, + string_max_length, + string_array, + ) + } + + #[inline] + pub unsafe fn read_unsigned_integer_16_bit( + &self, + dictionary_id: u32, + value: *mut u16, + ) -> OpenReturnCodes { + (self.read_unsigned_integer_16_bit)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_signed_integer_16_bit( + &self, + dictionary_id: u32, + value: *mut i16, + ) -> OpenReturnCodes { + (self.read_signed_integer_16_bit)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_unsigned_integer_32_bit( + &self, + dictionary_id: u32, + value: *mut u32, + ) -> OpenReturnCodes { + (self.read_unsigned_integer_32_bit)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_signed_integer_32_bit( + &self, + dictionary_id: u32, + value: *mut i32, + ) -> OpenReturnCodes { + (self.read_signed_integer_32_bit)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_unsigned_integer_64_bit( + &self, + dictionary_id: u32, + value: *mut u64, + ) -> OpenReturnCodes { + (self.read_unsigned_integer_64_bit)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_signed_integer_64_bit( + &self, + dictionary_id: u32, + value: *mut i64, + ) -> OpenReturnCodes { + (self.read_signed_integer_64_bit)(dictionary_id, value) + } + + #[inline] + pub unsafe fn get_num_array_elements( + &self, + dictionary_id: u32, + num_array_elements: *mut u32, + ) -> OpenReturnCodes { + (self.get_num_array_elements)(dictionary_id, num_array_elements) + } + + #[inline] + pub unsafe fn read_bit(&self, dictionary_id: u32, value: *mut Bool32) -> OpenReturnCodes { + (self.read_bit)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_bool(&self, dictionary_id: u32, value: *mut Bool32) -> OpenReturnCodes { + (self.read_bool)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_byte(&self, dictionary_id: u32, value: *mut u8) -> OpenReturnCodes { + (self.read_byte)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_double(&self, dictionary_id: u32, value: *mut f64) -> OpenReturnCodes { + (self.read_double)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_word(&self, dictionary_id: u32, value: *mut u16) -> OpenReturnCodes { + (self.read_word)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_double_word(&self, dictionary_id: u32, value: *mut u32) -> OpenReturnCodes { + (self.read_double_word)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_long_word(&self, dictionary_id: u32, value: *mut u64) -> OpenReturnCodes { + (self.read_long_word)(dictionary_id, value) + } + + #[inline] + pub unsafe fn read_next_event(&self, event: *mut u64) -> OpenReturnCodes { + (self.read_next_event)(event) + } + + #[inline] + pub unsafe fn read_next_event_with_ncu_index( + &self, + event: *mut u64, + ncu_index: *mut i32, + ) -> OpenReturnCodes { + (self.read_next_event_with_ncu_index)(event, ncu_index) + } + + #[inline] + pub unsafe fn write_bit(&self, dictionary_id: u32, value: Bool32) -> OpenReturnCodes { + (self.write_bit)(dictionary_id, value) + } + + #[inline] + pub unsafe fn write_bool(&self, dictionary_id: u32, value: Bool32) -> OpenReturnCodes { + (self.write_bool)(dictionary_id, value) + } + + #[inline] + pub unsafe fn write_byte(&self, dictionary_id: u32, value: u8) -> OpenReturnCodes { + (self.write_byte)(dictionary_id, value) + } + + #[inline] + pub unsafe fn write_double(&self, dictionary_id: u32, value: f64) -> OpenReturnCodes { + (self.write_double)(dictionary_id, value) + } + + #[inline] + pub unsafe fn write_word(&self, dictionary_id: u32, value: u16) -> OpenReturnCodes { + (self.write_word)(dictionary_id, value) + } + + #[inline] + pub unsafe fn write_double_word(&self, dictionary_id: u32, value: u32) -> OpenReturnCodes { + (self.write_double_word)(dictionary_id, value) + } + + #[inline] + pub unsafe fn write_long_word(&self, dictionary_id: u32, value: u64) -> OpenReturnCodes { + (self.write_long_word)(dictionary_id, value) + } + + #[inline] + pub unsafe fn write_bool_array( + &self, + dictionary_id: u32, + value_list_length: u32, + value_list: *const bool, + ) -> OpenReturnCodes { + (self.write_bool_array)(dictionary_id, value_list_length, value_list) + } + + #[inline] + pub unsafe fn get_simulation_speed(&self, percent: *mut u32) -> OpenReturnCodes { + (self.get_simulation_speed)(percent) + } + + #[inline] + pub unsafe fn set_simulation_speed(&self, percent: u32) -> OpenReturnCodes { + (self.set_simulation_speed)(percent) + } + + #[inline] + pub unsafe fn get_card_path( + &self, + card_path_max_length: u32, + card_path: PWSTR, + ) -> OpenReturnCodes { + (self.get_card_path)(card_path_max_length, card_path) + } + + #[inline] + pub unsafe fn get_card_paths( + &self, + card_paths_array_max_length: u32, + card_path_max_length: u32, + card_paths: PPWSTR, + ) -> OpenReturnCodes { + (self.get_card_paths)( + card_paths_array_max_length, + card_path_max_length, + card_paths, + ) + } + + #[inline] + pub unsafe fn get_file( + &self, + source_file_path: PCWSTR, + destination_file_path: PCWSTR, + ) -> OpenReturnCodes { + (self.get_file)(source_file_path, destination_file_path) + } + + #[inline] + pub unsafe fn put_file( + &self, + source_file_path: PCWSTR, + destination_file_path: PCWSTR, + ) -> OpenReturnCodes { + (self.put_file)(source_file_path, destination_file_path) + } + + #[inline] + pub unsafe fn select_file( + &self, + source_file_path: PCWSTR, + channel_name: PCWSTR, + ) -> OpenReturnCodes { + (self.select_file)(source_file_path, channel_name) + } + + #[inline] + pub unsafe fn delete_file(&self, file_path: PCWSTR) -> OpenReturnCodes { + (self.delete_file)(file_path) + } + + #[inline] + pub unsafe fn delete_directory(&self, directory_path: PCWSTR) -> OpenReturnCodes { + (self.delete_directory)(directory_path) + } + + #[inline] + pub unsafe fn create_directory(&self, directory_path: PCWSTR) -> OpenReturnCodes { + (self.create_directory)(directory_path) + } + + #[inline] + pub unsafe fn list_directory( + &self, + directory_path: PCWSTR, + result_file_path: PCWSTR, + ) -> OpenReturnCodes { + (self.list_directory)(directory_path, result_file_path) + } + + #[inline] + pub unsafe fn get_version_information(&self, destination_file_path: PCWSTR) -> OpenReturnCodes { + (self.get_version_information)(destination_file_path) + } + + #[inline] + pub unsafe fn get_project_information( + &self, + vcp_file_path: PCWSTR, + destination_file_path: PCWSTR, + ) -> OpenReturnCodes { + (self.get_project_information)(vcp_file_path, destination_file_path) + } + + #[inline] + pub unsafe fn get_current_project_information( + &self, + destination_file_path: PCWSTR, + ) -> OpenReturnCodes { + (self.get_current_project_information)(destination_file_path) + } + + #[inline] + pub unsafe fn get_current_project_state( + &self, + project_state: *mut OpenProjectStates, + ) -> OpenReturnCodes { + (self.get_current_project_state)(project_state) + } + + #[inline] + pub unsafe fn import_project_settings( + &self, + file_name: PCWSTR, + import_content_file_name: PCWSTR, + ) -> OpenReturnCodes { + (self.import_project_settings)(file_name, import_content_file_name) + } + + #[inline] + pub unsafe fn export_project_settings(&self, file_name: PCWSTR) -> OpenReturnCodes { + (self.export_project_settings)(file_name) + } + + #[inline] + pub unsafe fn write_unsigned_integer_8_bit_array( + &self, + dictionary_id: u32, + value_list_max_length: u32, + value_list: *const u8, + ) -> OpenReturnCodes { + (self.write_unsigned_integer_8_bit_array)(dictionary_id, value_list_max_length, value_list) + } + + #[inline] + pub unsafe fn get_number_of_ncus(&self, number_of_ncus: *mut u32) -> OpenReturnCodes { + (self.get_number_of_ncus)(number_of_ncus) } }