29 #define PEAK_CALL_CONV 458 return dynamicLoader;
460 bool loadLib(
const char* file);
462 bool setPointers(
bool load);
882 void* m_handle =
nullptr;
1300 return dlsym(module, proc_name);
1302 return GetProcAddress(static_cast<HMODULE>(module), proc_name);
1306 inline DynamicLoader::DynamicLoader()
1308 #if defined _WIN32 || defined _WIN64 1310 if (_wgetenv_s(&sz, NULL, 0, L
"IDS_PEAK_GENERIC_SDK_PATH") == 0
1313 std::vector<wchar_t> env_ids_peak(sz);
1314 if (_wgetenv_s(&sz, env_ids_peak.data(), sz, L
"IDS_PEAK_GENERIC_SDK_PATH") == 0)
1316 if (_wgetenv_s(&sz, NULL, 0, L
"PATH") == 0
1319 std::vector<wchar_t> env_path(sz);
1320 if (_wgetenv_s(&sz, env_path.data(), sz, L
"PATH") == 0)
1322 std::wstring ids_peak_path(env_ids_peak.data());
1324 ids_peak_path.append(L
"\\api\\lib\\x86_64");
1326 ids_peak_path.append(L
"\\api\\lib\\x86_32");
1328 std::wstring path_var(env_path.data());
1329 path_var.append(L
";").append(ids_peak_path);
1330 _wputenv_s(L
"PATH", path_var.c_str());
1336 loadLib(
"ids_peak.dll");
1338 loadLib(
"libids_peak.so");
1344 if(m_handle !=
nullptr)
1352 auto&& inst = instance();
1353 return inst.m_handle !=
nullptr;
1356 inline void DynamicLoader::unload()
1360 if (m_handle !=
nullptr)
1365 FreeLibrary(static_cast<HMODULE>(m_handle));
1372 inline bool DynamicLoader::loadLib(
const char* file)
1379 m_handle = dlopen(file, RTLD_NOW);
1381 m_handle = LoadLibraryA(file);
1383 if (m_handle !=
nullptr)
1388 }
catch (
const std::exception&) {
1395 throw std::runtime_error(std::string(
"Lib load failed: ") + file);
1400 throw std::runtime_error(
"Filename empty");
1406 inline bool DynamicLoader::setPointers(
bool load)
1410 if(m_PEAK_Library_Initialize ==
nullptr && load)
1412 throw std::runtime_error(
"Failed to load PEAK_Library_Initialize");
1416 if(m_PEAK_Library_Close ==
nullptr && load)
1418 throw std::runtime_error(
"Failed to load PEAK_Library_Close");
1422 if(m_PEAK_Library_IsInitialized ==
nullptr && load)
1424 throw std::runtime_error(
"Failed to load PEAK_Library_IsInitialized");
1428 if(m_PEAK_Library_GetVersionMajor ==
nullptr && load)
1430 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionMajor");
1434 if(m_PEAK_Library_GetVersionMinor ==
nullptr && load)
1436 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionMinor");
1440 if(m_PEAK_Library_GetVersionSubminor ==
nullptr && load)
1442 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionSubminor");
1446 if(m_PEAK_Library_GetLastError ==
nullptr && load)
1448 throw std::runtime_error(
"Failed to load PEAK_Library_GetLastError");
1452 if(m_PEAK_EnvironmentInspector_UpdateCTIPaths ==
nullptr && load)
1454 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_UpdateCTIPaths");
1458 if(m_PEAK_EnvironmentInspector_GetNumCTIPaths ==
nullptr && load)
1460 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_GetNumCTIPaths");
1464 if(m_PEAK_EnvironmentInspector_GetCTIPath ==
nullptr && load)
1466 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_GetCTIPath");
1470 if(m_PEAK_ProducerLibrary_Construct ==
nullptr && load)
1472 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_Construct");
1476 if(m_PEAK_ProducerLibrary_GetKey ==
nullptr && load)
1478 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_GetKey");
1482 if(m_PEAK_ProducerLibrary_GetSystem ==
nullptr && load)
1484 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_GetSystem");
1488 if(m_PEAK_ProducerLibrary_Destruct ==
nullptr && load)
1490 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_Destruct");
1494 if(m_PEAK_SystemDescriptor_ToModuleDescriptor ==
nullptr && load)
1496 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_ToModuleDescriptor");
1500 if(m_PEAK_SystemDescriptor_GetKey ==
nullptr && load)
1502 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetKey");
1506 if(m_PEAK_SystemDescriptor_GetInfo ==
nullptr && load)
1508 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetInfo");
1512 if(m_PEAK_SystemDescriptor_GetDisplayName ==
nullptr && load)
1514 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetDisplayName");
1518 if(m_PEAK_SystemDescriptor_GetVendorName ==
nullptr && load)
1520 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetVendorName");
1524 if(m_PEAK_SystemDescriptor_GetModelName ==
nullptr && load)
1526 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetModelName");
1530 if(m_PEAK_SystemDescriptor_GetVersion ==
nullptr && load)
1532 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetVersion");
1536 if(m_PEAK_SystemDescriptor_GetTLType ==
nullptr && load)
1538 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetTLType");
1542 if(m_PEAK_SystemDescriptor_GetCTIFileName ==
nullptr && load)
1544 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCTIFileName");
1548 if(m_PEAK_SystemDescriptor_GetCTIFullPath ==
nullptr && load)
1550 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCTIFullPath");
1554 if(m_PEAK_SystemDescriptor_GetGenTLVersionMajor ==
nullptr && load)
1556 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetGenTLVersionMajor");
1560 if(m_PEAK_SystemDescriptor_GetGenTLVersionMinor ==
nullptr && load)
1562 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetGenTLVersionMinor");
1566 if(m_PEAK_SystemDescriptor_GetCharacterEncoding ==
nullptr && load)
1568 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCharacterEncoding");
1572 if(m_PEAK_SystemDescriptor_GetParentLibrary ==
nullptr && load)
1574 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetParentLibrary");
1578 if(m_PEAK_SystemDescriptor_OpenSystem ==
nullptr && load)
1580 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_OpenSystem");
1584 if(m_PEAK_System_ToModule ==
nullptr && load)
1586 throw std::runtime_error(
"Failed to load PEAK_System_ToModule");
1590 if(m_PEAK_System_ToEventSupportingModule ==
nullptr && load)
1592 throw std::runtime_error(
"Failed to load PEAK_System_ToEventSupportingModule");
1596 if(m_PEAK_System_GetKey ==
nullptr && load)
1598 throw std::runtime_error(
"Failed to load PEAK_System_GetKey");
1602 if(m_PEAK_System_GetInfo ==
nullptr && load)
1604 throw std::runtime_error(
"Failed to load PEAK_System_GetInfo");
1608 if(m_PEAK_System_GetID ==
nullptr && load)
1610 throw std::runtime_error(
"Failed to load PEAK_System_GetID");
1614 if(m_PEAK_System_GetDisplayName ==
nullptr && load)
1616 throw std::runtime_error(
"Failed to load PEAK_System_GetDisplayName");
1620 if(m_PEAK_System_GetVendorName ==
nullptr && load)
1622 throw std::runtime_error(
"Failed to load PEAK_System_GetVendorName");
1626 if(m_PEAK_System_GetModelName ==
nullptr && load)
1628 throw std::runtime_error(
"Failed to load PEAK_System_GetModelName");
1632 if(m_PEAK_System_GetVersion ==
nullptr && load)
1634 throw std::runtime_error(
"Failed to load PEAK_System_GetVersion");
1638 if(m_PEAK_System_GetTLType ==
nullptr && load)
1640 throw std::runtime_error(
"Failed to load PEAK_System_GetTLType");
1644 if(m_PEAK_System_GetCTIFileName ==
nullptr && load)
1646 throw std::runtime_error(
"Failed to load PEAK_System_GetCTIFileName");
1650 if(m_PEAK_System_GetCTIFullPath ==
nullptr && load)
1652 throw std::runtime_error(
"Failed to load PEAK_System_GetCTIFullPath");
1656 if(m_PEAK_System_GetGenTLVersionMajor ==
nullptr && load)
1658 throw std::runtime_error(
"Failed to load PEAK_System_GetGenTLVersionMajor");
1662 if(m_PEAK_System_GetGenTLVersionMinor ==
nullptr && load)
1664 throw std::runtime_error(
"Failed to load PEAK_System_GetGenTLVersionMinor");
1668 if(m_PEAK_System_GetCharacterEncoding ==
nullptr && load)
1670 throw std::runtime_error(
"Failed to load PEAK_System_GetCharacterEncoding");
1674 if(m_PEAK_System_GetParentLibrary ==
nullptr && load)
1676 throw std::runtime_error(
"Failed to load PEAK_System_GetParentLibrary");
1680 if(m_PEAK_System_UpdateInterfaces ==
nullptr && load)
1682 throw std::runtime_error(
"Failed to load PEAK_System_UpdateInterfaces");
1686 if(m_PEAK_System_GetNumInterfaces ==
nullptr && load)
1688 throw std::runtime_error(
"Failed to load PEAK_System_GetNumInterfaces");
1692 if(m_PEAK_System_GetInterface ==
nullptr && load)
1694 throw std::runtime_error(
"Failed to load PEAK_System_GetInterface");
1698 if(m_PEAK_System_RegisterInterfaceFoundCallback ==
nullptr && load)
1700 throw std::runtime_error(
"Failed to load PEAK_System_RegisterInterfaceFoundCallback");
1704 if(m_PEAK_System_UnregisterInterfaceFoundCallback ==
nullptr && load)
1706 throw std::runtime_error(
"Failed to load PEAK_System_UnregisterInterfaceFoundCallback");
1710 if(m_PEAK_System_RegisterInterfaceLostCallback ==
nullptr && load)
1712 throw std::runtime_error(
"Failed to load PEAK_System_RegisterInterfaceLostCallback");
1716 if(m_PEAK_System_UnregisterInterfaceLostCallback ==
nullptr && load)
1718 throw std::runtime_error(
"Failed to load PEAK_System_UnregisterInterfaceLostCallback");
1722 if(m_PEAK_System_Destruct ==
nullptr && load)
1724 throw std::runtime_error(
"Failed to load PEAK_System_Destruct");
1728 if(m_PEAK_InterfaceDescriptor_ToModuleDescriptor ==
nullptr && load)
1730 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_ToModuleDescriptor");
1734 if(m_PEAK_InterfaceDescriptor_GetKey ==
nullptr && load)
1736 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetKey");
1740 if(m_PEAK_InterfaceDescriptor_GetInfo ==
nullptr && load)
1742 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetInfo");
1746 if(m_PEAK_InterfaceDescriptor_GetDisplayName ==
nullptr && load)
1748 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetDisplayName");
1752 if(m_PEAK_InterfaceDescriptor_GetTLType ==
nullptr && load)
1754 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetTLType");
1758 if(m_PEAK_InterfaceDescriptor_GetParentSystem ==
nullptr && load)
1760 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetParentSystem");
1764 if(m_PEAK_InterfaceDescriptor_OpenInterface ==
nullptr && load)
1766 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_OpenInterface");
1770 if(m_PEAK_Interface_ToModule ==
nullptr && load)
1772 throw std::runtime_error(
"Failed to load PEAK_Interface_ToModule");
1776 if(m_PEAK_Interface_ToEventSupportingModule ==
nullptr && load)
1778 throw std::runtime_error(
"Failed to load PEAK_Interface_ToEventSupportingModule");
1782 if(m_PEAK_Interface_GetKey ==
nullptr && load)
1784 throw std::runtime_error(
"Failed to load PEAK_Interface_GetKey");
1788 if(m_PEAK_Interface_GetInfo ==
nullptr && load)
1790 throw std::runtime_error(
"Failed to load PEAK_Interface_GetInfo");
1794 if(m_PEAK_Interface_GetID ==
nullptr && load)
1796 throw std::runtime_error(
"Failed to load PEAK_Interface_GetID");
1800 if(m_PEAK_Interface_GetDisplayName ==
nullptr && load)
1802 throw std::runtime_error(
"Failed to load PEAK_Interface_GetDisplayName");
1806 if(m_PEAK_Interface_GetTLType ==
nullptr && load)
1808 throw std::runtime_error(
"Failed to load PEAK_Interface_GetTLType");
1812 if(m_PEAK_Interface_GetParentSystem ==
nullptr && load)
1814 throw std::runtime_error(
"Failed to load PEAK_Interface_GetParentSystem");
1818 if(m_PEAK_Interface_UpdateDevices ==
nullptr && load)
1820 throw std::runtime_error(
"Failed to load PEAK_Interface_UpdateDevices");
1824 if(m_PEAK_Interface_GetNumDevices ==
nullptr && load)
1826 throw std::runtime_error(
"Failed to load PEAK_Interface_GetNumDevices");
1830 if(m_PEAK_Interface_GetDevice ==
nullptr && load)
1832 throw std::runtime_error(
"Failed to load PEAK_Interface_GetDevice");
1836 if(m_PEAK_Interface_RegisterDeviceFoundCallback ==
nullptr && load)
1838 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceFoundCallback");
1842 if(m_PEAK_Interface_UnregisterDeviceFoundCallback ==
nullptr && load)
1844 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceFoundCallback");
1848 if(m_PEAK_Interface_RegisterDeviceReconnectedCallback ==
nullptr && load)
1850 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceReconnectedCallback");
1854 if(m_PEAK_Interface_UnregisterDeviceReconnectedCallback ==
nullptr && load)
1856 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceReconnectedCallback");
1860 if(m_PEAK_Interface_RegisterDeviceDisconnectedCallback ==
nullptr && load)
1862 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceDisconnectedCallback");
1866 if(m_PEAK_Interface_UnregisterDeviceDisconnectedCallback ==
nullptr && load)
1868 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceDisconnectedCallback");
1872 if(m_PEAK_Interface_RegisterDeviceLostCallback ==
nullptr && load)
1874 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceLostCallback");
1878 if(m_PEAK_Interface_UnregisterDeviceLostCallback ==
nullptr && load)
1880 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceLostCallback");
1884 if(m_PEAK_Interface_RegisterDeviceListChangedCallback ==
nullptr && load)
1886 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceListChangedCallback");
1890 if(m_PEAK_Interface_UnregisterDeviceListChangedCallback ==
nullptr && load)
1892 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceListChangedCallback");
1896 if(m_PEAK_Interface_Destruct ==
nullptr && load)
1898 throw std::runtime_error(
"Failed to load PEAK_Interface_Destruct");
1902 if(m_PEAK_DeviceDescriptor_ToModuleDescriptor ==
nullptr && load)
1904 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_ToModuleDescriptor");
1908 if(m_PEAK_DeviceDescriptor_GetKey ==
nullptr && load)
1910 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetKey");
1914 if(m_PEAK_DeviceDescriptor_GetInfo ==
nullptr && load)
1916 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetInfo");
1920 if(m_PEAK_DeviceDescriptor_GetDisplayName ==
nullptr && load)
1922 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetDisplayName");
1926 if(m_PEAK_DeviceDescriptor_GetVendorName ==
nullptr && load)
1928 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetVendorName");
1932 if(m_PEAK_DeviceDescriptor_GetModelName ==
nullptr && load)
1934 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetModelName");
1938 if(m_PEAK_DeviceDescriptor_GetVersion ==
nullptr && load)
1940 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetVersion");
1944 if(m_PEAK_DeviceDescriptor_GetTLType ==
nullptr && load)
1946 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetTLType");
1950 if(m_PEAK_DeviceDescriptor_GetUserDefinedName ==
nullptr && load)
1952 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetUserDefinedName");
1956 if(m_PEAK_DeviceDescriptor_GetSerialNumber ==
nullptr && load)
1958 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetSerialNumber");
1962 if(m_PEAK_DeviceDescriptor_GetAccessStatus ==
nullptr && load)
1964 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetAccessStatus");
1968 if(m_PEAK_DeviceDescriptor_GetTimestampTickFrequency ==
nullptr && load)
1970 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetTimestampTickFrequency");
1974 if(m_PEAK_DeviceDescriptor_GetIsOpenableExclusive ==
nullptr && load)
1976 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetIsOpenableExclusive");
1980 if(m_PEAK_DeviceDescriptor_GetIsOpenable ==
nullptr && load)
1982 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetIsOpenable");
1986 if(m_PEAK_DeviceDescriptor_OpenDevice ==
nullptr && load)
1988 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_OpenDevice");
1992 if(m_PEAK_DeviceDescriptor_GetParentInterface ==
nullptr && load)
1994 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetParentInterface");
1998 if(m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval ==
nullptr && load)
2000 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetMonitoringUpdateInterval");
2004 if(m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval ==
nullptr && load)
2006 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_SetMonitoringUpdateInterval");
2010 if(m_PEAK_DeviceDescriptor_IsInformationRoleMonitored ==
nullptr && load)
2012 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_IsInformationRoleMonitored");
2016 if(m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring ==
nullptr && load)
2018 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_AddInformationRoleToMonitoring");
2022 if(m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring ==
nullptr && load)
2024 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring");
2028 if(m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback ==
nullptr && load)
2030 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_RegisterInformationChangedCallback");
2034 if(m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback ==
nullptr && load)
2036 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_UnregisterInformationChangedCallback");
2040 if(m_PEAK_Device_ToModule ==
nullptr && load)
2042 throw std::runtime_error(
"Failed to load PEAK_Device_ToModule");
2046 if(m_PEAK_Device_ToEventSupportingModule ==
nullptr && load)
2048 throw std::runtime_error(
"Failed to load PEAK_Device_ToEventSupportingModule");
2052 if(m_PEAK_Device_GetKey ==
nullptr && load)
2054 throw std::runtime_error(
"Failed to load PEAK_Device_GetKey");
2058 if(m_PEAK_Device_GetInfo ==
nullptr && load)
2060 throw std::runtime_error(
"Failed to load PEAK_Device_GetInfo");
2064 if(m_PEAK_Device_GetID ==
nullptr && load)
2066 throw std::runtime_error(
"Failed to load PEAK_Device_GetID");
2070 if(m_PEAK_Device_GetDisplayName ==
nullptr && load)
2072 throw std::runtime_error(
"Failed to load PEAK_Device_GetDisplayName");
2076 if(m_PEAK_Device_GetVendorName ==
nullptr && load)
2078 throw std::runtime_error(
"Failed to load PEAK_Device_GetVendorName");
2082 if(m_PEAK_Device_GetModelName ==
nullptr && load)
2084 throw std::runtime_error(
"Failed to load PEAK_Device_GetModelName");
2088 if(m_PEAK_Device_GetVersion ==
nullptr && load)
2090 throw std::runtime_error(
"Failed to load PEAK_Device_GetVersion");
2094 if(m_PEAK_Device_GetTLType ==
nullptr && load)
2096 throw std::runtime_error(
"Failed to load PEAK_Device_GetTLType");
2100 if(m_PEAK_Device_GetUserDefinedName ==
nullptr && load)
2102 throw std::runtime_error(
"Failed to load PEAK_Device_GetUserDefinedName");
2106 if(m_PEAK_Device_GetSerialNumber ==
nullptr && load)
2108 throw std::runtime_error(
"Failed to load PEAK_Device_GetSerialNumber");
2112 if(m_PEAK_Device_GetAccessStatus ==
nullptr && load)
2114 throw std::runtime_error(
"Failed to load PEAK_Device_GetAccessStatus");
2118 if(m_PEAK_Device_GetTimestampTickFrequency ==
nullptr && load)
2120 throw std::runtime_error(
"Failed to load PEAK_Device_GetTimestampTickFrequency");
2124 if(m_PEAK_Device_GetParentInterface ==
nullptr && load)
2126 throw std::runtime_error(
"Failed to load PEAK_Device_GetParentInterface");
2130 if(m_PEAK_Device_GetRemoteDevice ==
nullptr && load)
2132 throw std::runtime_error(
"Failed to load PEAK_Device_GetRemoteDevice");
2136 if(m_PEAK_Device_GetNumDataStreams ==
nullptr && load)
2138 throw std::runtime_error(
"Failed to load PEAK_Device_GetNumDataStreams");
2142 if(m_PEAK_Device_GetDataStream ==
nullptr && load)
2144 throw std::runtime_error(
"Failed to load PEAK_Device_GetDataStream");
2148 if(m_PEAK_Device_Destruct ==
nullptr && load)
2150 throw std::runtime_error(
"Failed to load PEAK_Device_Destruct");
2154 if(m_PEAK_RemoteDevice_ToModule ==
nullptr && load)
2156 throw std::runtime_error(
"Failed to load PEAK_RemoteDevice_ToModule");
2160 if(m_PEAK_RemoteDevice_GetLocalDevice ==
nullptr && load)
2162 throw std::runtime_error(
"Failed to load PEAK_RemoteDevice_GetLocalDevice");
2166 if(m_PEAK_DataStreamDescriptor_ToModuleDescriptor ==
nullptr && load)
2168 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_ToModuleDescriptor");
2172 if(m_PEAK_DataStreamDescriptor_GetKey ==
nullptr && load)
2174 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_GetKey");
2178 if(m_PEAK_DataStreamDescriptor_GetParentDevice ==
nullptr && load)
2180 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_GetParentDevice");
2184 if(m_PEAK_DataStreamDescriptor_OpenDataStream ==
nullptr && load)
2186 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_OpenDataStream");
2190 if(m_PEAK_DataStream_ToModule ==
nullptr && load)
2192 throw std::runtime_error(
"Failed to load PEAK_DataStream_ToModule");
2196 if(m_PEAK_DataStream_ToEventSupportingModule ==
nullptr && load)
2198 throw std::runtime_error(
"Failed to load PEAK_DataStream_ToEventSupportingModule");
2202 if(m_PEAK_DataStream_GetKey ==
nullptr && load)
2204 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetKey");
2208 if(m_PEAK_DataStream_GetInfo ==
nullptr && load)
2210 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetInfo");
2214 if(m_PEAK_DataStream_GetID ==
nullptr && load)
2216 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetID");
2220 if(m_PEAK_DataStream_GetTLType ==
nullptr && load)
2222 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetTLType");
2226 if(m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired ==
nullptr && load)
2228 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAnnouncedMinRequired");
2232 if(m_PEAK_DataStream_GetNumBuffersAnnounced ==
nullptr && load)
2234 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAnnounced");
2238 if(m_PEAK_DataStream_GetNumBuffersQueued ==
nullptr && load)
2240 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersQueued");
2244 if(m_PEAK_DataStream_GetNumBuffersAwaitDelivery ==
nullptr && load)
2246 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAwaitDelivery");
2250 if(m_PEAK_DataStream_GetNumBuffersDelivered ==
nullptr && load)
2252 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersDelivered");
2256 if(m_PEAK_DataStream_GetNumBuffersStarted ==
nullptr && load)
2258 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersStarted");
2262 if(m_PEAK_DataStream_GetNumUnderruns ==
nullptr && load)
2264 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumUnderruns");
2268 if(m_PEAK_DataStream_GetNumChunksPerBufferMax ==
nullptr && load)
2270 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumChunksPerBufferMax");
2274 if(m_PEAK_DataStream_GetBufferAlignment ==
nullptr && load)
2276 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetBufferAlignment");
2280 if(m_PEAK_DataStream_GetPayloadSize ==
nullptr && load)
2282 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetPayloadSize");
2286 if(m_PEAK_DataStream_GetDefinesPayloadSize ==
nullptr && load)
2288 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetDefinesPayloadSize");
2292 if(m_PEAK_DataStream_GetIsGrabbing ==
nullptr && load)
2294 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetIsGrabbing");
2298 if(m_PEAK_DataStream_GetParentDevice ==
nullptr && load)
2300 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetParentDevice");
2304 if(m_PEAK_DataStream_AnnounceBuffer ==
nullptr && load)
2306 throw std::runtime_error(
"Failed to load PEAK_DataStream_AnnounceBuffer");
2310 if(m_PEAK_DataStream_AllocAndAnnounceBuffer ==
nullptr && load)
2312 throw std::runtime_error(
"Failed to load PEAK_DataStream_AllocAndAnnounceBuffer");
2316 if(m_PEAK_DataStream_QueueBuffer ==
nullptr && load)
2318 throw std::runtime_error(
"Failed to load PEAK_DataStream_QueueBuffer");
2322 if(m_PEAK_DataStream_RevokeBuffer ==
nullptr && load)
2324 throw std::runtime_error(
"Failed to load PEAK_DataStream_RevokeBuffer");
2328 if(m_PEAK_DataStream_WaitForFinishedBuffer ==
nullptr && load)
2330 throw std::runtime_error(
"Failed to load PEAK_DataStream_WaitForFinishedBuffer");
2334 if(m_PEAK_DataStream_KillWait ==
nullptr && load)
2336 throw std::runtime_error(
"Failed to load PEAK_DataStream_KillWait");
2340 if(m_PEAK_DataStream_Flush ==
nullptr && load)
2342 throw std::runtime_error(
"Failed to load PEAK_DataStream_Flush");
2346 if(m_PEAK_DataStream_StartAcquisitionInfinite ==
nullptr && load)
2348 throw std::runtime_error(
"Failed to load PEAK_DataStream_StartAcquisitionInfinite");
2352 if(m_PEAK_DataStream_StartAcquisition ==
nullptr && load)
2354 throw std::runtime_error(
"Failed to load PEAK_DataStream_StartAcquisition");
2358 if(m_PEAK_DataStream_StopAcquisition ==
nullptr && load)
2360 throw std::runtime_error(
"Failed to load PEAK_DataStream_StopAcquisition");
2364 if(m_PEAK_DataStream_Destruct ==
nullptr && load)
2366 throw std::runtime_error(
"Failed to load PEAK_DataStream_Destruct");
2370 if(m_PEAK_Buffer_ToModule ==
nullptr && load)
2372 throw std::runtime_error(
"Failed to load PEAK_Buffer_ToModule");
2376 if(m_PEAK_Buffer_ToEventSupportingModule ==
nullptr && load)
2378 throw std::runtime_error(
"Failed to load PEAK_Buffer_ToEventSupportingModule");
2382 if(m_PEAK_Buffer_GetInfo ==
nullptr && load)
2384 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetInfo");
2388 if(m_PEAK_Buffer_GetTLType ==
nullptr && load)
2390 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTLType");
2394 if(m_PEAK_Buffer_GetBasePtr ==
nullptr && load)
2396 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetBasePtr");
2400 if(m_PEAK_Buffer_GetSize ==
nullptr && load)
2402 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetSize");
2406 if(m_PEAK_Buffer_GetUserPtr ==
nullptr && load)
2408 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetUserPtr");
2412 if(m_PEAK_Buffer_GetPayloadType ==
nullptr && load)
2414 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPayloadType");
2418 if(m_PEAK_Buffer_GetPixelFormat ==
nullptr && load)
2420 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelFormat");
2424 if(m_PEAK_Buffer_GetPixelFormatNamespace ==
nullptr && load)
2426 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelFormatNamespace");
2430 if(m_PEAK_Buffer_GetPixelEndianness ==
nullptr && load)
2432 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelEndianness");
2436 if(m_PEAK_Buffer_GetExpectedDataSize ==
nullptr && load)
2438 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetExpectedDataSize");
2442 if(m_PEAK_Buffer_GetDeliveredDataSize ==
nullptr && load)
2444 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredDataSize");
2448 if(m_PEAK_Buffer_GetFrameID ==
nullptr && load)
2450 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetFrameID");
2454 if(m_PEAK_Buffer_GetImageOffset ==
nullptr && load)
2456 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetImageOffset");
2460 if(m_PEAK_Buffer_GetDeliveredImageHeight ==
nullptr && load)
2462 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredImageHeight");
2466 if(m_PEAK_Buffer_GetDeliveredChunkPayloadSize ==
nullptr && load)
2468 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredChunkPayloadSize");
2472 if(m_PEAK_Buffer_GetChunkLayoutID ==
nullptr && load)
2474 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetChunkLayoutID");
2478 if(m_PEAK_Buffer_GetFileName ==
nullptr && load)
2480 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetFileName");
2484 if(m_PEAK_Buffer_GetWidth ==
nullptr && load)
2486 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetWidth");
2490 if(m_PEAK_Buffer_GetHeight ==
nullptr && load)
2492 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHeight");
2496 if(m_PEAK_Buffer_GetXOffset ==
nullptr && load)
2498 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetXOffset");
2502 if(m_PEAK_Buffer_GetYOffset ==
nullptr && load)
2504 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetYOffset");
2508 if(m_PEAK_Buffer_GetXPadding ==
nullptr && load)
2510 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetXPadding");
2514 if(m_PEAK_Buffer_GetYPadding ==
nullptr && load)
2516 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetYPadding");
2520 if(m_PEAK_Buffer_GetTimestamp_ticks ==
nullptr && load)
2522 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTimestamp_ticks");
2526 if(m_PEAK_Buffer_GetTimestamp_ns ==
nullptr && load)
2528 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTimestamp_ns");
2532 if(m_PEAK_Buffer_GetIsQueued ==
nullptr && load)
2534 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsQueued");
2538 if(m_PEAK_Buffer_GetIsAcquiring ==
nullptr && load)
2540 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsAcquiring");
2544 if(m_PEAK_Buffer_GetIsIncomplete ==
nullptr && load)
2546 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsIncomplete");
2550 if(m_PEAK_Buffer_GetHasNewData ==
nullptr && load)
2552 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasNewData");
2556 if(m_PEAK_Buffer_GetHasImage ==
nullptr && load)
2558 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasImage");
2562 if(m_PEAK_Buffer_GetHasChunks ==
nullptr && load)
2564 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasChunks");
2568 if(m_PEAK_Buffer_UpdateChunks ==
nullptr && load)
2570 throw std::runtime_error(
"Failed to load PEAK_Buffer_UpdateChunks");
2574 if(m_PEAK_Buffer_GetNumChunks ==
nullptr && load)
2576 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetNumChunks");
2580 if(m_PEAK_Buffer_GetChunk ==
nullptr && load)
2582 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetChunk");
2586 if(m_PEAK_Buffer_UpdateParts ==
nullptr && load)
2588 throw std::runtime_error(
"Failed to load PEAK_Buffer_UpdateParts");
2592 if(m_PEAK_Buffer_GetNumParts ==
nullptr && load)
2594 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetNumParts");
2598 if(m_PEAK_Buffer_GetPart ==
nullptr && load)
2600 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPart");
2604 if(m_PEAK_BufferChunk_GetID ==
nullptr && load)
2606 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetID");
2610 if(m_PEAK_BufferChunk_GetBasePtr ==
nullptr && load)
2612 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetBasePtr");
2616 if(m_PEAK_BufferChunk_GetSize ==
nullptr && load)
2618 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetSize");
2622 if(m_PEAK_BufferChunk_GetParentBuffer ==
nullptr && load)
2624 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetParentBuffer");
2628 if(m_PEAK_BufferChunk_Destruct ==
nullptr && load)
2630 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_Destruct");
2634 if(m_PEAK_BufferPart_GetInfo ==
nullptr && load)
2636 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetInfo");
2640 if(m_PEAK_BufferPart_GetSourceID ==
nullptr && load)
2642 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetSourceID");
2646 if(m_PEAK_BufferPart_GetBasePtr ==
nullptr && load)
2648 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetBasePtr");
2652 if(m_PEAK_BufferPart_GetSize ==
nullptr && load)
2654 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetSize");
2658 if(m_PEAK_BufferPart_GetType ==
nullptr && load)
2660 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetType");
2664 if(m_PEAK_BufferPart_GetFormat ==
nullptr && load)
2666 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetFormat");
2670 if(m_PEAK_BufferPart_GetFormatNamespace ==
nullptr && load)
2672 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetFormatNamespace");
2676 if(m_PEAK_BufferPart_GetWidth ==
nullptr && load)
2678 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetWidth");
2682 if(m_PEAK_BufferPart_GetHeight ==
nullptr && load)
2684 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetHeight");
2688 if(m_PEAK_BufferPart_GetXOffset ==
nullptr && load)
2690 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetXOffset");
2694 if(m_PEAK_BufferPart_GetYOffset ==
nullptr && load)
2696 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetYOffset");
2700 if(m_PEAK_BufferPart_GetXPadding ==
nullptr && load)
2702 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetXPadding");
2706 if(m_PEAK_BufferPart_GetDeliveredImageHeight ==
nullptr && load)
2708 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetDeliveredImageHeight");
2712 if(m_PEAK_BufferPart_GetParentBuffer ==
nullptr && load)
2714 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetParentBuffer");
2718 if(m_PEAK_BufferPart_Destruct ==
nullptr && load)
2720 throw std::runtime_error(
"Failed to load PEAK_BufferPart_Destruct");
2724 if(m_PEAK_ModuleDescriptor_GetID ==
nullptr && load)
2726 throw std::runtime_error(
"Failed to load PEAK_ModuleDescriptor_GetID");
2730 if(m_PEAK_Module_GetNumNodeMaps ==
nullptr && load)
2732 throw std::runtime_error(
"Failed to load PEAK_Module_GetNumNodeMaps");
2736 if(m_PEAK_Module_GetNodeMap ==
nullptr && load)
2738 throw std::runtime_error(
"Failed to load PEAK_Module_GetNodeMap");
2742 if(m_PEAK_Module_GetPort ==
nullptr && load)
2744 throw std::runtime_error(
"Failed to load PEAK_Module_GetPort");
2748 if(m_PEAK_NodeMap_GetHasNode ==
nullptr && load)
2750 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasNode");
2754 if(m_PEAK_NodeMap_FindNode ==
nullptr && load)
2756 throw std::runtime_error(
"Failed to load PEAK_NodeMap_FindNode");
2760 if(m_PEAK_NodeMap_InvalidateNodes ==
nullptr && load)
2762 throw std::runtime_error(
"Failed to load PEAK_NodeMap_InvalidateNodes");
2766 if(m_PEAK_NodeMap_PollNodes ==
nullptr && load)
2768 throw std::runtime_error(
"Failed to load PEAK_NodeMap_PollNodes");
2772 if(m_PEAK_NodeMap_GetNumNodes ==
nullptr && load)
2774 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetNumNodes");
2778 if(m_PEAK_NodeMap_GetNode ==
nullptr && load)
2780 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetNode");
2784 if(m_PEAK_NodeMap_GetHasBufferSupportedChunks ==
nullptr && load)
2786 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasBufferSupportedChunks");
2790 if(m_PEAK_NodeMap_UpdateChunkNodes ==
nullptr && load)
2792 throw std::runtime_error(
"Failed to load PEAK_NodeMap_UpdateChunkNodes");
2796 if(m_PEAK_NodeMap_GetHasEventSupportedData ==
nullptr && load)
2798 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasEventSupportedData");
2802 if(m_PEAK_NodeMap_UpdateEventNodes ==
nullptr && load)
2804 throw std::runtime_error(
"Failed to load PEAK_NodeMap_UpdateEventNodes");
2808 if(m_PEAK_NodeMap_StoreToFile ==
nullptr && load)
2810 throw std::runtime_error(
"Failed to load PEAK_NodeMap_StoreToFile");
2814 if(m_PEAK_NodeMap_LoadFromFile ==
nullptr && load)
2816 throw std::runtime_error(
"Failed to load PEAK_NodeMap_LoadFromFile");
2820 if(m_PEAK_NodeMap_Lock ==
nullptr && load)
2822 throw std::runtime_error(
"Failed to load PEAK_NodeMap_Lock");
2826 if(m_PEAK_NodeMap_Unlock ==
nullptr && load)
2828 throw std::runtime_error(
"Failed to load PEAK_NodeMap_Unlock");
2832 if(m_PEAK_Node_ToIntegerNode ==
nullptr && load)
2834 throw std::runtime_error(
"Failed to load PEAK_Node_ToIntegerNode");
2838 if(m_PEAK_Node_ToBooleanNode ==
nullptr && load)
2840 throw std::runtime_error(
"Failed to load PEAK_Node_ToBooleanNode");
2844 if(m_PEAK_Node_ToCommandNode ==
nullptr && load)
2846 throw std::runtime_error(
"Failed to load PEAK_Node_ToCommandNode");
2850 if(m_PEAK_Node_ToFloatNode ==
nullptr && load)
2852 throw std::runtime_error(
"Failed to load PEAK_Node_ToFloatNode");
2856 if(m_PEAK_Node_ToStringNode ==
nullptr && load)
2858 throw std::runtime_error(
"Failed to load PEAK_Node_ToStringNode");
2862 if(m_PEAK_Node_ToRegisterNode ==
nullptr && load)
2864 throw std::runtime_error(
"Failed to load PEAK_Node_ToRegisterNode");
2868 if(m_PEAK_Node_ToCategoryNode ==
nullptr && load)
2870 throw std::runtime_error(
"Failed to load PEAK_Node_ToCategoryNode");
2874 if(m_PEAK_Node_ToEnumerationNode ==
nullptr && load)
2876 throw std::runtime_error(
"Failed to load PEAK_Node_ToEnumerationNode");
2880 if(m_PEAK_Node_ToEnumerationEntryNode ==
nullptr && load)
2882 throw std::runtime_error(
"Failed to load PEAK_Node_ToEnumerationEntryNode");
2886 if(m_PEAK_Node_GetName ==
nullptr && load)
2888 throw std::runtime_error(
"Failed to load PEAK_Node_GetName");
2892 if(m_PEAK_Node_GetDisplayName ==
nullptr && load)
2894 throw std::runtime_error(
"Failed to load PEAK_Node_GetDisplayName");
2898 if(m_PEAK_Node_GetNamespace ==
nullptr && load)
2900 throw std::runtime_error(
"Failed to load PEAK_Node_GetNamespace");
2904 if(m_PEAK_Node_GetVisibility ==
nullptr && load)
2906 throw std::runtime_error(
"Failed to load PEAK_Node_GetVisibility");
2910 if(m_PEAK_Node_GetAccessStatus ==
nullptr && load)
2912 throw std::runtime_error(
"Failed to load PEAK_Node_GetAccessStatus");
2916 if(m_PEAK_Node_GetIsCacheable ==
nullptr && load)
2918 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsCacheable");
2922 if(m_PEAK_Node_GetIsAccessStatusCacheable ==
nullptr && load)
2924 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsAccessStatusCacheable");
2928 if(m_PEAK_Node_GetIsStreamable ==
nullptr && load)
2930 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsStreamable");
2934 if(m_PEAK_Node_GetIsDeprecated ==
nullptr && load)
2936 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsDeprecated");
2940 if(m_PEAK_Node_GetIsFeature ==
nullptr && load)
2942 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsFeature");
2946 if(m_PEAK_Node_GetCachingMode ==
nullptr && load)
2948 throw std::runtime_error(
"Failed to load PEAK_Node_GetCachingMode");
2952 if(m_PEAK_Node_GetPollingTime ==
nullptr && load)
2954 throw std::runtime_error(
"Failed to load PEAK_Node_GetPollingTime");
2958 if(m_PEAK_Node_GetToolTip ==
nullptr && load)
2960 throw std::runtime_error(
"Failed to load PEAK_Node_GetToolTip");
2964 if(m_PEAK_Node_GetDescription ==
nullptr && load)
2966 throw std::runtime_error(
"Failed to load PEAK_Node_GetDescription");
2970 if(m_PEAK_Node_GetType ==
nullptr && load)
2972 throw std::runtime_error(
"Failed to load PEAK_Node_GetType");
2976 if(m_PEAK_Node_GetParentNodeMap ==
nullptr && load)
2978 throw std::runtime_error(
"Failed to load PEAK_Node_GetParentNodeMap");
2982 if(m_PEAK_Node_FindInvalidatedNode ==
nullptr && load)
2984 throw std::runtime_error(
"Failed to load PEAK_Node_FindInvalidatedNode");
2988 if(m_PEAK_Node_GetNumInvalidatedNodes ==
nullptr && load)
2990 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumInvalidatedNodes");
2994 if(m_PEAK_Node_GetInvalidatedNode ==
nullptr && load)
2996 throw std::runtime_error(
"Failed to load PEAK_Node_GetInvalidatedNode");
3000 if(m_PEAK_Node_FindInvalidatingNode ==
nullptr && load)
3002 throw std::runtime_error(
"Failed to load PEAK_Node_FindInvalidatingNode");
3006 if(m_PEAK_Node_GetNumInvalidatingNodes ==
nullptr && load)
3008 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumInvalidatingNodes");
3012 if(m_PEAK_Node_GetInvalidatingNode ==
nullptr && load)
3014 throw std::runtime_error(
"Failed to load PEAK_Node_GetInvalidatingNode");
3018 if(m_PEAK_Node_FindSelectedNode ==
nullptr && load)
3020 throw std::runtime_error(
"Failed to load PEAK_Node_FindSelectedNode");
3024 if(m_PEAK_Node_GetNumSelectedNodes ==
nullptr && load)
3026 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumSelectedNodes");
3030 if(m_PEAK_Node_GetSelectedNode ==
nullptr && load)
3032 throw std::runtime_error(
"Failed to load PEAK_Node_GetSelectedNode");
3036 if(m_PEAK_Node_FindSelectingNode ==
nullptr && load)
3038 throw std::runtime_error(
"Failed to load PEAK_Node_FindSelectingNode");
3042 if(m_PEAK_Node_GetNumSelectingNodes ==
nullptr && load)
3044 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumSelectingNodes");
3048 if(m_PEAK_Node_GetSelectingNode ==
nullptr && load)
3050 throw std::runtime_error(
"Failed to load PEAK_Node_GetSelectingNode");
3054 if(m_PEAK_Node_RegisterChangedCallback ==
nullptr && load)
3056 throw std::runtime_error(
"Failed to load PEAK_Node_RegisterChangedCallback");
3060 if(m_PEAK_Node_UnregisterChangedCallback ==
nullptr && load)
3062 throw std::runtime_error(
"Failed to load PEAK_Node_UnregisterChangedCallback");
3066 if(m_PEAK_IntegerNode_ToNode ==
nullptr && load)
3068 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_ToNode");
3072 if(m_PEAK_IntegerNode_GetMinimum ==
nullptr && load)
3074 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetMinimum");
3078 if(m_PEAK_IntegerNode_GetMaximum ==
nullptr && load)
3080 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetMaximum");
3084 if(m_PEAK_IntegerNode_GetIncrement ==
nullptr && load)
3086 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetIncrement");
3090 if(m_PEAK_IntegerNode_GetIncrementType ==
nullptr && load)
3092 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetIncrementType");
3096 if(m_PEAK_IntegerNode_GetValidValues ==
nullptr && load)
3098 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetValidValues");
3102 if(m_PEAK_IntegerNode_GetRepresentation ==
nullptr && load)
3104 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetRepresentation");
3108 if(m_PEAK_IntegerNode_GetUnit ==
nullptr && load)
3110 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetUnit");
3114 if(m_PEAK_IntegerNode_GetValue ==
nullptr && load)
3116 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetValue");
3120 if(m_PEAK_IntegerNode_SetValue ==
nullptr && load)
3122 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_SetValue");
3126 if(m_PEAK_BooleanNode_ToNode ==
nullptr && load)
3128 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_ToNode");
3132 if(m_PEAK_BooleanNode_GetValue ==
nullptr && load)
3134 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_GetValue");
3138 if(m_PEAK_BooleanNode_SetValue ==
nullptr && load)
3140 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_SetValue");
3144 if(m_PEAK_CommandNode_ToNode ==
nullptr && load)
3146 throw std::runtime_error(
"Failed to load PEAK_CommandNode_ToNode");
3150 if(m_PEAK_CommandNode_GetIsDone ==
nullptr && load)
3152 throw std::runtime_error(
"Failed to load PEAK_CommandNode_GetIsDone");
3156 if(m_PEAK_CommandNode_Execute ==
nullptr && load)
3158 throw std::runtime_error(
"Failed to load PEAK_CommandNode_Execute");
3162 if(m_PEAK_CommandNode_WaitUntilDoneInfinite ==
nullptr && load)
3164 throw std::runtime_error(
"Failed to load PEAK_CommandNode_WaitUntilDoneInfinite");
3168 if(m_PEAK_CommandNode_WaitUntilDone ==
nullptr && load)
3170 throw std::runtime_error(
"Failed to load PEAK_CommandNode_WaitUntilDone");
3174 if(m_PEAK_FloatNode_ToNode ==
nullptr && load)
3176 throw std::runtime_error(
"Failed to load PEAK_FloatNode_ToNode");
3180 if(m_PEAK_FloatNode_GetMinimum ==
nullptr && load)
3182 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetMinimum");
3186 if(m_PEAK_FloatNode_GetMaximum ==
nullptr && load)
3188 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetMaximum");
3192 if(m_PEAK_FloatNode_GetIncrement ==
nullptr && load)
3194 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetIncrement");
3198 if(m_PEAK_FloatNode_GetIncrementType ==
nullptr && load)
3200 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetIncrementType");
3204 if(m_PEAK_FloatNode_GetValidValues ==
nullptr && load)
3206 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetValidValues");
3210 if(m_PEAK_FloatNode_GetRepresentation ==
nullptr && load)
3212 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetRepresentation");
3216 if(m_PEAK_FloatNode_GetUnit ==
nullptr && load)
3218 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetUnit");
3222 if(m_PEAK_FloatNode_GetDisplayNotation ==
nullptr && load)
3224 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetDisplayNotation");
3228 if(m_PEAK_FloatNode_GetDisplayPrecision ==
nullptr && load)
3230 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetDisplayPrecision");
3234 if(m_PEAK_FloatNode_GetHasConstantIncrement ==
nullptr && load)
3236 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetHasConstantIncrement");
3240 if(m_PEAK_FloatNode_GetValue ==
nullptr && load)
3242 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetValue");
3246 if(m_PEAK_FloatNode_SetValue ==
nullptr && load)
3248 throw std::runtime_error(
"Failed to load PEAK_FloatNode_SetValue");
3252 if(m_PEAK_StringNode_ToNode ==
nullptr && load)
3254 throw std::runtime_error(
"Failed to load PEAK_StringNode_ToNode");
3258 if(m_PEAK_StringNode_GetMaximumLength ==
nullptr && load)
3260 throw std::runtime_error(
"Failed to load PEAK_StringNode_GetMaximumLength");
3264 if(m_PEAK_StringNode_GetValue ==
nullptr && load)
3266 throw std::runtime_error(
"Failed to load PEAK_StringNode_GetValue");
3270 if(m_PEAK_StringNode_SetValue ==
nullptr && load)
3272 throw std::runtime_error(
"Failed to load PEAK_StringNode_SetValue");
3276 if(m_PEAK_RegisterNode_ToNode ==
nullptr && load)
3278 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_ToNode");
3282 if(m_PEAK_RegisterNode_GetAddress ==
nullptr && load)
3284 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_GetAddress");
3288 if(m_PEAK_RegisterNode_GetLength ==
nullptr && load)
3290 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_GetLength");
3294 if(m_PEAK_RegisterNode_Read ==
nullptr && load)
3296 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_Read");
3300 if(m_PEAK_RegisterNode_Write ==
nullptr && load)
3302 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_Write");
3306 if(m_PEAK_CategoryNode_ToNode ==
nullptr && load)
3308 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_ToNode");
3312 if(m_PEAK_CategoryNode_GetNumSubNodes ==
nullptr && load)
3314 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_GetNumSubNodes");
3318 if(m_PEAK_CategoryNode_GetSubNode ==
nullptr && load)
3320 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_GetSubNode");
3324 if(m_PEAK_EnumerationNode_ToNode ==
nullptr && load)
3326 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_ToNode");
3330 if(m_PEAK_EnumerationNode_GetCurrentEntry ==
nullptr && load)
3332 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetCurrentEntry");
3336 if(m_PEAK_EnumerationNode_SetCurrentEntry ==
nullptr && load)
3338 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntry");
3342 if(m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue ==
nullptr && load)
3344 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue");
3348 if(m_PEAK_EnumerationNode_SetCurrentEntryByValue ==
nullptr && load)
3350 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntryByValue");
3354 if(m_PEAK_EnumerationNode_FindEntryBySymbolicValue ==
nullptr && load)
3356 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_FindEntryBySymbolicValue");
3360 if(m_PEAK_EnumerationNode_FindEntryByValue ==
nullptr && load)
3362 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_FindEntryByValue");
3366 if(m_PEAK_EnumerationNode_GetNumEntries ==
nullptr && load)
3368 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetNumEntries");
3372 if(m_PEAK_EnumerationNode_GetEntry ==
nullptr && load)
3374 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetEntry");
3378 if(m_PEAK_EnumerationEntryNode_ToNode ==
nullptr && load)
3380 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_ToNode");
3384 if(m_PEAK_EnumerationEntryNode_GetIsSelfClearing ==
nullptr && load)
3386 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetIsSelfClearing");
3390 if(m_PEAK_EnumerationEntryNode_GetSymbolicValue ==
nullptr && load)
3392 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetSymbolicValue");
3396 if(m_PEAK_EnumerationEntryNode_GetValue ==
nullptr && load)
3398 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetValue");
3402 if(m_PEAK_Port_GetInfo ==
nullptr && load)
3404 throw std::runtime_error(
"Failed to load PEAK_Port_GetInfo");
3408 if(m_PEAK_Port_GetID ==
nullptr && load)
3410 throw std::runtime_error(
"Failed to load PEAK_Port_GetID");
3414 if(m_PEAK_Port_GetName ==
nullptr && load)
3416 throw std::runtime_error(
"Failed to load PEAK_Port_GetName");
3420 if(m_PEAK_Port_GetVendorName ==
nullptr && load)
3422 throw std::runtime_error(
"Failed to load PEAK_Port_GetVendorName");
3426 if(m_PEAK_Port_GetModelName ==
nullptr && load)
3428 throw std::runtime_error(
"Failed to load PEAK_Port_GetModelName");
3432 if(m_PEAK_Port_GetVersion ==
nullptr && load)
3434 throw std::runtime_error(
"Failed to load PEAK_Port_GetVersion");
3438 if(m_PEAK_Port_GetTLType ==
nullptr && load)
3440 throw std::runtime_error(
"Failed to load PEAK_Port_GetTLType");
3444 if(m_PEAK_Port_GetModuleName ==
nullptr && load)
3446 throw std::runtime_error(
"Failed to load PEAK_Port_GetModuleName");
3450 if(m_PEAK_Port_GetDataEndianness ==
nullptr && load)
3452 throw std::runtime_error(
"Failed to load PEAK_Port_GetDataEndianness");
3456 if(m_PEAK_Port_GetIsReadable ==
nullptr && load)
3458 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsReadable");
3462 if(m_PEAK_Port_GetIsWritable ==
nullptr && load)
3464 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsWritable");
3468 if(m_PEAK_Port_GetIsAvailable ==
nullptr && load)
3470 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsAvailable");
3474 if(m_PEAK_Port_GetIsImplemented ==
nullptr && load)
3476 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsImplemented");
3480 if(m_PEAK_Port_Read ==
nullptr && load)
3482 throw std::runtime_error(
"Failed to load PEAK_Port_Read");
3486 if(m_PEAK_Port_Write ==
nullptr && load)
3488 throw std::runtime_error(
"Failed to load PEAK_Port_Write");
3492 if(m_PEAK_Port_GetNumURLs ==
nullptr && load)
3494 throw std::runtime_error(
"Failed to load PEAK_Port_GetNumURLs");
3498 if(m_PEAK_Port_GetURL ==
nullptr && load)
3500 throw std::runtime_error(
"Failed to load PEAK_Port_GetURL");
3504 if(m_PEAK_PortURL_GetInfo ==
nullptr && load)
3506 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetInfo");
3510 if(m_PEAK_PortURL_GetURL ==
nullptr && load)
3512 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetURL");
3516 if(m_PEAK_PortURL_GetScheme ==
nullptr && load)
3518 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetScheme");
3522 if(m_PEAK_PortURL_GetFileName ==
nullptr && load)
3524 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileName");
3528 if(m_PEAK_PortURL_GetFileRegisterAddress ==
nullptr && load)
3530 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileRegisterAddress");
3534 if(m_PEAK_PortURL_GetFileSize ==
nullptr && load)
3536 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSize");
3540 if(m_PEAK_PortURL_GetFileSHA1Hash ==
nullptr && load)
3542 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSHA1Hash");
3546 if(m_PEAK_PortURL_GetFileVersionMajor ==
nullptr && load)
3548 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionMajor");
3552 if(m_PEAK_PortURL_GetFileVersionMinor ==
nullptr && load)
3554 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionMinor");
3558 if(m_PEAK_PortURL_GetFileVersionSubminor ==
nullptr && load)
3560 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionSubminor");
3564 if(m_PEAK_PortURL_GetFileSchemaVersionMajor ==
nullptr && load)
3566 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSchemaVersionMajor");
3570 if(m_PEAK_PortURL_GetFileSchemaVersionMinor ==
nullptr && load)
3572 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSchemaVersionMinor");
3576 if(m_PEAK_PortURL_GetParentPort ==
nullptr && load)
3578 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetParentPort");
3582 if(m_PEAK_EventSupportingModule_EnableEvents ==
nullptr && load)
3584 throw std::runtime_error(
"Failed to load PEAK_EventSupportingModule_EnableEvents");
3588 if(m_PEAK_EventController_GetInfo ==
nullptr && load)
3590 throw std::runtime_error(
"Failed to load PEAK_EventController_GetInfo");
3594 if(m_PEAK_EventController_GetNumEventsInQueue ==
nullptr && load)
3596 throw std::runtime_error(
"Failed to load PEAK_EventController_GetNumEventsInQueue");
3600 if(m_PEAK_EventController_GetNumEventsFired ==
nullptr && load)
3602 throw std::runtime_error(
"Failed to load PEAK_EventController_GetNumEventsFired");
3606 if(m_PEAK_EventController_GetEventMaxSize ==
nullptr && load)
3608 throw std::runtime_error(
"Failed to load PEAK_EventController_GetEventMaxSize");
3612 if(m_PEAK_EventController_GetEventDataMaxSize ==
nullptr && load)
3614 throw std::runtime_error(
"Failed to load PEAK_EventController_GetEventDataMaxSize");
3618 if(m_PEAK_EventController_GetControlledEventType ==
nullptr && load)
3620 throw std::runtime_error(
"Failed to load PEAK_EventController_GetControlledEventType");
3624 if(m_PEAK_EventController_WaitForEvent ==
nullptr && load)
3626 throw std::runtime_error(
"Failed to load PEAK_EventController_WaitForEvent");
3630 if(m_PEAK_EventController_KillWait ==
nullptr && load)
3632 throw std::runtime_error(
"Failed to load PEAK_EventController_KillWait");
3636 if(m_PEAK_EventController_FlushEvents ==
nullptr && load)
3638 throw std::runtime_error(
"Failed to load PEAK_EventController_FlushEvents");
3642 if(m_PEAK_EventController_Destruct ==
nullptr && load)
3644 throw std::runtime_error(
"Failed to load PEAK_EventController_Destruct");
3648 if(m_PEAK_Event_GetInfo ==
nullptr && load)
3650 throw std::runtime_error(
"Failed to load PEAK_Event_GetInfo");
3654 if(m_PEAK_Event_GetID ==
nullptr && load)
3656 throw std::runtime_error(
"Failed to load PEAK_Event_GetID");
3660 if(m_PEAK_Event_GetData ==
nullptr && load)
3662 throw std::runtime_error(
"Failed to load PEAK_Event_GetData");
3666 if(m_PEAK_Event_GetType ==
nullptr && load)
3668 throw std::runtime_error(
"Failed to load PEAK_Event_GetType");
3672 if(m_PEAK_Event_GetRawData ==
nullptr && load)
3674 throw std::runtime_error(
"Failed to load PEAK_Event_GetRawData");
3678 if(m_PEAK_Event_Destruct ==
nullptr && load)
3680 throw std::runtime_error(
"Failed to load PEAK_Event_Destruct");
3684 if(m_PEAK_FirmwareUpdater_Construct ==
nullptr && load)
3686 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_Construct");
3690 if(m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation ==
nullptr && load)
3692 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation");
3696 if(m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation ==
nullptr && load)
3698 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation");
3702 if(m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation ==
nullptr && load)
3704 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation");
3708 if(m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation ==
nullptr && load)
3710 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_GetFirmwareUpdateInformation");
3714 if(m_PEAK_FirmwareUpdater_UpdateDevice ==
nullptr && load)
3716 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_UpdateDevice");
3720 if(m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout ==
nullptr && load)
3722 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout");
3726 if(m_PEAK_FirmwareUpdater_Destruct ==
nullptr && load)
3728 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_Destruct");
3732 if(m_PEAK_FirmwareUpdateInformation_GetIsValid ==
nullptr && load)
3734 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetIsValid");
3738 if(m_PEAK_FirmwareUpdateInformation_GetFileName ==
nullptr && load)
3740 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetFileName");
3744 if(m_PEAK_FirmwareUpdateInformation_GetDescription ==
nullptr && load)
3746 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetDescription");
3750 if(m_PEAK_FirmwareUpdateInformation_GetVersion ==
nullptr && load)
3752 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersion");
3756 if(m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern ==
nullptr && load)
3758 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern");
3762 if(m_PEAK_FirmwareUpdateInformation_GetVersionStyle ==
nullptr && load)
3764 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersionStyle");
3768 if(m_PEAK_FirmwareUpdateInformation_GetReleaseNotes ==
nullptr && load)
3770 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetReleaseNotes");
3774 if(m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL ==
nullptr && load)
3776 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetReleaseNotesURL");
3780 if(m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence ==
nullptr && load)
3782 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetUserSetPersistence");
3786 if(m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence ==
nullptr && load)
3788 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence");
3792 if(m_PEAK_FirmwareUpdateProgressObserver_Construct ==
nullptr && load)
3794 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_Construct");
3798 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback ==
nullptr && load)
3800 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback");
3804 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback ==
nullptr && load)
3806 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback");
3810 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback ==
nullptr && load)
3812 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback");
3816 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback ==
nullptr && load)
3818 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback");
3822 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback ==
nullptr && load)
3824 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback");
3828 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback ==
nullptr && load)
3830 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback");
3834 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback ==
nullptr && load)
3836 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback");
3840 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback ==
nullptr && load)
3842 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback");
3846 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback ==
nullptr && load)
3848 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback");
3852 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback ==
nullptr && load)
3854 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback");
3858 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback ==
nullptr && load)
3860 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback");
3864 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback ==
nullptr && load)
3866 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback");
3870 if(m_PEAK_FirmwareUpdateProgressObserver_Destruct ==
nullptr && load)
3872 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_Destruct");
3881 auto& inst = instance();
3882 if(inst.m_PEAK_Library_Initialize)
3884 return inst.m_PEAK_Library_Initialize();
3888 throw std::runtime_error(
"Library not loaded!");
3894 auto& inst = instance();
3895 if(inst.m_PEAK_Library_Close)
3897 return inst.m_PEAK_Library_Close();
3901 throw std::runtime_error(
"Library not loaded!");
3907 auto& inst = instance();
3908 if(inst.m_PEAK_Library_IsInitialized)
3910 return inst.m_PEAK_Library_IsInitialized(isInitialized);
3914 throw std::runtime_error(
"Library not loaded!");
3920 auto& inst = instance();
3921 if(inst.m_PEAK_Library_GetVersionMajor)
3923 return inst.m_PEAK_Library_GetVersionMajor(libraryVersionMajor);
3927 throw std::runtime_error(
"Library not loaded!");
3933 auto& inst = instance();
3934 if(inst.m_PEAK_Library_GetVersionMinor)
3936 return inst.m_PEAK_Library_GetVersionMinor(libraryVersionMinor);
3940 throw std::runtime_error(
"Library not loaded!");
3946 auto& inst = instance();
3947 if(inst.m_PEAK_Library_GetVersionSubminor)
3949 return inst.m_PEAK_Library_GetVersionSubminor(libraryVersionSubminor);
3953 throw std::runtime_error(
"Library not loaded!");
3959 auto& inst = instance();
3960 if(inst.m_PEAK_Library_GetLastError)
3962 return inst.m_PEAK_Library_GetLastError(lastErrorCode, lastErrorDescription, lastErrorDescriptionSize);
3966 throw std::runtime_error(
"Library not loaded!");
3972 auto& inst = instance();
3973 if(inst.m_PEAK_EnvironmentInspector_UpdateCTIPaths)
3975 return inst.m_PEAK_EnvironmentInspector_UpdateCTIPaths();
3979 throw std::runtime_error(
"Library not loaded!");
3985 auto& inst = instance();
3986 if(inst.m_PEAK_EnvironmentInspector_GetNumCTIPaths)
3988 return inst.m_PEAK_EnvironmentInspector_GetNumCTIPaths(numCtiPaths);
3992 throw std::runtime_error(
"Library not loaded!");
3998 auto& inst = instance();
3999 if(inst.m_PEAK_EnvironmentInspector_GetCTIPath)
4001 return inst.m_PEAK_EnvironmentInspector_GetCTIPath(index, ctiPath, ctiPathSize);
4005 throw std::runtime_error(
"Library not loaded!");
4011 auto& inst = instance();
4012 if(inst.m_PEAK_ProducerLibrary_Construct)
4014 return inst.m_PEAK_ProducerLibrary_Construct(ctiPath, ctiPathSize, producerLibraryHandle);
4018 throw std::runtime_error(
"Library not loaded!");
4024 auto& inst = instance();
4025 if(inst.m_PEAK_ProducerLibrary_GetKey)
4027 return inst.m_PEAK_ProducerLibrary_GetKey(producerLibraryHandle, key, keySize);
4031 throw std::runtime_error(
"Library not loaded!");
4037 auto& inst = instance();
4038 if(inst.m_PEAK_ProducerLibrary_GetSystem)
4040 return inst.m_PEAK_ProducerLibrary_GetSystem(producerLibraryHandle, systemDescriptorHandle);
4044 throw std::runtime_error(
"Library not loaded!");
4050 auto& inst = instance();
4051 if(inst.m_PEAK_ProducerLibrary_Destruct)
4053 return inst.m_PEAK_ProducerLibrary_Destruct(producerLibraryHandle);
4057 throw std::runtime_error(
"Library not loaded!");
4063 auto& inst = instance();
4064 if(inst.m_PEAK_SystemDescriptor_ToModuleDescriptor)
4066 return inst.m_PEAK_SystemDescriptor_ToModuleDescriptor(systemDescriptorHandle, moduleDescriptorHandle);
4070 throw std::runtime_error(
"Library not loaded!");
4076 auto& inst = instance();
4077 if(inst.m_PEAK_SystemDescriptor_GetKey)
4079 return inst.m_PEAK_SystemDescriptor_GetKey(systemDescriptorHandle, key, keySize);
4083 throw std::runtime_error(
"Library not loaded!");
4089 auto& inst = instance();
4090 if(inst.m_PEAK_SystemDescriptor_GetInfo)
4092 return inst.m_PEAK_SystemDescriptor_GetInfo(systemDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4096 throw std::runtime_error(
"Library not loaded!");
4102 auto& inst = instance();
4103 if(inst.m_PEAK_SystemDescriptor_GetDisplayName)
4105 return inst.m_PEAK_SystemDescriptor_GetDisplayName(systemDescriptorHandle, displayName, displayNameSize);
4109 throw std::runtime_error(
"Library not loaded!");
4115 auto& inst = instance();
4116 if(inst.m_PEAK_SystemDescriptor_GetVendorName)
4118 return inst.m_PEAK_SystemDescriptor_GetVendorName(systemDescriptorHandle, vendorName, vendorNameSize);
4122 throw std::runtime_error(
"Library not loaded!");
4128 auto& inst = instance();
4129 if(inst.m_PEAK_SystemDescriptor_GetModelName)
4131 return inst.m_PEAK_SystemDescriptor_GetModelName(systemDescriptorHandle, modelName, modelNameSize);
4135 throw std::runtime_error(
"Library not loaded!");
4141 auto& inst = instance();
4142 if(inst.m_PEAK_SystemDescriptor_GetVersion)
4144 return inst.m_PEAK_SystemDescriptor_GetVersion(systemDescriptorHandle, version, versionSize);
4148 throw std::runtime_error(
"Library not loaded!");
4154 auto& inst = instance();
4155 if(inst.m_PEAK_SystemDescriptor_GetTLType)
4157 return inst.m_PEAK_SystemDescriptor_GetTLType(systemDescriptorHandle, tlType, tlTypeSize);
4161 throw std::runtime_error(
"Library not loaded!");
4167 auto& inst = instance();
4168 if(inst.m_PEAK_SystemDescriptor_GetCTIFileName)
4170 return inst.m_PEAK_SystemDescriptor_GetCTIFileName(systemDescriptorHandle, ctiFileName, ctiFileNameSize);
4174 throw std::runtime_error(
"Library not loaded!");
4180 auto& inst = instance();
4181 if(inst.m_PEAK_SystemDescriptor_GetCTIFullPath)
4183 return inst.m_PEAK_SystemDescriptor_GetCTIFullPath(systemDescriptorHandle, ctiFullPath, ctiFullPathSize);
4187 throw std::runtime_error(
"Library not loaded!");
4193 auto& inst = instance();
4194 if(inst.m_PEAK_SystemDescriptor_GetGenTLVersionMajor)
4196 return inst.m_PEAK_SystemDescriptor_GetGenTLVersionMajor(systemDescriptorHandle, gentlVersionMajor);
4200 throw std::runtime_error(
"Library not loaded!");
4206 auto& inst = instance();
4207 if(inst.m_PEAK_SystemDescriptor_GetGenTLVersionMinor)
4209 return inst.m_PEAK_SystemDescriptor_GetGenTLVersionMinor(systemDescriptorHandle, gentlVersionMinor);
4213 throw std::runtime_error(
"Library not loaded!");
4219 auto& inst = instance();
4220 if(inst.m_PEAK_SystemDescriptor_GetCharacterEncoding)
4222 return inst.m_PEAK_SystemDescriptor_GetCharacterEncoding(systemDescriptorHandle, characterEncoding);
4226 throw std::runtime_error(
"Library not loaded!");
4232 auto& inst = instance();
4233 if(inst.m_PEAK_SystemDescriptor_GetParentLibrary)
4235 return inst.m_PEAK_SystemDescriptor_GetParentLibrary(systemDescriptorHandle, producerLibraryHandle);
4239 throw std::runtime_error(
"Library not loaded!");
4245 auto& inst = instance();
4246 if(inst.m_PEAK_SystemDescriptor_OpenSystem)
4248 return inst.m_PEAK_SystemDescriptor_OpenSystem(systemDescriptorHandle, systemHandle);
4252 throw std::runtime_error(
"Library not loaded!");
4258 auto& inst = instance();
4259 if(inst.m_PEAK_System_ToModule)
4261 return inst.m_PEAK_System_ToModule(systemHandle, moduleHandle);
4265 throw std::runtime_error(
"Library not loaded!");
4271 auto& inst = instance();
4272 if(inst.m_PEAK_System_ToEventSupportingModule)
4274 return inst.m_PEAK_System_ToEventSupportingModule(systemHandle, eventSupportingModuleHandle);
4278 throw std::runtime_error(
"Library not loaded!");
4284 auto& inst = instance();
4285 if(inst.m_PEAK_System_GetKey)
4287 return inst.m_PEAK_System_GetKey(systemHandle, key, keySize);
4291 throw std::runtime_error(
"Library not loaded!");
4297 auto& inst = instance();
4298 if(inst.m_PEAK_System_GetInfo)
4300 return inst.m_PEAK_System_GetInfo(systemHandle, infoCommand, infoDataType, info, infoSize);
4304 throw std::runtime_error(
"Library not loaded!");
4310 auto& inst = instance();
4311 if(inst.m_PEAK_System_GetID)
4313 return inst.m_PEAK_System_GetID(systemHandle,
id, idSize);
4317 throw std::runtime_error(
"Library not loaded!");
4323 auto& inst = instance();
4324 if(inst.m_PEAK_System_GetDisplayName)
4326 return inst.m_PEAK_System_GetDisplayName(systemHandle, displayName, displayNameSize);
4330 throw std::runtime_error(
"Library not loaded!");
4336 auto& inst = instance();
4337 if(inst.m_PEAK_System_GetVendorName)
4339 return inst.m_PEAK_System_GetVendorName(systemHandle, vendorName, vendorNameSize);
4343 throw std::runtime_error(
"Library not loaded!");
4349 auto& inst = instance();
4350 if(inst.m_PEAK_System_GetModelName)
4352 return inst.m_PEAK_System_GetModelName(systemHandle, modelName, modelNameSize);
4356 throw std::runtime_error(
"Library not loaded!");
4362 auto& inst = instance();
4363 if(inst.m_PEAK_System_GetVersion)
4365 return inst.m_PEAK_System_GetVersion(systemHandle, version, versionSize);
4369 throw std::runtime_error(
"Library not loaded!");
4375 auto& inst = instance();
4376 if(inst.m_PEAK_System_GetTLType)
4378 return inst.m_PEAK_System_GetTLType(systemHandle, tlType, tlTypeSize);
4382 throw std::runtime_error(
"Library not loaded!");
4388 auto& inst = instance();
4389 if(inst.m_PEAK_System_GetCTIFileName)
4391 return inst.m_PEAK_System_GetCTIFileName(systemHandle, ctiFileName, ctiFileNameSize);
4395 throw std::runtime_error(
"Library not loaded!");
4401 auto& inst = instance();
4402 if(inst.m_PEAK_System_GetCTIFullPath)
4404 return inst.m_PEAK_System_GetCTIFullPath(systemHandle, ctiFullPath, ctiFullPathSize);
4408 throw std::runtime_error(
"Library not loaded!");
4414 auto& inst = instance();
4415 if(inst.m_PEAK_System_GetGenTLVersionMajor)
4417 return inst.m_PEAK_System_GetGenTLVersionMajor(systemHandle, gentlVersionMajor);
4421 throw std::runtime_error(
"Library not loaded!");
4427 auto& inst = instance();
4428 if(inst.m_PEAK_System_GetGenTLVersionMinor)
4430 return inst.m_PEAK_System_GetGenTLVersionMinor(systemHandle, gentlVersionMinor);
4434 throw std::runtime_error(
"Library not loaded!");
4440 auto& inst = instance();
4441 if(inst.m_PEAK_System_GetCharacterEncoding)
4443 return inst.m_PEAK_System_GetCharacterEncoding(systemHandle, characterEncoding);
4447 throw std::runtime_error(
"Library not loaded!");
4453 auto& inst = instance();
4454 if(inst.m_PEAK_System_GetParentLibrary)
4456 return inst.m_PEAK_System_GetParentLibrary(systemHandle, producerLibraryHandle);
4460 throw std::runtime_error(
"Library not loaded!");
4466 auto& inst = instance();
4467 if(inst.m_PEAK_System_UpdateInterfaces)
4469 return inst.m_PEAK_System_UpdateInterfaces(systemHandle, timeout_ms);
4473 throw std::runtime_error(
"Library not loaded!");
4479 auto& inst = instance();
4480 if(inst.m_PEAK_System_GetNumInterfaces)
4482 return inst.m_PEAK_System_GetNumInterfaces(systemHandle, numInterfaces);
4486 throw std::runtime_error(
"Library not loaded!");
4492 auto& inst = instance();
4493 if(inst.m_PEAK_System_GetInterface)
4495 return inst.m_PEAK_System_GetInterface(systemHandle, index, interfaceDescriptorHandle);
4499 throw std::runtime_error(
"Library not loaded!");
4505 auto& inst = instance();
4506 if(inst.m_PEAK_System_RegisterInterfaceFoundCallback)
4508 return inst.m_PEAK_System_RegisterInterfaceFoundCallback(systemHandle, callback, callbackContext, callbackHandle);
4512 throw std::runtime_error(
"Library not loaded!");
4518 auto& inst = instance();
4519 if(inst.m_PEAK_System_UnregisterInterfaceFoundCallback)
4521 return inst.m_PEAK_System_UnregisterInterfaceFoundCallback(systemHandle, callbackHandle);
4525 throw std::runtime_error(
"Library not loaded!");
4531 auto& inst = instance();
4532 if(inst.m_PEAK_System_RegisterInterfaceLostCallback)
4534 return inst.m_PEAK_System_RegisterInterfaceLostCallback(systemHandle, callback, callbackContext, callbackHandle);
4538 throw std::runtime_error(
"Library not loaded!");
4544 auto& inst = instance();
4545 if(inst.m_PEAK_System_UnregisterInterfaceLostCallback)
4547 return inst.m_PEAK_System_UnregisterInterfaceLostCallback(systemHandle, callbackHandle);
4551 throw std::runtime_error(
"Library not loaded!");
4557 auto& inst = instance();
4558 if(inst.m_PEAK_System_Destruct)
4560 return inst.m_PEAK_System_Destruct(systemHandle);
4564 throw std::runtime_error(
"Library not loaded!");
4570 auto& inst = instance();
4571 if(inst.m_PEAK_InterfaceDescriptor_ToModuleDescriptor)
4573 return inst.m_PEAK_InterfaceDescriptor_ToModuleDescriptor(interfaceDescriptorHandle, moduleDescriptorHandle);
4577 throw std::runtime_error(
"Library not loaded!");
4583 auto& inst = instance();
4584 if(inst.m_PEAK_InterfaceDescriptor_GetKey)
4586 return inst.m_PEAK_InterfaceDescriptor_GetKey(interfaceDescriptorHandle, key, keySize);
4590 throw std::runtime_error(
"Library not loaded!");
4596 auto& inst = instance();
4597 if(inst.m_PEAK_InterfaceDescriptor_GetInfo)
4599 return inst.m_PEAK_InterfaceDescriptor_GetInfo(interfaceDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4603 throw std::runtime_error(
"Library not loaded!");
4609 auto& inst = instance();
4610 if(inst.m_PEAK_InterfaceDescriptor_GetDisplayName)
4612 return inst.m_PEAK_InterfaceDescriptor_GetDisplayName(interfaceDescriptorHandle, displayName, displayNameSize);
4616 throw std::runtime_error(
"Library not loaded!");
4622 auto& inst = instance();
4623 if(inst.m_PEAK_InterfaceDescriptor_GetTLType)
4625 return inst.m_PEAK_InterfaceDescriptor_GetTLType(interfaceDescriptorHandle, tlType, tlTypeSize);
4629 throw std::runtime_error(
"Library not loaded!");
4635 auto& inst = instance();
4636 if(inst.m_PEAK_InterfaceDescriptor_GetParentSystem)
4638 return inst.m_PEAK_InterfaceDescriptor_GetParentSystem(interfaceDescriptorHandle, systemHandle);
4642 throw std::runtime_error(
"Library not loaded!");
4648 auto& inst = instance();
4649 if(inst.m_PEAK_InterfaceDescriptor_OpenInterface)
4651 return inst.m_PEAK_InterfaceDescriptor_OpenInterface(interfaceDescriptorHandle, interfaceHandle);
4655 throw std::runtime_error(
"Library not loaded!");
4661 auto& inst = instance();
4662 if(inst.m_PEAK_Interface_ToModule)
4664 return inst.m_PEAK_Interface_ToModule(interfaceHandle, moduleHandle);
4668 throw std::runtime_error(
"Library not loaded!");
4674 auto& inst = instance();
4675 if(inst.m_PEAK_Interface_ToEventSupportingModule)
4677 return inst.m_PEAK_Interface_ToEventSupportingModule(interfaceHandle, eventSupportingModuleHandle);
4681 throw std::runtime_error(
"Library not loaded!");
4687 auto& inst = instance();
4688 if(inst.m_PEAK_Interface_GetKey)
4690 return inst.m_PEAK_Interface_GetKey(interfaceHandle, key, keySize);
4694 throw std::runtime_error(
"Library not loaded!");
4700 auto& inst = instance();
4701 if(inst.m_PEAK_Interface_GetInfo)
4703 return inst.m_PEAK_Interface_GetInfo(interfaceHandle, infoCommand, infoDataType, info, infoSize);
4707 throw std::runtime_error(
"Library not loaded!");
4713 auto& inst = instance();
4714 if(inst.m_PEAK_Interface_GetID)
4716 return inst.m_PEAK_Interface_GetID(interfaceHandle,
id, idSize);
4720 throw std::runtime_error(
"Library not loaded!");
4726 auto& inst = instance();
4727 if(inst.m_PEAK_Interface_GetDisplayName)
4729 return inst.m_PEAK_Interface_GetDisplayName(interfaceHandle, displayName, displayNameSize);
4733 throw std::runtime_error(
"Library not loaded!");
4739 auto& inst = instance();
4740 if(inst.m_PEAK_Interface_GetTLType)
4742 return inst.m_PEAK_Interface_GetTLType(interfaceHandle, tlType, tlTypeSize);
4746 throw std::runtime_error(
"Library not loaded!");
4752 auto& inst = instance();
4753 if(inst.m_PEAK_Interface_GetParentSystem)
4755 return inst.m_PEAK_Interface_GetParentSystem(interfaceHandle, systemHandle);
4759 throw std::runtime_error(
"Library not loaded!");
4765 auto& inst = instance();
4766 if(inst.m_PEAK_Interface_UpdateDevices)
4768 return inst.m_PEAK_Interface_UpdateDevices(interfaceHandle, timeout_ms);
4772 throw std::runtime_error(
"Library not loaded!");
4778 auto& inst = instance();
4779 if(inst.m_PEAK_Interface_GetNumDevices)
4781 return inst.m_PEAK_Interface_GetNumDevices(interfaceHandle, numDevices);
4785 throw std::runtime_error(
"Library not loaded!");
4791 auto& inst = instance();
4792 if(inst.m_PEAK_Interface_GetDevice)
4794 return inst.m_PEAK_Interface_GetDevice(interfaceHandle, index, deviceDescriptorHandle);
4798 throw std::runtime_error(
"Library not loaded!");
4804 auto& inst = instance();
4805 if(inst.m_PEAK_Interface_RegisterDeviceFoundCallback)
4807 return inst.m_PEAK_Interface_RegisterDeviceFoundCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4811 throw std::runtime_error(
"Library not loaded!");
4817 auto& inst = instance();
4818 if(inst.m_PEAK_Interface_UnregisterDeviceFoundCallback)
4820 return inst.m_PEAK_Interface_UnregisterDeviceFoundCallback(interfaceHandle, callbackHandle);
4824 throw std::runtime_error(
"Library not loaded!");
4830 auto& inst = instance();
4831 if(inst.m_PEAK_Interface_RegisterDeviceReconnectedCallback)
4833 return inst.m_PEAK_Interface_RegisterDeviceReconnectedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4837 throw std::runtime_error(
"Library not loaded!");
4843 auto& inst = instance();
4844 if(inst.m_PEAK_Interface_UnregisterDeviceReconnectedCallback)
4846 return inst.m_PEAK_Interface_UnregisterDeviceReconnectedCallback(interfaceHandle, callbackHandle);
4850 throw std::runtime_error(
"Library not loaded!");
4856 auto& inst = instance();
4857 if(inst.m_PEAK_Interface_RegisterDeviceDisconnectedCallback)
4859 return inst.m_PEAK_Interface_RegisterDeviceDisconnectedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4863 throw std::runtime_error(
"Library not loaded!");
4869 auto& inst = instance();
4870 if(inst.m_PEAK_Interface_UnregisterDeviceDisconnectedCallback)
4872 return inst.m_PEAK_Interface_UnregisterDeviceDisconnectedCallback(interfaceHandle, callbackHandle);
4876 throw std::runtime_error(
"Library not loaded!");
4882 auto& inst = instance();
4883 if(inst.m_PEAK_Interface_RegisterDeviceLostCallback)
4885 return inst.m_PEAK_Interface_RegisterDeviceLostCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4889 throw std::runtime_error(
"Library not loaded!");
4895 auto& inst = instance();
4896 if(inst.m_PEAK_Interface_UnregisterDeviceLostCallback)
4898 return inst.m_PEAK_Interface_UnregisterDeviceLostCallback(interfaceHandle, callbackHandle);
4902 throw std::runtime_error(
"Library not loaded!");
4908 auto& inst = instance();
4909 if(inst.m_PEAK_Interface_RegisterDeviceListChangedCallback)
4911 return inst.m_PEAK_Interface_RegisterDeviceListChangedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4915 throw std::runtime_error(
"Library not loaded!");
4921 auto& inst = instance();
4922 if(inst.m_PEAK_Interface_UnregisterDeviceListChangedCallback)
4924 return inst.m_PEAK_Interface_UnregisterDeviceListChangedCallback(interfaceHandle, callbackHandle);
4928 throw std::runtime_error(
"Library not loaded!");
4934 auto& inst = instance();
4935 if(inst.m_PEAK_Interface_Destruct)
4937 return inst.m_PEAK_Interface_Destruct(interfaceHandle);
4941 throw std::runtime_error(
"Library not loaded!");
4947 auto& inst = instance();
4948 if(inst.m_PEAK_DeviceDescriptor_ToModuleDescriptor)
4950 return inst.m_PEAK_DeviceDescriptor_ToModuleDescriptor(deviceDescriptorHandle, moduleDescriptorHandle);
4954 throw std::runtime_error(
"Library not loaded!");
4960 auto& inst = instance();
4961 if(inst.m_PEAK_DeviceDescriptor_GetKey)
4963 return inst.m_PEAK_DeviceDescriptor_GetKey(deviceDescriptorHandle, key, keySize);
4967 throw std::runtime_error(
"Library not loaded!");
4973 auto& inst = instance();
4974 if(inst.m_PEAK_DeviceDescriptor_GetInfo)
4976 return inst.m_PEAK_DeviceDescriptor_GetInfo(deviceDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4980 throw std::runtime_error(
"Library not loaded!");
4986 auto& inst = instance();
4987 if(inst.m_PEAK_DeviceDescriptor_GetDisplayName)
4989 return inst.m_PEAK_DeviceDescriptor_GetDisplayName(deviceDescriptorHandle, displayName, displayNameSize);
4993 throw std::runtime_error(
"Library not loaded!");
4999 auto& inst = instance();
5000 if(inst.m_PEAK_DeviceDescriptor_GetVendorName)
5002 return inst.m_PEAK_DeviceDescriptor_GetVendorName(deviceDescriptorHandle, vendorName, vendorNameSize);
5006 throw std::runtime_error(
"Library not loaded!");
5012 auto& inst = instance();
5013 if(inst.m_PEAK_DeviceDescriptor_GetModelName)
5015 return inst.m_PEAK_DeviceDescriptor_GetModelName(deviceDescriptorHandle, modelName, modelNameSize);
5019 throw std::runtime_error(
"Library not loaded!");
5025 auto& inst = instance();
5026 if(inst.m_PEAK_DeviceDescriptor_GetVersion)
5028 return inst.m_PEAK_DeviceDescriptor_GetVersion(deviceDescriptorHandle, version, versionSize);
5032 throw std::runtime_error(
"Library not loaded!");
5038 auto& inst = instance();
5039 if(inst.m_PEAK_DeviceDescriptor_GetTLType)
5041 return inst.m_PEAK_DeviceDescriptor_GetTLType(deviceDescriptorHandle, tlType, tlTypeSize);
5045 throw std::runtime_error(
"Library not loaded!");
5051 auto& inst = instance();
5052 if(inst.m_PEAK_DeviceDescriptor_GetUserDefinedName)
5054 return inst.m_PEAK_DeviceDescriptor_GetUserDefinedName(deviceDescriptorHandle, userDefinedName, userDefinedNameSize);
5058 throw std::runtime_error(
"Library not loaded!");
5064 auto& inst = instance();
5065 if(inst.m_PEAK_DeviceDescriptor_GetSerialNumber)
5067 return inst.m_PEAK_DeviceDescriptor_GetSerialNumber(deviceDescriptorHandle, serialNumber, serialNumberSize);
5071 throw std::runtime_error(
"Library not loaded!");
5077 auto& inst = instance();
5078 if(inst.m_PEAK_DeviceDescriptor_GetAccessStatus)
5080 return inst.m_PEAK_DeviceDescriptor_GetAccessStatus(deviceDescriptorHandle, accessStatus);
5084 throw std::runtime_error(
"Library not loaded!");
5090 auto& inst = instance();
5091 if(inst.m_PEAK_DeviceDescriptor_GetTimestampTickFrequency)
5093 return inst.m_PEAK_DeviceDescriptor_GetTimestampTickFrequency(deviceDescriptorHandle, timestampTickFrequency);
5097 throw std::runtime_error(
"Library not loaded!");
5103 auto& inst = instance();
5104 if(inst.m_PEAK_DeviceDescriptor_GetIsOpenableExclusive)
5106 return inst.m_PEAK_DeviceDescriptor_GetIsOpenableExclusive(deviceDescriptorHandle, isOpenable);
5110 throw std::runtime_error(
"Library not loaded!");
5116 auto& inst = instance();
5117 if(inst.m_PEAK_DeviceDescriptor_GetIsOpenable)
5119 return inst.m_PEAK_DeviceDescriptor_GetIsOpenable(deviceDescriptorHandle, accessType, isOpenable);
5123 throw std::runtime_error(
"Library not loaded!");
5129 auto& inst = instance();
5130 if(inst.m_PEAK_DeviceDescriptor_OpenDevice)
5132 return inst.m_PEAK_DeviceDescriptor_OpenDevice(deviceDescriptorHandle, accessType, deviceHandle);
5136 throw std::runtime_error(
"Library not loaded!");
5142 auto& inst = instance();
5143 if(inst.m_PEAK_DeviceDescriptor_GetParentInterface)
5145 return inst.m_PEAK_DeviceDescriptor_GetParentInterface(deviceDescriptorHandle, interfaceHandle);
5149 throw std::runtime_error(
"Library not loaded!");
5155 auto& inst = instance();
5156 if(inst.m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval)
5158 return inst.m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(deviceDescriptorHandle, monitoringUpdateInterval_ms);
5162 throw std::runtime_error(
"Library not loaded!");
5168 auto& inst = instance();
5169 if(inst.m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval)
5171 return inst.m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(deviceDescriptorHandle, monitoringUpdateInterval_ms);
5175 throw std::runtime_error(
"Library not loaded!");
5181 auto& inst = instance();
5182 if(inst.m_PEAK_DeviceDescriptor_IsInformationRoleMonitored)
5184 return inst.m_PEAK_DeviceDescriptor_IsInformationRoleMonitored(deviceDescriptorHandle, informationRole, isInformationRoleMonitored);
5188 throw std::runtime_error(
"Library not loaded!");
5194 auto& inst = instance();
5195 if(inst.m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring)
5197 return inst.m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(deviceDescriptorHandle, informationRole);
5201 throw std::runtime_error(
"Library not loaded!");
5207 auto& inst = instance();
5208 if(inst.m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring)
5210 return inst.m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(deviceDescriptorHandle, informationRole);
5214 throw std::runtime_error(
"Library not loaded!");
5220 auto& inst = instance();
5221 if(inst.m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback)
5223 return inst.m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback(deviceDescriptorHandle, callback, callbackContext, callbackHandle);
5227 throw std::runtime_error(
"Library not loaded!");
5233 auto& inst = instance();
5234 if(inst.m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback)
5236 return inst.m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(deviceDescriptorHandle, callbackHandle);
5240 throw std::runtime_error(
"Library not loaded!");
5246 auto& inst = instance();
5247 if(inst.m_PEAK_Device_ToModule)
5249 return inst.m_PEAK_Device_ToModule(deviceHandle, moduleHandle);
5253 throw std::runtime_error(
"Library not loaded!");
5259 auto& inst = instance();
5260 if(inst.m_PEAK_Device_ToEventSupportingModule)
5262 return inst.m_PEAK_Device_ToEventSupportingModule(deviceHandle, eventSupportingModuleHandle);
5266 throw std::runtime_error(
"Library not loaded!");
5272 auto& inst = instance();
5273 if(inst.m_PEAK_Device_GetKey)
5275 return inst.m_PEAK_Device_GetKey(deviceHandle, key, keySize);
5279 throw std::runtime_error(
"Library not loaded!");
5285 auto& inst = instance();
5286 if(inst.m_PEAK_Device_GetInfo)
5288 return inst.m_PEAK_Device_GetInfo(deviceHandle, infoCommand, infoDataType, info, infoSize);
5292 throw std::runtime_error(
"Library not loaded!");
5298 auto& inst = instance();
5299 if(inst.m_PEAK_Device_GetID)
5301 return inst.m_PEAK_Device_GetID(deviceHandle,
id, idSize);
5305 throw std::runtime_error(
"Library not loaded!");
5311 auto& inst = instance();
5312 if(inst.m_PEAK_Device_GetDisplayName)
5314 return inst.m_PEAK_Device_GetDisplayName(deviceHandle, displayName, displayNameSize);
5318 throw std::runtime_error(
"Library not loaded!");
5324 auto& inst = instance();
5325 if(inst.m_PEAK_Device_GetVendorName)
5327 return inst.m_PEAK_Device_GetVendorName(deviceHandle, vendorName, vendorNameSize);
5331 throw std::runtime_error(
"Library not loaded!");
5337 auto& inst = instance();
5338 if(inst.m_PEAK_Device_GetModelName)
5340 return inst.m_PEAK_Device_GetModelName(deviceHandle, modelName, modelNameSize);
5344 throw std::runtime_error(
"Library not loaded!");
5350 auto& inst = instance();
5351 if(inst.m_PEAK_Device_GetVersion)
5353 return inst.m_PEAK_Device_GetVersion(deviceHandle, version, versionSize);
5357 throw std::runtime_error(
"Library not loaded!");
5363 auto& inst = instance();
5364 if(inst.m_PEAK_Device_GetTLType)
5366 return inst.m_PEAK_Device_GetTLType(deviceHandle, tlType, tlTypeSize);
5370 throw std::runtime_error(
"Library not loaded!");
5376 auto& inst = instance();
5377 if(inst.m_PEAK_Device_GetUserDefinedName)
5379 return inst.m_PEAK_Device_GetUserDefinedName(deviceHandle, userDefinedName, userDefinedNameSize);
5383 throw std::runtime_error(
"Library not loaded!");
5389 auto& inst = instance();
5390 if(inst.m_PEAK_Device_GetSerialNumber)
5392 return inst.m_PEAK_Device_GetSerialNumber(deviceHandle, serialNumber, serialNumberSize);
5396 throw std::runtime_error(
"Library not loaded!");
5402 auto& inst = instance();
5403 if(inst.m_PEAK_Device_GetAccessStatus)
5405 return inst.m_PEAK_Device_GetAccessStatus(deviceHandle, accessStatus);
5409 throw std::runtime_error(
"Library not loaded!");
5415 auto& inst = instance();
5416 if(inst.m_PEAK_Device_GetTimestampTickFrequency)
5418 return inst.m_PEAK_Device_GetTimestampTickFrequency(deviceHandle, timestampTickFrequency);
5422 throw std::runtime_error(
"Library not loaded!");
5428 auto& inst = instance();
5429 if(inst.m_PEAK_Device_GetParentInterface)
5431 return inst.m_PEAK_Device_GetParentInterface(deviceHandle, interfaceHandle);
5435 throw std::runtime_error(
"Library not loaded!");
5441 auto& inst = instance();
5442 if(inst.m_PEAK_Device_GetRemoteDevice)
5444 return inst.m_PEAK_Device_GetRemoteDevice(deviceHandle, remoteDeviceHandle);
5448 throw std::runtime_error(
"Library not loaded!");
5454 auto& inst = instance();
5455 if(inst.m_PEAK_Device_GetNumDataStreams)
5457 return inst.m_PEAK_Device_GetNumDataStreams(deviceHandle, numDataStreams);
5461 throw std::runtime_error(
"Library not loaded!");
5467 auto& inst = instance();
5468 if(inst.m_PEAK_Device_GetDataStream)
5470 return inst.m_PEAK_Device_GetDataStream(deviceHandle, index, dataStreamDescriptorHandle);
5474 throw std::runtime_error(
"Library not loaded!");
5480 auto& inst = instance();
5481 if(inst.m_PEAK_Device_Destruct)
5483 return inst.m_PEAK_Device_Destruct(deviceHandle);
5487 throw std::runtime_error(
"Library not loaded!");
5493 auto& inst = instance();
5494 if(inst.m_PEAK_RemoteDevice_ToModule)
5496 return inst.m_PEAK_RemoteDevice_ToModule(remoteDeviceHandle, moduleHandle);
5500 throw std::runtime_error(
"Library not loaded!");
5506 auto& inst = instance();
5507 if(inst.m_PEAK_RemoteDevice_GetLocalDevice)
5509 return inst.m_PEAK_RemoteDevice_GetLocalDevice(remoteDeviceHandle, deviceHandle);
5513 throw std::runtime_error(
"Library not loaded!");
5519 auto& inst = instance();
5520 if(inst.m_PEAK_DataStreamDescriptor_ToModuleDescriptor)
5522 return inst.m_PEAK_DataStreamDescriptor_ToModuleDescriptor(dataStreamDescriptorHandle, moduleDescriptorHandle);
5526 throw std::runtime_error(
"Library not loaded!");
5532 auto& inst = instance();
5533 if(inst.m_PEAK_DataStreamDescriptor_GetKey)
5535 return inst.m_PEAK_DataStreamDescriptor_GetKey(dataStreamDescriptorHandle, key, keySize);
5539 throw std::runtime_error(
"Library not loaded!");
5545 auto& inst = instance();
5546 if(inst.m_PEAK_DataStreamDescriptor_GetParentDevice)
5548 return inst.m_PEAK_DataStreamDescriptor_GetParentDevice(dataStreamDescriptorHandle, deviceHandle);
5552 throw std::runtime_error(
"Library not loaded!");
5558 auto& inst = instance();
5559 if(inst.m_PEAK_DataStreamDescriptor_OpenDataStream)
5561 return inst.m_PEAK_DataStreamDescriptor_OpenDataStream(dataStreamDescriptorHandle, dataStreamHandle);
5565 throw std::runtime_error(
"Library not loaded!");
5571 auto& inst = instance();
5572 if(inst.m_PEAK_DataStream_ToModule)
5574 return inst.m_PEAK_DataStream_ToModule(dataStreamHandle, moduleHandle);
5578 throw std::runtime_error(
"Library not loaded!");
5584 auto& inst = instance();
5585 if(inst.m_PEAK_DataStream_ToEventSupportingModule)
5587 return inst.m_PEAK_DataStream_ToEventSupportingModule(dataStreamHandle, eventSupportingModuleHandle);
5591 throw std::runtime_error(
"Library not loaded!");
5597 auto& inst = instance();
5598 if(inst.m_PEAK_DataStream_GetKey)
5600 return inst.m_PEAK_DataStream_GetKey(dataStreamHandle, key, keySize);
5604 throw std::runtime_error(
"Library not loaded!");
5610 auto& inst = instance();
5611 if(inst.m_PEAK_DataStream_GetInfo)
5613 return inst.m_PEAK_DataStream_GetInfo(dataStreamHandle, infoCommand, infoDataType, info, infoSize);
5617 throw std::runtime_error(
"Library not loaded!");
5623 auto& inst = instance();
5624 if(inst.m_PEAK_DataStream_GetID)
5626 return inst.m_PEAK_DataStream_GetID(dataStreamHandle,
id, idSize);
5630 throw std::runtime_error(
"Library not loaded!");
5636 auto& inst = instance();
5637 if(inst.m_PEAK_DataStream_GetTLType)
5639 return inst.m_PEAK_DataStream_GetTLType(dataStreamHandle, tlType, tlTypeSize);
5643 throw std::runtime_error(
"Library not loaded!");
5649 auto& inst = instance();
5650 if(inst.m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired)
5652 return inst.m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(dataStreamHandle, numBuffersAnnouncedMinRequired);
5656 throw std::runtime_error(
"Library not loaded!");
5662 auto& inst = instance();
5663 if(inst.m_PEAK_DataStream_GetNumBuffersAnnounced)
5665 return inst.m_PEAK_DataStream_GetNumBuffersAnnounced(dataStreamHandle, numBuffersAnnounced);
5669 throw std::runtime_error(
"Library not loaded!");
5675 auto& inst = instance();
5676 if(inst.m_PEAK_DataStream_GetNumBuffersQueued)
5678 return inst.m_PEAK_DataStream_GetNumBuffersQueued(dataStreamHandle, numBuffersQueued);
5682 throw std::runtime_error(
"Library not loaded!");
5688 auto& inst = instance();
5689 if(inst.m_PEAK_DataStream_GetNumBuffersAwaitDelivery)
5691 return inst.m_PEAK_DataStream_GetNumBuffersAwaitDelivery(dataStreamHandle, numBuffersAwaitDelivery);
5695 throw std::runtime_error(
"Library not loaded!");
5701 auto& inst = instance();
5702 if(inst.m_PEAK_DataStream_GetNumBuffersDelivered)
5704 return inst.m_PEAK_DataStream_GetNumBuffersDelivered(dataStreamHandle, numBuffersDelivered);
5708 throw std::runtime_error(
"Library not loaded!");
5714 auto& inst = instance();
5715 if(inst.m_PEAK_DataStream_GetNumBuffersStarted)
5717 return inst.m_PEAK_DataStream_GetNumBuffersStarted(dataStreamHandle, numBuffersStarted);
5721 throw std::runtime_error(
"Library not loaded!");
5727 auto& inst = instance();
5728 if(inst.m_PEAK_DataStream_GetNumUnderruns)
5730 return inst.m_PEAK_DataStream_GetNumUnderruns(dataStreamHandle, numUnderruns);
5734 throw std::runtime_error(
"Library not loaded!");
5740 auto& inst = instance();
5741 if(inst.m_PEAK_DataStream_GetNumChunksPerBufferMax)
5743 return inst.m_PEAK_DataStream_GetNumChunksPerBufferMax(dataStreamHandle, numChunksPerBufferMax);
5747 throw std::runtime_error(
"Library not loaded!");
5753 auto& inst = instance();
5754 if(inst.m_PEAK_DataStream_GetBufferAlignment)
5756 return inst.m_PEAK_DataStream_GetBufferAlignment(dataStreamHandle, bufferAlignment);
5760 throw std::runtime_error(
"Library not loaded!");
5766 auto& inst = instance();
5767 if(inst.m_PEAK_DataStream_GetPayloadSize)
5769 return inst.m_PEAK_DataStream_GetPayloadSize(dataStreamHandle, payloadSize);
5773 throw std::runtime_error(
"Library not loaded!");
5779 auto& inst = instance();
5780 if(inst.m_PEAK_DataStream_GetDefinesPayloadSize)
5782 return inst.m_PEAK_DataStream_GetDefinesPayloadSize(dataStreamHandle, definesPayloadSize);
5786 throw std::runtime_error(
"Library not loaded!");
5792 auto& inst = instance();
5793 if(inst.m_PEAK_DataStream_GetIsGrabbing)
5795 return inst.m_PEAK_DataStream_GetIsGrabbing(dataStreamHandle, isGrabbing);
5799 throw std::runtime_error(
"Library not loaded!");
5805 auto& inst = instance();
5806 if(inst.m_PEAK_DataStream_GetParentDevice)
5808 return inst.m_PEAK_DataStream_GetParentDevice(dataStreamHandle, deviceHandle);
5812 throw std::runtime_error(
"Library not loaded!");
5818 auto& inst = instance();
5819 if(inst.m_PEAK_DataStream_AnnounceBuffer)
5821 return inst.m_PEAK_DataStream_AnnounceBuffer(dataStreamHandle, buffer, bufferSize, userPtr, revocationCallback, callbackContext, bufferHandle);
5825 throw std::runtime_error(
"Library not loaded!");
5831 auto& inst = instance();
5832 if(inst.m_PEAK_DataStream_AllocAndAnnounceBuffer)
5834 return inst.m_PEAK_DataStream_AllocAndAnnounceBuffer(dataStreamHandle, bufferSize, userPtr, bufferHandle);
5838 throw std::runtime_error(
"Library not loaded!");
5844 auto& inst = instance();
5845 if(inst.m_PEAK_DataStream_QueueBuffer)
5847 return inst.m_PEAK_DataStream_QueueBuffer(dataStreamHandle, bufferHandle);
5851 throw std::runtime_error(
"Library not loaded!");
5857 auto& inst = instance();
5858 if(inst.m_PEAK_DataStream_RevokeBuffer)
5860 return inst.m_PEAK_DataStream_RevokeBuffer(dataStreamHandle, bufferHandle);
5864 throw std::runtime_error(
"Library not loaded!");
5870 auto& inst = instance();
5871 if(inst.m_PEAK_DataStream_WaitForFinishedBuffer)
5873 return inst.m_PEAK_DataStream_WaitForFinishedBuffer(dataStreamHandle, timeout_ms, bufferHandle);
5877 throw std::runtime_error(
"Library not loaded!");
5883 auto& inst = instance();
5884 if(inst.m_PEAK_DataStream_KillWait)
5886 return inst.m_PEAK_DataStream_KillWait(dataStreamHandle);
5890 throw std::runtime_error(
"Library not loaded!");
5896 auto& inst = instance();
5897 if(inst.m_PEAK_DataStream_Flush)
5899 return inst.m_PEAK_DataStream_Flush(dataStreamHandle, flushMode);
5903 throw std::runtime_error(
"Library not loaded!");
5909 auto& inst = instance();
5910 if(inst.m_PEAK_DataStream_StartAcquisitionInfinite)
5912 return inst.m_PEAK_DataStream_StartAcquisitionInfinite(dataStreamHandle, startMode);
5916 throw std::runtime_error(
"Library not loaded!");
5922 auto& inst = instance();
5923 if(inst.m_PEAK_DataStream_StartAcquisition)
5925 return inst.m_PEAK_DataStream_StartAcquisition(dataStreamHandle, startMode, numToAcquire);
5929 throw std::runtime_error(
"Library not loaded!");
5935 auto& inst = instance();
5936 if(inst.m_PEAK_DataStream_StopAcquisition)
5938 return inst.m_PEAK_DataStream_StopAcquisition(dataStreamHandle, stopMode);
5942 throw std::runtime_error(
"Library not loaded!");
5948 auto& inst = instance();
5949 if(inst.m_PEAK_DataStream_Destruct)
5951 return inst.m_PEAK_DataStream_Destruct(dataStreamHandle);
5955 throw std::runtime_error(
"Library not loaded!");
5961 auto& inst = instance();
5962 if(inst.m_PEAK_Buffer_ToModule)
5964 return inst.m_PEAK_Buffer_ToModule(bufferHandle, moduleHandle);
5968 throw std::runtime_error(
"Library not loaded!");
5974 auto& inst = instance();
5975 if(inst.m_PEAK_Buffer_ToEventSupportingModule)
5977 return inst.m_PEAK_Buffer_ToEventSupportingModule(bufferHandle, eventSupportingModuleHandle);
5981 throw std::runtime_error(
"Library not loaded!");
5987 auto& inst = instance();
5988 if(inst.m_PEAK_Buffer_GetInfo)
5990 return inst.m_PEAK_Buffer_GetInfo(bufferHandle, infoCommand, infoDataType, info, infoSize);
5994 throw std::runtime_error(
"Library not loaded!");
6000 auto& inst = instance();
6001 if(inst.m_PEAK_Buffer_GetTLType)
6003 return inst.m_PEAK_Buffer_GetTLType(bufferHandle, tlType, tlTypeSize);
6007 throw std::runtime_error(
"Library not loaded!");
6013 auto& inst = instance();
6014 if(inst.m_PEAK_Buffer_GetBasePtr)
6016 return inst.m_PEAK_Buffer_GetBasePtr(bufferHandle, basePtr);
6020 throw std::runtime_error(
"Library not loaded!");
6026 auto& inst = instance();
6027 if(inst.m_PEAK_Buffer_GetSize)
6029 return inst.m_PEAK_Buffer_GetSize(bufferHandle, size);
6033 throw std::runtime_error(
"Library not loaded!");
6039 auto& inst = instance();
6040 if(inst.m_PEAK_Buffer_GetUserPtr)
6042 return inst.m_PEAK_Buffer_GetUserPtr(bufferHandle, userPtr);
6046 throw std::runtime_error(
"Library not loaded!");
6052 auto& inst = instance();
6053 if(inst.m_PEAK_Buffer_GetPayloadType)
6055 return inst.m_PEAK_Buffer_GetPayloadType(bufferHandle, payloadType);
6059 throw std::runtime_error(
"Library not loaded!");
6065 auto& inst = instance();
6066 if(inst.m_PEAK_Buffer_GetPixelFormat)
6068 return inst.m_PEAK_Buffer_GetPixelFormat(bufferHandle, pixelFormat);
6072 throw std::runtime_error(
"Library not loaded!");
6078 auto& inst = instance();
6079 if(inst.m_PEAK_Buffer_GetPixelFormatNamespace)
6081 return inst.m_PEAK_Buffer_GetPixelFormatNamespace(bufferHandle, pixelFormatNamespace);
6085 throw std::runtime_error(
"Library not loaded!");
6091 auto& inst = instance();
6092 if(inst.m_PEAK_Buffer_GetPixelEndianness)
6094 return inst.m_PEAK_Buffer_GetPixelEndianness(bufferHandle, pixelEndianness);
6098 throw std::runtime_error(
"Library not loaded!");
6104 auto& inst = instance();
6105 if(inst.m_PEAK_Buffer_GetExpectedDataSize)
6107 return inst.m_PEAK_Buffer_GetExpectedDataSize(bufferHandle, expectedDataSize);
6111 throw std::runtime_error(
"Library not loaded!");
6117 auto& inst = instance();
6118 if(inst.m_PEAK_Buffer_GetDeliveredDataSize)
6120 return inst.m_PEAK_Buffer_GetDeliveredDataSize(bufferHandle, deliveredDataSize);
6124 throw std::runtime_error(
"Library not loaded!");
6130 auto& inst = instance();
6131 if(inst.m_PEAK_Buffer_GetFrameID)
6133 return inst.m_PEAK_Buffer_GetFrameID(bufferHandle, frameId);
6137 throw std::runtime_error(
"Library not loaded!");
6143 auto& inst = instance();
6144 if(inst.m_PEAK_Buffer_GetImageOffset)
6146 return inst.m_PEAK_Buffer_GetImageOffset(bufferHandle, imageOffset);
6150 throw std::runtime_error(
"Library not loaded!");
6156 auto& inst = instance();
6157 if(inst.m_PEAK_Buffer_GetDeliveredImageHeight)
6159 return inst.m_PEAK_Buffer_GetDeliveredImageHeight(bufferHandle, deliveredImageHeight);
6163 throw std::runtime_error(
"Library not loaded!");
6169 auto& inst = instance();
6170 if(inst.m_PEAK_Buffer_GetDeliveredChunkPayloadSize)
6172 return inst.m_PEAK_Buffer_GetDeliveredChunkPayloadSize(bufferHandle, deliveredChunkPayloadSize);
6176 throw std::runtime_error(
"Library not loaded!");
6182 auto& inst = instance();
6183 if(inst.m_PEAK_Buffer_GetChunkLayoutID)
6185 return inst.m_PEAK_Buffer_GetChunkLayoutID(bufferHandle, chunkLayoutId);
6189 throw std::runtime_error(
"Library not loaded!");
6195 auto& inst = instance();
6196 if(inst.m_PEAK_Buffer_GetFileName)
6198 return inst.m_PEAK_Buffer_GetFileName(bufferHandle, fileName, fileNameSize);
6202 throw std::runtime_error(
"Library not loaded!");
6208 auto& inst = instance();
6209 if(inst.m_PEAK_Buffer_GetWidth)
6211 return inst.m_PEAK_Buffer_GetWidth(bufferHandle, width);
6215 throw std::runtime_error(
"Library not loaded!");
6221 auto& inst = instance();
6222 if(inst.m_PEAK_Buffer_GetHeight)
6224 return inst.m_PEAK_Buffer_GetHeight(bufferHandle, height);
6228 throw std::runtime_error(
"Library not loaded!");
6234 auto& inst = instance();
6235 if(inst.m_PEAK_Buffer_GetXOffset)
6237 return inst.m_PEAK_Buffer_GetXOffset(bufferHandle, xOffset);
6241 throw std::runtime_error(
"Library not loaded!");
6247 auto& inst = instance();
6248 if(inst.m_PEAK_Buffer_GetYOffset)
6250 return inst.m_PEAK_Buffer_GetYOffset(bufferHandle, yOffset);
6254 throw std::runtime_error(
"Library not loaded!");
6260 auto& inst = instance();
6261 if(inst.m_PEAK_Buffer_GetXPadding)
6263 return inst.m_PEAK_Buffer_GetXPadding(bufferHandle, xPadding);
6267 throw std::runtime_error(
"Library not loaded!");
6273 auto& inst = instance();
6274 if(inst.m_PEAK_Buffer_GetYPadding)
6276 return inst.m_PEAK_Buffer_GetYPadding(bufferHandle, yPadding);
6280 throw std::runtime_error(
"Library not loaded!");
6286 auto& inst = instance();
6287 if(inst.m_PEAK_Buffer_GetTimestamp_ticks)
6289 return inst.m_PEAK_Buffer_GetTimestamp_ticks(bufferHandle, timestamp_ticks);
6293 throw std::runtime_error(
"Library not loaded!");
6299 auto& inst = instance();
6300 if(inst.m_PEAK_Buffer_GetTimestamp_ns)
6302 return inst.m_PEAK_Buffer_GetTimestamp_ns(bufferHandle, timestamp_ns);
6306 throw std::runtime_error(
"Library not loaded!");
6312 auto& inst = instance();
6313 if(inst.m_PEAK_Buffer_GetIsQueued)
6315 return inst.m_PEAK_Buffer_GetIsQueued(bufferHandle, isQueued);
6319 throw std::runtime_error(
"Library not loaded!");
6325 auto& inst = instance();
6326 if(inst.m_PEAK_Buffer_GetIsAcquiring)
6328 return inst.m_PEAK_Buffer_GetIsAcquiring(bufferHandle, isAcquiring);
6332 throw std::runtime_error(
"Library not loaded!");
6338 auto& inst = instance();
6339 if(inst.m_PEAK_Buffer_GetIsIncomplete)
6341 return inst.m_PEAK_Buffer_GetIsIncomplete(bufferHandle, isIncomplete);
6345 throw std::runtime_error(
"Library not loaded!");
6351 auto& inst = instance();
6352 if(inst.m_PEAK_Buffer_GetHasNewData)
6354 return inst.m_PEAK_Buffer_GetHasNewData(bufferHandle, hasNewData);
6358 throw std::runtime_error(
"Library not loaded!");
6364 auto& inst = instance();
6365 if(inst.m_PEAK_Buffer_GetHasImage)
6367 return inst.m_PEAK_Buffer_GetHasImage(bufferHandle, hasImage);
6371 throw std::runtime_error(
"Library not loaded!");
6377 auto& inst = instance();
6378 if(inst.m_PEAK_Buffer_GetHasChunks)
6380 return inst.m_PEAK_Buffer_GetHasChunks(bufferHandle, hasChunks);
6384 throw std::runtime_error(
"Library not loaded!");
6390 auto& inst = instance();
6391 if(inst.m_PEAK_Buffer_UpdateChunks)
6393 return inst.m_PEAK_Buffer_UpdateChunks(bufferHandle);
6397 throw std::runtime_error(
"Library not loaded!");
6403 auto& inst = instance();
6404 if(inst.m_PEAK_Buffer_GetNumChunks)
6406 return inst.m_PEAK_Buffer_GetNumChunks(bufferHandle, numChunks);
6410 throw std::runtime_error(
"Library not loaded!");
6416 auto& inst = instance();
6417 if(inst.m_PEAK_Buffer_GetChunk)
6419 return inst.m_PEAK_Buffer_GetChunk(bufferHandle, index, bufferChunkHandle);
6423 throw std::runtime_error(
"Library not loaded!");
6429 auto& inst = instance();
6430 if(inst.m_PEAK_Buffer_UpdateParts)
6432 return inst.m_PEAK_Buffer_UpdateParts(bufferHandle);
6436 throw std::runtime_error(
"Library not loaded!");
6442 auto& inst = instance();
6443 if(inst.m_PEAK_Buffer_GetNumParts)
6445 return inst.m_PEAK_Buffer_GetNumParts(bufferHandle, numParts);
6449 throw std::runtime_error(
"Library not loaded!");
6455 auto& inst = instance();
6456 if(inst.m_PEAK_Buffer_GetPart)
6458 return inst.m_PEAK_Buffer_GetPart(bufferHandle, index, bufferPartHandle);
6462 throw std::runtime_error(
"Library not loaded!");
6468 auto& inst = instance();
6469 if(inst.m_PEAK_BufferChunk_GetID)
6471 return inst.m_PEAK_BufferChunk_GetID(bufferChunkHandle,
id);
6475 throw std::runtime_error(
"Library not loaded!");
6481 auto& inst = instance();
6482 if(inst.m_PEAK_BufferChunk_GetBasePtr)
6484 return inst.m_PEAK_BufferChunk_GetBasePtr(bufferChunkHandle, basePtr);
6488 throw std::runtime_error(
"Library not loaded!");
6494 auto& inst = instance();
6495 if(inst.m_PEAK_BufferChunk_GetSize)
6497 return inst.m_PEAK_BufferChunk_GetSize(bufferChunkHandle, size);
6501 throw std::runtime_error(
"Library not loaded!");
6507 auto& inst = instance();
6508 if(inst.m_PEAK_BufferChunk_GetParentBuffer)
6510 return inst.m_PEAK_BufferChunk_GetParentBuffer(bufferChunkHandle, bufferHandle);
6514 throw std::runtime_error(
"Library not loaded!");
6520 auto& inst = instance();
6521 if(inst.m_PEAK_BufferChunk_Destruct)
6523 return inst.m_PEAK_BufferChunk_Destruct(bufferChunkHandle);
6527 throw std::runtime_error(
"Library not loaded!");
6533 auto& inst = instance();
6534 if(inst.m_PEAK_BufferPart_GetInfo)
6536 return inst.m_PEAK_BufferPart_GetInfo(bufferPartHandle, infoCommand, infoDataType, info, infoSize);
6540 throw std::runtime_error(
"Library not loaded!");
6546 auto& inst = instance();
6547 if(inst.m_PEAK_BufferPart_GetSourceID)
6549 return inst.m_PEAK_BufferPart_GetSourceID(bufferPartHandle, sourceId);
6553 throw std::runtime_error(
"Library not loaded!");
6559 auto& inst = instance();
6560 if(inst.m_PEAK_BufferPart_GetBasePtr)
6562 return inst.m_PEAK_BufferPart_GetBasePtr(bufferPartHandle, basePtr);
6566 throw std::runtime_error(
"Library not loaded!");
6572 auto& inst = instance();
6573 if(inst.m_PEAK_BufferPart_GetSize)
6575 return inst.m_PEAK_BufferPart_GetSize(bufferPartHandle, size);
6579 throw std::runtime_error(
"Library not loaded!");
6585 auto& inst = instance();
6586 if(inst.m_PEAK_BufferPart_GetType)
6588 return inst.m_PEAK_BufferPart_GetType(bufferPartHandle, type);
6592 throw std::runtime_error(
"Library not loaded!");
6598 auto& inst = instance();
6599 if(inst.m_PEAK_BufferPart_GetFormat)
6601 return inst.m_PEAK_BufferPart_GetFormat(bufferPartHandle, format);
6605 throw std::runtime_error(
"Library not loaded!");
6611 auto& inst = instance();
6612 if(inst.m_PEAK_BufferPart_GetFormatNamespace)
6614 return inst.m_PEAK_BufferPart_GetFormatNamespace(bufferPartHandle, formatNamespace);
6618 throw std::runtime_error(
"Library not loaded!");
6624 auto& inst = instance();
6625 if(inst.m_PEAK_BufferPart_GetWidth)
6627 return inst.m_PEAK_BufferPart_GetWidth(bufferPartHandle, width);
6631 throw std::runtime_error(
"Library not loaded!");
6637 auto& inst = instance();
6638 if(inst.m_PEAK_BufferPart_GetHeight)
6640 return inst.m_PEAK_BufferPart_GetHeight(bufferPartHandle, height);
6644 throw std::runtime_error(
"Library not loaded!");
6650 auto& inst = instance();
6651 if(inst.m_PEAK_BufferPart_GetXOffset)
6653 return inst.m_PEAK_BufferPart_GetXOffset(bufferPartHandle, xOffset);
6657 throw std::runtime_error(
"Library not loaded!");
6663 auto& inst = instance();
6664 if(inst.m_PEAK_BufferPart_GetYOffset)
6666 return inst.m_PEAK_BufferPart_GetYOffset(bufferPartHandle, yOffset);
6670 throw std::runtime_error(
"Library not loaded!");
6676 auto& inst = instance();
6677 if(inst.m_PEAK_BufferPart_GetXPadding)
6679 return inst.m_PEAK_BufferPart_GetXPadding(bufferPartHandle, xPadding);
6683 throw std::runtime_error(
"Library not loaded!");
6689 auto& inst = instance();
6690 if(inst.m_PEAK_BufferPart_GetDeliveredImageHeight)
6692 return inst.m_PEAK_BufferPart_GetDeliveredImageHeight(bufferPartHandle, deliveredImageHeight);
6696 throw std::runtime_error(
"Library not loaded!");
6702 auto& inst = instance();
6703 if(inst.m_PEAK_BufferPart_GetParentBuffer)
6705 return inst.m_PEAK_BufferPart_GetParentBuffer(bufferPartHandle, bufferHandle);
6709 throw std::runtime_error(
"Library not loaded!");
6715 auto& inst = instance();
6716 if(inst.m_PEAK_BufferPart_Destruct)
6718 return inst.m_PEAK_BufferPart_Destruct(bufferPartHandle);
6722 throw std::runtime_error(
"Library not loaded!");
6728 auto& inst = instance();
6729 if(inst.m_PEAK_ModuleDescriptor_GetID)
6731 return inst.m_PEAK_ModuleDescriptor_GetID(moduleDescriptorHandle,
id, idSize);
6735 throw std::runtime_error(
"Library not loaded!");
6741 auto& inst = instance();
6742 if(inst.m_PEAK_Module_GetNumNodeMaps)
6744 return inst.m_PEAK_Module_GetNumNodeMaps(moduleHandle, numNodeMaps);
6748 throw std::runtime_error(
"Library not loaded!");
6754 auto& inst = instance();
6755 if(inst.m_PEAK_Module_GetNodeMap)
6757 return inst.m_PEAK_Module_GetNodeMap(moduleHandle, index, nodeMapHandle);
6761 throw std::runtime_error(
"Library not loaded!");
6767 auto& inst = instance();
6768 if(inst.m_PEAK_Module_GetPort)
6770 return inst.m_PEAK_Module_GetPort(moduleHandle, portHandle);
6774 throw std::runtime_error(
"Library not loaded!");
6780 auto& inst = instance();
6781 if(inst.m_PEAK_NodeMap_GetHasNode)
6783 return inst.m_PEAK_NodeMap_GetHasNode(nodeMapHandle, nodeName, nodeNameSize, hasNode);
6787 throw std::runtime_error(
"Library not loaded!");
6793 auto& inst = instance();
6794 if(inst.m_PEAK_NodeMap_FindNode)
6796 return inst.m_PEAK_NodeMap_FindNode(nodeMapHandle, nodeName, nodeNameSize, nodeHandle);
6800 throw std::runtime_error(
"Library not loaded!");
6806 auto& inst = instance();
6807 if(inst.m_PEAK_NodeMap_InvalidateNodes)
6809 return inst.m_PEAK_NodeMap_InvalidateNodes(nodeMapHandle);
6813 throw std::runtime_error(
"Library not loaded!");
6819 auto& inst = instance();
6820 if(inst.m_PEAK_NodeMap_PollNodes)
6822 return inst.m_PEAK_NodeMap_PollNodes(nodeMapHandle, elapsedTime_ms);
6826 throw std::runtime_error(
"Library not loaded!");
6832 auto& inst = instance();
6833 if(inst.m_PEAK_NodeMap_GetNumNodes)
6835 return inst.m_PEAK_NodeMap_GetNumNodes(nodeMapHandle, numNodes);
6839 throw std::runtime_error(
"Library not loaded!");
6845 auto& inst = instance();
6846 if(inst.m_PEAK_NodeMap_GetNode)
6848 return inst.m_PEAK_NodeMap_GetNode(nodeMapHandle, index, nodeHandle);
6852 throw std::runtime_error(
"Library not loaded!");
6858 auto& inst = instance();
6859 if(inst.m_PEAK_NodeMap_GetHasBufferSupportedChunks)
6861 return inst.m_PEAK_NodeMap_GetHasBufferSupportedChunks(nodeMapHandle, bufferHandle, hasSupportedChunks);
6865 throw std::runtime_error(
"Library not loaded!");
6871 auto& inst = instance();
6872 if(inst.m_PEAK_NodeMap_UpdateChunkNodes)
6874 return inst.m_PEAK_NodeMap_UpdateChunkNodes(nodeMapHandle, bufferHandle);
6878 throw std::runtime_error(
"Library not loaded!");
6884 auto& inst = instance();
6885 if(inst.m_PEAK_NodeMap_GetHasEventSupportedData)
6887 return inst.m_PEAK_NodeMap_GetHasEventSupportedData(nodeMapHandle, eventHandle, hasSupportedData);
6891 throw std::runtime_error(
"Library not loaded!");
6897 auto& inst = instance();
6898 if(inst.m_PEAK_NodeMap_UpdateEventNodes)
6900 return inst.m_PEAK_NodeMap_UpdateEventNodes(nodeMapHandle, eventHandle);
6904 throw std::runtime_error(
"Library not loaded!");
6910 auto& inst = instance();
6911 if(inst.m_PEAK_NodeMap_StoreToFile)
6913 return inst.m_PEAK_NodeMap_StoreToFile(nodeMapHandle, filePath, filePathSize);
6917 throw std::runtime_error(
"Library not loaded!");
6923 auto& inst = instance();
6924 if(inst.m_PEAK_NodeMap_LoadFromFile)
6926 return inst.m_PEAK_NodeMap_LoadFromFile(nodeMapHandle, filePath, filePathSize);
6930 throw std::runtime_error(
"Library not loaded!");
6936 auto& inst = instance();
6937 if(inst.m_PEAK_NodeMap_Lock)
6939 return inst.m_PEAK_NodeMap_Lock(nodeMapHandle);
6943 throw std::runtime_error(
"Library not loaded!");
6949 auto& inst = instance();
6950 if(inst.m_PEAK_NodeMap_Unlock)
6952 return inst.m_PEAK_NodeMap_Unlock(nodeMapHandle);
6956 throw std::runtime_error(
"Library not loaded!");
6962 auto& inst = instance();
6963 if(inst.m_PEAK_Node_ToIntegerNode)
6965 return inst.m_PEAK_Node_ToIntegerNode(nodeHandle, integerNodeHandle);
6969 throw std::runtime_error(
"Library not loaded!");
6975 auto& inst = instance();
6976 if(inst.m_PEAK_Node_ToBooleanNode)
6978 return inst.m_PEAK_Node_ToBooleanNode(nodeHandle, booleanNodeHandle);
6982 throw std::runtime_error(
"Library not loaded!");
6988 auto& inst = instance();
6989 if(inst.m_PEAK_Node_ToCommandNode)
6991 return inst.m_PEAK_Node_ToCommandNode(nodeHandle, commandNodeHandle);
6995 throw std::runtime_error(
"Library not loaded!");
7001 auto& inst = instance();
7002 if(inst.m_PEAK_Node_ToFloatNode)
7004 return inst.m_PEAK_Node_ToFloatNode(nodeHandle, floatNodeHandle);
7008 throw std::runtime_error(
"Library not loaded!");
7014 auto& inst = instance();
7015 if(inst.m_PEAK_Node_ToStringNode)
7017 return inst.m_PEAK_Node_ToStringNode(nodeHandle, stringNodeHandle);
7021 throw std::runtime_error(
"Library not loaded!");
7027 auto& inst = instance();
7028 if(inst.m_PEAK_Node_ToRegisterNode)
7030 return inst.m_PEAK_Node_ToRegisterNode(nodeHandle, registerNodeHandle);
7034 throw std::runtime_error(
"Library not loaded!");
7040 auto& inst = instance();
7041 if(inst.m_PEAK_Node_ToCategoryNode)
7043 return inst.m_PEAK_Node_ToCategoryNode(nodeHandle, categoryNodeHandle);
7047 throw std::runtime_error(
"Library not loaded!");
7053 auto& inst = instance();
7054 if(inst.m_PEAK_Node_ToEnumerationNode)
7056 return inst.m_PEAK_Node_ToEnumerationNode(nodeHandle, enumerationNodeHandle);
7060 throw std::runtime_error(
"Library not loaded!");
7066 auto& inst = instance();
7067 if(inst.m_PEAK_Node_ToEnumerationEntryNode)
7069 return inst.m_PEAK_Node_ToEnumerationEntryNode(nodeHandle, enumerationEntryNodeHandle);
7073 throw std::runtime_error(
"Library not loaded!");
7079 auto& inst = instance();
7080 if(inst.m_PEAK_Node_GetName)
7082 return inst.m_PEAK_Node_GetName(nodeHandle, name, nameSize);
7086 throw std::runtime_error(
"Library not loaded!");
7092 auto& inst = instance();
7093 if(inst.m_PEAK_Node_GetDisplayName)
7095 return inst.m_PEAK_Node_GetDisplayName(nodeHandle, displayName, displayNameSize);
7099 throw std::runtime_error(
"Library not loaded!");
7105 auto& inst = instance();
7106 if(inst.m_PEAK_Node_GetNamespace)
7108 return inst.m_PEAK_Node_GetNamespace(nodeHandle, _namespace);
7112 throw std::runtime_error(
"Library not loaded!");
7118 auto& inst = instance();
7119 if(inst.m_PEAK_Node_GetVisibility)
7121 return inst.m_PEAK_Node_GetVisibility(nodeHandle, visibility);
7125 throw std::runtime_error(
"Library not loaded!");
7131 auto& inst = instance();
7132 if(inst.m_PEAK_Node_GetAccessStatus)
7134 return inst.m_PEAK_Node_GetAccessStatus(nodeHandle, accessStatus);
7138 throw std::runtime_error(
"Library not loaded!");
7144 auto& inst = instance();
7145 if(inst.m_PEAK_Node_GetIsCacheable)
7147 return inst.m_PEAK_Node_GetIsCacheable(nodeHandle, isCacheable);
7151 throw std::runtime_error(
"Library not loaded!");
7157 auto& inst = instance();
7158 if(inst.m_PEAK_Node_GetIsAccessStatusCacheable)
7160 return inst.m_PEAK_Node_GetIsAccessStatusCacheable(nodeHandle, isAccessStatusCacheable);
7164 throw std::runtime_error(
"Library not loaded!");
7170 auto& inst = instance();
7171 if(inst.m_PEAK_Node_GetIsStreamable)
7173 return inst.m_PEAK_Node_GetIsStreamable(nodeHandle, isStreamable);
7177 throw std::runtime_error(
"Library not loaded!");
7183 auto& inst = instance();
7184 if(inst.m_PEAK_Node_GetIsDeprecated)
7186 return inst.m_PEAK_Node_GetIsDeprecated(nodeHandle, isDeprecated);
7190 throw std::runtime_error(
"Library not loaded!");
7196 auto& inst = instance();
7197 if(inst.m_PEAK_Node_GetIsFeature)
7199 return inst.m_PEAK_Node_GetIsFeature(nodeHandle, isFeature);
7203 throw std::runtime_error(
"Library not loaded!");
7209 auto& inst = instance();
7210 if(inst.m_PEAK_Node_GetCachingMode)
7212 return inst.m_PEAK_Node_GetCachingMode(nodeHandle, cachingMode);
7216 throw std::runtime_error(
"Library not loaded!");
7222 auto& inst = instance();
7223 if(inst.m_PEAK_Node_GetPollingTime)
7225 return inst.m_PEAK_Node_GetPollingTime(nodeHandle, pollingTime_ms);
7229 throw std::runtime_error(
"Library not loaded!");
7235 auto& inst = instance();
7236 if(inst.m_PEAK_Node_GetToolTip)
7238 return inst.m_PEAK_Node_GetToolTip(nodeHandle, toolTip, toolTipSize);
7242 throw std::runtime_error(
"Library not loaded!");
7248 auto& inst = instance();
7249 if(inst.m_PEAK_Node_GetDescription)
7251 return inst.m_PEAK_Node_GetDescription(nodeHandle, description, descriptionSize);
7255 throw std::runtime_error(
"Library not loaded!");
7261 auto& inst = instance();
7262 if(inst.m_PEAK_Node_GetType)
7264 return inst.m_PEAK_Node_GetType(nodeHandle, type);
7268 throw std::runtime_error(
"Library not loaded!");
7274 auto& inst = instance();
7275 if(inst.m_PEAK_Node_GetParentNodeMap)
7277 return inst.m_PEAK_Node_GetParentNodeMap(nodeHandle, nodeMapHandle);
7281 throw std::runtime_error(
"Library not loaded!");
7287 auto& inst = instance();
7288 if(inst.m_PEAK_Node_FindInvalidatedNode)
7290 return inst.m_PEAK_Node_FindInvalidatedNode(nodeHandle, name, nameSize, invalidatedNodeHandle);
7294 throw std::runtime_error(
"Library not loaded!");
7300 auto& inst = instance();
7301 if(inst.m_PEAK_Node_GetNumInvalidatedNodes)
7303 return inst.m_PEAK_Node_GetNumInvalidatedNodes(nodeHandle, numInvalidatedNodes);
7307 throw std::runtime_error(
"Library not loaded!");
7313 auto& inst = instance();
7314 if(inst.m_PEAK_Node_GetInvalidatedNode)
7316 return inst.m_PEAK_Node_GetInvalidatedNode(nodeHandle, index, invalidatedNodeHandle);
7320 throw std::runtime_error(
"Library not loaded!");
7326 auto& inst = instance();
7327 if(inst.m_PEAK_Node_FindInvalidatingNode)
7329 return inst.m_PEAK_Node_FindInvalidatingNode(nodeHandle, name, nameSize, invalidatingNodeHandle);
7333 throw std::runtime_error(
"Library not loaded!");
7339 auto& inst = instance();
7340 if(inst.m_PEAK_Node_GetNumInvalidatingNodes)
7342 return inst.m_PEAK_Node_GetNumInvalidatingNodes(nodeHandle, numInvalidatingNodes);
7346 throw std::runtime_error(
"Library not loaded!");
7352 auto& inst = instance();
7353 if(inst.m_PEAK_Node_GetInvalidatingNode)
7355 return inst.m_PEAK_Node_GetInvalidatingNode(nodeHandle, index, invalidatingNodeHandle);
7359 throw std::runtime_error(
"Library not loaded!");
7365 auto& inst = instance();
7366 if(inst.m_PEAK_Node_FindSelectedNode)
7368 return inst.m_PEAK_Node_FindSelectedNode(nodeHandle, name, nameSize, selectedNodeHandle);
7372 throw std::runtime_error(
"Library not loaded!");
7378 auto& inst = instance();
7379 if(inst.m_PEAK_Node_GetNumSelectedNodes)
7381 return inst.m_PEAK_Node_GetNumSelectedNodes(nodeHandle, numSelectedNodes);
7385 throw std::runtime_error(
"Library not loaded!");
7391 auto& inst = instance();
7392 if(inst.m_PEAK_Node_GetSelectedNode)
7394 return inst.m_PEAK_Node_GetSelectedNode(nodeHandle, index, selectedNodeHandle);
7398 throw std::runtime_error(
"Library not loaded!");
7404 auto& inst = instance();
7405 if(inst.m_PEAK_Node_FindSelectingNode)
7407 return inst.m_PEAK_Node_FindSelectingNode(nodeHandle, name, nameSize, selectingNodeHandle);
7411 throw std::runtime_error(
"Library not loaded!");
7417 auto& inst = instance();
7418 if(inst.m_PEAK_Node_GetNumSelectingNodes)
7420 return inst.m_PEAK_Node_GetNumSelectingNodes(nodeHandle, numSelectingNodes);
7424 throw std::runtime_error(
"Library not loaded!");
7430 auto& inst = instance();
7431 if(inst.m_PEAK_Node_GetSelectingNode)
7433 return inst.m_PEAK_Node_GetSelectingNode(nodeHandle, index, selectingNodeHandle);
7437 throw std::runtime_error(
"Library not loaded!");
7443 auto& inst = instance();
7444 if(inst.m_PEAK_Node_RegisterChangedCallback)
7446 return inst.m_PEAK_Node_RegisterChangedCallback(nodeHandle, callback, callbackContext, callbackHandle);
7450 throw std::runtime_error(
"Library not loaded!");
7456 auto& inst = instance();
7457 if(inst.m_PEAK_Node_UnregisterChangedCallback)
7459 return inst.m_PEAK_Node_UnregisterChangedCallback(nodeHandle, callbackHandle);
7463 throw std::runtime_error(
"Library not loaded!");
7469 auto& inst = instance();
7470 if(inst.m_PEAK_IntegerNode_ToNode)
7472 return inst.m_PEAK_IntegerNode_ToNode(integerNodeHandle, nodeHandle);
7476 throw std::runtime_error(
"Library not loaded!");
7482 auto& inst = instance();
7483 if(inst.m_PEAK_IntegerNode_GetMinimum)
7485 return inst.m_PEAK_IntegerNode_GetMinimum(integerNodeHandle, minimum);
7489 throw std::runtime_error(
"Library not loaded!");
7495 auto& inst = instance();
7496 if(inst.m_PEAK_IntegerNode_GetMaximum)
7498 return inst.m_PEAK_IntegerNode_GetMaximum(integerNodeHandle, maximum);
7502 throw std::runtime_error(
"Library not loaded!");
7508 auto& inst = instance();
7509 if(inst.m_PEAK_IntegerNode_GetIncrement)
7511 return inst.m_PEAK_IntegerNode_GetIncrement(integerNodeHandle, increment);
7515 throw std::runtime_error(
"Library not loaded!");
7521 auto& inst = instance();
7522 if(inst.m_PEAK_IntegerNode_GetIncrementType)
7524 return inst.m_PEAK_IntegerNode_GetIncrementType(integerNodeHandle, incrementType);
7528 throw std::runtime_error(
"Library not loaded!");
7534 auto& inst = instance();
7535 if(inst.m_PEAK_IntegerNode_GetValidValues)
7537 return inst.m_PEAK_IntegerNode_GetValidValues(integerNodeHandle, validValues, validValuesSize);
7541 throw std::runtime_error(
"Library not loaded!");
7547 auto& inst = instance();
7548 if(inst.m_PEAK_IntegerNode_GetRepresentation)
7550 return inst.m_PEAK_IntegerNode_GetRepresentation(integerNodeHandle, representation);
7554 throw std::runtime_error(
"Library not loaded!");
7560 auto& inst = instance();
7561 if(inst.m_PEAK_IntegerNode_GetUnit)
7563 return inst.m_PEAK_IntegerNode_GetUnit(integerNodeHandle, unit, unitSize);
7567 throw std::runtime_error(
"Library not loaded!");
7573 auto& inst = instance();
7574 if(inst.m_PEAK_IntegerNode_GetValue)
7576 return inst.m_PEAK_IntegerNode_GetValue(integerNodeHandle, cacheUsePolicy, value);
7580 throw std::runtime_error(
"Library not loaded!");
7586 auto& inst = instance();
7587 if(inst.m_PEAK_IntegerNode_SetValue)
7589 return inst.m_PEAK_IntegerNode_SetValue(integerNodeHandle, value);
7593 throw std::runtime_error(
"Library not loaded!");
7599 auto& inst = instance();
7600 if(inst.m_PEAK_BooleanNode_ToNode)
7602 return inst.m_PEAK_BooleanNode_ToNode(booleanNodeHandle, nodeHandle);
7606 throw std::runtime_error(
"Library not loaded!");
7612 auto& inst = instance();
7613 if(inst.m_PEAK_BooleanNode_GetValue)
7615 return inst.m_PEAK_BooleanNode_GetValue(booleanNodeHandle, cacheUsePolicy, value);
7619 throw std::runtime_error(
"Library not loaded!");
7625 auto& inst = instance();
7626 if(inst.m_PEAK_BooleanNode_SetValue)
7628 return inst.m_PEAK_BooleanNode_SetValue(booleanNodeHandle, value);
7632 throw std::runtime_error(
"Library not loaded!");
7638 auto& inst = instance();
7639 if(inst.m_PEAK_CommandNode_ToNode)
7641 return inst.m_PEAK_CommandNode_ToNode(commandNodeHandle, nodeHandle);
7645 throw std::runtime_error(
"Library not loaded!");
7651 auto& inst = instance();
7652 if(inst.m_PEAK_CommandNode_GetIsDone)
7654 return inst.m_PEAK_CommandNode_GetIsDone(commandNodeHandle, isDone);
7658 throw std::runtime_error(
"Library not loaded!");
7664 auto& inst = instance();
7665 if(inst.m_PEAK_CommandNode_Execute)
7667 return inst.m_PEAK_CommandNode_Execute(commandNodeHandle);
7671 throw std::runtime_error(
"Library not loaded!");
7677 auto& inst = instance();
7678 if(inst.m_PEAK_CommandNode_WaitUntilDoneInfinite)
7680 return inst.m_PEAK_CommandNode_WaitUntilDoneInfinite(commandNodeHandle);
7684 throw std::runtime_error(
"Library not loaded!");
7690 auto& inst = instance();
7691 if(inst.m_PEAK_CommandNode_WaitUntilDone)
7693 return inst.m_PEAK_CommandNode_WaitUntilDone(commandNodeHandle, waitTimeout_ms);
7697 throw std::runtime_error(
"Library not loaded!");
7703 auto& inst = instance();
7704 if(inst.m_PEAK_FloatNode_ToNode)
7706 return inst.m_PEAK_FloatNode_ToNode(floatNodeHandle, nodeHandle);
7710 throw std::runtime_error(
"Library not loaded!");
7716 auto& inst = instance();
7717 if(inst.m_PEAK_FloatNode_GetMinimum)
7719 return inst.m_PEAK_FloatNode_GetMinimum(floatNodeHandle, minimum);
7723 throw std::runtime_error(
"Library not loaded!");
7729 auto& inst = instance();
7730 if(inst.m_PEAK_FloatNode_GetMaximum)
7732 return inst.m_PEAK_FloatNode_GetMaximum(floatNodeHandle, maximum);
7736 throw std::runtime_error(
"Library not loaded!");
7742 auto& inst = instance();
7743 if(inst.m_PEAK_FloatNode_GetIncrement)
7745 return inst.m_PEAK_FloatNode_GetIncrement(floatNodeHandle, increment);
7749 throw std::runtime_error(
"Library not loaded!");
7755 auto& inst = instance();
7756 if(inst.m_PEAK_FloatNode_GetIncrementType)
7758 return inst.m_PEAK_FloatNode_GetIncrementType(floatNodeHandle, incrementType);
7762 throw std::runtime_error(
"Library not loaded!");
7768 auto& inst = instance();
7769 if(inst.m_PEAK_FloatNode_GetValidValues)
7771 return inst.m_PEAK_FloatNode_GetValidValues(floatNodeHandle, validValues, validValuesSize);
7775 throw std::runtime_error(
"Library not loaded!");
7781 auto& inst = instance();
7782 if(inst.m_PEAK_FloatNode_GetRepresentation)
7784 return inst.m_PEAK_FloatNode_GetRepresentation(floatNodeHandle, representation);
7788 throw std::runtime_error(
"Library not loaded!");
7794 auto& inst = instance();
7795 if(inst.m_PEAK_FloatNode_GetUnit)
7797 return inst.m_PEAK_FloatNode_GetUnit(floatNodeHandle, unit, unitSize);
7801 throw std::runtime_error(
"Library not loaded!");
7807 auto& inst = instance();
7808 if(inst.m_PEAK_FloatNode_GetDisplayNotation)
7810 return inst.m_PEAK_FloatNode_GetDisplayNotation(floatNodeHandle, displayNotation);
7814 throw std::runtime_error(
"Library not loaded!");
7820 auto& inst = instance();
7821 if(inst.m_PEAK_FloatNode_GetDisplayPrecision)
7823 return inst.m_PEAK_FloatNode_GetDisplayPrecision(floatNodeHandle, displayPrecision);
7827 throw std::runtime_error(
"Library not loaded!");
7833 auto& inst = instance();
7834 if(inst.m_PEAK_FloatNode_GetHasConstantIncrement)
7836 return inst.m_PEAK_FloatNode_GetHasConstantIncrement(floatNodeHandle, hasConstantIncrement);
7840 throw std::runtime_error(
"Library not loaded!");
7846 auto& inst = instance();
7847 if(inst.m_PEAK_FloatNode_GetValue)
7849 return inst.m_PEAK_FloatNode_GetValue(floatNodeHandle, cacheUsePolicy, value);
7853 throw std::runtime_error(
"Library not loaded!");
7859 auto& inst = instance();
7860 if(inst.m_PEAK_FloatNode_SetValue)
7862 return inst.m_PEAK_FloatNode_SetValue(floatNodeHandle, value);
7866 throw std::runtime_error(
"Library not loaded!");
7872 auto& inst = instance();
7873 if(inst.m_PEAK_StringNode_ToNode)
7875 return inst.m_PEAK_StringNode_ToNode(stringNodeHandle, nodeHandle);
7879 throw std::runtime_error(
"Library not loaded!");
7885 auto& inst = instance();
7886 if(inst.m_PEAK_StringNode_GetMaximumLength)
7888 return inst.m_PEAK_StringNode_GetMaximumLength(stringNodeHandle, maximumLength);
7892 throw std::runtime_error(
"Library not loaded!");
7898 auto& inst = instance();
7899 if(inst.m_PEAK_StringNode_GetValue)
7901 return inst.m_PEAK_StringNode_GetValue(stringNodeHandle, cacheUsePolicy, value, valueSize);
7905 throw std::runtime_error(
"Library not loaded!");
7911 auto& inst = instance();
7912 if(inst.m_PEAK_StringNode_SetValue)
7914 return inst.m_PEAK_StringNode_SetValue(stringNodeHandle, value, valueSize);
7918 throw std::runtime_error(
"Library not loaded!");
7924 auto& inst = instance();
7925 if(inst.m_PEAK_RegisterNode_ToNode)
7927 return inst.m_PEAK_RegisterNode_ToNode(registerNodeHandle, nodeHandle);
7931 throw std::runtime_error(
"Library not loaded!");
7937 auto& inst = instance();
7938 if(inst.m_PEAK_RegisterNode_GetAddress)
7940 return inst.m_PEAK_RegisterNode_GetAddress(registerNodeHandle, address);
7944 throw std::runtime_error(
"Library not loaded!");
7950 auto& inst = instance();
7951 if(inst.m_PEAK_RegisterNode_GetLength)
7953 return inst.m_PEAK_RegisterNode_GetLength(registerNodeHandle, length);
7957 throw std::runtime_error(
"Library not loaded!");
7963 auto& inst = instance();
7964 if(inst.m_PEAK_RegisterNode_Read)
7966 return inst.m_PEAK_RegisterNode_Read(registerNodeHandle, cacheUsePolicy, bytesToRead, bytesToReadSize);
7970 throw std::runtime_error(
"Library not loaded!");
7976 auto& inst = instance();
7977 if(inst.m_PEAK_RegisterNode_Write)
7979 return inst.m_PEAK_RegisterNode_Write(registerNodeHandle, bytesToWrite, bytesToWriteSize);
7983 throw std::runtime_error(
"Library not loaded!");
7989 auto& inst = instance();
7990 if(inst.m_PEAK_CategoryNode_ToNode)
7992 return inst.m_PEAK_CategoryNode_ToNode(categoryNodeHandle, nodeHandle);
7996 throw std::runtime_error(
"Library not loaded!");
8002 auto& inst = instance();
8003 if(inst.m_PEAK_CategoryNode_GetNumSubNodes)
8005 return inst.m_PEAK_CategoryNode_GetNumSubNodes(categoryNodeHandle, numSubNodes);
8009 throw std::runtime_error(
"Library not loaded!");
8015 auto& inst = instance();
8016 if(inst.m_PEAK_CategoryNode_GetSubNode)
8018 return inst.m_PEAK_CategoryNode_GetSubNode(categoryNodeHandle, index, nodeHandle);
8022 throw std::runtime_error(
"Library not loaded!");
8028 auto& inst = instance();
8029 if(inst.m_PEAK_EnumerationNode_ToNode)
8031 return inst.m_PEAK_EnumerationNode_ToNode(enumerationNodeHandle, nodeHandle);
8035 throw std::runtime_error(
"Library not loaded!");
8041 auto& inst = instance();
8042 if(inst.m_PEAK_EnumerationNode_GetCurrentEntry)
8044 return inst.m_PEAK_EnumerationNode_GetCurrentEntry(enumerationNodeHandle, cacheUsePolicy, enumerationEntryNodeHandle);
8048 throw std::runtime_error(
"Library not loaded!");
8054 auto& inst = instance();
8055 if(inst.m_PEAK_EnumerationNode_SetCurrentEntry)
8057 return inst.m_PEAK_EnumerationNode_SetCurrentEntry(enumerationNodeHandle, enumerationEntryNodeHandle);
8061 throw std::runtime_error(
"Library not loaded!");
8067 auto& inst = instance();
8068 if(inst.m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue)
8070 return inst.m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize);
8074 throw std::runtime_error(
"Library not loaded!");
8080 auto& inst = instance();
8081 if(inst.m_PEAK_EnumerationNode_SetCurrentEntryByValue)
8083 return inst.m_PEAK_EnumerationNode_SetCurrentEntryByValue(enumerationNodeHandle, value);
8087 throw std::runtime_error(
"Library not loaded!");
8093 auto& inst = instance();
8094 if(inst.m_PEAK_EnumerationNode_FindEntryBySymbolicValue)
8096 return inst.m_PEAK_EnumerationNode_FindEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize, enumerationEntryNodeHandle);
8100 throw std::runtime_error(
"Library not loaded!");
8106 auto& inst = instance();
8107 if(inst.m_PEAK_EnumerationNode_FindEntryByValue)
8109 return inst.m_PEAK_EnumerationNode_FindEntryByValue(enumerationNodeHandle, value, enumerationEntryNodeHandle);
8113 throw std::runtime_error(
"Library not loaded!");
8119 auto& inst = instance();
8120 if(inst.m_PEAK_EnumerationNode_GetNumEntries)
8122 return inst.m_PEAK_EnumerationNode_GetNumEntries(enumerationNodeHandle, numEntries);
8126 throw std::runtime_error(
"Library not loaded!");
8132 auto& inst = instance();
8133 if(inst.m_PEAK_EnumerationNode_GetEntry)
8135 return inst.m_PEAK_EnumerationNode_GetEntry(enumerationNodeHandle, index, enumerationEntryNodeHandle);
8139 throw std::runtime_error(
"Library not loaded!");
8145 auto& inst = instance();
8146 if(inst.m_PEAK_EnumerationEntryNode_ToNode)
8148 return inst.m_PEAK_EnumerationEntryNode_ToNode(enumerationEntryNodeHandle, nodeHandle);
8152 throw std::runtime_error(
"Library not loaded!");
8158 auto& inst = instance();
8159 if(inst.m_PEAK_EnumerationEntryNode_GetIsSelfClearing)
8161 return inst.m_PEAK_EnumerationEntryNode_GetIsSelfClearing(enumerationEntryNodeHandle, isSelfClearing);
8165 throw std::runtime_error(
"Library not loaded!");
8171 auto& inst = instance();
8172 if(inst.m_PEAK_EnumerationEntryNode_GetSymbolicValue)
8174 return inst.m_PEAK_EnumerationEntryNode_GetSymbolicValue(enumerationEntryNodeHandle, symbolicValue, symbolicValueSize);
8178 throw std::runtime_error(
"Library not loaded!");
8184 auto& inst = instance();
8185 if(inst.m_PEAK_EnumerationEntryNode_GetValue)
8187 return inst.m_PEAK_EnumerationEntryNode_GetValue(enumerationEntryNodeHandle, value);
8191 throw std::runtime_error(
"Library not loaded!");
8197 auto& inst = instance();
8198 if(inst.m_PEAK_Port_GetInfo)
8200 return inst.m_PEAK_Port_GetInfo(portHandle, infoCommand, infoDataType, info, infoSize);
8204 throw std::runtime_error(
"Library not loaded!");
8210 auto& inst = instance();
8211 if(inst.m_PEAK_Port_GetID)
8213 return inst.m_PEAK_Port_GetID(portHandle,
id, idSize);
8217 throw std::runtime_error(
"Library not loaded!");
8223 auto& inst = instance();
8224 if(inst.m_PEAK_Port_GetName)
8226 return inst.m_PEAK_Port_GetName(portHandle, name, nameSize);
8230 throw std::runtime_error(
"Library not loaded!");
8236 auto& inst = instance();
8237 if(inst.m_PEAK_Port_GetVendorName)
8239 return inst.m_PEAK_Port_GetVendorName(portHandle, vendorName, vendorNameSize);
8243 throw std::runtime_error(
"Library not loaded!");
8249 auto& inst = instance();
8250 if(inst.m_PEAK_Port_GetModelName)
8252 return inst.m_PEAK_Port_GetModelName(portHandle, modelName, modelNameSize);
8256 throw std::runtime_error(
"Library not loaded!");
8262 auto& inst = instance();
8263 if(inst.m_PEAK_Port_GetVersion)
8265 return inst.m_PEAK_Port_GetVersion(portHandle, version, versionSize);
8269 throw std::runtime_error(
"Library not loaded!");
8275 auto& inst = instance();
8276 if(inst.m_PEAK_Port_GetTLType)
8278 return inst.m_PEAK_Port_GetTLType(portHandle, tlType, tlTypeSize);
8282 throw std::runtime_error(
"Library not loaded!");
8288 auto& inst = instance();
8289 if(inst.m_PEAK_Port_GetModuleName)
8291 return inst.m_PEAK_Port_GetModuleName(portHandle, moduleName, moduleNameSize);
8295 throw std::runtime_error(
"Library not loaded!");
8301 auto& inst = instance();
8302 if(inst.m_PEAK_Port_GetDataEndianness)
8304 return inst.m_PEAK_Port_GetDataEndianness(portHandle, dataEndianness);
8308 throw std::runtime_error(
"Library not loaded!");
8314 auto& inst = instance();
8315 if(inst.m_PEAK_Port_GetIsReadable)
8317 return inst.m_PEAK_Port_GetIsReadable(portHandle, isReadable);
8321 throw std::runtime_error(
"Library not loaded!");
8327 auto& inst = instance();
8328 if(inst.m_PEAK_Port_GetIsWritable)
8330 return inst.m_PEAK_Port_GetIsWritable(portHandle, isWritable);
8334 throw std::runtime_error(
"Library not loaded!");
8340 auto& inst = instance();
8341 if(inst.m_PEAK_Port_GetIsAvailable)
8343 return inst.m_PEAK_Port_GetIsAvailable(portHandle, isAvailable);
8347 throw std::runtime_error(
"Library not loaded!");
8353 auto& inst = instance();
8354 if(inst.m_PEAK_Port_GetIsImplemented)
8356 return inst.m_PEAK_Port_GetIsImplemented(portHandle, isImplemented);
8360 throw std::runtime_error(
"Library not loaded!");
8366 auto& inst = instance();
8367 if(inst.m_PEAK_Port_Read)
8369 return inst.m_PEAK_Port_Read(portHandle, address, bytesToRead, bytesToReadSize);
8373 throw std::runtime_error(
"Library not loaded!");
8379 auto& inst = instance();
8380 if(inst.m_PEAK_Port_Write)
8382 return inst.m_PEAK_Port_Write(portHandle, address, bytesToWrite, bytesToWriteSize);
8386 throw std::runtime_error(
"Library not loaded!");
8392 auto& inst = instance();
8393 if(inst.m_PEAK_Port_GetNumURLs)
8395 return inst.m_PEAK_Port_GetNumURLs(portHandle, numUrls);
8399 throw std::runtime_error(
"Library not loaded!");
8405 auto& inst = instance();
8406 if(inst.m_PEAK_Port_GetURL)
8408 return inst.m_PEAK_Port_GetURL(portHandle, index, portUrlHandle);
8412 throw std::runtime_error(
"Library not loaded!");
8418 auto& inst = instance();
8419 if(inst.m_PEAK_PortURL_GetInfo)
8421 return inst.m_PEAK_PortURL_GetInfo(portUrlHandle, infoCommand, infoDataType, info, infoSize);
8425 throw std::runtime_error(
"Library not loaded!");
8431 auto& inst = instance();
8432 if(inst.m_PEAK_PortURL_GetURL)
8434 return inst.m_PEAK_PortURL_GetURL(portUrlHandle, url, urlSize);
8438 throw std::runtime_error(
"Library not loaded!");
8444 auto& inst = instance();
8445 if(inst.m_PEAK_PortURL_GetScheme)
8447 return inst.m_PEAK_PortURL_GetScheme(portUrlHandle, scheme);
8451 throw std::runtime_error(
"Library not loaded!");
8457 auto& inst = instance();
8458 if(inst.m_PEAK_PortURL_GetFileName)
8460 return inst.m_PEAK_PortURL_GetFileName(portUrlHandle, fileName, fileNameSize);
8464 throw std::runtime_error(
"Library not loaded!");
8470 auto& inst = instance();
8471 if(inst.m_PEAK_PortURL_GetFileRegisterAddress)
8473 return inst.m_PEAK_PortURL_GetFileRegisterAddress(portUrlHandle, fileRegisterAddress);
8477 throw std::runtime_error(
"Library not loaded!");
8483 auto& inst = instance();
8484 if(inst.m_PEAK_PortURL_GetFileSize)
8486 return inst.m_PEAK_PortURL_GetFileSize(portUrlHandle, fileSize);
8490 throw std::runtime_error(
"Library not loaded!");
8496 auto& inst = instance();
8497 if(inst.m_PEAK_PortURL_GetFileSHA1Hash)
8499 return inst.m_PEAK_PortURL_GetFileSHA1Hash(portUrlHandle, fileSha1Hash, fileSha1HashSize);
8503 throw std::runtime_error(
"Library not loaded!");
8509 auto& inst = instance();
8510 if(inst.m_PEAK_PortURL_GetFileVersionMajor)
8512 return inst.m_PEAK_PortURL_GetFileVersionMajor(portUrlHandle, fileVersionMajor);
8516 throw std::runtime_error(
"Library not loaded!");
8522 auto& inst = instance();
8523 if(inst.m_PEAK_PortURL_GetFileVersionMinor)
8525 return inst.m_PEAK_PortURL_GetFileVersionMinor(portUrlHandle, fileVersionMinor);
8529 throw std::runtime_error(
"Library not loaded!");
8535 auto& inst = instance();
8536 if(inst.m_PEAK_PortURL_GetFileVersionSubminor)
8538 return inst.m_PEAK_PortURL_GetFileVersionSubminor(portUrlHandle, fileVersionSubminor);
8542 throw std::runtime_error(
"Library not loaded!");
8548 auto& inst = instance();
8549 if(inst.m_PEAK_PortURL_GetFileSchemaVersionMajor)
8551 return inst.m_PEAK_PortURL_GetFileSchemaVersionMajor(portUrlHandle, fileSchemaVersionMajor);
8555 throw std::runtime_error(
"Library not loaded!");
8561 auto& inst = instance();
8562 if(inst.m_PEAK_PortURL_GetFileSchemaVersionMinor)
8564 return inst.m_PEAK_PortURL_GetFileSchemaVersionMinor(portUrlHandle, fileSchemaVersionMinor);
8568 throw std::runtime_error(
"Library not loaded!");
8574 auto& inst = instance();
8575 if(inst.m_PEAK_PortURL_GetParentPort)
8577 return inst.m_PEAK_PortURL_GetParentPort(portUrlHandle, portHandle);
8581 throw std::runtime_error(
"Library not loaded!");
8587 auto& inst = instance();
8588 if(inst.m_PEAK_EventSupportingModule_EnableEvents)
8590 return inst.m_PEAK_EventSupportingModule_EnableEvents(eventSupportingModuleHandle, eventType, eventControllerHandle);
8594 throw std::runtime_error(
"Library not loaded!");
8600 auto& inst = instance();
8601 if(inst.m_PEAK_EventController_GetInfo)
8603 return inst.m_PEAK_EventController_GetInfo(eventControllerHandle, infoCommand, infoDataType, info, infoSize);
8607 throw std::runtime_error(
"Library not loaded!");
8613 auto& inst = instance();
8614 if(inst.m_PEAK_EventController_GetNumEventsInQueue)
8616 return inst.m_PEAK_EventController_GetNumEventsInQueue(eventControllerHandle, numEventsInQueue);
8620 throw std::runtime_error(
"Library not loaded!");
8626 auto& inst = instance();
8627 if(inst.m_PEAK_EventController_GetNumEventsFired)
8629 return inst.m_PEAK_EventController_GetNumEventsFired(eventControllerHandle, numEventsFired);
8633 throw std::runtime_error(
"Library not loaded!");
8639 auto& inst = instance();
8640 if(inst.m_PEAK_EventController_GetEventMaxSize)
8642 return inst.m_PEAK_EventController_GetEventMaxSize(eventControllerHandle, eventMaxSize);
8646 throw std::runtime_error(
"Library not loaded!");
8652 auto& inst = instance();
8653 if(inst.m_PEAK_EventController_GetEventDataMaxSize)
8655 return inst.m_PEAK_EventController_GetEventDataMaxSize(eventControllerHandle, eventDataMaxSize);
8659 throw std::runtime_error(
"Library not loaded!");
8665 auto& inst = instance();
8666 if(inst.m_PEAK_EventController_GetControlledEventType)
8668 return inst.m_PEAK_EventController_GetControlledEventType(eventControllerHandle, controlledEventType);
8672 throw std::runtime_error(
"Library not loaded!");
8678 auto& inst = instance();
8679 if(inst.m_PEAK_EventController_WaitForEvent)
8681 return inst.m_PEAK_EventController_WaitForEvent(eventControllerHandle, timeout_ms, eventHandle);
8685 throw std::runtime_error(
"Library not loaded!");
8691 auto& inst = instance();
8692 if(inst.m_PEAK_EventController_KillWait)
8694 return inst.m_PEAK_EventController_KillWait(eventControllerHandle);
8698 throw std::runtime_error(
"Library not loaded!");
8704 auto& inst = instance();
8705 if(inst.m_PEAK_EventController_FlushEvents)
8707 return inst.m_PEAK_EventController_FlushEvents(eventControllerHandle);
8711 throw std::runtime_error(
"Library not loaded!");
8717 auto& inst = instance();
8718 if(inst.m_PEAK_EventController_Destruct)
8720 return inst.m_PEAK_EventController_Destruct(eventControllerHandle);
8724 throw std::runtime_error(
"Library not loaded!");
8730 auto& inst = instance();
8731 if(inst.m_PEAK_Event_GetInfo)
8733 return inst.m_PEAK_Event_GetInfo(eventHandle, infoCommand, infoDataType, info, infoSize);
8737 throw std::runtime_error(
"Library not loaded!");
8743 auto& inst = instance();
8744 if(inst.m_PEAK_Event_GetID)
8746 return inst.m_PEAK_Event_GetID(eventHandle,
id);
8750 throw std::runtime_error(
"Library not loaded!");
8756 auto& inst = instance();
8757 if(inst.m_PEAK_Event_GetData)
8759 return inst.m_PEAK_Event_GetData(eventHandle, data, dataSize);
8763 throw std::runtime_error(
"Library not loaded!");
8769 auto& inst = instance();
8770 if(inst.m_PEAK_Event_GetType)
8772 return inst.m_PEAK_Event_GetType(eventHandle, type);
8776 throw std::runtime_error(
"Library not loaded!");
8782 auto& inst = instance();
8783 if(inst.m_PEAK_Event_GetRawData)
8785 return inst.m_PEAK_Event_GetRawData(eventHandle, rawData, rawDataSize);
8789 throw std::runtime_error(
"Library not loaded!");
8795 auto& inst = instance();
8796 if(inst.m_PEAK_Event_Destruct)
8798 return inst.m_PEAK_Event_Destruct(eventHandle);
8802 throw std::runtime_error(
"Library not loaded!");
8808 auto& inst = instance();
8809 if(inst.m_PEAK_FirmwareUpdater_Construct)
8811 return inst.m_PEAK_FirmwareUpdater_Construct(firmwareUpdaterHandle);
8815 throw std::runtime_error(
"Library not loaded!");
8821 auto& inst = instance();
8822 if(inst.m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation)
8824 return inst.m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(firmwareUpdaterHandle, gufPath, gufPathSize);
8828 throw std::runtime_error(
"Library not loaded!");
8834 auto& inst = instance();
8835 if(inst.m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation)
8837 return inst.m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(firmwareUpdaterHandle, gufPath, gufPathSize, deviceDescriptorHandle);
8841 throw std::runtime_error(
"Library not loaded!");
8847 auto& inst = instance();
8848 if(inst.m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation)
8850 return inst.m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(firmwareUpdaterHandle, numFirmwareUpdateInformation);
8854 throw std::runtime_error(
"Library not loaded!");
8860 auto& inst = instance();
8861 if(inst.m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation)
8863 return inst.m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(firmwareUpdaterHandle, index, firmwareUpdateInformationHandle);
8867 throw std::runtime_error(
"Library not loaded!");
8873 auto& inst = instance();
8874 if(inst.m_PEAK_FirmwareUpdater_UpdateDevice)
8876 return inst.m_PEAK_FirmwareUpdater_UpdateDevice(firmwareUpdaterHandle, deviceDescriptorHandle, firmwareUpdateInformationHandle, firmwareUpdateProgressObserverHandle);
8880 throw std::runtime_error(
"Library not loaded!");
8886 auto& inst = instance();
8887 if(inst.m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout)
8889 return inst.m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(firmwareUpdaterHandle, deviceDescriptorHandle, firmwareUpdateInformationHandle, firmwareUpdateProgressObserverHandle, deviceResetDiscoveryTimeout_ms);
8893 throw std::runtime_error(
"Library not loaded!");
8899 auto& inst = instance();
8900 if(inst.m_PEAK_FirmwareUpdater_Destruct)
8902 return inst.m_PEAK_FirmwareUpdater_Destruct(firmwareUpdaterHandle);
8906 throw std::runtime_error(
"Library not loaded!");
8912 auto& inst = instance();
8913 if(inst.m_PEAK_FirmwareUpdateInformation_GetIsValid)
8915 return inst.m_PEAK_FirmwareUpdateInformation_GetIsValid(firmwareUpdateInformationHandle, isValid);
8919 throw std::runtime_error(
"Library not loaded!");
8925 auto& inst = instance();
8926 if(inst.m_PEAK_FirmwareUpdateInformation_GetFileName)
8928 return inst.m_PEAK_FirmwareUpdateInformation_GetFileName(firmwareUpdateInformationHandle, fileName, fileNameSize);
8932 throw std::runtime_error(
"Library not loaded!");
8938 auto& inst = instance();
8939 if(inst.m_PEAK_FirmwareUpdateInformation_GetDescription)
8941 return inst.m_PEAK_FirmwareUpdateInformation_GetDescription(firmwareUpdateInformationHandle, description, descriptionSize);
8945 throw std::runtime_error(
"Library not loaded!");
8951 auto& inst = instance();
8952 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersion)
8954 return inst.m_PEAK_FirmwareUpdateInformation_GetVersion(firmwareUpdateInformationHandle, version, versionSize);
8958 throw std::runtime_error(
"Library not loaded!");
8964 auto& inst = instance();
8965 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern)
8967 return inst.m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(firmwareUpdateInformationHandle, versionExtractionPattern, versionExtractionPatternSize);
8971 throw std::runtime_error(
"Library not loaded!");
8977 auto& inst = instance();
8978 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersionStyle)
8980 return inst.m_PEAK_FirmwareUpdateInformation_GetVersionStyle(firmwareUpdateInformationHandle, versionStyle);
8984 throw std::runtime_error(
"Library not loaded!");
8990 auto& inst = instance();
8991 if(inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotes)
8993 return inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotes(firmwareUpdateInformationHandle, releaseNotes, releaseNotesSize);
8997 throw std::runtime_error(
"Library not loaded!");
9003 auto& inst = instance();
9004 if(inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL)
9006 return inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(firmwareUpdateInformationHandle, releaseNotesUrl, releaseNotesUrlSize);
9010 throw std::runtime_error(
"Library not loaded!");
9016 auto& inst = instance();
9017 if(inst.m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence)
9019 return inst.m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence(firmwareUpdateInformationHandle, userSetPersistence);
9023 throw std::runtime_error(
"Library not loaded!");
9029 auto& inst = instance();
9030 if(inst.m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence)
9032 return inst.m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(firmwareUpdateInformationHandle, sequencerSetPersistence);
9036 throw std::runtime_error(
"Library not loaded!");
9042 auto& inst = instance();
9043 if(inst.m_PEAK_FirmwareUpdateProgressObserver_Construct)
9045 return inst.m_PEAK_FirmwareUpdateProgressObserver_Construct(firmwareUpdateProgressObserverHandle);
9049 throw std::runtime_error(
"Library not loaded!");
9055 auto& inst = instance();
9056 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback)
9058 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9062 throw std::runtime_error(
"Library not loaded!");
9068 auto& inst = instance();
9069 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback)
9071 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9075 throw std::runtime_error(
"Library not loaded!");
9081 auto& inst = instance();
9082 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback)
9084 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9088 throw std::runtime_error(
"Library not loaded!");
9094 auto& inst = instance();
9095 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback)
9097 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9101 throw std::runtime_error(
"Library not loaded!");
9107 auto& inst = instance();
9108 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback)
9110 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9114 throw std::runtime_error(
"Library not loaded!");
9120 auto& inst = instance();
9121 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback)
9123 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9127 throw std::runtime_error(
"Library not loaded!");
9133 auto& inst = instance();
9134 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback)
9136 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9140 throw std::runtime_error(
"Library not loaded!");
9146 auto& inst = instance();
9147 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback)
9149 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9153 throw std::runtime_error(
"Library not loaded!");
9159 auto& inst = instance();
9160 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback)
9162 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9166 throw std::runtime_error(
"Library not loaded!");
9172 auto& inst = instance();
9173 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback)
9175 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9179 throw std::runtime_error(
"Library not loaded!");
9185 auto& inst = instance();
9186 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback)
9188 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9192 throw std::runtime_error(
"Library not loaded!");
9198 auto& inst = instance();
9199 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback)
9201 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9205 throw std::runtime_error(
"Library not loaded!");
9211 auto& inst = instance();
9212 if(inst.m_PEAK_FirmwareUpdateProgressObserver_Destruct)
9214 return inst.m_PEAK_FirmwareUpdateProgressObserver_Destruct(firmwareUpdateProgressObserverHandle);
9218 throw std::runtime_error(
"Library not loaded!");
static PEAK_C_API PEAK_Interface_UnregisterDeviceDisconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:4867
static PEAK_C_API PEAK_DataStream_GetNumBuffersQueued(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersQueued)
Definition: peak_dynamic_loader.h:5673
static PEAK_C_API PEAK_PortURL_GetFileVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Definition: peak_dynamic_loader.h:8507
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_OpenDataStream)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Definition: peak_dynamic_loader.h:166
static PEAK_C_API PEAK_Node_GetInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition: peak_dynamic_loader.h:7311
static PEAK_C_API PEAK_EventController_KillWait(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition: peak_dynamic_loader.h:8689
static PEAK_C_API PEAK_BufferPart_GetSourceID(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Definition: peak_dynamic_loader.h:6544
struct PEAK_FIRMWARE_UPDATER * PEAK_FIRMWARE_UPDATER_HANDLE
Definition: peak_backend.h:471
PEAK_C_API(* dyn_PEAK_PortURL_GetParentPort)(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Definition: peak_dynamic_loader.h:398
static PEAK_C_API PEAK_EventController_WaitForEvent(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t timeout_ms, PEAK_EVENT_HANDLE *eventHandle)
Definition: peak_dynamic_loader.h:8676
static PEAK_C_API PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition: peak_dynamic_loader.h:5192
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition: peak_dynamic_loader.h:138
PEAK_C_API(* dyn_PEAK_NodeMap_StoreToFile)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition: peak_dynamic_loader.h:270
static PEAK_C_API PEAK_Device_GetRemoteDevice(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Definition: peak_dynamic_loader.h:5439
static PEAK_C_API PEAK_Node_GetNumSelectingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Definition: peak_dynamic_loader.h:7415
static PEAK_C_API PEAK_DeviceDescriptor_RegisterInformationChangedCallback(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:5218
static PEAK_C_API PEAK_BufferPart_GetFormat(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Definition: peak_dynamic_loader.h:6596
PEAK_C_API(* dyn_PEAK_Buffer_GetImageOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Definition: peak_dynamic_loader.h:211
static PEAK_C_API PEAK_StringNode_GetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, char *value, size_t *valueSize)
Definition: peak_dynamic_loader.h:7896
PEAK_C_API(* dyn_PEAK_FloatNode_GetIncrementType)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition: peak_dynamic_loader.h:335
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_IsInformationRoleMonitored)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole, PEAK_BOOL8 *isInformationRoleMonitored)
Definition: peak_dynamic_loader.h:137
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetParentInterface)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition: peak_dynamic_loader.h:134
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetUserSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Definition: peak_dynamic_loader.h:9014
PEAK_C_API(* dyn_PEAK_Buffer_GetPayloadType)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Definition: peak_dynamic_loader.h:204
PEAK_C_API(* dyn_PEAK_Node_GetCachingMode)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Definition: peak_dynamic_loader.h:293
int32_t PEAK_ACQUISITION_STOP_MODE
Definition: peak_backend.h:45
static PEAK_C_API PEAK_BooleanNode_SetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Definition: peak_dynamic_loader.h:7623
static PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenableExclusive(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Definition: peak_dynamic_loader.h:5101
PEAK_C_API(* dyn_PEAK_Module_GetNumNodeMaps)(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Definition: peak_dynamic_loader.h:257
PEAK_C_API(* dyn_PEAK_Device_GetID)(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:146
PEAK_C_API(* dyn_PEAK_IntegerNode_GetIncrement)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Definition: peak_dynamic_loader.h:316
PEAK_C_API(* dyn_PEAK_Node_GetSelectedNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition: peak_dynamic_loader.h:307
static PEAK_C_API PEAK_FloatNode_GetIncrementType(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition: peak_dynamic_loader.h:7753
struct PEAK_PRODUCER_LIBRARY * PEAK_PRODUCER_LIBRARY_HANDLE
Definition: peak_backend.h:347
PEAK_C_API(* dyn_PEAK_Module_GetPort)(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Definition: peak_dynamic_loader.h:259
static PEAK_C_API PEAK_DeviceDescriptor_OpenDevice(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_DEVICE_HANDLE *deviceHandle)
Definition: peak_dynamic_loader.h:5127
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:9053
static PEAK_C_API PEAK_BooleanNode_GetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_BOOL8 *value)
Definition: peak_dynamic_loader.h:7610
static PEAK_C_API PEAK_DeviceDescriptor_ToModuleDescriptor(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition: peak_dynamic_loader.h:4945
PEAK_C_API(* dyn_PEAK_DataStream_GetPayloadSize)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Definition: peak_dynamic_loader.h:182
static PEAK_C_API PEAK_System_GetGenTLVersionMinor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Definition: peak_dynamic_loader.h:4425
PEAK_C_API(* dyn_PEAK_EnumerationNode_GetNumEntries)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Definition: peak_dynamic_loader.h:363
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetFileName(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Definition: peak_dynamic_loader.h:8923
static PEAK_C_API PEAK_Buffer_GetInfo(PEAK_BUFFER_HANDLE bufferHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:5985
static PEAK_C_API PEAK_NodeMap_GetHasNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_BOOL8 *hasNode)
Definition: peak_dynamic_loader.h:6778
PEAK_C_API(* dyn_PEAK_IntegerNode_SetValue)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Definition: peak_dynamic_loader.h:322
PEAK_C_API(* dyn_PEAK_SystemDescriptor_OpenSystem)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition: peak_dynamic_loader.h:65
PEAK_C_API(* dyn_PEAK_System_GetCharacterEncoding)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition: peak_dynamic_loader.h:80
static PEAK_C_API PEAK_Interface_RegisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK callback, void *callbackContext, PEAK_DEVICE_LOST_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:4880
static PEAK_C_API PEAK_PortURL_GetScheme(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Definition: peak_dynamic_loader.h:8442
PEAK_C_API(* dyn_PEAK_BufferPart_GetBasePtr)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Definition: peak_dynamic_loader.h:243
PEAK_C_API(* dyn_PEAK_Interface_GetNumDevices)(PEAK_INTERFACE_HANDLE interfaceHandle, size_t *numDevices)
Definition: peak_dynamic_loader.h:106
PEAK_C_API(* dyn_PEAK_FloatNode_ToNode)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:331
static PEAK_C_API PEAK_BufferChunk_GetSize(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Definition: peak_dynamic_loader.h:6492
static PEAK_C_API PEAK_DataStream_StartAcquisitionInfinite(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Definition: peak_dynamic_loader.h:5907
static PEAK_C_API PEAK_System_GetModelName(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:4347
PEAK_C_API(* dyn_PEAK_EventController_Destruct)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition: peak_dynamic_loader.h:409
static PEAK_C_API PEAK_EnvironmentInspector_UpdateCTIPaths()
Definition: peak_dynamic_loader.h:3970
static PEAK_C_API PEAK_DeviceDescriptor_GetSerialNumber(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Definition: peak_dynamic_loader.h:5062
static PEAK_C_API PEAK_Buffer_GetIsAcquiring(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Definition: peak_dynamic_loader.h:6323
PEAK_C_API(* dyn_PEAK_System_GetVendorName)(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:72
int32_t PEAK_NODE_CACHING_MODE
Definition: peak_backend.h:217
static PEAK_C_API PEAK_Interface_GetNumDevices(PEAK_INTERFACE_HANDLE interfaceHandle, size_t *numDevices)
Definition: peak_dynamic_loader.h:4776
PEAK_C_API(* dyn_PEAK_Port_Write)(PEAK_PORT_HANDLE portHandle, uint64_t address, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition: peak_dynamic_loader.h:383
PEAK_C_API(* dyn_PEAK_Buffer_GetTLType)(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:200
static PEAK_C_API PEAK_CommandNode_WaitUntilDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Definition: peak_dynamic_loader.h:7688
PEAK_C_API(* dyn_PEAK_Device_GetDataStream)(PEAK_DEVICE_HANDLE deviceHandle, size_t index, PEAK_DATA_STREAM_DESCRIPTOR_HANDLE *dataStreamDescriptorHandle)
Definition: peak_dynamic_loader.h:159
static PEAK_C_API PEAK_Library_IsInitialized(PEAK_BOOL8 *isInitialized)
Definition: peak_dynamic_loader.h:3905
PEAK_C_API(* dyn_PEAK_IntegerNode_GetMaximum)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Definition: peak_dynamic_loader.h:315
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredImageHeight)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Definition: peak_dynamic_loader.h:212
static PEAK_C_API PEAK_Node_ToIntegerNode(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Definition: peak_dynamic_loader.h:6960
PEAK_C_API(* dyn_PEAK_Node_GetNamespace)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Definition: peak_dynamic_loader.h:285
static PEAK_C_API PEAK_DataStream_GetKey(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:5595
static PEAK_C_API PEAK_Device_ToModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:5244
PEAK_C_API(* dyn_PEAK_Node_ToCategoryNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Definition: peak_dynamic_loader.h:280
static PEAK_C_API PEAK_EnumerationNode_GetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:8039
static PEAK_C_API PEAK_Buffer_GetDeliveredChunkPayloadSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Definition: peak_dynamic_loader.h:6167
int32_t PEAK_PORT_URL_SCHEME
Definition: peak_backend.h:312
static PEAK_C_API PEAK_FloatNode_GetDisplayNotation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Definition: peak_dynamic_loader.h:7805
static PEAK_C_API PEAK_PortURL_GetFileRegisterAddress(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Definition: peak_dynamic_loader.h:8468
PEAK_C_API(* dyn_PEAK_EventController_WaitForEvent)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t timeout_ms, PEAK_EVENT_HANDLE *eventHandle)
Definition: peak_dynamic_loader.h:406
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetVendorName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:55
PEAK_C_API(* dyn_PEAK_Node_GetDisplayName)(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:284
static PEAK_C_API PEAK_SystemDescriptor_GetModelName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:4126
PEAK_C_API(* dyn_PEAK_Node_GetName)(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Definition: peak_dynamic_loader.h:283
PEAK_C_API(* dyn_PEAK_Buffer_GetIsQueued)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Definition: peak_dynamic_loader.h:224
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:437
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Definition: peak_dynamic_loader.h:419
int32_t PEAK_ACQUISITION_START_MODE
Definition: peak_backend.h:35
static PEAK_C_API PEAK_SystemDescriptor_ToModuleDescriptor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition: peak_dynamic_loader.h:4061
static PEAK_C_API PEAK_Buffer_GetPixelFormatNamespace(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Definition: peak_dynamic_loader.h:6076
PEAK_C_API(* dyn_PEAK_RegisterNode_Write)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition: peak_dynamic_loader.h:352
PEAK_C_API(* dyn_PEAK_BufferPart_GetType)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Definition: peak_dynamic_loader.h:245
static PEAK_C_API PEAK_Buffer_GetHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Definition: peak_dynamic_loader.h:6219
PEAK_C_API(* dyn_PEAK_Device_GetParentInterface)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition: peak_dynamic_loader.h:156
static PEAK_C_API PEAK_Interface_GetID(PEAK_INTERFACE_HANDLE interfaceHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:4711
PEAK_C_API(* dyn_PEAK_System_UnregisterInterfaceLostCallback)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:88
static PEAK_C_API PEAK_Device_Destruct(PEAK_DEVICE_HANDLE deviceHandle)
Definition: peak_dynamic_loader.h:5478
static PEAK_C_API PEAK_DataStream_ToModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:5569
PEAK_C_API(* dyn_PEAK_Buffer_GetFrameID)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Definition: peak_dynamic_loader.h:210
static PEAK_C_API PEAK_FloatNode_GetMaximum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Definition: peak_dynamic_loader.h:7727
PEAK_C_API(* dyn_PEAK_EnumerationNode_FindEntryBySymbolicValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:361
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetTimestampTickFrequency)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Definition: peak_dynamic_loader.h:130
static PEAK_C_API PEAK_Device_ToEventSupportingModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:5257
PEAK_C_API(* dyn_PEAK_DataStream_KillWait)(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition: peak_dynamic_loader.h:191
PEAK_C_API(* dyn_PEAK_NodeMap_GetHasBufferSupportedChunks)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Definition: peak_dynamic_loader.h:266
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSize)(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Definition: peak_dynamic_loader.h:391
static PEAK_C_API PEAK_Port_Read(PEAK_PORT_HANDLE portHandle, uint64_t address, uint8_t *bytesToRead, size_t bytesToReadSize)
Definition: peak_dynamic_loader.h:8364
PEAK_C_API(* dyn_PEAK_NodeMap_UpdateChunkNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:267
static PEAK_C_API PEAK_Node_GetToolTip(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Definition: peak_dynamic_loader.h:7233
PEAK_C_API(* dyn_PEAK_Event_GetData)(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Definition: peak_dynamic_loader.h:412
static PEAK_C_API PEAK_FloatNode_GetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, double *value)
Definition: peak_dynamic_loader.h:7844
static PEAK_C_API PEAK_ProducerLibrary_GetKey(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:4022
static PEAK_C_API PEAK_DataStream_AnnounceBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, void *buffer, size_t bufferSize, void *userPtr, PEAK_BUFFER_REVOCATION_CALLBACK revocationCallback, void *callbackContext, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:5816
PEAK_C_API(* dyn_PEAK_Port_GetURL)(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Definition: peak_dynamic_loader.h:385
static PEAK_C_API PEAK_IntegerNode_GetRepresentation(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition: peak_dynamic_loader.h:7545
static PEAK_C_API PEAK_EnumerationNode_FindEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:8104
static PEAK_C_API PEAK_DataStream_GetTLType(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:5634
struct PEAK_PORT_URL * PEAK_PORT_URL_HANDLE
Definition: peak_backend.h:455
static PEAK_C_API PEAK_Port_GetVersion(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:8260
static PEAK_C_API PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t index, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE *firmwareUpdateInformationHandle)
Definition: peak_dynamic_loader.h:8858
static PEAK_C_API PEAK_Interface_GetKey(PEAK_INTERFACE_HANDLE interfaceHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:4685
PEAK_C_API(* dyn_PEAK_CommandNode_Execute)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition: peak_dynamic_loader.h:328
int8_t PEAK_BOOL8
Definition: peak_backend.h:26
static PEAK_C_API PEAK_System_GetGenTLVersionMajor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMajor)
Definition: peak_dynamic_loader.h:4412
PEAK_C_API(* dyn_PEAK_Event_GetID)(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Definition: peak_dynamic_loader.h:411
PEAK_C_API(* dyn_PEAK_Interface_ToEventSupportingModule)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:98
static PEAK_C_API PEAK_InterfaceDescriptor_GetKey(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:4581
static PEAK_C_API PEAK_System_GetVersion(PEAK_SYSTEM_HANDLE systemHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:4360
static PEAK_C_API PEAK_BufferPart_GetDeliveredImageHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Definition: peak_dynamic_loader.h:6687
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:9183
PEAK_C_API(* dyn_PEAK_Library_GetVersionSubminor)(uint32_t *libraryVersionSubminor)
Definition: peak_dynamic_loader.h:42
int32_t PEAK_DEVICE_INFORMATION_ROLE
Definition: peak_backend.h:146
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersAnnounced)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnounced)
Definition: peak_dynamic_loader.h:174
PEAK_C_API(* dyn_PEAK_Device_GetTLType)(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:151
static PEAK_C_API PEAK_PortURL_GetFileSize(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Definition: peak_dynamic_loader.h:8481
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_Construct)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Definition: peak_dynamic_loader.h:434
PEAK_C_API(* dyn_PEAK_Interface_RegisterDeviceReconnectedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:110
PEAK_C_API(* dyn_PEAK_Device_ToEventSupportingModule)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:143
PEAK_C_API(* dyn_PEAK_EnumerationNode_FindEntryByValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:362
static PEAK_C_API PEAK_Port_GetVendorName(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:8234
static PEAK_C_API PEAK_System_GetCharacterEncoding(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition: peak_dynamic_loader.h:4438
static PEAK_C_API PEAK_DataStream_StopAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Definition: peak_dynamic_loader.h:5933
PEAK_C_API(* dyn_PEAK_Buffer_GetNumChunks)(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Definition: peak_dynamic_loader.h:231
static PEAK_C_API PEAK_Device_GetTimestampTickFrequency(PEAK_DEVICE_HANDLE deviceHandle, uint64_t *timestampTickFrequency)
Definition: peak_dynamic_loader.h:5413
static PEAK_C_API PEAK_Node_GetNamespace(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Definition: peak_dynamic_loader.h:7103
PEAK_C_API(* dyn_PEAK_Node_UnregisterChangedCallback)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:312
static PEAK_C_API PEAK_BufferPart_GetXOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Definition: peak_dynamic_loader.h:6648
static PEAK_C_API PEAK_Node_ToBooleanNode(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Definition: peak_dynamic_loader.h:6973
static PEAK_C_API PEAK_EventSupportingModule_EnableEvents(PEAK_EVENT_SUPPORTING_MODULE_HANDLE eventSupportingModuleHandle, PEAK_EVENT_TYPE eventType, PEAK_EVENT_CONTROLLER_HANDLE *eventControllerHandle)
Definition: peak_dynamic_loader.h:8585
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Definition: peak_dynamic_loader.h:9027
PEAK_C_API(* dyn_PEAK_Port_GetName)(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Definition: peak_dynamic_loader.h:371
static PEAK_C_API PEAK_NodeMap_GetNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:6843
struct PEAK_INTERFACE_DESCRIPTOR * PEAK_INTERFACE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:359
PEAK_C_API(* dyn_PEAK_Library_GetVersionMajor)(uint32_t *libraryVersionMajor)
Definition: peak_dynamic_loader.h:40
PEAK_C_API(* dyn_PEAK_Event_Destruct)(PEAK_EVENT_HANDLE eventHandle)
Definition: peak_dynamic_loader.h:415
static PEAK_C_API PEAK_System_UnregisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:4516
static PEAK_C_API PEAK_FloatNode_SetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Definition: peak_dynamic_loader.h:7857
static PEAK_C_API PEAK_Buffer_GetHasNewData(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Definition: peak_dynamic_loader.h:6349
void(PEAK_CALL_CONV * PEAK_DEVICE_DISCONNETED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE disconnectedDevice, void *context)
Definition: peak_backend.h:539
static PEAK_C_API PEAK_Node_FindSelectedNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition: peak_dynamic_loader.h:7363
static PEAK_C_API PEAK_Event_GetData(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Definition: peak_dynamic_loader.h:8754
static PEAK_C_API PEAK_Node_GetAccessStatus(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Definition: peak_dynamic_loader.h:7129
static PEAK_C_API PEAK_Interface_GetDisplayName(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:4724
static PEAK_C_API PEAK_Buffer_GetTimestamp_ns(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Definition: peak_dynamic_loader.h:6297
static PEAK_C_API PEAK_NodeMap_UpdateEventNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Definition: peak_dynamic_loader.h:6895
static PEAK_C_API PEAK_DataStream_AllocAndAnnounceBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t bufferSize, void *userPtr, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:5829
PEAK_C_API(* dyn_PEAK_IntegerNode_GetRepresentation)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition: peak_dynamic_loader.h:319
static PEAK_C_API PEAK_PortURL_GetFileSHA1Hash(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Definition: peak_dynamic_loader.h:8494
static PEAK_C_API PEAK_SystemDescriptor_GetKey(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:4074
int32_t PEAK_NODE_TYPE
Definition: peak_backend.h:279
static PEAK_C_API PEAK_EventController_GetEventMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Definition: peak_dynamic_loader.h:8637
PEAK_C_API(* dyn_PEAK_NodeMap_GetHasNode)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_BOOL8 *hasNode)
Definition: peak_dynamic_loader.h:260
The "peak" namespace directly contains convenience functionality like the DeviceManager as well as th...
Definition: peak_dynamic_loader.h:32
static PEAK_C_API PEAK_DeviceDescriptor_GetVersion(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:5023
static PEAK_C_API PEAK_IntegerNode_GetIncrementType(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition: peak_dynamic_loader.h:7519
PEAK_C_API(* dyn_PEAK_BufferPart_GetXPadding)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Definition: peak_dynamic_loader.h:252
static PEAK_C_API PEAK_EventController_GetControlledEventType(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Definition: peak_dynamic_loader.h:8663
~DynamicLoader()
Definition: peak_dynamic_loader.h:1342
static PEAK_C_API PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Definition: peak_dynamic_loader.h:5153
PEAK_C_API(* dyn_PEAK_PortURL_GetInfo)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:386
static PEAK_C_API PEAK_EnumerationEntryNode_GetValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Definition: peak_dynamic_loader.h:8182
PEAK_C_API(* dyn_PEAK_NodeMap_LoadFromFile)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition: peak_dynamic_loader.h:271
struct PEAK_INTEGER_NODE * PEAK_INTEGER_NODE_HANDLE
Definition: peak_backend.h:415
static PEAK_C_API PEAK_BufferPart_GetInfo(PEAK_BUFFER_PART_HANDLE bufferPartHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:6531
struct PEAK_EVENT_SUPPORTING_MODULE * PEAK_EVENT_SUPPORTING_MODULE_HANDLE
Definition: peak_backend.h:459
static PEAK_C_API PEAK_BooleanNode_ToNode(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:7597
PEAK_C_API(* dyn_PEAK_DataStream_StopAcquisition)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Definition: peak_dynamic_loader.h:195
void(PEAK_CALL_CONV * PEAK_DEVICE_FOUND_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void *context)
Definition: peak_backend.h:530
PEAK_C_API(* dyn_PEAK_DataStream_AnnounceBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, void *buffer, size_t bufferSize, void *userPtr, PEAK_BUFFER_REVOCATION_CALLBACK revocationCallback, void *callbackContext, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:186
static PEAK_C_API PEAK_Node_GetIsDeprecated(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Definition: peak_dynamic_loader.h:7181
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetKey)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:91
PEAK_C_API(* dyn_PEAK_DataStream_AllocAndAnnounceBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t bufferSize, void *userPtr, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:187
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_Construct)(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Definition: peak_dynamic_loader.h:416
PEAK_C_API(* dyn_PEAK_Buffer_ToEventSupportingModule)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:198
static PEAK_C_API PEAK_Port_GetTLType(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:8273
PEAK_C_API(* dyn_PEAK_Node_GetSelectingNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition: peak_dynamic_loader.h:310
PEAK_C_API(* dyn_PEAK_System_GetInfo)(PEAK_SYSTEM_HANDLE systemHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:69
static PEAK_C_API PEAK_Node_GetIsStreamable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Definition: peak_dynamic_loader.h:7168
PEAK_C_API(* dyn_PEAK_Port_GetTLType)(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:375
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:9144
static PEAK_C_API PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:5231
PEAK_C_API(* dyn_PEAK_Node_GetDescription)(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Definition: peak_dynamic_loader.h:296
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:8052
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetDisplayName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:54
PEAK_C_API(* dyn_PEAK_PortURL_GetFileRegisterAddress)(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Definition: peak_dynamic_loader.h:390
struct PEAK_CATEGORY_NODE * PEAK_CATEGORY_NODE_HANDLE
Definition: peak_backend.h:439
static PEAK_C_API PEAK_System_UpdateInterfaces(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Definition: peak_dynamic_loader.h:4464
PEAK_C_API(* dyn_PEAK_IntegerNode_GetValue)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, int64_t *value)
Definition: peak_dynamic_loader.h:321
PEAK_C_API(* dyn_PEAK_NodeMap_GetHasEventSupportedData)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Definition: peak_dynamic_loader.h:268
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:443
static PEAK_C_API PEAK_EventController_GetEventDataMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Definition: peak_dynamic_loader.h:8650
static PEAK_C_API PEAK_Buffer_GetTLType(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:5998
PEAK_C_API(* dyn_PEAK_Node_GetIsDeprecated)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Definition: peak_dynamic_loader.h:291
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:9157
static PEAK_C_API PEAK_Device_GetInfo(PEAK_DEVICE_HANDLE deviceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:5283
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntry)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:358
int32_t PEAK_NODE_INCREMENT_TYPE
Definition: peak_backend.h:243
static PEAK_C_API PEAK_System_GetID(PEAK_SYSTEM_HANDLE systemHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:4308
static PEAK_C_API PEAK_System_RegisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK callback, void *callbackContext, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:4503
static PEAK_C_API PEAK_Port_GetIsAvailable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Definition: peak_dynamic_loader.h:8338
static PEAK_C_API PEAK_FirmwareUpdater_Destruct(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Definition: peak_dynamic_loader.h:8897
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetUserDefinedName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition: peak_dynamic_loader.h:127
static PEAK_C_API PEAK_SystemDescriptor_GetVendorName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:4113
static PEAK_C_API PEAK_RegisterNode_GetLength(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Definition: peak_dynamic_loader.h:7948
int32_t PEAK_NODE_VISIBILITY
Definition: peak_backend.h:289
PEAK_C_API(* dyn_PEAK_IntegerNode_GetMinimum)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Definition: peak_dynamic_loader.h:314
PEAK_C_API(* dyn_PEAK_NodeMap_UpdateEventNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Definition: peak_dynamic_loader.h:269
static PEAK_C_API PEAK_BufferPart_GetBasePtr(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Definition: peak_dynamic_loader.h:6557
static PEAK_C_API PEAK_Buffer_GetChunk(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Definition: peak_dynamic_loader.h:6414
static PEAK_C_API PEAK_InterfaceDescriptor_OpenInterface(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition: peak_dynamic_loader.h:4646
PEAK_C_API(* dyn_PEAK_Device_GetModelName)(PEAK_DEVICE_HANDLE deviceHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:149
PEAK_C_API(* dyn_PEAK_Node_ToEnumerationNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Definition: peak_dynamic_loader.h:281
PEAK_C_API(* dyn_PEAK_Buffer_GetTimestamp_ns)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Definition: peak_dynamic_loader.h:223
static PEAK_C_API PEAK_RegisterNode_Write(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition: peak_dynamic_loader.h:7974
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionMinor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Definition: peak_dynamic_loader.h:394
PEAK_C_API(* dyn_PEAK_EventController_GetControlledEventType)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Definition: peak_dynamic_loader.h:405
static PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenable(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_BOOL8 *isOpenable)
Definition: peak_dynamic_loader.h:5114
static PEAK_C_API PEAK_Interface_ToEventSupportingModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:4672
static PEAK_C_API PEAK_FloatNode_GetHasConstantIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Definition: peak_dynamic_loader.h:7831
PEAK_C_API(* dyn_PEAK_Node_GetIsAccessStatusCacheable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Definition: peak_dynamic_loader.h:289
static PEAK_C_API PEAK_Port_GetInfo(PEAK_PORT_HANDLE portHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:8195
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_UpdateCTIPaths)()
Definition: peak_dynamic_loader.h:44
static PEAK_C_API PEAK_SystemDescriptor_GetCTIFileName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition: peak_dynamic_loader.h:4165
PEAK_C_API(* dyn_PEAK_Buffer_GetHasChunks)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Definition: peak_dynamic_loader.h:229
struct PEAK_EVENT_CONTROLLER * PEAK_EVENT_CONTROLLER_HANDLE
Definition: peak_backend.h:463
static PEAK_C_API PEAK_FirmwareUpdater_Construct(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Definition: peak_dynamic_loader.h:8806
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_ToModuleDescriptor)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition: peak_dynamic_loader.h:119
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_RegisterInformationChangedCallback)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:140
PEAK_C_API(* dyn_PEAK_IntegerNode_GetUnit)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Definition: peak_dynamic_loader.h:320
PEAK_C_API(* dyn_PEAK_Port_GetIsWritable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Definition: peak_dynamic_loader.h:379
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetSerialNumber)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Definition: peak_dynamic_loader.h:128
static PEAK_C_API PEAK_System_ToEventSupportingModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:4269
static PEAK_C_API PEAK_Device_GetUserDefinedName(PEAK_DEVICE_HANDLE deviceHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition: peak_dynamic_loader.h:5374
static PEAK_C_API PEAK_Node_GetDescription(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Definition: peak_dynamic_loader.h:7246
PEAK_C_API(* dyn_PEAK_Buffer_GetSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Definition: peak_dynamic_loader.h:202
int32_t PEAK_RETURN_CODE
Definition: peak_backend.h:337
static PEAK_C_API PEAK_IntegerNode_GetUnit(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Definition: peak_dynamic_loader.h:7558
PEAK_C_API(* dyn_PEAK_Buffer_GetYPadding)(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Definition: peak_dynamic_loader.h:221
PEAK_C_API(* dyn_PEAK_BufferPart_GetParentBuffer)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:254
static PEAK_C_API PEAK_RegisterNode_Read(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, uint8_t *bytesToRead, size_t bytesToReadSize)
Definition: peak_dynamic_loader.h:7961
static PEAK_C_API PEAK_Node_ToRegisterNode(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Definition: peak_dynamic_loader.h:7025
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition: peak_dynamic_loader.h:139
PEAK_C_API(* dyn_PEAK_FloatNode_SetValue)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Definition: peak_dynamic_loader.h:343
static PEAK_C_API PEAK_Node_ToCategoryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Definition: peak_dynamic_loader.h:7038
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t index, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE *firmwareUpdateInformationHandle)
Definition: peak_dynamic_loader.h:420
PEAK_C_API(* dyn_PEAK_Node_GetType)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Definition: peak_dynamic_loader.h:297
static PEAK_C_API PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition: peak_dynamic_loader.h:5205
PEAK_C_API(* dyn_PEAK_RemoteDevice_ToModule)(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:161
PEAK_C_API(* dyn_PEAK_Device_ToModule)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:142
PEAK_C_API(* dyn_PEAK_System_Destruct)(PEAK_SYSTEM_HANDLE systemHandle)
Definition: peak_dynamic_loader.h:89
static PEAK_C_API PEAK_BufferPart_GetXPadding(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Definition: peak_dynamic_loader.h:6674
static PEAK_C_API PEAK_Interface_GetTLType(PEAK_INTERFACE_HANDLE interfaceHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:4737
static PEAK_C_API PEAK_RegisterNode_GetAddress(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Definition: peak_dynamic_loader.h:7935
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetModelName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:124
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:9170
PEAK_C_API(* dyn_PEAK_Library_Close)()
Definition: peak_dynamic_loader.h:38
void(PEAK_CALL_CONV * PEAK_INTERFACE_FOUND_CALLBACK)(PEAK_INTERFACE_DESCRIPTOR_HANDLE foundInterface, void *context)
Definition: peak_backend.h:483
PEAK_C_API(* dyn_PEAK_Node_RegisterChangedCallback)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK callback, void *callbackContext, PEAK_NODE_CHANGED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:311
PEAK_C_API(* dyn_PEAK_CommandNode_WaitUntilDoneInfinite)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition: peak_dynamic_loader.h:329
PEAK_C_API(* dyn_PEAK_BufferPart_GetWidth)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Definition: peak_dynamic_loader.h:248
static PEAK_C_API PEAK_Node_FindInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition: peak_dynamic_loader.h:7324
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionStyle(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Definition: peak_dynamic_loader.h:8975
static PEAK_C_API PEAK_PortURL_GetURL(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Definition: peak_dynamic_loader.h:8429
static PEAK_C_API PEAK_DataStreamDescriptor_GetParentDevice(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition: peak_dynamic_loader.h:5543
PEAK_C_API(* dyn_PEAK_EventController_FlushEvents)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition: peak_dynamic_loader.h:408
PEAK_C_API(* dyn_PEAK_Port_GetDataEndianness)(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Definition: peak_dynamic_loader.h:377
static PEAK_C_API PEAK_System_RegisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK callback, void *callbackContext, PEAK_INTERFACE_LOST_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:4529
static PEAK_C_API PEAK_Buffer_GetExpectedDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Definition: peak_dynamic_loader.h:6102
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, double progressPercentage, void *context)
Definition: peak_backend.h:581
PEAK_C_API(* dyn_PEAK_Interface_GetDevice)(PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE *deviceDescriptorHandle)
Definition: peak_dynamic_loader.h:107
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetParentSystem)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition: peak_dynamic_loader.h:95
PEAK_C_API(* dyn_PEAK_CommandNode_WaitUntilDone)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Definition: peak_dynamic_loader.h:330
PEAK_C_API(* dyn_PEAK_System_GetGenTLVersionMajor)(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMajor)
Definition: peak_dynamic_loader.h:78
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:445
static PEAK_C_API PEAK_Buffer_GetImageOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Definition: peak_dynamic_loader.h:6141
PEAK_C_API(* dyn_PEAK_Node_GetIsCacheable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Definition: peak_dynamic_loader.h:288
static PEAK_C_API PEAK_NodeMap_GetHasBufferSupportedChunks(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Definition: peak_dynamic_loader.h:6856
static PEAK_C_API PEAK_Node_GetNumInvalidatingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Definition: peak_dynamic_loader.h:7337
static PEAK_C_API PEAK_DataStream_Flush(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Definition: peak_dynamic_loader.h:5894
struct PEAK_NODE * PEAK_NODE_HANDLE
Definition: peak_backend.h:411
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetIsValid(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Definition: peak_dynamic_loader.h:8910
PEAK_C_API(* dyn_PEAK_NodeMap_Unlock)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition: peak_dynamic_loader.h:273
PEAK_C_API(* dyn_PEAK_Interface_RegisterDeviceLostCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK callback, void *callbackContext, PEAK_DEVICE_LOST_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:114
static PEAK_C_API PEAK_Buffer_UpdateChunks(PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:6388
static PEAK_C_API PEAK_Node_GetSelectedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition: peak_dynamic_loader.h:7389
static PEAK_C_API PEAK_Node_GetIsAccessStatusCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Definition: peak_dynamic_loader.h:7155
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnouncedMinRequired)
Definition: peak_dynamic_loader.h:173
PEAK_C_API(* dyn_PEAK_Node_ToIntegerNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Definition: peak_dynamic_loader.h:274
static PEAK_C_API PEAK_NodeMap_InvalidateNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition: peak_dynamic_loader.h:6804
PEAK_C_API(* dyn_PEAK_EnumerationNode_GetEntry)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t index, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:364
PEAK_C_API(* dyn_PEAK_Node_ToEnumerationEntryNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:282
static PEAK_C_API PEAK_Buffer_GetFrameID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Definition: peak_dynamic_loader.h:6128
PEAK_C_API(* dyn_PEAK_DataStream_GetIsGrabbing)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Definition: peak_dynamic_loader.h:184
static PEAK_C_API PEAK_Node_RegisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK callback, void *callbackContext, PEAK_NODE_CHANGED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:7441
static PEAK_C_API PEAK_BufferPart_GetType(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Definition: peak_dynamic_loader.h:6583
static PEAK_C_API PEAK_BufferPart_GetHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Definition: peak_dynamic_loader.h:6635
static PEAK_C_API PEAK_Port_GetIsImplemented(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Definition: peak_dynamic_loader.h:8351
PEAK_C_API(* dyn_PEAK_Port_GetVendorName)(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:372
PEAK_C_API(* dyn_PEAK_Port_GetNumURLs)(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Definition: peak_dynamic_loader.h:384
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelEndianness)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Definition: peak_dynamic_loader.h:207
static PEAK_C_API PEAK_SystemDescriptor_GetCharacterEncoding(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition: peak_dynamic_loader.h:4217
int32_t PEAK_NODE_DISPLAY_NOTATION
Definition: peak_backend.h:234
static PEAK_C_API PEAK_FirmwareUpdater_UpdateDevice(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition: peak_dynamic_loader.h:8871
PEAK_C_API(* dyn_PEAK_System_UnregisterInterfaceFoundCallback)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:86
static PEAK_C_API PEAK_Port_GetName(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Definition: peak_dynamic_loader.h:8221
static PEAK_C_API PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle)
Definition: peak_dynamic_loader.h:8832
static PEAK_C_API PEAK_Buffer_GetDeliveredDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Definition: peak_dynamic_loader.h:6115
int32_t PEAK_NODE_NAMESPACE
Definition: peak_backend.h:251
static PEAK_C_API PEAK_Interface_RegisterDeviceDisconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNETED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:4854
static PEAK_C_API PEAK_Node_ToEnumerationNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Definition: peak_dynamic_loader.h:7051
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetKey)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:52
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:9066
static PEAK_C_API PEAK_DeviceDescriptor_GetModelName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:5010
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetVersion)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:57
PEAK_C_API(* dyn_PEAK_StringNode_GetMaximumLength)(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Definition: peak_dynamic_loader.h:345
PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE
Definition: peak_backend.h:594
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:446
PEAK_DEVICE_DISCONNETED_CALLBACK * PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE
Definition: peak_backend.h:548
int32_t PEAK_CHARACTER_ENCODING
Definition: peak_backend.h:90
PEAK_C_API(* dyn_PEAK_BufferPart_GetHeight)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Definition: peak_dynamic_loader.h:249
PEAK_DEVICE_LIST_CHANGED_CALLBACK * PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:552
PEAK_C_API(* dyn_PEAK_CategoryNode_ToNode)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:353
static PEAK_C_API PEAK_SystemDescriptor_GetDisplayName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:4100
int32_t PEAK_DEVICE_ACCESS_TYPE
Definition: peak_backend.h:128
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSchemaVersionMinor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Definition: peak_dynamic_loader.h:397
int32_t PEAK_DATA_STREAM_FLUSH_MODE
Definition: peak_backend.h:103
PEAK_C_API(* dyn_PEAK_BufferPart_GetFormat)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Definition: peak_dynamic_loader.h:246
static PEAK_C_API PEAK_Interface_GetInfo(PEAK_INTERFACE_HANDLE interfaceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:4698
PEAK_C_API(* dyn_PEAK_DataStream_ToEventSupportingModule)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:168
int32_t PEAK_ENDIANNESS
Definition: peak_backend.h:155
static PEAK_C_API PEAK_Buffer_GetHasImage(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Definition: peak_dynamic_loader.h:6362
static PEAK_C_API PEAK_NodeMap_PollNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Definition: peak_dynamic_loader.h:6817
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Definition: peak_dynamic_loader.h:359
static PEAK_C_API PEAK_ProducerLibrary_Construct(const char *ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition: peak_dynamic_loader.h:4009
PEAK_C_API(* dyn_PEAK_ProducerLibrary_GetSystem)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Definition: peak_dynamic_loader.h:49
static PEAK_C_API PEAK_Buffer_GetPixelFormat(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Definition: peak_dynamic_loader.h:6063
static PEAK_C_API PEAK_BufferChunk_Destruct(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Definition: peak_dynamic_loader.h:6518
PEAK_C_API(* dyn_PEAK_Interface_RegisterDeviceListChangedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:116
static PEAK_C_API PEAK_EnumerationEntryNode_GetSymbolicValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Definition: peak_dynamic_loader.h:8169
int32_t PEAK_EVENT_TYPE
Definition: peak_backend.h:168
static PEAK_C_API PEAK_IntegerNode_ToNode(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:7467
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetTLType)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:126
struct PEAK_NODE_MAP * PEAK_NODE_MAP_HANDLE
Definition: peak_backend.h:407
static PEAK_C_API PEAK_Buffer_GetYPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Definition: peak_dynamic_loader.h:6271
static PEAK_C_API PEAK_DataStream_GetIsGrabbing(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Definition: peak_dynamic_loader.h:5790
PEAK_C_API(* dyn_PEAK_Device_GetNumDataStreams)(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Definition: peak_dynamic_loader.h:158
struct PEAK_MODULE_DESCRIPTOR * PEAK_MODULE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:399
static PEAK_C_API PEAK_System_GetParentLibrary(PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition: peak_dynamic_loader.h:4451
PEAK_C_API(* dyn_PEAK_DataStream_GetTLType)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:172
PEAK_C_API(* dyn_PEAK_BufferChunk_GetID)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Definition: peak_dynamic_loader.h:236
static PEAK_C_API PEAK_Buffer_GetChunkLayoutID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Definition: peak_dynamic_loader.h:6180
PEAK_C_API(* dyn_PEAK_Port_GetIsReadable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Definition: peak_dynamic_loader.h:378
struct PEAK_ENUMERATION_ENTRY_NODE * PEAK_ENUMERATION_ENTRY_NODE_HANDLE
Definition: peak_backend.h:447
PEAK_C_API(* dyn_PEAK_FloatNode_GetMinimum)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Definition: peak_dynamic_loader.h:332
static PEAK_C_API PEAK_Event_GetRawData(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Definition: peak_dynamic_loader.h:8780
static PEAK_C_API PEAK_Interface_GetParentSystem(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition: peak_dynamic_loader.h:4750
PEAK_C_API(* dyn_PEAK_Buffer_GetNumParts)(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Definition: peak_dynamic_loader.h:234
static PEAK_C_API PEAK_Interface_UnregisterDeviceReconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:4841
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:141
PEAK_C_API(* dyn_PEAK_Interface_GetDisplayName)(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:102
static PEAK_C_API PEAK_Device_GetVersion(PEAK_DEVICE_HANDLE deviceHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:5348
PEAK_DEVICE_FOUND_CALLBACK * PEAK_DEVICE_FOUND_CALLBACK_HANDLE
Definition: peak_backend.h:544
static PEAK_C_API PEAK_EnvironmentInspector_GetNumCTIPaths(size_t *numCtiPaths)
Definition: peak_dynamic_loader.h:3983
PEAK_C_API(* dyn_PEAK_Buffer_GetInfo)(PEAK_BUFFER_HANDLE bufferHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:199
static PEAK_C_API PEAK_BufferPart_GetParentBuffer(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:6700
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetFileName)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Definition: peak_dynamic_loader.h:425
static PEAK_C_API PEAK_Port_GetIsReadable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Definition: peak_dynamic_loader.h:8312
static PEAK_C_API PEAK_System_GetCTIFileName(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition: peak_dynamic_loader.h:4386
static PEAK_C_API PEAK_Buffer_GetPayloadType(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Definition: peak_dynamic_loader.h:6050
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetReleaseNotes)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Definition: peak_dynamic_loader.h:430
static PEAK_C_API PEAK_EnumerationNode_GetEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t index, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:8130
PEAK_C_API(* dyn_PEAK_Interface_RegisterDeviceFoundCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK callback, void *callbackContext, PEAK_DEVICE_FOUND_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:108
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetTLType)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:58
PEAK_C_API(* dyn_PEAK_CategoryNode_GetNumSubNodes)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Definition: peak_dynamic_loader.h:354
static PEAK_C_API PEAK_DataStream_GetBufferAlignment(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *bufferAlignment)
Definition: peak_dynamic_loader.h:5751
struct PEAK_REMOTE_DEVICE * PEAK_REMOTE_DEVICE_HANDLE
Definition: peak_backend.h:375
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetDisplayName)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:93
static PEAK_C_API PEAK_Buffer_GetWidth(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Definition: peak_dynamic_loader.h:6206
PEAK_C_API(* dyn_PEAK_PortURL_GetURL)(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Definition: peak_dynamic_loader.h:387
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_GetNumCTIPaths)(size_t *numCtiPaths)
Definition: peak_dynamic_loader.h:45
PEAK_C_API(* dyn_PEAK_BufferPart_GetSourceID)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Definition: peak_dynamic_loader.h:242
static bool isLoaded()
Definition: peak_dynamic_loader.h:1350
PEAK_C_API(* dyn_PEAK_BufferChunk_Destruct)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Definition: peak_dynamic_loader.h:240
int32_t PEAK_BUFFER_PART_TYPE
Definition: peak_backend.h:63
PEAK_C_API(* dyn_PEAK_FloatNode_GetDisplayPrecision)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Definition: peak_dynamic_loader.h:340
PEAK_C_API(* dyn_PEAK_Library_Initialize)()
Definition: peak_dynamic_loader.h:37
static PEAK_C_API PEAK_Buffer_GetNumChunks(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Definition: peak_dynamic_loader.h:6401
static PEAK_C_API PEAK_EnumerationEntryNode_ToNode(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:8143
static PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMinor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Definition: peak_dynamic_loader.h:4204
PEAK_C_API(* dyn_PEAK_System_RegisterInterfaceLostCallback)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK callback, void *callbackContext, PEAK_INTERFACE_LOST_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:87
PEAK_C_API(* dyn_PEAK_Node_GetNumSelectingNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Definition: peak_dynamic_loader.h:309
struct PEAK_ENUMERATION_NODE * PEAK_ENUMERATION_NODE_HANDLE
Definition: peak_backend.h:443
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:441
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:9105
static PEAK_C_API PEAK_DeviceDescriptor_IsInformationRoleMonitored(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole, PEAK_BOOL8 *isInformationRoleMonitored)
Definition: peak_dynamic_loader.h:5179
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Definition: peak_dynamic_loader.h:417
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersion)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:427
static PEAK_C_API PEAK_Interface_UnregisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:4893
PEAK_C_API(* dyn_PEAK_EnumerationNode_GetCurrentEntry)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:357
PEAK_C_API(* dyn_PEAK_Node_FindInvalidatedNode)(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition: peak_dynamic_loader.h:299
static PEAK_C_API PEAK_IntegerNode_GetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, int64_t *value)
Definition: peak_dynamic_loader.h:7571
static PEAK_C_API PEAK_DeviceDescriptor_GetTLType(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:5036
PEAK_C_API(* dyn_PEAK_FloatNode_GetUnit)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Definition: peak_dynamic_loader.h:338
static PEAK_C_API PEAK_BufferChunk_GetParentBuffer(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:6505
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetUserSetPersistence)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Definition: peak_dynamic_loader.h:432
PEAK_C_API(* dyn_PEAK_BufferPart_GetFormatNamespace)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Definition: peak_dynamic_loader.h:247
PEAK_C_API(* dyn_PEAK_Interface_GetInfo)(PEAK_INTERFACE_HANDLE interfaceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:100
static PEAK_C_API PEAK_DataStream_Destruct(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition: peak_dynamic_loader.h:5946
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_UpdateDevice)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition: peak_dynamic_loader.h:421
static PEAK_C_API PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnouncedMinRequired)
Definition: peak_dynamic_loader.h:5647
PEAK_C_API(* dyn_PEAK_System_ToModule)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:66
static PEAK_C_API PEAK_System_ToModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:4256
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersion(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:8949
static PEAK_C_API PEAK_CommandNode_ToNode(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:7636
static PEAK_C_API PEAK_InterfaceDescriptor_GetInfo(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:4594
PEAK_C_API(* dyn_PEAK_BooleanNode_GetValue)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, PEAK_BOOL8 *value)
Definition: peak_dynamic_loader.h:324
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:444
PEAK_C_API(* dyn_PEAK_BooleanNode_ToNode)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:323
PEAK_C_API(* dyn_PEAK_RemoteDevice_GetLocalDevice)(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition: peak_dynamic_loader.h:162
static PEAK_C_API PEAK_DataStreamDescriptor_ToModuleDescriptor(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition: peak_dynamic_loader.h:5517
static PEAK_C_API PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms)
Definition: peak_dynamic_loader.h:5166
static PEAK_C_API PEAK_Event_Destruct(PEAK_EVENT_HANDLE eventHandle)
Definition: peak_dynamic_loader.h:8793
static PEAK_C_API PEAK_BufferChunk_GetBasePtr(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Definition: peak_dynamic_loader.h:6479
void(PEAK_CALL_CONV * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK)(const PEAK_DEVICE_INFORMATION_ROLE *changedRoles, size_t changedRolesSize, void *context)
Definition: peak_backend.h:563
static PEAK_C_API PEAK_CategoryNode_ToNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:7987
static PEAK_C_API PEAK_EventController_GetNumEventsInQueue(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Definition: peak_dynamic_loader.h:8611
PEAK_C_API(* dyn_PEAK_CommandNode_GetIsDone)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Definition: peak_dynamic_loader.h:327
static PEAK_C_API PEAK_Buffer_GetTimestamp_ticks(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Definition: peak_dynamic_loader.h:6284
PEAK_C_API(* dyn_PEAK_SystemDescriptor_ToModuleDescriptor)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition: peak_dynamic_loader.h:51
static PEAK_C_API PEAK_SystemDescriptor_GetTLType(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:4152
PEAK_C_API(* dyn_PEAK_Buffer_GetIsAcquiring)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Definition: peak_dynamic_loader.h:225
PEAK_C_API(* dyn_PEAK_NodeMap_GetNumNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Definition: peak_dynamic_loader.h:264
static PEAK_C_API PEAK_RegisterNode_ToNode(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:7922
PEAK_C_API(* dyn_PEAK_Node_ToStringNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Definition: peak_dynamic_loader.h:278
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetCTIFullPath)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition: peak_dynamic_loader.h:60
static PEAK_C_API PEAK_IntegerNode_SetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Definition: peak_dynamic_loader.h:7584
struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER * PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE
Definition: peak_backend.h:479
PEAK_C_API(* dyn_PEAK_Node_GetInvalidatingNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition: peak_dynamic_loader.h:304
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_Destruct)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition: peak_dynamic_loader.h:447
static PEAK_C_API PEAK_Port_Write(PEAK_PORT_HANDLE portHandle, uint64_t address, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition: peak_dynamic_loader.h:8377
struct PEAK_EVENT * PEAK_EVENT_HANDLE
Definition: peak_backend.h:467
static PEAK_C_API PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Definition: peak_dynamic_loader.h:8845
static PEAK_C_API PEAK_EventController_Destruct(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition: peak_dynamic_loader.h:8715
static PEAK_C_API PEAK_NodeMap_FindNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:6791
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, uint32_t estimatedDuration_ms, const char *description, size_t descriptionSize, void *context)
Definition: peak_backend.h:576
PEAK_C_API(* dyn_PEAK_Node_ToFloatNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Definition: peak_dynamic_loader.h:277
struct PEAK_BUFFER * PEAK_BUFFER_HANDLE
Definition: peak_backend.h:387
static PEAK_C_API PEAK_CommandNode_Execute(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition: peak_dynamic_loader.h:7662
static PEAK_C_API PEAK_RemoteDevice_GetLocalDevice(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition: peak_dynamic_loader.h:5504
static PEAK_C_API PEAK_Buffer_GetDeliveredImageHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Definition: peak_dynamic_loader.h:6154
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_ToModuleDescriptor)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition: peak_dynamic_loader.h:163
struct PEAK_BOOLEAN_NODE * PEAK_BOOLEAN_NODE_HANDLE
Definition: peak_backend.h:419
static PEAK_C_API PEAK_Buffer_GetBasePtr(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Definition: peak_dynamic_loader.h:6011
static PEAK_C_API PEAK_Device_GetTLType(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:5361
static PEAK_C_API PEAK_Node_GetType(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Definition: peak_dynamic_loader.h:7259
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Definition: peak_dynamic_loader.h:428
static PEAK_C_API PEAK_DataStream_ToEventSupportingModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:5582
static PEAK_C_API PEAK_Node_GetPollingTime(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Definition: peak_dynamic_loader.h:7220
static PEAK_C_API PEAK_PortURL_GetFileVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Definition: peak_dynamic_loader.h:8520
static PEAK_C_API PEAK_Buffer_GetNumParts(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Definition: peak_dynamic_loader.h:6440
PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE
Definition: peak_backend.h:579
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:439
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms)
Definition: peak_dynamic_loader.h:136
PEAK_C_API(* dyn_PEAK_FloatNode_GetValue)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, double *value)
Definition: peak_dynamic_loader.h:342
static PEAK_C_API PEAK_Interface_UnregisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:4815
PEAK_C_API(* dyn_PEAK_Node_GetVisibility)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Definition: peak_dynamic_loader.h:286
static PEAK_C_API PEAK_Node_ToFloatNode(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Definition: peak_dynamic_loader.h:6999
static PEAK_C_API PEAK_FloatNode_GetDisplayPrecision(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Definition: peak_dynamic_loader.h:7818
PEAK_C_API(* dyn_PEAK_Node_GetToolTip)(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Definition: peak_dynamic_loader.h:295
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetParentLibrary)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition: peak_dynamic_loader.h:64
static PEAK_C_API PEAK_DataStream_GetNumBuffersDelivered(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersDelivered)
Definition: peak_dynamic_loader.h:5699
static PEAK_C_API PEAK_Device_GetKey(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:5270
static PEAK_C_API PEAK_Interface_GetDevice(PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE *deviceDescriptorHandle)
Definition: peak_dynamic_loader.h:4789
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK)(void *context)
Definition: peak_backend.h:592
PEAK_C_API(* dyn_PEAK_StringNode_GetValue)(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, char *value, size_t *valueSize)
Definition: peak_dynamic_loader.h:346
static PEAK_C_API PEAK_DataStreamDescriptor_OpenDataStream(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Definition: peak_dynamic_loader.h:5556
struct PEAK_STRING_NODE * PEAK_STRING_NODE_HANDLE
Definition: peak_backend.h:431
static PEAK_C_API PEAK_Port_GetModelName(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:8247
PEAK_C_API(* dyn_PEAK_Device_GetUserDefinedName)(PEAK_DEVICE_HANDLE deviceHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition: peak_dynamic_loader.h:152
PEAK_C_API(* dyn_PEAK_FloatNode_GetValidValues)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Definition: peak_dynamic_loader.h:336
static PEAK_C_API PEAK_Device_GetID(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:5296
PEAK_C_API(* dyn_PEAK_BufferPart_GetDeliveredImageHeight)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Definition: peak_dynamic_loader.h:253
static PEAK_C_API PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, uint64_t deviceResetDiscoveryTimeout_ms)
Definition: peak_dynamic_loader.h:8884
PEAK_C_API(* dyn_PEAK_Port_GetInfo)(PEAK_PORT_HANDLE portHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:369
static PEAK_C_API PEAK_Library_GetVersionMinor(uint32_t *libraryVersionMinor)
Definition: peak_dynamic_loader.h:3931
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceReconnectedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:111
static PEAK_C_API PEAK_InterfaceDescriptor_ToModuleDescriptor(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition: peak_dynamic_loader.h:4568
PEAK_C_API(* dyn_PEAK_NodeMap_Lock)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition: peak_dynamic_loader.h:272
int32_t PEAK_NODE_ACCESS_STATUS
Definition: peak_backend.h:208
void * import_function(void *module, const char *proc_name)
Definition: peak_dynamic_loader.h:1297
PEAK_C_API(* dyn_PEAK_EventController_GetNumEventsInQueue)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Definition: peak_dynamic_loader.h:401
PEAK_C_API(* dyn_PEAK_System_UpdateInterfaces)(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Definition: peak_dynamic_loader.h:82
static PEAK_C_API PEAK_System_GetDisplayName(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:4321
static PEAK_C_API PEAK_EnumerationNode_ToNode(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:8026
PEAK_C_API(* dyn_PEAK_Node_GetNumInvalidatedNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Definition: peak_dynamic_loader.h:300
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetIsValid)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Definition: peak_dynamic_loader.h:424
static PEAK_C_API PEAK_Event_GetID(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Definition: peak_dynamic_loader.h:8741
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Definition: peak_dynamic_loader.h:8078
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceListChangedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:117
static PEAK_C_API PEAK_BufferChunk_GetID(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Definition: peak_dynamic_loader.h:6466
PEAK_C_API(* dyn_PEAK_EventSupportingModule_EnableEvents)(PEAK_EVENT_SUPPORTING_MODULE_HANDLE eventSupportingModuleHandle, PEAK_EVENT_TYPE eventType, PEAK_EVENT_CONTROLLER_HANDLE *eventControllerHandle)
Definition: peak_dynamic_loader.h:399
PEAK_C_API(* dyn_PEAK_EnumerationNode_ToNode)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:356
static PEAK_C_API PEAK_Interface_UpdateDevices(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms)
Definition: peak_dynamic_loader.h:4763
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Definition: peak_dynamic_loader.h:135
void(PEAK_CALL_CONV * PEAK_INTERFACE_LOST_CALLBACK)(const char *lostInterfaceId, size_t lostInterfaceIdSize, void *context)
Definition: peak_backend.h:486
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_ToModuleDescriptor)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition: peak_dynamic_loader.h:90
PEAK_C_API(* dyn_PEAK_System_GetVersion)(PEAK_SYSTEM_HANDLE systemHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:74
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_Destruct)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Definition: peak_dynamic_loader.h:423
static PEAK_C_API PEAK_Buffer_GetHasChunks(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Definition: peak_dynamic_loader.h:6375
PEAK_C_API(* dyn_PEAK_RegisterNode_GetAddress)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Definition: peak_dynamic_loader.h:349
static PEAK_C_API PEAK_Node_GetVisibility(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Definition: peak_dynamic_loader.h:7116
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetIsOpenable)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_BOOL8 *isOpenable)
Definition: peak_dynamic_loader.h:132
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetKey)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:120
void(PEAK_CALL_CONV * PEAK_DEVICE_RECONNECTED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE reconnectedDevice, PEAK_DEVICE_RECONNECT_INFORMATION reconnectInformation, void *context)
Definition: peak_backend.h:533
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntryByValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Definition: peak_dynamic_loader.h:360
PEAK_NODE_CHANGED_CALLBACK * PEAK_NODE_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:560
static PEAK_C_API PEAK_Interface_RegisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK callback, void *callbackContext, PEAK_DEVICE_FOUND_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:4802
static PEAK_C_API PEAK_EnvironmentInspector_GetCTIPath(size_t index, char *ctiPath, size_t *ctiPathSize)
Definition: peak_dynamic_loader.h:3996
static PEAK_C_API PEAK_System_GetNumInterfaces(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Definition: peak_dynamic_loader.h:4477
PEAK_C_API(* dyn_PEAK_DataStream_GetParentDevice)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition: peak_dynamic_loader.h:185
static PEAK_C_API PEAK_DeviceDescriptor_GetDisplayName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:4984
static PEAK_C_API PEAK_System_GetCTIFullPath(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition: peak_dynamic_loader.h:4399
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:9196
PEAK_C_API(* dyn_PEAK_Device_GetRemoteDevice)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Definition: peak_dynamic_loader.h:157
static PEAK_C_API PEAK_Node_GetDisplayName(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:7090
PEAK_C_API(* dyn_PEAK_PortURL_GetFileName)(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Definition: peak_dynamic_loader.h:389
static PEAK_C_API PEAK_SystemDescriptor_GetVersion(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:4139
PEAK_C_API(* dyn_PEAK_RegisterNode_ToNode)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:348
PEAK_C_API(* dyn_PEAK_Buffer_GetChunkLayoutID)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Definition: peak_dynamic_loader.h:214
static PEAK_C_API PEAK_Node_ToCommandNode(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Definition: peak_dynamic_loader.h:6986
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetAccessStatus)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition: peak_dynamic_loader.h:129
PEAK_C_API(* dyn_PEAK_RegisterNode_Read)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, uint8_t *bytesToRead, size_t bytesToReadSize)
Definition: peak_dynamic_loader.h:351
static PEAK_C_API PEAK_Port_GetNumURLs(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Definition: peak_dynamic_loader.h:8390
struct PEAK_FLOAT_NODE * PEAK_FLOAT_NODE_HANDLE
Definition: peak_backend.h:427
PEAK_C_API(* dyn_PEAK_BufferPart_Destruct)(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Definition: peak_dynamic_loader.h:255
PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE
Definition: peak_backend.h:590
PEAK_C_API(* dyn_PEAK_Buffer_GetIsIncomplete)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Definition: peak_dynamic_loader.h:226
PEAK_C_API(* dyn_PEAK_Buffer_GetHasNewData)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Definition: peak_dynamic_loader.h:227
PEAK_C_API(* dyn_PEAK_System_GetDisplayName)(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:71
static PEAK_C_API PEAK_FloatNode_GetRepresentation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition: peak_dynamic_loader.h:7779
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:9092
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetDescription)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Definition: peak_dynamic_loader.h:426
PEAK_C_API(* dyn_PEAK_Buffer_GetTimestamp_ticks)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Definition: peak_dynamic_loader.h:222
#define PEAK_C_API
Definition: peak_backend.h:602
PEAK_C_API(* dyn_PEAK_Device_GetVendorName)(PEAK_DEVICE_HANDLE deviceHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:148
PEAK_C_API(* dyn_PEAK_DataStream_GetNumChunksPerBufferMax)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numChunksPerBufferMax)
Definition: peak_dynamic_loader.h:180
PEAK_C_API(* dyn_PEAK_EventController_GetNumEventsFired)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Definition: peak_dynamic_loader.h:402
static PEAK_C_API PEAK_CategoryNode_GetNumSubNodes(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Definition: peak_dynamic_loader.h:8000
static PEAK_C_API PEAK_CommandNode_GetIsDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Definition: peak_dynamic_loader.h:7649
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetTLType)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:94
static PEAK_C_API PEAK_DeviceDescriptor_GetVendorName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:4997
static PEAK_C_API PEAK_Node_UnregisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:7454
PEAK_C_API(* dyn_PEAK_CategoryNode_GetSubNode)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:355
static PEAK_C_API PEAK_Library_Initialize()
Definition: peak_dynamic_loader.h:3879
PEAK_C_API(* dyn_PEAK_DataStream_StartAcquisition)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire)
Definition: peak_dynamic_loader.h:194
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetVendorName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:123
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_GetKey)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:164
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersStarted)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Definition: peak_dynamic_loader.h:178
static PEAK_C_API PEAK_Port_GetModuleName(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Definition: peak_dynamic_loader.h:8286
PEAK_C_API(* dyn_PEAK_Device_GetVersion)(PEAK_DEVICE_HANDLE deviceHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:150
PEAK_C_API(* dyn_PEAK_DataStream_RevokeBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:189
PEAK_C_API(* dyn_PEAK_Device_GetAccessStatus)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition: peak_dynamic_loader.h:154
static PEAK_C_API PEAK_DataStream_GetNumBuffersStarted(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Definition: peak_dynamic_loader.h:5712
static PEAK_C_API PEAK_DataStream_GetDefinesPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *definesPayloadSize)
Definition: peak_dynamic_loader.h:5777
static PEAK_C_API PEAK_Interface_ToModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:4659
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceDisconnectedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:113
struct PEAK_SYSTEM * PEAK_SYSTEM_HANDLE
Definition: peak_backend.h:355
static PEAK_C_API PEAK_DataStream_GetParentDevice(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition: peak_dynamic_loader.h:5803
void(PEAK_CALL_CONV * PEAK_DEVICE_LOST_CALLBACK)(const char *lostDeviceId, size_t lostDeviceIdSize, void *context)
Definition: peak_backend.h:536
static PEAK_C_API PEAK_Buffer_GetPixelEndianness(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Definition: peak_dynamic_loader.h:6089
PEAK_C_API(* dyn_PEAK_Event_GetInfo)(PEAK_EVENT_HANDLE eventHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:410
PEAK_C_API(* dyn_PEAK_System_GetParentLibrary)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition: peak_dynamic_loader.h:81
PEAK_C_API(* dyn_PEAK_Port_GetIsImplemented)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Definition: peak_dynamic_loader.h:381
static PEAK_C_API PEAK_BufferPart_GetSize(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Definition: peak_dynamic_loader.h:6570
static PEAK_C_API PEAK_FloatNode_ToNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:7701
static PEAK_C_API PEAK_Library_GetVersionMajor(uint32_t *libraryVersionMajor)
Definition: peak_dynamic_loader.h:3918
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_OpenDevice)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_TYPE accessType, PEAK_DEVICE_HANDLE *deviceHandle)
Definition: peak_dynamic_loader.h:133
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceFoundCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:109
PEAK_C_API(* dyn_PEAK_BooleanNode_SetValue)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Definition: peak_dynamic_loader.h:325
struct PEAK_SYSTEM_DESCRIPTOR * PEAK_SYSTEM_DESCRIPTOR_HANDLE
Definition: peak_backend.h:351
static PEAK_C_API PEAK_DataStream_GetNumBuffersAwaitDelivery(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAwaitDelivery)
Definition: peak_dynamic_loader.h:5686
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotes(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Definition: peak_dynamic_loader.h:8988
static PEAK_C_API PEAK_Node_FindInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition: peak_dynamic_loader.h:7285
PEAK_C_API(* dyn_PEAK_Buffer_GetFileName)(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Definition: peak_dynamic_loader.h:215
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetDisplayName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:122
static PEAK_C_API PEAK_Device_GetDisplayName(PEAK_DEVICE_HANDLE deviceHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:5309
static PEAK_C_API PEAK_Interface_UnregisterDeviceListChangedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:4919
static PEAK_C_API PEAK_EventController_GetInfo(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:8598
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:436
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetGenTLVersionMinor)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Definition: peak_dynamic_loader.h:62
static PEAK_C_API PEAK_InterfaceDescriptor_GetDisplayName(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:4607
PEAK_C_API(* dyn_PEAK_Buffer_GetYOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Definition: peak_dynamic_loader.h:219
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:9131
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredChunkPayloadSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Definition: peak_dynamic_loader.h:213
static PEAK_C_API PEAK_DeviceDescriptor_GetInfo(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:4971
static PEAK_C_API PEAK_SystemDescriptor_GetInfo(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:4087
static PEAK_C_API PEAK_System_GetInterface(PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE *interfaceDescriptorHandle)
Definition: peak_dynamic_loader.h:4490
PEAK_DEVICE_RECONNECTED_CALLBACK * PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE
Definition: peak_backend.h:546
struct PEAK_DATA_STREAM * PEAK_DATA_STREAM_HANDLE
Definition: peak_backend.h:383
static PEAK_C_API PEAK_ModuleDescriptor_GetID(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:6726
static PEAK_C_API PEAK_Module_GetNodeMap(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition: peak_dynamic_loader.h:6752
PEAK_C_API(* dyn_PEAK_Device_GetSerialNumber)(PEAK_DEVICE_HANDLE deviceHandle, char *serialNumber, size_t *serialNumberSize)
Definition: peak_dynamic_loader.h:153
PEAK_C_API(* dyn_PEAK_Node_GetInvalidatedNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition: peak_dynamic_loader.h:301
static PEAK_C_API PEAK_FloatNode_GetMinimum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Definition: peak_dynamic_loader.h:7714
static PEAK_C_API PEAK_ProducerLibrary_Destruct(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Definition: peak_dynamic_loader.h:4048
PEAK_C_API(* dyn_PEAK_Device_GetKey)(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:144
static PEAK_C_API PEAK_Node_GetNumSelectedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Definition: peak_dynamic_loader.h:7376
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, uint32_t estimatedDuration_ms, void *context)
Definition: peak_backend.h:570
static PEAK_C_API PEAK_Buffer_GetIsQueued(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Definition: peak_dynamic_loader.h:6310
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetIsSelfClearing)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Definition: peak_dynamic_loader.h:366
PEAK_C_API(* dyn_PEAK_NodeMap_FindNode)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:261
PEAK_C_API(* dyn_PEAK_Library_GetLastError)(PEAK_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Definition: peak_dynamic_loader.h:43
PEAK_C_API(* dyn_PEAK_Module_GetNodeMap)(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition: peak_dynamic_loader.h:258
static PEAK_C_API PEAK_DataStream_GetNumBuffersAnnounced(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnounced)
Definition: peak_dynamic_loader.h:5660
static PEAK_C_API PEAK_DataStream_StartAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire)
Definition: peak_dynamic_loader.h:5920
static PEAK_C_API PEAK_IntegerNode_GetValidValues(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Definition: peak_dynamic_loader.h:7532
static PEAK_C_API PEAK_System_GetTLType(PEAK_SYSTEM_HANDLE systemHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:4373
PEAK_C_API(* dyn_PEAK_EventController_KillWait)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition: peak_dynamic_loader.h:407
struct PEAK_DEVICE_DESCRIPTOR * PEAK_DEVICE_DESCRIPTOR_HANDLE
Definition: peak_backend.h:367
struct PEAK_PORT * PEAK_PORT_HANDLE
Definition: peak_backend.h:451
static PEAK_C_API PEAK_System_UnregisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:4542
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:9118
static PEAK_C_API PEAK_FloatNode_GetIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Definition: peak_dynamic_loader.h:7740
static PEAK_C_API PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Definition: peak_dynamic_loader.h:8819
PEAK_C_API(* dyn_PEAK_Node_GetNumInvalidatingNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Definition: peak_dynamic_loader.h:303
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Definition: peak_dynamic_loader.h:9001
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersionStyle)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Definition: peak_dynamic_loader.h:429
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionSubminor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Definition: peak_dynamic_loader.h:395
static PEAK_C_API PEAK_Buffer_GetPart(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Definition: peak_dynamic_loader.h:6453
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Definition: peak_dynamic_loader.h:8962
PEAK_C_API(* dyn_PEAK_Node_ToBooleanNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Definition: peak_dynamic_loader.h:275
PEAK_C_API(* dyn_PEAK_DataStream_ToModule)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:167
static PEAK_C_API PEAK_DeviceDescriptor_GetParentInterface(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition: peak_dynamic_loader.h:5140
static PEAK_C_API PEAK_Library_GetVersionSubminor(uint32_t *libraryVersionSubminor)
Definition: peak_dynamic_loader.h:3944
PEAK_C_API(* dyn_PEAK_Port_GetIsAvailable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Definition: peak_dynamic_loader.h:380
PEAK_C_API(* dyn_PEAK_Buffer_GetXOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Definition: peak_dynamic_loader.h:218
PEAK_C_API(* dyn_PEAK_FloatNode_GetMaximum)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Definition: peak_dynamic_loader.h:333
PEAK_C_API(* dyn_PEAK_CommandNode_ToNode)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:326
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Definition: peak_dynamic_loader.h:8065
static PEAK_C_API PEAK_Node_FindSelectingNode(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition: peak_dynamic_loader.h:7402
static PEAK_C_API PEAK_Buffer_GetSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Definition: peak_dynamic_loader.h:6024
static PEAK_C_API PEAK_Port_GetURL(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Definition: peak_dynamic_loader.h:8403
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetSymbolicValue)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Definition: peak_dynamic_loader.h:367
static PEAK_C_API PEAK_Module_GetNumNodeMaps(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Definition: peak_dynamic_loader.h:6739
static PEAK_C_API PEAK_Port_GetIsWritable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Definition: peak_dynamic_loader.h:8325
PEAK_C_API(* dyn_PEAK_Interface_GetKey)(PEAK_INTERFACE_HANDLE interfaceHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:99
PEAK_C_API(* dyn_PEAK_Library_IsInitialized)(PEAK_BOOL8 *isInitialized)
Definition: peak_dynamic_loader.h:39
PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:567
static PEAK_C_API PEAK_Module_GetPort(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Definition: peak_dynamic_loader.h:6765
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Destruct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition: peak_dynamic_loader.h:9209
static PEAK_C_API PEAK_FloatNode_GetValidValues(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Definition: peak_dynamic_loader.h:7766
static PEAK_C_API PEAK_NodeMap_Unlock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition: peak_dynamic_loader.h:6947
PEAK_C_API(* dyn_PEAK_NodeMap_PollNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Definition: peak_dynamic_loader.h:263
static PEAK_C_API PEAK_SystemDescriptor_OpenSystem(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition: peak_dynamic_loader.h:4243
static PEAK_C_API PEAK_Buffer_ToModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:5959
int32_t PEAK_BUFFER_PAYLOAD_TYPE
Definition: peak_backend.h:82
int32_t PEAK_NODE_CACHE_USE_POLICY
Definition: peak_backend.h:225
static PEAK_C_API PEAK_NodeMap_GetNumNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Definition: peak_dynamic_loader.h:6830
PEAK_C_API(* dyn_PEAK_DataStream_Destruct)(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition: peak_dynamic_loader.h:196
static PEAK_C_API PEAK_NodeMap_StoreToFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition: peak_dynamic_loader.h:6908
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle)
Definition: peak_dynamic_loader.h:418
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetInfo)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:92
PEAK_C_API(* dyn_PEAK_Buffer_GetBasePtr)(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Definition: peak_dynamic_loader.h:201
int32_t PEAK_DEVICE_ACCESS_STATUS
Definition: peak_backend.h:117
static PEAK_C_API PEAK_Device_GetVendorName(PEAK_DEVICE_HANDLE deviceHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:5322
PEAK_C_API(* dyn_PEAK_RegisterNode_GetLength)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Definition: peak_dynamic_loader.h:350
struct PEAK_INTERFACE * PEAK_INTERFACE_HANDLE
Definition: peak_backend.h:363
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:9079
PEAK_C_API(* dyn_PEAK_DataStream_Flush)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Definition: peak_dynamic_loader.h:192
PEAK_C_API(* dyn_PEAK_System_GetTLType)(PEAK_SYSTEM_HANDLE systemHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:75
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetValue)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Definition: peak_dynamic_loader.h:368
PEAK_C_API(* dyn_PEAK_System_GetKey)(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:68
static PEAK_C_API PEAK_Event_GetType(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Definition: peak_dynamic_loader.h:8767
static PEAK_C_API PEAK_FloatNode_GetUnit(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Definition: peak_dynamic_loader.h:7792
static PEAK_C_API PEAK_DeviceDescriptor_GetTimestampTickFrequency(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Definition: peak_dynamic_loader.h:5088
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Definition: peak_dynamic_loader.h:433
static PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Definition: peak_dynamic_loader.h:8559
static PEAK_C_API PEAK_Buffer_GetXOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Definition: peak_dynamic_loader.h:6232
PEAK_C_API(* dyn_PEAK_Node_GetPollingTime)(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Definition: peak_dynamic_loader.h:294
static PEAK_C_API PEAK_NodeMap_LoadFromFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition: peak_dynamic_loader.h:6921
static PEAK_C_API PEAK_Device_GetModelName(PEAK_DEVICE_HANDLE deviceHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:5335
PEAK_C_API(* dyn_PEAK_IntegerNode_ToNode)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:313
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, void *context)
Definition: peak_backend.h:587
PEAK_C_API(* dyn_PEAK_FloatNode_GetDisplayNotation)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Definition: peak_dynamic_loader.h:339
static PEAK_C_API PEAK_Device_GetSerialNumber(PEAK_DEVICE_HANDLE deviceHandle, char *serialNumber, size_t *serialNumberSize)
Definition: peak_dynamic_loader.h:5387
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetCharacterEncoding)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition: peak_dynamic_loader.h:63
static PEAK_C_API PEAK_StringNode_GetMaximumLength(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Definition: peak_dynamic_loader.h:7883
PEAK_C_API(* dyn_PEAK_ProducerLibrary_GetKey)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:48
int32_t PEAK_FIRMWARE_UPDATE_PERSISTENCE
Definition: peak_backend.h:176
static PEAK_C_API PEAK_NodeMap_Lock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition: peak_dynamic_loader.h:6934
PEAK_C_API(* dyn_PEAK_BufferPart_GetInfo)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:241
PEAK_C_API(* dyn_PEAK_BufferPart_GetYOffset)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Definition: peak_dynamic_loader.h:251
PEAK_C_API(* dyn_PEAK_StringNode_ToNode)(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:344
PEAK_C_API(* dyn_PEAK_Device_GetTimestampTickFrequency)(PEAK_DEVICE_HANDLE deviceHandle, uint64_t *timestampTickFrequency)
Definition: peak_dynamic_loader.h:155
PEAK_C_API(* dyn_PEAK_BufferChunk_GetSize)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Definition: peak_dynamic_loader.h:238
PEAK_C_API(* dyn_PEAK_Library_GetVersionMinor)(uint32_t *libraryVersionMinor)
Definition: peak_dynamic_loader.h:41
PEAK_C_API(* dyn_PEAK_Buffer_GetPart)(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Definition: peak_dynamic_loader.h:235
PEAK_C_API(* dyn_PEAK_EventController_GetInfo)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:400
static PEAK_C_API PEAK_DataStream_WaitForFinishedBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t timeout_ms, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:5868
PEAK_C_API(* dyn_PEAK_DataStream_StartAcquisitionInfinite)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Definition: peak_dynamic_loader.h:193
PEAK_C_API(* dyn_PEAK_Interface_ToModule)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:97
static PEAK_C_API PEAK_SystemDescriptor_GetParentLibrary(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition: peak_dynamic_loader.h:4230
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetCTIFileName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition: peak_dynamic_loader.h:59
static PEAK_C_API PEAK_DataStream_GetPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Definition: peak_dynamic_loader.h:5764
PEAK_C_API(* dyn_PEAK_Interface_Destruct)(PEAK_INTERFACE_HANDLE interfaceHandle)
Definition: peak_dynamic_loader.h:118
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSchemaVersionMajor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Definition: peak_dynamic_loader.h:396
int32_t PEAK_PIXEL_FORMAT_NAMESPACE
Definition: peak_backend.h:301
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionMajor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Definition: peak_dynamic_loader.h:393
static PEAK_C_API PEAK_BufferPart_GetFormatNamespace(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Definition: peak_dynamic_loader.h:6609
struct PEAK_BUFFER_CHUNK * PEAK_BUFFER_CHUNK_HANDLE
Definition: peak_backend.h:391
static PEAK_C_API PEAK_Library_Close()
Definition: peak_dynamic_loader.h:3892
static PEAK_C_API PEAK_DataStreamDescriptor_GetKey(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:5530
Definition: peak_dynamic_loader.h:450
PEAK_C_API(* dyn_PEAK_System_GetCTIFileName)(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition: peak_dynamic_loader.h:76
PEAK_C_API(* dyn_PEAK_Port_Read)(PEAK_PORT_HANDLE portHandle, uint64_t address, uint8_t *bytesToRead, size_t bytesToReadSize)
Definition: peak_dynamic_loader.h:382
static PEAK_C_API PEAK_Node_GetSelectingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition: peak_dynamic_loader.h:7428
PEAK_C_API(* dyn_PEAK_Buffer_GetHeight)(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Definition: peak_dynamic_loader.h:217
PEAK_C_API(* dyn_PEAK_Device_GetInfo)(PEAK_DEVICE_HANDLE deviceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:145
static PEAK_C_API PEAK_BufferPart_GetWidth(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Definition: peak_dynamic_loader.h:6622
PEAK_C_API(* dyn_PEAK_Port_GetVersion)(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:374
struct PEAK_FIRMWARE_UPDATE_INFORMATION * PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE
Definition: peak_backend.h:475
PEAK_C_API(* dyn_PEAK_Node_GetIsStreamable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Definition: peak_dynamic_loader.h:290
PEAK_C_API(* dyn_PEAK_StringNode_SetValue)(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Definition: peak_dynamic_loader.h:347
PEAK_C_API(* dyn_PEAK_Event_GetRawData)(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Definition: peak_dynamic_loader.h:414
static PEAK_C_API PEAK_Buffer_GetXPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Definition: peak_dynamic_loader.h:6258
static PEAK_C_API PEAK_RemoteDevice_ToModule(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:5491
static PEAK_C_API PEAK_Interface_RegisterDeviceReconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:4828
PEAK_C_API(* dyn_PEAK_ProducerLibrary_Destruct)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Definition: peak_dynamic_loader.h:50
static PEAK_C_API PEAK_PortURL_GetInfo(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:8416
static PEAK_C_API PEAK_PortURL_GetFileName(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Definition: peak_dynamic_loader.h:8455
static PEAK_C_API PEAK_CommandNode_WaitUntilDoneInfinite(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition: peak_dynamic_loader.h:7675
void(PEAK_CALL_CONV * PEAK_BUFFER_REVOCATION_CALLBACK)(void *buffer, void *userPtr, void *context)
Definition: peak_backend.h:555
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetIsOpenableExclusive)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Definition: peak_dynamic_loader.h:131
void(PEAK_CALL_CONV * PEAK_NODE_CHANGED_CALLBACK)(PEAK_NODE_HANDLE changedNode, void *context)
Definition: peak_backend.h:558
PEAK_C_API(* dyn_PEAK_System_GetCTIFullPath)(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition: peak_dynamic_loader.h:77
PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE
Definition: peak_backend.h:574
struct PEAK_MODULE * PEAK_MODULE_HANDLE
Definition: peak_backend.h:403
PEAK_C_API(* dyn_PEAK_Port_GetModelName)(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:373
PEAK_C_API(* dyn_PEAK_Buffer_GetWidth)(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Definition: peak_dynamic_loader.h:216
static PEAK_C_API PEAK_Event_GetInfo(PEAK_EVENT_HANDLE eventHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:8728
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Construct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Definition: peak_dynamic_loader.h:9040
PEAK_C_API(* dyn_PEAK_Buffer_GetChunk)(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Definition: peak_dynamic_loader.h:232
static PEAK_C_API PEAK_Device_GetAccessStatus(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition: peak_dynamic_loader.h:5400
PEAK_C_API(* dyn_PEAK_DataStream_GetDefinesPayloadSize)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *definesPayloadSize)
Definition: peak_dynamic_loader.h:183
PEAK_C_API(* dyn_PEAK_Interface_GetTLType)(PEAK_INTERFACE_HANDLE interfaceHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:103
PEAK_C_API(* dyn_PEAK_Node_ToRegisterNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Definition: peak_dynamic_loader.h:279
static PEAK_C_API PEAK_StringNode_ToNode(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:7870
PEAK_C_API(* dyn_PEAK_Port_GetModuleName)(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Definition: peak_dynamic_loader.h:376
PEAK_C_API(* dyn_PEAK_DataStream_WaitForFinishedBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t timeout_ms, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:190
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_GetCTIPath)(size_t index, char *ctiPath, size_t *ctiPathSize)
Definition: peak_dynamic_loader.h:46
PEAK_DEVICE_LOST_CALLBACK * PEAK_DEVICE_LOST_CALLBACK_HANDLE
Definition: peak_backend.h:550
static PEAK_C_API PEAK_Node_GetIsFeature(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Definition: peak_dynamic_loader.h:7194
static PEAK_C_API PEAK_CategoryNode_GetSubNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:8013
struct PEAK_DEVICE * PEAK_DEVICE_HANDLE
Definition: peak_backend.h:371
struct PEAK_COMMAND_NODE * PEAK_COMMAND_NODE_HANDLE
Definition: peak_backend.h:423
PEAK_C_API(* dyn_PEAK_Interface_GetParentSystem)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition: peak_dynamic_loader.h:104
PEAK_C_API(* dyn_PEAK_System_GetID)(PEAK_SYSTEM_HANDLE systemHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:70
PEAK_C_API(* dyn_PEAK_Node_GetAccessStatus)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Definition: peak_dynamic_loader.h:287
static PEAK_C_API PEAK_Buffer_GetYOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Definition: peak_dynamic_loader.h:6245
PEAK_C_API(* dyn_PEAK_EventController_GetEventDataMaxSize)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Definition: peak_dynamic_loader.h:404
static PEAK_C_API PEAK_Device_GetDataStream(PEAK_DEVICE_HANDLE deviceHandle, size_t index, PEAK_DATA_STREAM_DESCRIPTOR_HANDLE *dataStreamDescriptorHandle)
Definition: peak_dynamic_loader.h:5465
static PEAK_C_API PEAK_NodeMap_UpdateChunkNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:6869
PEAK_C_API(* dyn_PEAK_System_GetNumInterfaces)(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Definition: peak_dynamic_loader.h:83
static PEAK_C_API PEAK_InterfaceDescriptor_GetTLType(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition: peak_dynamic_loader.h:4620
PEAK_C_API(* dyn_PEAK_DataStream_GetInfo)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:170
PEAK_C_API(* dyn_PEAK_BufferPart_GetXOffset)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Definition: peak_dynamic_loader.h:250
static PEAK_C_API PEAK_System_GetKey(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:4282
void(PEAK_CALL_CONV * PEAK_DEVICE_LIST_CHANGED_CALLBACK)(void *context)
Definition: peak_backend.h:542
static PEAK_C_API PEAK_DataStream_KillWait(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition: peak_dynamic_loader.h:5881
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:442
PEAK_C_API(* dyn_PEAK_Buffer_ToModule)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition: peak_dynamic_loader.h:197
static PEAK_C_API PEAK_EnumerationEntryNode_GetIsSelfClearing(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Definition: peak_dynamic_loader.h:8156
static PEAK_C_API PEAK_System_GetInfo(PEAK_SYSTEM_HANDLE systemHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:4295
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetModelName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:56
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelFormat)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Definition: peak_dynamic_loader.h:205
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK)(const char *errorDescription, size_t errorDescriptionSize, void *context)
Definition: peak_backend.h:596
static PEAK_C_API PEAK_Device_GetNumDataStreams(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Definition: peak_dynamic_loader.h:5452
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_GetParentDevice)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition: peak_dynamic_loader.h:165
static PEAK_C_API PEAK_EnumerationNode_GetNumEntries(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Definition: peak_dynamic_loader.h:8117
PEAK_C_API(* dyn_PEAK_Buffer_GetExpectedDataSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Definition: peak_dynamic_loader.h:208
static PEAK_C_API PEAK_Buffer_GetUserPtr(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Definition: peak_dynamic_loader.h:6037
static PEAK_C_API PEAK_DeviceDescriptor_GetAccessStatus(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition: peak_dynamic_loader.h:5075
PEAK_C_API(* dyn_PEAK_NodeMap_GetNode)(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:265
static PEAK_C_API PEAK_Port_GetID(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:8208
static PEAK_C_API PEAK_DataStream_RevokeBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:5855
static PEAK_C_API PEAK_IntegerNode_GetMaximum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Definition: peak_dynamic_loader.h:7493
static PEAK_C_API PEAK_DataStream_QueueBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:5842
int32_t PEAK_NODE_REPRESENTATION
Definition: peak_backend.h:264
PEAK_C_API(* dyn_PEAK_Device_Destruct)(PEAK_DEVICE_HANDLE deviceHandle)
Definition: peak_dynamic_loader.h:160
static PEAK_C_API PEAK_IntegerNode_GetMinimum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Definition: peak_dynamic_loader.h:7480
PEAK_C_API(* dyn_PEAK_FloatNode_GetRepresentation)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition: peak_dynamic_loader.h:337
struct PEAK_DATA_STREAM_DESCRIPTOR * PEAK_DATA_STREAM_DESCRIPTOR_HANDLE
Definition: peak_backend.h:379
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersAwaitDelivery)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAwaitDelivery)
Definition: peak_dynamic_loader.h:176
PEAK_C_API(* dyn_PEAK_System_GetGenTLVersionMinor)(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Definition: peak_dynamic_loader.h:79
static PEAK_C_API PEAK_Node_GetName(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Definition: peak_dynamic_loader.h:7077
static PEAK_C_API PEAK_Buffer_ToEventSupportingModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:5972
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetInfo)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:53
PEAK_C_API(* dyn_PEAK_Interface_GetID)(PEAK_INTERFACE_HANDLE interfaceHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:101
PEAK_C_API(* dyn_PEAK_ModuleDescriptor_GetID)(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:256
static PEAK_C_API PEAK_Device_GetParentInterface(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition: peak_dynamic_loader.h:5426
PEAK_C_API(* dyn_PEAK_System_GetInterface)(PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE *interfaceDescriptorHandle)
Definition: peak_dynamic_loader.h:84
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredDataSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Definition: peak_dynamic_loader.h:209
PEAK_C_API(* dyn_PEAK_Buffer_UpdateChunks)(PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:230
PEAK_C_API(* dyn_PEAK_ProducerLibrary_Construct)(const char *ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition: peak_dynamic_loader.h:47
PEAK_C_API(* dyn_PEAK_Port_GetID)(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:370
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, uint64_t deviceResetDiscoveryTimeout_ms)
Definition: peak_dynamic_loader.h:422
static PEAK_C_API PEAK_NodeMap_GetHasEventSupportedData(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Definition: peak_dynamic_loader.h:6882
static PEAK_C_API PEAK_System_Destruct(PEAK_SYSTEM_HANDLE systemHandle)
Definition: peak_dynamic_loader.h:4555
PEAK_C_API(* dyn_PEAK_Buffer_GetHasImage)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Definition: peak_dynamic_loader.h:228
static PEAK_C_API PEAK_Buffer_GetIsIncomplete(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Definition: peak_dynamic_loader.h:6336
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetVersion)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *version, size_t *versionSize)
Definition: peak_dynamic_loader.h:125
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceLostCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:115
PEAK_C_API(* dyn_PEAK_Interface_RegisterDeviceDisconnectedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNETED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:112
static PEAK_C_API PEAK_Node_GetCachingMode(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Definition: peak_dynamic_loader.h:7207
PEAK_INTERFACE_LOST_CALLBACK * PEAK_INTERFACE_LOST_CALLBACK_HANDLE
Definition: peak_backend.h:493
PEAK_C_API(* dyn_PEAK_NodeMap_InvalidateNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition: peak_dynamic_loader.h:262
PEAK_INTERFACE_FOUND_CALLBACK * PEAK_INTERFACE_FOUND_CALLBACK_HANDLE
Definition: peak_backend.h:491
PEAK_C_API(* dyn_PEAK_EventController_GetEventMaxSize)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Definition: peak_dynamic_loader.h:403
static PEAK_C_API PEAK_PortURL_GetParentPort(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Definition: peak_dynamic_loader.h:8572
PEAK_C_API(* dyn_PEAK_System_ToEventSupportingModule)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition: peak_dynamic_loader.h:67
PEAK_C_API(* dyn_PEAK_Node_GetParentNodeMap)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition: peak_dynamic_loader.h:298
static PEAK_C_API PEAK_Library_GetLastError(PEAK_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Definition: peak_dynamic_loader.h:3957
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetInfo)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:121
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetGenTLVersionMajor)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMajor)
Definition: peak_dynamic_loader.h:61
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelFormatNamespace)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Definition: peak_dynamic_loader.h:206
static PEAK_C_API PEAK_DeviceDescriptor_GetUserDefinedName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition: peak_dynamic_loader.h:5049
PEAK_C_API(* dyn_PEAK_Event_GetType)(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Definition: peak_dynamic_loader.h:413
PEAK_C_API(* dyn_PEAK_DataStream_GetID)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:171
static PEAK_C_API PEAK_System_GetVendorName(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Definition: peak_dynamic_loader.h:4334
PEAK_C_API(* dyn_PEAK_IntegerNode_GetIncrementType)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition: peak_dynamic_loader.h:317
static PEAK_C_API PEAK_Node_GetNumInvalidatedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Definition: peak_dynamic_loader.h:7298
PEAK_C_API(* dyn_PEAK_Node_FindSelectingNode)(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition: peak_dynamic_loader.h:308
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_ToNode)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition: peak_dynamic_loader.h:365
static PEAK_C_API PEAK_EventController_FlushEvents(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition: peak_dynamic_loader.h:8702
PEAK_C_API(* dyn_PEAK_Device_GetDisplayName)(PEAK_DEVICE_HANDLE deviceHandle, char *displayName, size_t *displayNameSize)
Definition: peak_dynamic_loader.h:147
PEAK_C_API(* dyn_PEAK_DataStream_GetBufferAlignment)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *bufferAlignment)
Definition: peak_dynamic_loader.h:181
PEAK_C_API(* dyn_PEAK_Node_FindInvalidatingNode)(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition: peak_dynamic_loader.h:302
PEAK_C_API(* dyn_PEAK_BufferChunk_GetBasePtr)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Definition: peak_dynamic_loader.h:237
int32_t PEAK_FIRMWARE_UPDATE_VERSION_STYLE
Definition: peak_backend.h:197
PEAK_C_API(* dyn_PEAK_PortURL_GetScheme)(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Definition: peak_dynamic_loader.h:388
static PEAK_C_API PEAK_SystemDescriptor_GetCTIFullPath(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition: peak_dynamic_loader.h:4178
static PEAK_C_API PEAK_PortURL_GetFileVersionSubminor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Definition: peak_dynamic_loader.h:8533
struct PEAK_BUFFER_PART * PEAK_BUFFER_PART_HANDLE
Definition: peak_backend.h:395
static PEAK_C_API PEAK_Buffer_GetFileName(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Definition: peak_dynamic_loader.h:6193
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_OpenInterface)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition: peak_dynamic_loader.h:96
struct PEAK_REGISTER_NODE * PEAK_REGISTER_NODE_HANDLE
Definition: peak_backend.h:435
static PEAK_C_API PEAK_Node_GetInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition: peak_dynamic_loader.h:7350
PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE
Definition: peak_backend.h:585
static PEAK_C_API PEAK_Port_GetDataEndianness(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Definition: peak_dynamic_loader.h:8299
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersDelivered)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersDelivered)
Definition: peak_dynamic_loader.h:177
PEAK_C_API(* dyn_PEAK_Buffer_GetXPadding)(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Definition: peak_dynamic_loader.h:220
static PEAK_C_API PEAK_ProducerLibrary_GetSystem(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Definition: peak_dynamic_loader.h:4035
static PEAK_C_API PEAK_BufferPart_GetYOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Definition: peak_dynamic_loader.h:6661
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:438
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSHA1Hash)(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Definition: peak_dynamic_loader.h:392
static PEAK_C_API PEAK_Node_ToStringNode(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Definition: peak_dynamic_loader.h:7012
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK callback, void *callbackContext, PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:435
PEAK_C_API(* dyn_PEAK_BufferChunk_GetParentBuffer)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition: peak_dynamic_loader.h:239
static PEAK_C_API PEAK_Buffer_UpdateParts(PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:6427
PEAK_C_API(* dyn_PEAK_BufferPart_GetSize)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Definition: peak_dynamic_loader.h:244
PEAK_C_API(* dyn_PEAK_Node_ToCommandNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Definition: peak_dynamic_loader.h:276
PEAK_C_API(* dyn_PEAK_DataStream_QueueBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:188
PEAK_C_API(* dyn_PEAK_Node_FindSelectedNode)(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition: peak_dynamic_loader.h:305
PEAK_C_API(* dyn_PEAK_System_RegisterInterfaceFoundCallback)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK callback, void *callbackContext, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:85
static PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Definition: peak_dynamic_loader.h:8546
static PEAK_C_API PEAK_Interface_Destruct(PEAK_INTERFACE_HANDLE interfaceHandle)
Definition: peak_dynamic_loader.h:4932
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetDescription(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Definition: peak_dynamic_loader.h:8936
static PEAK_C_API PEAK_DataStream_GetID(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Definition: peak_dynamic_loader.h:5621
PEAK_C_API(* dyn_PEAK_Node_GetNumSelectedNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Definition: peak_dynamic_loader.h:306
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Definition: peak_dynamic_loader.h:431
static PEAK_C_API PEAK_DataStream_GetNumUnderruns(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Definition: peak_dynamic_loader.h:5725
PEAK_C_API(* dyn_PEAK_System_GetModelName)(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Definition: peak_dynamic_loader.h:73
static PEAK_C_API PEAK_EnumerationNode_FindEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:8091
static PEAK_C_API PEAK_DataStream_GetInfo(PEAK_DATA_STREAM_HANDLE dataStreamHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition: peak_dynamic_loader.h:5608
static PEAK_C_API PEAK_Node_GetIsCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Definition: peak_dynamic_loader.h:7142
static PEAK_C_API PEAK_InterfaceDescriptor_GetParentSystem(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition: peak_dynamic_loader.h:4633
PEAK_C_API(* dyn_PEAK_Interface_UpdateDevices)(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms)
Definition: peak_dynamic_loader.h:105
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersQueued)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersQueued)
Definition: peak_dynamic_loader.h:175
PEAK_C_API(* dyn_PEAK_Buffer_UpdateParts)(PEAK_BUFFER_HANDLE bufferHandle)
Definition: peak_dynamic_loader.h:233
PEAK_C_API(* dyn_PEAK_Node_GetIsFeature)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Definition: peak_dynamic_loader.h:292
PEAK_C_API(* dyn_PEAK_DataStream_GetNumUnderruns)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Definition: peak_dynamic_loader.h:179
static PEAK_C_API PEAK_Interface_RegisterDeviceListChangedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK callback, void *callbackContext, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE *callbackHandle)
Definition: peak_dynamic_loader.h:4906
static PEAK_C_API PEAK_DeviceDescriptor_GetKey(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:4958
static PEAK_C_API PEAK_BufferPart_Destruct(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Definition: peak_dynamic_loader.h:6713
static PEAK_C_API PEAK_Node_GetParentNodeMap(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition: peak_dynamic_loader.h:7272
static PEAK_C_API PEAK_Node_ToEnumerationEntryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition: peak_dynamic_loader.h:7064
static PEAK_C_API PEAK_IntegerNode_GetIncrement(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Definition: peak_dynamic_loader.h:7506
PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE
Definition: peak_backend.h:599
PEAK_C_API(* dyn_PEAK_DataStream_GetKey)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Definition: peak_dynamic_loader.h:169
static PEAK_C_API PEAK_DataStream_GetNumChunksPerBufferMax(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numChunksPerBufferMax)
Definition: peak_dynamic_loader.h:5738
PEAK_C_API(* dyn_PEAK_IntegerNode_GetValidValues)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Definition: peak_dynamic_loader.h:318
static PEAK_C_API PEAK_StringNode_SetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Definition: peak_dynamic_loader.h:7909
static PEAK_C_API PEAK_EventController_GetNumEventsFired(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Definition: peak_dynamic_loader.h:8624
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition: peak_dynamic_loader.h:440
PEAK_C_API(* dyn_PEAK_FloatNode_GetIncrement)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Definition: peak_dynamic_loader.h:334
static PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMajor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMajor)
Definition: peak_dynamic_loader.h:4191
PEAK_C_API(* dyn_PEAK_Buffer_GetUserPtr)(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Definition: peak_dynamic_loader.h:203
PEAK_C_API(* dyn_PEAK_FloatNode_GetHasConstantIncrement)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Definition: peak_dynamic_loader.h:341
