1192 lines
42 KiB
Rust
1192 lines
42 KiB
Rust
#![allow(non_snake_case)]
|
|
use libloading::{ Library, Symbol };
|
|
use std::path::{ Path, PathBuf };
|
|
|
|
/// 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,
|
|
}
|
|
|
|
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<T: Copy>(lib: &'static Library, name: &[u8]) -> Result<T, libloading::Error> {
|
|
unsafe {
|
|
let symbol: Symbol<T> = 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.
|
|
///
|
|
/// If `path` resolves to an empty string (e.g. `""`), the default `bin/open.dll`
|
|
/// relative to the current working directory is used.
|
|
pub unsafe fn load<P: AsRef<Path>>(path: P) -> Result<Self, libloading::Error> {
|
|
// Load the DLL
|
|
let provided_path = path.as_ref();
|
|
let fallback_path;
|
|
let dll_path = if provided_path.as_os_str().is_empty() {
|
|
fallback_path = PathBuf::from("bin").join("open.dll");
|
|
fallback_path.as_path()
|
|
} else {
|
|
provided_path
|
|
};
|
|
let lib = Library::new(dll_path)?;
|
|
// 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::<StartApplicationFn>(lib, b"startApplication")?;
|
|
let stop_application = load_symbol::<StopApplicationFn>(lib, b"stopApplication")?;
|
|
let connect = load_symbol::<ConnectFn>(lib, b"connect")?;
|
|
let disconnect = load_symbol::<DisconnectFn>(lib, b"disconnect")?;
|
|
let open_project = load_symbol::<OpenProjectFn>(lib, b"openProject")?;
|
|
let create_project = load_symbol::<CreateProjectFn>(lib, b"createProject")?;
|
|
let create_project_with_scaling = load_symbol::<CreateProjectWithScalingFn>(
|
|
lib,
|
|
b"createProjectWithScaling"
|
|
)?;
|
|
let create_project_with_scaling_ncu_number =
|
|
load_symbol::<CreateProjectWithScalingNcuNumberFn>(
|
|
lib,
|
|
b"createProjectWithScalingNCUNumber"
|
|
)?;
|
|
let save_project = load_symbol::<SaveProjectFn>(lib, b"saveProject")?;
|
|
let close_project = load_symbol::<CloseProjectFn>(lib, b"closeProject")?;
|
|
let boot_controller = load_symbol::<BootControllerFn>(lib, b"bootController")?;
|
|
let shutdown_controller = load_symbol::<ShutdownControllerFn>(lib, b"shutdownController")?;
|
|
let reset_controller = load_symbol::<ResetControllerFn>(lib, b"resetController")?;
|
|
let register_for_events = load_symbol::<RegisterForEventsFn>(lib, b"registerForEvents")?;
|
|
let unregister_events = load_symbol::<UnregisterEventsFn>(lib, b"unregisterEvents")?;
|
|
let wait_for_events = load_symbol::<WaitForEventsFn>(lib, b"waitForEvents")?;
|
|
let continue_simulation = load_symbol::<ContinueSimulationFn>(lib, b"continueSimulation")?;
|
|
let get_dictionary_id = load_symbol::<GetDictionaryIdFn>(lib, b"getDictionaryId")?;
|
|
let register_watch = load_symbol::<RegisterWatchFn>(lib, b"registerWatch")?;
|
|
let unregister_watch = load_symbol::<UnregisterWatchFn>(lib, b"unregisterWatch")?;
|
|
let get_dictionary_element_type = load_symbol::<GetDictionaryElementTypeFn>(
|
|
lib,
|
|
b"getDictionaryElementType"
|
|
)?;
|
|
let read_unsigned_integer_64_bit_array = load_symbol::<ReadUnsignedInteger64BitArrayFn>(
|
|
lib,
|
|
b"readUnsignedInteger64BitArray"
|
|
)?;
|
|
let read_signed_integer_32_bit_array = load_symbol::<ReadSignedInteger32BitArrayFn>(
|
|
lib,
|
|
b"readSignedInteger32BitArray"
|
|
)?;
|
|
let read_unsigned_integer_32_bit_array = load_symbol::<ReadUnsignedInteger32BitArrayFn>(
|
|
lib,
|
|
b"readUnsignedInteger32BitArray"
|
|
)?;
|
|
let read_unsigned_integer_16_bit_array = load_symbol::<ReadUnsignedInteger16BitArrayFn>(
|
|
lib,
|
|
b"readUnsignedInteger16BitArray"
|
|
)?;
|
|
let read_unsigned_integer_8_bit_array = load_symbol::<ReadUnsignedInteger8BitArrayFn>(
|
|
lib,
|
|
b"readUnsignedInteger8BitArray"
|
|
)?;
|
|
let read_bool_array = load_symbol::<ReadBoolArrayFn>(lib, b"readBoolArray")?;
|
|
let read_double_array = load_symbol::<ReadDoubleArrayFn>(lib, b"readDoubleArray")?;
|
|
let read_string = load_symbol::<ReadStringFn>(lib, b"readString")?;
|
|
let read_string_array = load_symbol::<ReadStringArrayFn>(lib, b"readStringArray")?;
|
|
let read_unsigned_integer_16_bit = load_symbol::<ReadUnsignedInteger16BitFn>(
|
|
lib,
|
|
b"readUnsignedInteger16Bit"
|
|
)?;
|
|
let read_signed_integer_16_bit = load_symbol::<ReadSignedInteger16BitFn>(
|
|
lib,
|
|
b"readSignedInteger16Bit"
|
|
)?;
|
|
let read_unsigned_integer_32_bit = load_symbol::<ReadUnsignedInteger32BitFn>(
|
|
lib,
|
|
b"readUnsignedInteger32Bit"
|
|
)?;
|
|
let read_signed_integer_32_bit = load_symbol::<ReadSignedInteger32BitFn>(
|
|
lib,
|
|
b"readSignedInteger32Bit"
|
|
)?;
|
|
let read_unsigned_integer_64_bit = load_symbol::<ReadUnsignedInteger64BitFn>(
|
|
lib,
|
|
b"readUnsignedInteger64Bit"
|
|
)?;
|
|
let read_signed_integer_64_bit = load_symbol::<ReadSignedInteger64BitFn>(
|
|
lib,
|
|
b"readSignedInteger64Bit"
|
|
)?;
|
|
let get_num_array_elements = load_symbol::<GetNumArrayElementsFn>(
|
|
lib,
|
|
b"getNumArrayElements"
|
|
)?;
|
|
let read_bit = load_symbol::<ReadBitFn>(lib, b"readBit")?;
|
|
let read_bool = load_symbol::<ReadBoolFn>(lib, b"readBool")?;
|
|
let read_byte = load_symbol::<ReadByteFn>(lib, b"readByte")?;
|
|
let read_double = load_symbol::<ReadDoubleFn>(lib, b"readDouble")?;
|
|
let read_word = load_symbol::<ReadWordFn>(lib, b"readWord")?;
|
|
let read_double_word = load_symbol::<ReadDoubleWordFn>(lib, b"readDoubleWord")?;
|
|
let read_long_word = load_symbol::<ReadLongWordFn>(lib, b"readLongWord")?;
|
|
let read_next_event = load_symbol::<ReadNextEventFn>(lib, b"readNextEvent")?;
|
|
let read_next_event_with_ncu_index = load_symbol::<ReadNextEventWithNcuIndexFn>(
|
|
lib,
|
|
b"readNextEventWithNcuIndex"
|
|
)?;
|
|
let write_bit = load_symbol::<WriteBitFn>(lib, b"writeBit")?;
|
|
let write_bool = load_symbol::<WriteBoolFn>(lib, b"writeBool")?;
|
|
let write_byte = load_symbol::<WriteByteFn>(lib, b"writeByte")?;
|
|
let write_double = load_symbol::<WriteDoubleFn>(lib, b"writeDouble")?;
|
|
let write_word = load_symbol::<WriteWordFn>(lib, b"writeWord")?;
|
|
let write_double_word = load_symbol::<WriteDoubleWordFn>(lib, b"writeDoubleWord")?;
|
|
let write_long_word = load_symbol::<WriteLongWordFn>(lib, b"writeLongWord")?;
|
|
let write_bool_array = load_symbol::<WriteBoolArrayFn>(lib, b"writeBoolArray")?;
|
|
let get_simulation_speed = load_symbol::<GetSimulationSpeedFn>(lib, b"getSimulationSpeed")?;
|
|
let set_simulation_speed = load_symbol::<SetSimulationSpeedFn>(lib, b"setSimulationSpeed")?;
|
|
let get_card_path = load_symbol::<GetCardPathFn>(lib, b"getCardPath")?;
|
|
let get_card_paths = load_symbol::<GetCardPathsFn>(lib, b"getCardPaths")?;
|
|
let get_file = load_symbol::<GetFileFn>(lib, b"getFile")?;
|
|
let put_file = load_symbol::<PutFileFn>(lib, b"putFile")?;
|
|
let select_file = load_symbol::<SelectFileFn>(lib, b"selectFile")?;
|
|
let delete_file = load_symbol::<DeleteFileFn>(lib, b"deleteFile")?;
|
|
let delete_directory = load_symbol::<DeleteDirectoryFn>(lib, b"deleteDirectory")?;
|
|
let create_directory = load_symbol::<CreateDirectoryFn>(lib, b"createDirectory")?;
|
|
let list_directory = load_symbol::<ListDirectoryFn>(lib, b"listDirectory")?;
|
|
let get_version_information = load_symbol::<GetVersionInformationFn>(
|
|
lib,
|
|
b"getVersionInformation"
|
|
)?;
|
|
let get_project_information = load_symbol::<GetProjectInformationFn>(
|
|
lib,
|
|
b"getProjectInformation"
|
|
)?;
|
|
let get_current_project_information = load_symbol::<GetCurrentProjectInformationFn>(
|
|
lib,
|
|
b"getCurrentProjectInformation"
|
|
)?;
|
|
let get_current_project_state = load_symbol::<GetCurrentProjectStateFn>(
|
|
lib,
|
|
b"getCurrentProjectState"
|
|
)?;
|
|
let import_project_settings = load_symbol::<ImportProjectSettingsFn>(
|
|
lib,
|
|
b"importProjectSettings"
|
|
)?;
|
|
let export_project_settings = load_symbol::<ExportProjectSettingsFn>(
|
|
lib,
|
|
b"exportProjectSettings"
|
|
)?;
|
|
let write_unsigned_integer_8_bit_array = load_symbol::<WriteUnsignedInteger8BitArrayFn>(
|
|
lib,
|
|
b"writeUnsignedInteger8BitArray"
|
|
)?;
|
|
let get_number_of_ncus = load_symbol::<GetNumberOfNcusFn>(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)
|
|
}
|
|
}
|