467 using std::runtime_error::runtime_error;
475 static DynamicLoader& instance()
477 static DynamicLoader dynamicLoader{};
478 return dynamicLoader;
480 bool loadLib(
const char* file);
482 bool setPointers(
bool load);
918 void* m_handle =
nullptr;
1352 return dlsym(module, proc_name);
1354 return reinterpret_cast<void*
>(GetProcAddress(
static_cast<HMODULE
>(module), proc_name));
1358inline DynamicLoader::DynamicLoader()
1360#if defined _WIN32 || defined _WIN64
1362 if (_wgetenv_s(&sz, NULL, 0, L
"IDS_PEAK_GENERIC_SDK_PATH") == 0
1365 std::vector<wchar_t> env_ids_peak(sz);
1366 if (_wgetenv_s(&sz, env_ids_peak.data(), sz, L
"IDS_PEAK_GENERIC_SDK_PATH") == 0)
1368 if (_wgetenv_s(&sz, NULL, 0, L
"PATH") == 0
1371 std::vector<wchar_t> env_path(sz);
1372 if (_wgetenv_s(&sz, env_path.data(), sz, L
"PATH") == 0)
1374 std::wstring ids_peak_path(env_ids_peak.data());
1376 ids_peak_path.append(L
"\\api\\lib\\x86_64");
1378 ids_peak_path.append(L
"\\api\\lib\\x86_32");
1380 AddDllDirectory(ids_peak_path.c_str());
1386 loadLib(
"ids_peak.dll");
1388 loadLib(
"libids_peak.so");
1394 if(m_handle !=
nullptr)
1402 auto&& inst = instance();
1403 return inst.m_handle !=
nullptr;
1406inline void DynamicLoader::unload()
1410 if (m_handle !=
nullptr)
1415 FreeLibrary(
static_cast<HMODULE
>(m_handle));
1422inline bool DynamicLoader::loadLib(
const char* file)
1429 m_handle = dlopen(file, RTLD_NOW);
1431 m_handle = LoadLibraryExA(file,
nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
1433 if (m_handle !=
nullptr)
1438 }
catch (
const std::exception&) {
1445 throw LoadLibraryException(std::string(
"Lib load failed: ") + file);
1450 throw LoadLibraryException(
"Filename empty");
1456inline bool DynamicLoader::setPointers(
bool load)
1460 if(m_PEAK_Library_Initialize ==
nullptr && load)
1462 throw std::runtime_error(
"Failed to load PEAK_Library_Initialize");
1466 if(m_PEAK_Library_Close ==
nullptr && load)
1468 throw std::runtime_error(
"Failed to load PEAK_Library_Close");
1472 if(m_PEAK_Library_IsInitialized ==
nullptr && load)
1474 throw std::runtime_error(
"Failed to load PEAK_Library_IsInitialized");
1478 if(m_PEAK_Library_GetVersionMajor ==
nullptr && load)
1480 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionMajor");
1484 if(m_PEAK_Library_GetVersionMinor ==
nullptr && load)
1486 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionMinor");
1490 if(m_PEAK_Library_GetVersionSubminor ==
nullptr && load)
1492 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionSubminor");
1496 if(m_PEAK_Library_GetLastError ==
nullptr && load)
1498 throw std::runtime_error(
"Failed to load PEAK_Library_GetLastError");
1502 if(m_PEAK_EnvironmentInspector_UpdateCTIPaths ==
nullptr && load)
1504 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_UpdateCTIPaths");
1508 if(m_PEAK_EnvironmentInspector_GetNumCTIPaths ==
nullptr && load)
1510 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_GetNumCTIPaths");
1514 if(m_PEAK_EnvironmentInspector_GetCTIPath ==
nullptr && load)
1516 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_GetCTIPath");
1520 if(m_PEAK_ProducerLibrary_Construct ==
nullptr && load)
1522 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_Construct");
1526 if(m_PEAK_ProducerLibrary_GetKey ==
nullptr && load)
1528 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_GetKey");
1532 if(m_PEAK_ProducerLibrary_GetSystem ==
nullptr && load)
1534 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_GetSystem");
1538 if(m_PEAK_ProducerLibrary_Destruct ==
nullptr && load)
1540 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_Destruct");
1544 if(m_PEAK_SystemDescriptor_ToModuleDescriptor ==
nullptr && load)
1546 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_ToModuleDescriptor");
1550 if(m_PEAK_SystemDescriptor_GetKey ==
nullptr && load)
1552 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetKey");
1556 if(m_PEAK_SystemDescriptor_GetInfo ==
nullptr && load)
1558 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetInfo");
1562 if(m_PEAK_SystemDescriptor_GetDisplayName ==
nullptr && load)
1564 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetDisplayName");
1568 if(m_PEAK_SystemDescriptor_GetVendorName ==
nullptr && load)
1570 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetVendorName");
1574 if(m_PEAK_SystemDescriptor_GetModelName ==
nullptr && load)
1576 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetModelName");
1580 if(m_PEAK_SystemDescriptor_GetVersion ==
nullptr && load)
1582 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetVersion");
1586 if(m_PEAK_SystemDescriptor_GetTLType ==
nullptr && load)
1588 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetTLType");
1592 if(m_PEAK_SystemDescriptor_GetCTIFileName ==
nullptr && load)
1594 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCTIFileName");
1598 if(m_PEAK_SystemDescriptor_GetCTIFullPath ==
nullptr && load)
1600 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCTIFullPath");
1604 if(m_PEAK_SystemDescriptor_GetGenTLVersionMajor ==
nullptr && load)
1606 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetGenTLVersionMajor");
1610 if(m_PEAK_SystemDescriptor_GetGenTLVersionMinor ==
nullptr && load)
1612 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetGenTLVersionMinor");
1616 if(m_PEAK_SystemDescriptor_GetCharacterEncoding ==
nullptr && load)
1618 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCharacterEncoding");
1622 if(m_PEAK_SystemDescriptor_GetParentLibrary ==
nullptr && load)
1624 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetParentLibrary");
1628 if(m_PEAK_SystemDescriptor_OpenSystem ==
nullptr && load)
1630 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_OpenSystem");
1634 if(m_PEAK_System_ToModule ==
nullptr && load)
1636 throw std::runtime_error(
"Failed to load PEAK_System_ToModule");
1640 if(m_PEAK_System_ToEventSupportingModule ==
nullptr && load)
1642 throw std::runtime_error(
"Failed to load PEAK_System_ToEventSupportingModule");
1646 if(m_PEAK_System_GetKey ==
nullptr && load)
1648 throw std::runtime_error(
"Failed to load PEAK_System_GetKey");
1652 if(m_PEAK_System_GetInfo ==
nullptr && load)
1654 throw std::runtime_error(
"Failed to load PEAK_System_GetInfo");
1658 if(m_PEAK_System_GetID ==
nullptr && load)
1660 throw std::runtime_error(
"Failed to load PEAK_System_GetID");
1664 if(m_PEAK_System_GetDisplayName ==
nullptr && load)
1666 throw std::runtime_error(
"Failed to load PEAK_System_GetDisplayName");
1670 if(m_PEAK_System_GetVendorName ==
nullptr && load)
1672 throw std::runtime_error(
"Failed to load PEAK_System_GetVendorName");
1676 if(m_PEAK_System_GetModelName ==
nullptr && load)
1678 throw std::runtime_error(
"Failed to load PEAK_System_GetModelName");
1682 if(m_PEAK_System_GetVersion ==
nullptr && load)
1684 throw std::runtime_error(
"Failed to load PEAK_System_GetVersion");
1688 if(m_PEAK_System_GetTLType ==
nullptr && load)
1690 throw std::runtime_error(
"Failed to load PEAK_System_GetTLType");
1694 if(m_PEAK_System_GetCTIFileName ==
nullptr && load)
1696 throw std::runtime_error(
"Failed to load PEAK_System_GetCTIFileName");
1700 if(m_PEAK_System_GetCTIFullPath ==
nullptr && load)
1702 throw std::runtime_error(
"Failed to load PEAK_System_GetCTIFullPath");
1706 if(m_PEAK_System_GetGenTLVersionMajor ==
nullptr && load)
1708 throw std::runtime_error(
"Failed to load PEAK_System_GetGenTLVersionMajor");
1712 if(m_PEAK_System_GetGenTLVersionMinor ==
nullptr && load)
1714 throw std::runtime_error(
"Failed to load PEAK_System_GetGenTLVersionMinor");
1718 if(m_PEAK_System_GetCharacterEncoding ==
nullptr && load)
1720 throw std::runtime_error(
"Failed to load PEAK_System_GetCharacterEncoding");
1724 if(m_PEAK_System_GetParentLibrary ==
nullptr && load)
1726 throw std::runtime_error(
"Failed to load PEAK_System_GetParentLibrary");
1730 if(m_PEAK_System_UpdateInterfaces ==
nullptr && load)
1732 throw std::runtime_error(
"Failed to load PEAK_System_UpdateInterfaces");
1736 if(m_PEAK_System_GetNumInterfaces ==
nullptr && load)
1738 throw std::runtime_error(
"Failed to load PEAK_System_GetNumInterfaces");
1742 if(m_PEAK_System_GetInterface ==
nullptr && load)
1744 throw std::runtime_error(
"Failed to load PEAK_System_GetInterface");
1748 if(m_PEAK_System_RegisterInterfaceFoundCallback ==
nullptr && load)
1750 throw std::runtime_error(
"Failed to load PEAK_System_RegisterInterfaceFoundCallback");
1754 if(m_PEAK_System_UnregisterInterfaceFoundCallback ==
nullptr && load)
1756 throw std::runtime_error(
"Failed to load PEAK_System_UnregisterInterfaceFoundCallback");
1760 if(m_PEAK_System_RegisterInterfaceLostCallback ==
nullptr && load)
1762 throw std::runtime_error(
"Failed to load PEAK_System_RegisterInterfaceLostCallback");
1766 if(m_PEAK_System_UnregisterInterfaceLostCallback ==
nullptr && load)
1768 throw std::runtime_error(
"Failed to load PEAK_System_UnregisterInterfaceLostCallback");
1772 if(m_PEAK_System_Destruct ==
nullptr && load)
1774 throw std::runtime_error(
"Failed to load PEAK_System_Destruct");
1778 if(m_PEAK_InterfaceDescriptor_ToModuleDescriptor ==
nullptr && load)
1780 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_ToModuleDescriptor");
1784 if(m_PEAK_InterfaceDescriptor_GetKey ==
nullptr && load)
1786 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetKey");
1790 if(m_PEAK_InterfaceDescriptor_GetInfo ==
nullptr && load)
1792 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetInfo");
1796 if(m_PEAK_InterfaceDescriptor_GetDisplayName ==
nullptr && load)
1798 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetDisplayName");
1802 if(m_PEAK_InterfaceDescriptor_GetTLType ==
nullptr && load)
1804 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetTLType");
1808 if(m_PEAK_InterfaceDescriptor_GetParentSystem ==
nullptr && load)
1810 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetParentSystem");
1814 if(m_PEAK_InterfaceDescriptor_OpenInterface ==
nullptr && load)
1816 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_OpenInterface");
1820 if(m_PEAK_Interface_ToModule ==
nullptr && load)
1822 throw std::runtime_error(
"Failed to load PEAK_Interface_ToModule");
1826 if(m_PEAK_Interface_ToEventSupportingModule ==
nullptr && load)
1828 throw std::runtime_error(
"Failed to load PEAK_Interface_ToEventSupportingModule");
1832 if(m_PEAK_Interface_GetKey ==
nullptr && load)
1834 throw std::runtime_error(
"Failed to load PEAK_Interface_GetKey");
1838 if(m_PEAK_Interface_GetInfo ==
nullptr && load)
1840 throw std::runtime_error(
"Failed to load PEAK_Interface_GetInfo");
1844 if(m_PEAK_Interface_GetID ==
nullptr && load)
1846 throw std::runtime_error(
"Failed to load PEAK_Interface_GetID");
1850 if(m_PEAK_Interface_GetDisplayName ==
nullptr && load)
1852 throw std::runtime_error(
"Failed to load PEAK_Interface_GetDisplayName");
1856 if(m_PEAK_Interface_GetTLType ==
nullptr && load)
1858 throw std::runtime_error(
"Failed to load PEAK_Interface_GetTLType");
1862 if(m_PEAK_Interface_GetParentSystem ==
nullptr && load)
1864 throw std::runtime_error(
"Failed to load PEAK_Interface_GetParentSystem");
1868 if(m_PEAK_Interface_UpdateDevices ==
nullptr && load)
1870 throw std::runtime_error(
"Failed to load PEAK_Interface_UpdateDevices");
1874 if(m_PEAK_Interface_GetNumDevices ==
nullptr && load)
1876 throw std::runtime_error(
"Failed to load PEAK_Interface_GetNumDevices");
1880 if(m_PEAK_Interface_GetDevice ==
nullptr && load)
1882 throw std::runtime_error(
"Failed to load PEAK_Interface_GetDevice");
1886 if(m_PEAK_Interface_RegisterDeviceFoundCallback ==
nullptr && load)
1888 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceFoundCallback");
1892 if(m_PEAK_Interface_UnregisterDeviceFoundCallback ==
nullptr && load)
1894 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceFoundCallback");
1898 if(m_PEAK_Interface_RegisterDeviceReconnectedCallback ==
nullptr && load)
1900 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceReconnectedCallback");
1904 if(m_PEAK_Interface_UnregisterDeviceReconnectedCallback ==
nullptr && load)
1906 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceReconnectedCallback");
1910 if(m_PEAK_Interface_RegisterDeviceDisconnectedCallback ==
nullptr && load)
1912 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceDisconnectedCallback");
1916 if(m_PEAK_Interface_UnregisterDeviceDisconnectedCallback ==
nullptr && load)
1918 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceDisconnectedCallback");
1922 if(m_PEAK_Interface_RegisterDeviceLostCallback ==
nullptr && load)
1924 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceLostCallback");
1928 if(m_PEAK_Interface_UnregisterDeviceLostCallback ==
nullptr && load)
1930 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceLostCallback");
1934 if(m_PEAK_Interface_RegisterDeviceListChangedCallback ==
nullptr && load)
1936 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceListChangedCallback");
1940 if(m_PEAK_Interface_UnregisterDeviceListChangedCallback ==
nullptr && load)
1942 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceListChangedCallback");
1946 if(m_PEAK_Interface_Destruct ==
nullptr && load)
1948 throw std::runtime_error(
"Failed to load PEAK_Interface_Destruct");
1952 if(m_PEAK_DeviceDescriptor_ToModuleDescriptor ==
nullptr && load)
1954 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_ToModuleDescriptor");
1958 if(m_PEAK_DeviceDescriptor_GetKey ==
nullptr && load)
1960 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetKey");
1964 if(m_PEAK_DeviceDescriptor_GetInfo ==
nullptr && load)
1966 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetInfo");
1970 if(m_PEAK_DeviceDescriptor_GetDisplayName ==
nullptr && load)
1972 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetDisplayName");
1976 if(m_PEAK_DeviceDescriptor_GetVendorName ==
nullptr && load)
1978 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetVendorName");
1982 if(m_PEAK_DeviceDescriptor_GetModelName ==
nullptr && load)
1984 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetModelName");
1988 if(m_PEAK_DeviceDescriptor_GetVersion ==
nullptr && load)
1990 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetVersion");
1994 if(m_PEAK_DeviceDescriptor_GetTLType ==
nullptr && load)
1996 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetTLType");
2000 if(m_PEAK_DeviceDescriptor_GetUserDefinedName ==
nullptr && load)
2002 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetUserDefinedName");
2006 if(m_PEAK_DeviceDescriptor_GetSerialNumber ==
nullptr && load)
2008 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetSerialNumber");
2012 if(m_PEAK_DeviceDescriptor_GetAccessStatus ==
nullptr && load)
2014 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetAccessStatus");
2018 if(m_PEAK_DeviceDescriptor_GetTimestampTickFrequency ==
nullptr && load)
2020 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetTimestampTickFrequency");
2024 if(m_PEAK_DeviceDescriptor_GetIsOpenableExclusive ==
nullptr && load)
2026 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetIsOpenableExclusive");
2030 if(m_PEAK_DeviceDescriptor_GetIsOpenable ==
nullptr && load)
2032 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetIsOpenable");
2036 if(m_PEAK_DeviceDescriptor_OpenDevice ==
nullptr && load)
2038 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_OpenDevice");
2042 if(m_PEAK_DeviceDescriptor_GetParentInterface ==
nullptr && load)
2044 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetParentInterface");
2048 if(m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval ==
nullptr && load)
2050 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetMonitoringUpdateInterval");
2054 if(m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval ==
nullptr && load)
2056 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_SetMonitoringUpdateInterval");
2060 if(m_PEAK_DeviceDescriptor_IsInformationRoleMonitored ==
nullptr && load)
2062 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_IsInformationRoleMonitored");
2066 if(m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring ==
nullptr && load)
2068 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_AddInformationRoleToMonitoring");
2072 if(m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring ==
nullptr && load)
2074 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring");
2078 if(m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback ==
nullptr && load)
2080 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_RegisterInformationChangedCallback");
2084 if(m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback ==
nullptr && load)
2086 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_UnregisterInformationChangedCallback");
2090 if(m_PEAK_Device_ToModule ==
nullptr && load)
2092 throw std::runtime_error(
"Failed to load PEAK_Device_ToModule");
2096 if(m_PEAK_Device_ToEventSupportingModule ==
nullptr && load)
2098 throw std::runtime_error(
"Failed to load PEAK_Device_ToEventSupportingModule");
2102 if(m_PEAK_Device_GetKey ==
nullptr && load)
2104 throw std::runtime_error(
"Failed to load PEAK_Device_GetKey");
2108 if(m_PEAK_Device_GetInfo ==
nullptr && load)
2110 throw std::runtime_error(
"Failed to load PEAK_Device_GetInfo");
2114 if(m_PEAK_Device_GetID ==
nullptr && load)
2116 throw std::runtime_error(
"Failed to load PEAK_Device_GetID");
2120 if(m_PEAK_Device_GetDisplayName ==
nullptr && load)
2122 throw std::runtime_error(
"Failed to load PEAK_Device_GetDisplayName");
2126 if(m_PEAK_Device_GetVendorName ==
nullptr && load)
2128 throw std::runtime_error(
"Failed to load PEAK_Device_GetVendorName");
2132 if(m_PEAK_Device_GetModelName ==
nullptr && load)
2134 throw std::runtime_error(
"Failed to load PEAK_Device_GetModelName");
2138 if(m_PEAK_Device_GetVersion ==
nullptr && load)
2140 throw std::runtime_error(
"Failed to load PEAK_Device_GetVersion");
2144 if(m_PEAK_Device_GetTLType ==
nullptr && load)
2146 throw std::runtime_error(
"Failed to load PEAK_Device_GetTLType");
2150 if(m_PEAK_Device_GetUserDefinedName ==
nullptr && load)
2152 throw std::runtime_error(
"Failed to load PEAK_Device_GetUserDefinedName");
2156 if(m_PEAK_Device_GetSerialNumber ==
nullptr && load)
2158 throw std::runtime_error(
"Failed to load PEAK_Device_GetSerialNumber");
2162 if(m_PEAK_Device_GetAccessStatus ==
nullptr && load)
2164 throw std::runtime_error(
"Failed to load PEAK_Device_GetAccessStatus");
2168 if(m_PEAK_Device_GetTimestampTickFrequency ==
nullptr && load)
2170 throw std::runtime_error(
"Failed to load PEAK_Device_GetTimestampTickFrequency");
2174 if(m_PEAK_Device_GetParentInterface ==
nullptr && load)
2176 throw std::runtime_error(
"Failed to load PEAK_Device_GetParentInterface");
2180 if(m_PEAK_Device_GetRemoteDevice ==
nullptr && load)
2182 throw std::runtime_error(
"Failed to load PEAK_Device_GetRemoteDevice");
2186 if(m_PEAK_Device_GetNumDataStreams ==
nullptr && load)
2188 throw std::runtime_error(
"Failed to load PEAK_Device_GetNumDataStreams");
2192 if(m_PEAK_Device_GetDataStream ==
nullptr && load)
2194 throw std::runtime_error(
"Failed to load PEAK_Device_GetDataStream");
2198 if(m_PEAK_Device_Destruct ==
nullptr && load)
2200 throw std::runtime_error(
"Failed to load PEAK_Device_Destruct");
2204 if(m_PEAK_RemoteDevice_ToModule ==
nullptr && load)
2206 throw std::runtime_error(
"Failed to load PEAK_RemoteDevice_ToModule");
2210 if(m_PEAK_RemoteDevice_GetLocalDevice ==
nullptr && load)
2212 throw std::runtime_error(
"Failed to load PEAK_RemoteDevice_GetLocalDevice");
2216 if(m_PEAK_DataStreamDescriptor_ToModuleDescriptor ==
nullptr && load)
2218 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_ToModuleDescriptor");
2222 if(m_PEAK_DataStreamDescriptor_GetKey ==
nullptr && load)
2224 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_GetKey");
2228 if(m_PEAK_DataStreamDescriptor_GetParentDevice ==
nullptr && load)
2230 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_GetParentDevice");
2234 if(m_PEAK_DataStreamDescriptor_OpenDataStream ==
nullptr && load)
2236 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_OpenDataStream");
2240 if(m_PEAK_DataStream_ToModule ==
nullptr && load)
2242 throw std::runtime_error(
"Failed to load PEAK_DataStream_ToModule");
2246 if(m_PEAK_DataStream_ToEventSupportingModule ==
nullptr && load)
2248 throw std::runtime_error(
"Failed to load PEAK_DataStream_ToEventSupportingModule");
2252 if(m_PEAK_DataStream_GetKey ==
nullptr && load)
2254 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetKey");
2258 if(m_PEAK_DataStream_GetInfo ==
nullptr && load)
2260 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetInfo");
2264 if(m_PEAK_DataStream_GetID ==
nullptr && load)
2266 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetID");
2270 if(m_PEAK_DataStream_GetTLType ==
nullptr && load)
2272 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetTLType");
2276 if(m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired ==
nullptr && load)
2278 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAnnouncedMinRequired");
2282 if(m_PEAK_DataStream_GetNumBuffersAnnounced ==
nullptr && load)
2284 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAnnounced");
2288 if(m_PEAK_DataStream_GetNumBuffersQueued ==
nullptr && load)
2290 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersQueued");
2294 if(m_PEAK_DataStream_GetNumBuffersAwaitDelivery ==
nullptr && load)
2296 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAwaitDelivery");
2300 if(m_PEAK_DataStream_GetNumBuffersDelivered ==
nullptr && load)
2302 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersDelivered");
2306 if(m_PEAK_DataStream_GetNumBuffersStarted ==
nullptr && load)
2308 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersStarted");
2312 if(m_PEAK_DataStream_GetNumUnderruns ==
nullptr && load)
2314 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumUnderruns");
2318 if(m_PEAK_DataStream_GetNumChunksPerBufferMax ==
nullptr && load)
2320 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumChunksPerBufferMax");
2324 if(m_PEAK_DataStream_GetBufferAlignment ==
nullptr && load)
2326 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetBufferAlignment");
2330 if(m_PEAK_DataStream_GetPayloadSize ==
nullptr && load)
2332 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetPayloadSize");
2336 if(m_PEAK_DataStream_GetDefinesPayloadSize ==
nullptr && load)
2338 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetDefinesPayloadSize");
2342 if(m_PEAK_DataStream_GetIsGrabbing ==
nullptr && load)
2344 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetIsGrabbing");
2348 if(m_PEAK_DataStream_GetParentDevice ==
nullptr && load)
2350 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetParentDevice");
2354 if(m_PEAK_DataStream_AnnounceBuffer ==
nullptr && load)
2356 throw std::runtime_error(
"Failed to load PEAK_DataStream_AnnounceBuffer");
2360 if(m_PEAK_DataStream_AllocAndAnnounceBuffer ==
nullptr && load)
2362 throw std::runtime_error(
"Failed to load PEAK_DataStream_AllocAndAnnounceBuffer");
2366 if(m_PEAK_DataStream_QueueBuffer ==
nullptr && load)
2368 throw std::runtime_error(
"Failed to load PEAK_DataStream_QueueBuffer");
2372 if(m_PEAK_DataStream_RevokeBuffer ==
nullptr && load)
2374 throw std::runtime_error(
"Failed to load PEAK_DataStream_RevokeBuffer");
2378 if(m_PEAK_DataStream_WaitForFinishedBuffer ==
nullptr && load)
2380 throw std::runtime_error(
"Failed to load PEAK_DataStream_WaitForFinishedBuffer");
2384 if(m_PEAK_DataStream_KillWait ==
nullptr && load)
2386 throw std::runtime_error(
"Failed to load PEAK_DataStream_KillWait");
2390 if(m_PEAK_DataStream_FlushPendingKillWaits ==
nullptr && load)
2392 throw std::runtime_error(
"Failed to load PEAK_DataStream_FlushPendingKillWaits");
2396 if(m_PEAK_DataStream_Flush ==
nullptr && load)
2398 throw std::runtime_error(
"Failed to load PEAK_DataStream_Flush");
2402 if(m_PEAK_DataStream_StartAcquisitionInfinite ==
nullptr && load)
2404 throw std::runtime_error(
"Failed to load PEAK_DataStream_StartAcquisitionInfinite");
2408 if(m_PEAK_DataStream_StartAcquisition ==
nullptr && load)
2410 throw std::runtime_error(
"Failed to load PEAK_DataStream_StartAcquisition");
2414 if(m_PEAK_DataStream_StopAcquisition ==
nullptr && load)
2416 throw std::runtime_error(
"Failed to load PEAK_DataStream_StopAcquisition");
2420 if(m_PEAK_DataStream_Destruct ==
nullptr && load)
2422 throw std::runtime_error(
"Failed to load PEAK_DataStream_Destruct");
2426 if(m_PEAK_Buffer_ToModule ==
nullptr && load)
2428 throw std::runtime_error(
"Failed to load PEAK_Buffer_ToModule");
2432 if(m_PEAK_Buffer_ToEventSupportingModule ==
nullptr && load)
2434 throw std::runtime_error(
"Failed to load PEAK_Buffer_ToEventSupportingModule");
2438 if(m_PEAK_Buffer_GetInfo ==
nullptr && load)
2440 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetInfo");
2444 if(m_PEAK_Buffer_GetTLType ==
nullptr && load)
2446 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTLType");
2450 if(m_PEAK_Buffer_GetBasePtr ==
nullptr && load)
2452 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetBasePtr");
2456 if(m_PEAK_Buffer_GetSize ==
nullptr && load)
2458 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetSize");
2462 if(m_PEAK_Buffer_GetUserPtr ==
nullptr && load)
2464 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetUserPtr");
2468 if(m_PEAK_Buffer_GetPayloadType ==
nullptr && load)
2470 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPayloadType");
2474 if(m_PEAK_Buffer_GetPixelFormat ==
nullptr && load)
2476 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelFormat");
2480 if(m_PEAK_Buffer_GetPixelFormatNamespace ==
nullptr && load)
2482 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelFormatNamespace");
2486 if(m_PEAK_Buffer_GetPixelEndianness ==
nullptr && load)
2488 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelEndianness");
2492 if(m_PEAK_Buffer_GetExpectedDataSize ==
nullptr && load)
2494 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetExpectedDataSize");
2498 if(m_PEAK_Buffer_GetDeliveredDataSize ==
nullptr && load)
2500 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredDataSize");
2504 if(m_PEAK_Buffer_GetFrameID ==
nullptr && load)
2506 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetFrameID");
2510 if(m_PEAK_Buffer_GetImageOffset ==
nullptr && load)
2512 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetImageOffset");
2516 if(m_PEAK_Buffer_GetDeliveredImageHeight ==
nullptr && load)
2518 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredImageHeight");
2522 if(m_PEAK_Buffer_GetDeliveredChunkPayloadSize ==
nullptr && load)
2524 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredChunkPayloadSize");
2528 if(m_PEAK_Buffer_GetChunkLayoutID ==
nullptr && load)
2530 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetChunkLayoutID");
2534 if(m_PEAK_Buffer_GetFileName ==
nullptr && load)
2536 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetFileName");
2540 if(m_PEAK_Buffer_GetWidth ==
nullptr && load)
2542 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetWidth");
2546 if(m_PEAK_Buffer_GetHeight ==
nullptr && load)
2548 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHeight");
2552 if(m_PEAK_Buffer_GetXOffset ==
nullptr && load)
2554 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetXOffset");
2558 if(m_PEAK_Buffer_GetYOffset ==
nullptr && load)
2560 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetYOffset");
2564 if(m_PEAK_Buffer_GetXPadding ==
nullptr && load)
2566 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetXPadding");
2570 if(m_PEAK_Buffer_GetYPadding ==
nullptr && load)
2572 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetYPadding");
2576 if(m_PEAK_Buffer_GetTimestamp_ticks ==
nullptr && load)
2578 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTimestamp_ticks");
2582 if(m_PEAK_Buffer_GetTimestamp_ns ==
nullptr && load)
2584 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTimestamp_ns");
2588 if(m_PEAK_Buffer_GetIsQueued ==
nullptr && load)
2590 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsQueued");
2594 if(m_PEAK_Buffer_GetIsAcquiring ==
nullptr && load)
2596 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsAcquiring");
2600 if(m_PEAK_Buffer_GetIsIncomplete ==
nullptr && load)
2602 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsIncomplete");
2606 if(m_PEAK_Buffer_GetHasNewData ==
nullptr && load)
2608 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasNewData");
2612 if(m_PEAK_Buffer_GetHasImage ==
nullptr && load)
2614 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasImage");
2618 if(m_PEAK_Buffer_GetHasChunks ==
nullptr && load)
2620 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasChunks");
2624 if(m_PEAK_Buffer_GetHasParts ==
nullptr && load)
2626 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasParts");
2630 if(m_PEAK_Buffer_UpdateChunks ==
nullptr && load)
2632 throw std::runtime_error(
"Failed to load PEAK_Buffer_UpdateChunks");
2636 if(m_PEAK_Buffer_GetNumChunks ==
nullptr && load)
2638 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetNumChunks");
2642 if(m_PEAK_Buffer_GetChunk ==
nullptr && load)
2644 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetChunk");
2648 if(m_PEAK_Buffer_UpdateParts ==
nullptr && load)
2650 throw std::runtime_error(
"Failed to load PEAK_Buffer_UpdateParts");
2654 if(m_PEAK_Buffer_GetNumParts ==
nullptr && load)
2656 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetNumParts");
2660 if(m_PEAK_Buffer_GetPart ==
nullptr && load)
2662 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPart");
2666 if(m_PEAK_BufferChunk_GetID ==
nullptr && load)
2668 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetID");
2672 if(m_PEAK_BufferChunk_GetBasePtr ==
nullptr && load)
2674 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetBasePtr");
2678 if(m_PEAK_BufferChunk_GetSize ==
nullptr && load)
2680 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetSize");
2684 if(m_PEAK_BufferChunk_GetParentBuffer ==
nullptr && load)
2686 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetParentBuffer");
2690 if(m_PEAK_BufferChunk_Destruct ==
nullptr && load)
2692 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_Destruct");
2696 if(m_PEAK_BufferPart_GetInfo ==
nullptr && load)
2698 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetInfo");
2702 if(m_PEAK_BufferPart_GetSourceID ==
nullptr && load)
2704 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetSourceID");
2708 if(m_PEAK_BufferPart_GetBasePtr ==
nullptr && load)
2710 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetBasePtr");
2714 if(m_PEAK_BufferPart_GetSize ==
nullptr && load)
2716 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetSize");
2720 if(m_PEAK_BufferPart_GetType ==
nullptr && load)
2722 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetType");
2726 if(m_PEAK_BufferPart_GetFormat ==
nullptr && load)
2728 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetFormat");
2732 if(m_PEAK_BufferPart_GetFormatNamespace ==
nullptr && load)
2734 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetFormatNamespace");
2738 if(m_PEAK_BufferPart_GetWidth ==
nullptr && load)
2740 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetWidth");
2744 if(m_PEAK_BufferPart_GetHeight ==
nullptr && load)
2746 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetHeight");
2750 if(m_PEAK_BufferPart_GetXOffset ==
nullptr && load)
2752 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetXOffset");
2756 if(m_PEAK_BufferPart_GetYOffset ==
nullptr && load)
2758 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetYOffset");
2762 if(m_PEAK_BufferPart_GetXPadding ==
nullptr && load)
2764 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetXPadding");
2768 if(m_PEAK_BufferPart_GetDeliveredImageHeight ==
nullptr && load)
2770 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetDeliveredImageHeight");
2774 if(m_PEAK_BufferPart_GetParentBuffer ==
nullptr && load)
2776 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetParentBuffer");
2780 if(m_PEAK_BufferPart_Destruct ==
nullptr && load)
2782 throw std::runtime_error(
"Failed to load PEAK_BufferPart_Destruct");
2786 if(m_PEAK_ModuleDescriptor_GetID ==
nullptr && load)
2788 throw std::runtime_error(
"Failed to load PEAK_ModuleDescriptor_GetID");
2792 if(m_PEAK_Module_GetNumNodeMaps ==
nullptr && load)
2794 throw std::runtime_error(
"Failed to load PEAK_Module_GetNumNodeMaps");
2798 if(m_PEAK_Module_GetNodeMap ==
nullptr && load)
2800 throw std::runtime_error(
"Failed to load PEAK_Module_GetNodeMap");
2804 if(m_PEAK_Module_GetPort ==
nullptr && load)
2806 throw std::runtime_error(
"Failed to load PEAK_Module_GetPort");
2810 if(m_PEAK_NodeMap_GetHasNode ==
nullptr && load)
2812 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasNode");
2816 if(m_PEAK_NodeMap_FindNode ==
nullptr && load)
2818 throw std::runtime_error(
"Failed to load PEAK_NodeMap_FindNode");
2822 if(m_PEAK_NodeMap_TryFindNode ==
nullptr && load)
2824 throw std::runtime_error(
"Failed to load PEAK_NodeMap_TryFindNode");
2828 if(m_PEAK_NodeMap_InvalidateNodes ==
nullptr && load)
2830 throw std::runtime_error(
"Failed to load PEAK_NodeMap_InvalidateNodes");
2834 if(m_PEAK_NodeMap_PollNodes ==
nullptr && load)
2836 throw std::runtime_error(
"Failed to load PEAK_NodeMap_PollNodes");
2840 if(m_PEAK_NodeMap_GetNumNodes ==
nullptr && load)
2842 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetNumNodes");
2846 if(m_PEAK_NodeMap_GetNode ==
nullptr && load)
2848 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetNode");
2852 if(m_PEAK_NodeMap_GetHasBufferSupportedChunks ==
nullptr && load)
2854 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasBufferSupportedChunks");
2858 if(m_PEAK_NodeMap_UpdateChunkNodes ==
nullptr && load)
2860 throw std::runtime_error(
"Failed to load PEAK_NodeMap_UpdateChunkNodes");
2864 if(m_PEAK_NodeMap_GetHasEventSupportedData ==
nullptr && load)
2866 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasEventSupportedData");
2870 if(m_PEAK_NodeMap_UpdateEventNodes ==
nullptr && load)
2872 throw std::runtime_error(
"Failed to load PEAK_NodeMap_UpdateEventNodes");
2876 if(m_PEAK_NodeMap_StoreToFile ==
nullptr && load)
2878 throw std::runtime_error(
"Failed to load PEAK_NodeMap_StoreToFile");
2882 if(m_PEAK_NodeMap_LoadFromFile ==
nullptr && load)
2884 throw std::runtime_error(
"Failed to load PEAK_NodeMap_LoadFromFile");
2888 if(m_PEAK_NodeMap_Lock ==
nullptr && load)
2890 throw std::runtime_error(
"Failed to load PEAK_NodeMap_Lock");
2894 if(m_PEAK_NodeMap_TryLock ==
nullptr && load)
2896 throw std::runtime_error(
"Failed to load PEAK_NodeMap_TryLock");
2900 if(m_PEAK_NodeMap_Unlock ==
nullptr && load)
2902 throw std::runtime_error(
"Failed to load PEAK_NodeMap_Unlock");
2906 if(m_PEAK_Node_ToIntegerNode ==
nullptr && load)
2908 throw std::runtime_error(
"Failed to load PEAK_Node_ToIntegerNode");
2912 if(m_PEAK_Node_ToBooleanNode ==
nullptr && load)
2914 throw std::runtime_error(
"Failed to load PEAK_Node_ToBooleanNode");
2918 if(m_PEAK_Node_ToCommandNode ==
nullptr && load)
2920 throw std::runtime_error(
"Failed to load PEAK_Node_ToCommandNode");
2924 if(m_PEAK_Node_ToFloatNode ==
nullptr && load)
2926 throw std::runtime_error(
"Failed to load PEAK_Node_ToFloatNode");
2930 if(m_PEAK_Node_ToStringNode ==
nullptr && load)
2932 throw std::runtime_error(
"Failed to load PEAK_Node_ToStringNode");
2936 if(m_PEAK_Node_ToRegisterNode ==
nullptr && load)
2938 throw std::runtime_error(
"Failed to load PEAK_Node_ToRegisterNode");
2942 if(m_PEAK_Node_ToCategoryNode ==
nullptr && load)
2944 throw std::runtime_error(
"Failed to load PEAK_Node_ToCategoryNode");
2948 if(m_PEAK_Node_ToEnumerationNode ==
nullptr && load)
2950 throw std::runtime_error(
"Failed to load PEAK_Node_ToEnumerationNode");
2954 if(m_PEAK_Node_ToEnumerationEntryNode ==
nullptr && load)
2956 throw std::runtime_error(
"Failed to load PEAK_Node_ToEnumerationEntryNode");
2960 if(m_PEAK_Node_GetName ==
nullptr && load)
2962 throw std::runtime_error(
"Failed to load PEAK_Node_GetName");
2966 if(m_PEAK_Node_GetDisplayName ==
nullptr && load)
2968 throw std::runtime_error(
"Failed to load PEAK_Node_GetDisplayName");
2972 if(m_PEAK_Node_GetNamespace ==
nullptr && load)
2974 throw std::runtime_error(
"Failed to load PEAK_Node_GetNamespace");
2978 if(m_PEAK_Node_GetVisibility ==
nullptr && load)
2980 throw std::runtime_error(
"Failed to load PEAK_Node_GetVisibility");
2984 if(m_PEAK_Node_GetAccessStatus ==
nullptr && load)
2986 throw std::runtime_error(
"Failed to load PEAK_Node_GetAccessStatus");
2990 if(m_PEAK_Node_GetIsCacheable ==
nullptr && load)
2992 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsCacheable");
2996 if(m_PEAK_Node_GetIsAccessStatusCacheable ==
nullptr && load)
2998 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsAccessStatusCacheable");
3002 if(m_PEAK_Node_GetIsStreamable ==
nullptr && load)
3004 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsStreamable");
3008 if(m_PEAK_Node_GetIsDeprecated ==
nullptr && load)
3010 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsDeprecated");
3014 if(m_PEAK_Node_GetIsFeature ==
nullptr && load)
3016 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsFeature");
3020 if(m_PEAK_Node_GetCachingMode ==
nullptr && load)
3022 throw std::runtime_error(
"Failed to load PEAK_Node_GetCachingMode");
3026 if(m_PEAK_Node_GetPollingTime ==
nullptr && load)
3028 throw std::runtime_error(
"Failed to load PEAK_Node_GetPollingTime");
3032 if(m_PEAK_Node_GetToolTip ==
nullptr && load)
3034 throw std::runtime_error(
"Failed to load PEAK_Node_GetToolTip");
3038 if(m_PEAK_Node_GetDescription ==
nullptr && load)
3040 throw std::runtime_error(
"Failed to load PEAK_Node_GetDescription");
3044 if(m_PEAK_Node_GetType ==
nullptr && load)
3046 throw std::runtime_error(
"Failed to load PEAK_Node_GetType");
3050 if(m_PEAK_Node_GetParentNodeMap ==
nullptr && load)
3052 throw std::runtime_error(
"Failed to load PEAK_Node_GetParentNodeMap");
3056 if(m_PEAK_Node_FindInvalidatedNode ==
nullptr && load)
3058 throw std::runtime_error(
"Failed to load PEAK_Node_FindInvalidatedNode");
3062 if(m_PEAK_Node_GetNumInvalidatedNodes ==
nullptr && load)
3064 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumInvalidatedNodes");
3068 if(m_PEAK_Node_GetInvalidatedNode ==
nullptr && load)
3070 throw std::runtime_error(
"Failed to load PEAK_Node_GetInvalidatedNode");
3074 if(m_PEAK_Node_FindInvalidatingNode ==
nullptr && load)
3076 throw std::runtime_error(
"Failed to load PEAK_Node_FindInvalidatingNode");
3080 if(m_PEAK_Node_GetNumInvalidatingNodes ==
nullptr && load)
3082 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumInvalidatingNodes");
3086 if(m_PEAK_Node_GetInvalidatingNode ==
nullptr && load)
3088 throw std::runtime_error(
"Failed to load PEAK_Node_GetInvalidatingNode");
3092 if(m_PEAK_Node_FindSelectedNode ==
nullptr && load)
3094 throw std::runtime_error(
"Failed to load PEAK_Node_FindSelectedNode");
3098 if(m_PEAK_Node_GetNumSelectedNodes ==
nullptr && load)
3100 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumSelectedNodes");
3104 if(m_PEAK_Node_GetSelectedNode ==
nullptr && load)
3106 throw std::runtime_error(
"Failed to load PEAK_Node_GetSelectedNode");
3110 if(m_PEAK_Node_FindSelectingNode ==
nullptr && load)
3112 throw std::runtime_error(
"Failed to load PEAK_Node_FindSelectingNode");
3116 if(m_PEAK_Node_GetNumSelectingNodes ==
nullptr && load)
3118 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumSelectingNodes");
3122 if(m_PEAK_Node_GetSelectingNode ==
nullptr && load)
3124 throw std::runtime_error(
"Failed to load PEAK_Node_GetSelectingNode");
3128 if(m_PEAK_Node_RegisterChangedCallback ==
nullptr && load)
3130 throw std::runtime_error(
"Failed to load PEAK_Node_RegisterChangedCallback");
3134 if(m_PEAK_Node_UnregisterChangedCallback ==
nullptr && load)
3136 throw std::runtime_error(
"Failed to load PEAK_Node_UnregisterChangedCallback");
3140 if(m_PEAK_IntegerNode_ToNode ==
nullptr && load)
3142 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_ToNode");
3146 if(m_PEAK_IntegerNode_GetMinimum ==
nullptr && load)
3148 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetMinimum");
3152 if(m_PEAK_IntegerNode_GetMaximum ==
nullptr && load)
3154 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetMaximum");
3158 if(m_PEAK_IntegerNode_GetIncrement ==
nullptr && load)
3160 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetIncrement");
3164 if(m_PEAK_IntegerNode_GetIncrementType ==
nullptr && load)
3166 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetIncrementType");
3170 if(m_PEAK_IntegerNode_GetValidValues ==
nullptr && load)
3172 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetValidValues");
3176 if(m_PEAK_IntegerNode_GetRepresentation ==
nullptr && load)
3178 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetRepresentation");
3182 if(m_PEAK_IntegerNode_GetUnit ==
nullptr && load)
3184 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetUnit");
3188 if(m_PEAK_IntegerNode_GetValue ==
nullptr && load)
3190 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetValue");
3194 if(m_PEAK_IntegerNode_SetValue ==
nullptr && load)
3196 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_SetValue");
3200 if(m_PEAK_BooleanNode_ToNode ==
nullptr && load)
3202 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_ToNode");
3206 if(m_PEAK_BooleanNode_GetValue ==
nullptr && load)
3208 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_GetValue");
3212 if(m_PEAK_BooleanNode_SetValue ==
nullptr && load)
3214 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_SetValue");
3218 if(m_PEAK_CommandNode_ToNode ==
nullptr && load)
3220 throw std::runtime_error(
"Failed to load PEAK_CommandNode_ToNode");
3224 if(m_PEAK_CommandNode_GetIsDone ==
nullptr && load)
3226 throw std::runtime_error(
"Failed to load PEAK_CommandNode_GetIsDone");
3230 if(m_PEAK_CommandNode_Execute ==
nullptr && load)
3232 throw std::runtime_error(
"Failed to load PEAK_CommandNode_Execute");
3236 if(m_PEAK_CommandNode_WaitUntilDoneInfinite ==
nullptr && load)
3238 throw std::runtime_error(
"Failed to load PEAK_CommandNode_WaitUntilDoneInfinite");
3242 if(m_PEAK_CommandNode_WaitUntilDone ==
nullptr && load)
3244 throw std::runtime_error(
"Failed to load PEAK_CommandNode_WaitUntilDone");
3248 if(m_PEAK_FloatNode_ToNode ==
nullptr && load)
3250 throw std::runtime_error(
"Failed to load PEAK_FloatNode_ToNode");
3254 if(m_PEAK_FloatNode_GetMinimum ==
nullptr && load)
3256 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetMinimum");
3260 if(m_PEAK_FloatNode_GetMaximum ==
nullptr && load)
3262 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetMaximum");
3266 if(m_PEAK_FloatNode_GetIncrement ==
nullptr && load)
3268 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetIncrement");
3272 if(m_PEAK_FloatNode_GetIncrementType ==
nullptr && load)
3274 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetIncrementType");
3278 if(m_PEAK_FloatNode_GetValidValues ==
nullptr && load)
3280 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetValidValues");
3284 if(m_PEAK_FloatNode_GetRepresentation ==
nullptr && load)
3286 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetRepresentation");
3290 if(m_PEAK_FloatNode_GetUnit ==
nullptr && load)
3292 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetUnit");
3296 if(m_PEAK_FloatNode_GetDisplayNotation ==
nullptr && load)
3298 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetDisplayNotation");
3302 if(m_PEAK_FloatNode_GetDisplayPrecision ==
nullptr && load)
3304 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetDisplayPrecision");
3308 if(m_PEAK_FloatNode_GetHasConstantIncrement ==
nullptr && load)
3310 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetHasConstantIncrement");
3314 if(m_PEAK_FloatNode_GetValue ==
nullptr && load)
3316 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetValue");
3320 if(m_PEAK_FloatNode_SetValue ==
nullptr && load)
3322 throw std::runtime_error(
"Failed to load PEAK_FloatNode_SetValue");
3326 if(m_PEAK_StringNode_ToNode ==
nullptr && load)
3328 throw std::runtime_error(
"Failed to load PEAK_StringNode_ToNode");
3332 if(m_PEAK_StringNode_GetMaximumLength ==
nullptr && load)
3334 throw std::runtime_error(
"Failed to load PEAK_StringNode_GetMaximumLength");
3338 if(m_PEAK_StringNode_GetValue ==
nullptr && load)
3340 throw std::runtime_error(
"Failed to load PEAK_StringNode_GetValue");
3344 if(m_PEAK_StringNode_SetValue ==
nullptr && load)
3346 throw std::runtime_error(
"Failed to load PEAK_StringNode_SetValue");
3350 if(m_PEAK_RegisterNode_ToNode ==
nullptr && load)
3352 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_ToNode");
3356 if(m_PEAK_RegisterNode_GetAddress ==
nullptr && load)
3358 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_GetAddress");
3362 if(m_PEAK_RegisterNode_GetLength ==
nullptr && load)
3364 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_GetLength");
3368 if(m_PEAK_RegisterNode_Read ==
nullptr && load)
3370 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_Read");
3374 if(m_PEAK_RegisterNode_Write ==
nullptr && load)
3376 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_Write");
3380 if(m_PEAK_CategoryNode_ToNode ==
nullptr && load)
3382 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_ToNode");
3386 if(m_PEAK_CategoryNode_GetNumSubNodes ==
nullptr && load)
3388 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_GetNumSubNodes");
3392 if(m_PEAK_CategoryNode_GetSubNode ==
nullptr && load)
3394 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_GetSubNode");
3398 if(m_PEAK_EnumerationNode_ToNode ==
nullptr && load)
3400 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_ToNode");
3404 if(m_PEAK_EnumerationNode_GetCurrentEntry ==
nullptr && load)
3406 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetCurrentEntry");
3410 if(m_PEAK_EnumerationNode_SetCurrentEntry ==
nullptr && load)
3412 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntry");
3416 if(m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue ==
nullptr && load)
3418 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue");
3422 if(m_PEAK_EnumerationNode_SetCurrentEntryByValue ==
nullptr && load)
3424 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntryByValue");
3428 if(m_PEAK_EnumerationNode_GetHasEntryBySymbolicValue ==
nullptr && load)
3430 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetHasEntryBySymbolicValue");
3434 if(m_PEAK_EnumerationNode_GetHasEntryByValue ==
nullptr && load)
3436 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetHasEntryByValue");
3440 if(m_PEAK_EnumerationNode_FindEntryBySymbolicValue ==
nullptr && load)
3442 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_FindEntryBySymbolicValue");
3446 if(m_PEAK_EnumerationNode_FindEntryByValue ==
nullptr && load)
3448 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_FindEntryByValue");
3452 if(m_PEAK_EnumerationNode_TryFindEntryBySymbolicValue ==
nullptr && load)
3454 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_TryFindEntryBySymbolicValue");
3458 if(m_PEAK_EnumerationNode_TryFindEntryByValue ==
nullptr && load)
3460 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_TryFindEntryByValue");
3464 if(m_PEAK_EnumerationNode_GetNumEntries ==
nullptr && load)
3466 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetNumEntries");
3470 if(m_PEAK_EnumerationNode_GetEntry ==
nullptr && load)
3472 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetEntry");
3476 if(m_PEAK_EnumerationEntryNode_ToNode ==
nullptr && load)
3478 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_ToNode");
3482 if(m_PEAK_EnumerationEntryNode_GetIsSelfClearing ==
nullptr && load)
3484 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetIsSelfClearing");
3488 if(m_PEAK_EnumerationEntryNode_GetSymbolicValue ==
nullptr && load)
3490 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetSymbolicValue");
3494 if(m_PEAK_EnumerationEntryNode_GetValue ==
nullptr && load)
3496 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetValue");
3500 if(m_PEAK_Port_GetInfo ==
nullptr && load)
3502 throw std::runtime_error(
"Failed to load PEAK_Port_GetInfo");
3506 if(m_PEAK_Port_GetID ==
nullptr && load)
3508 throw std::runtime_error(
"Failed to load PEAK_Port_GetID");
3512 if(m_PEAK_Port_GetName ==
nullptr && load)
3514 throw std::runtime_error(
"Failed to load PEAK_Port_GetName");
3518 if(m_PEAK_Port_GetVendorName ==
nullptr && load)
3520 throw std::runtime_error(
"Failed to load PEAK_Port_GetVendorName");
3524 if(m_PEAK_Port_GetModelName ==
nullptr && load)
3526 throw std::runtime_error(
"Failed to load PEAK_Port_GetModelName");
3530 if(m_PEAK_Port_GetVersion ==
nullptr && load)
3532 throw std::runtime_error(
"Failed to load PEAK_Port_GetVersion");
3536 if(m_PEAK_Port_GetTLType ==
nullptr && load)
3538 throw std::runtime_error(
"Failed to load PEAK_Port_GetTLType");
3542 if(m_PEAK_Port_GetModuleName ==
nullptr && load)
3544 throw std::runtime_error(
"Failed to load PEAK_Port_GetModuleName");
3548 if(m_PEAK_Port_GetDataEndianness ==
nullptr && load)
3550 throw std::runtime_error(
"Failed to load PEAK_Port_GetDataEndianness");
3554 if(m_PEAK_Port_GetIsReadable ==
nullptr && load)
3556 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsReadable");
3560 if(m_PEAK_Port_GetIsWritable ==
nullptr && load)
3562 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsWritable");
3566 if(m_PEAK_Port_GetIsAvailable ==
nullptr && load)
3568 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsAvailable");
3572 if(m_PEAK_Port_GetIsImplemented ==
nullptr && load)
3574 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsImplemented");
3578 if(m_PEAK_Port_Read ==
nullptr && load)
3580 throw std::runtime_error(
"Failed to load PEAK_Port_Read");
3584 if(m_PEAK_Port_Write ==
nullptr && load)
3586 throw std::runtime_error(
"Failed to load PEAK_Port_Write");
3590 if(m_PEAK_Port_GetNumURLs ==
nullptr && load)
3592 throw std::runtime_error(
"Failed to load PEAK_Port_GetNumURLs");
3596 if(m_PEAK_Port_GetURL ==
nullptr && load)
3598 throw std::runtime_error(
"Failed to load PEAK_Port_GetURL");
3602 if(m_PEAK_PortURL_GetInfo ==
nullptr && load)
3604 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetInfo");
3608 if(m_PEAK_PortURL_GetURL ==
nullptr && load)
3610 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetURL");
3614 if(m_PEAK_PortURL_GetScheme ==
nullptr && load)
3616 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetScheme");
3620 if(m_PEAK_PortURL_GetFileName ==
nullptr && load)
3622 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileName");
3626 if(m_PEAK_PortURL_GetFileRegisterAddress ==
nullptr && load)
3628 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileRegisterAddress");
3632 if(m_PEAK_PortURL_GetFileSize ==
nullptr && load)
3634 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSize");
3638 if(m_PEAK_PortURL_GetFileSHA1Hash ==
nullptr && load)
3640 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSHA1Hash");
3644 if(m_PEAK_PortURL_GetFileVersionMajor ==
nullptr && load)
3646 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionMajor");
3650 if(m_PEAK_PortURL_GetFileVersionMinor ==
nullptr && load)
3652 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionMinor");
3656 if(m_PEAK_PortURL_GetFileVersionSubminor ==
nullptr && load)
3658 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionSubminor");
3662 if(m_PEAK_PortURL_GetFileSchemaVersionMajor ==
nullptr && load)
3664 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSchemaVersionMajor");
3668 if(m_PEAK_PortURL_GetFileSchemaVersionMinor ==
nullptr && load)
3670 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSchemaVersionMinor");
3674 if(m_PEAK_PortURL_GetParentPort ==
nullptr && load)
3676 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetParentPort");
3680 if(m_PEAK_EventSupportingModule_EnableEvents ==
nullptr && load)
3682 throw std::runtime_error(
"Failed to load PEAK_EventSupportingModule_EnableEvents");
3686 if(m_PEAK_EventController_GetInfo ==
nullptr && load)
3688 throw std::runtime_error(
"Failed to load PEAK_EventController_GetInfo");
3692 if(m_PEAK_EventController_GetNumEventsInQueue ==
nullptr && load)
3694 throw std::runtime_error(
"Failed to load PEAK_EventController_GetNumEventsInQueue");
3698 if(m_PEAK_EventController_GetNumEventsFired ==
nullptr && load)
3700 throw std::runtime_error(
"Failed to load PEAK_EventController_GetNumEventsFired");
3704 if(m_PEAK_EventController_GetEventMaxSize ==
nullptr && load)
3706 throw std::runtime_error(
"Failed to load PEAK_EventController_GetEventMaxSize");
3710 if(m_PEAK_EventController_GetEventDataMaxSize ==
nullptr && load)
3712 throw std::runtime_error(
"Failed to load PEAK_EventController_GetEventDataMaxSize");
3716 if(m_PEAK_EventController_GetControlledEventType ==
nullptr && load)
3718 throw std::runtime_error(
"Failed to load PEAK_EventController_GetControlledEventType");
3722 if(m_PEAK_EventController_WaitForEvent ==
nullptr && load)
3724 throw std::runtime_error(
"Failed to load PEAK_EventController_WaitForEvent");
3728 if(m_PEAK_EventController_KillWait ==
nullptr && load)
3730 throw std::runtime_error(
"Failed to load PEAK_EventController_KillWait");
3734 if(m_PEAK_EventController_FlushPendingKillWaits ==
nullptr && load)
3736 throw std::runtime_error(
"Failed to load PEAK_EventController_FlushPendingKillWaits");
3740 if(m_PEAK_EventController_FlushEvents ==
nullptr && load)
3742 throw std::runtime_error(
"Failed to load PEAK_EventController_FlushEvents");
3746 if(m_PEAK_EventController_Destruct ==
nullptr && load)
3748 throw std::runtime_error(
"Failed to load PEAK_EventController_Destruct");
3752 if(m_PEAK_Event_GetInfo ==
nullptr && load)
3754 throw std::runtime_error(
"Failed to load PEAK_Event_GetInfo");
3758 if(m_PEAK_Event_GetID ==
nullptr && load)
3760 throw std::runtime_error(
"Failed to load PEAK_Event_GetID");
3764 if(m_PEAK_Event_GetData ==
nullptr && load)
3766 throw std::runtime_error(
"Failed to load PEAK_Event_GetData");
3770 if(m_PEAK_Event_GetType ==
nullptr && load)
3772 throw std::runtime_error(
"Failed to load PEAK_Event_GetType");
3776 if(m_PEAK_Event_GetRawData ==
nullptr && load)
3778 throw std::runtime_error(
"Failed to load PEAK_Event_GetRawData");
3782 if(m_PEAK_Event_Destruct ==
nullptr && load)
3784 throw std::runtime_error(
"Failed to load PEAK_Event_Destruct");
3788 if(m_PEAK_FirmwareUpdater_Construct ==
nullptr && load)
3790 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_Construct");
3794 if(m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation ==
nullptr && load)
3796 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation");
3800 if(m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation ==
nullptr && load)
3802 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation");
3806 if(m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation ==
nullptr && load)
3808 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation");
3812 if(m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation ==
nullptr && load)
3814 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_GetFirmwareUpdateInformation");
3818 if(m_PEAK_FirmwareUpdater_UpdateDevice ==
nullptr && load)
3820 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_UpdateDevice");
3824 if(m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout ==
nullptr && load)
3826 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout");
3830 if(m_PEAK_FirmwareUpdater_Destruct ==
nullptr && load)
3832 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_Destruct");
3836 if(m_PEAK_FirmwareUpdateInformation_GetIsValid ==
nullptr && load)
3838 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetIsValid");
3842 if(m_PEAK_FirmwareUpdateInformation_GetFileName ==
nullptr && load)
3844 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetFileName");
3848 if(m_PEAK_FirmwareUpdateInformation_GetDescription ==
nullptr && load)
3850 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetDescription");
3854 if(m_PEAK_FirmwareUpdateInformation_GetVersion ==
nullptr && load)
3856 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersion");
3860 if(m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern ==
nullptr && load)
3862 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern");
3866 if(m_PEAK_FirmwareUpdateInformation_GetVersionStyle ==
nullptr && load)
3868 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersionStyle");
3872 if(m_PEAK_FirmwareUpdateInformation_GetReleaseNotes ==
nullptr && load)
3874 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetReleaseNotes");
3878 if(m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL ==
nullptr && load)
3880 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetReleaseNotesURL");
3884 if(m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence ==
nullptr && load)
3886 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetUserSetPersistence");
3890 if(m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence ==
nullptr && load)
3892 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence");
3896 if(m_PEAK_FirmwareUpdateProgressObserver_Construct ==
nullptr && load)
3898 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_Construct");
3902 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback ==
nullptr && load)
3904 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback");
3908 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback ==
nullptr && load)
3910 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback");
3914 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback ==
nullptr && load)
3916 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback");
3920 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback ==
nullptr && load)
3922 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback");
3926 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback ==
nullptr && load)
3928 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback");
3932 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback ==
nullptr && load)
3934 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback");
3938 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback ==
nullptr && load)
3940 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback");
3944 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback ==
nullptr && load)
3946 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback");
3950 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback ==
nullptr && load)
3952 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback");
3956 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback ==
nullptr && load)
3958 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback");
3962 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback ==
nullptr && load)
3964 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback");
3968 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback ==
nullptr && load)
3970 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback");
3974 if(m_PEAK_FirmwareUpdateProgressObserver_Destruct ==
nullptr && load)
3976 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_Destruct");
3980 if(m_PEAK_FileAdapter_Construct ==
nullptr && load)
3982 throw std::runtime_error(
"Failed to load PEAK_FileAdapter_Construct");
3986 if(m_PEAK_FileAdapter_Destruct ==
nullptr && load)
3988 throw std::runtime_error(
"Failed to load PEAK_FileAdapter_Destruct");
3992 if(m_PEAK_FileAdapter_Read ==
nullptr && load)
3994 throw std::runtime_error(
"Failed to load PEAK_FileAdapter_Read");
3998 if(m_PEAK_FileAdapter_Write ==
nullptr && load)
4000 throw std::runtime_error(
"Failed to load PEAK_FileAdapter_Write");
4004 if(m_PEAK_FileAdapter_Delete ==
nullptr && load)
4006 throw std::runtime_error(
"Failed to load PEAK_FileAdapter_Delete");
4010 if(m_PEAK_FileAdapter_GetSize ==
nullptr && load)
4012 throw std::runtime_error(
"Failed to load PEAK_FileAdapter_GetSize");
4016 if(m_PEAK_FileAdapter_GetMaxSize ==
nullptr && load)
4018 throw std::runtime_error(
"Failed to load PEAK_FileAdapter_GetMaxSize");
4027 auto& inst = instance();
4028 if(inst.m_PEAK_Library_Initialize)
4030 return inst.m_PEAK_Library_Initialize();
4034 throw std::runtime_error(
"Library not loaded!");
4040 auto& inst = instance();
4041 if(inst.m_PEAK_Library_Close)
4043 return inst.m_PEAK_Library_Close();
4047 throw std::runtime_error(
"Library not loaded!");
4053 auto& inst = instance();
4054 if(inst.m_PEAK_Library_IsInitialized)
4056 return inst.m_PEAK_Library_IsInitialized(isInitialized);
4060 throw std::runtime_error(
"Library not loaded!");
4066 auto& inst = instance();
4067 if(inst.m_PEAK_Library_GetVersionMajor)
4069 return inst.m_PEAK_Library_GetVersionMajor(libraryVersionMajor);
4073 throw std::runtime_error(
"Library not loaded!");
4079 auto& inst = instance();
4080 if(inst.m_PEAK_Library_GetVersionMinor)
4082 return inst.m_PEAK_Library_GetVersionMinor(libraryVersionMinor);
4086 throw std::runtime_error(
"Library not loaded!");
4092 auto& inst = instance();
4093 if(inst.m_PEAK_Library_GetVersionSubminor)
4095 return inst.m_PEAK_Library_GetVersionSubminor(libraryVersionSubminor);
4099 throw std::runtime_error(
"Library not loaded!");
4105 auto& inst = instance();
4106 if(inst.m_PEAK_Library_GetLastError)
4108 return inst.m_PEAK_Library_GetLastError(lastErrorCode, lastErrorDescription, lastErrorDescriptionSize);
4112 throw std::runtime_error(
"Library not loaded!");
4118 auto& inst = instance();
4119 if(inst.m_PEAK_EnvironmentInspector_UpdateCTIPaths)
4121 return inst.m_PEAK_EnvironmentInspector_UpdateCTIPaths();
4125 throw std::runtime_error(
"Library not loaded!");
4131 auto& inst = instance();
4132 if(inst.m_PEAK_EnvironmentInspector_GetNumCTIPaths)
4134 return inst.m_PEAK_EnvironmentInspector_GetNumCTIPaths(numCtiPaths);
4138 throw std::runtime_error(
"Library not loaded!");
4144 auto& inst = instance();
4145 if(inst.m_PEAK_EnvironmentInspector_GetCTIPath)
4147 return inst.m_PEAK_EnvironmentInspector_GetCTIPath(index, ctiPath, ctiPathSize);
4151 throw std::runtime_error(
"Library not loaded!");
4157 auto& inst = instance();
4158 if(inst.m_PEAK_ProducerLibrary_Construct)
4160 return inst.m_PEAK_ProducerLibrary_Construct(ctiPath, ctiPathSize, producerLibraryHandle);
4164 throw std::runtime_error(
"Library not loaded!");
4170 auto& inst = instance();
4171 if(inst.m_PEAK_ProducerLibrary_GetKey)
4173 return inst.m_PEAK_ProducerLibrary_GetKey(producerLibraryHandle, key, keySize);
4177 throw std::runtime_error(
"Library not loaded!");
4183 auto& inst = instance();
4184 if(inst.m_PEAK_ProducerLibrary_GetSystem)
4186 return inst.m_PEAK_ProducerLibrary_GetSystem(producerLibraryHandle, systemDescriptorHandle);
4190 throw std::runtime_error(
"Library not loaded!");
4196 auto& inst = instance();
4197 if(inst.m_PEAK_ProducerLibrary_Destruct)
4199 return inst.m_PEAK_ProducerLibrary_Destruct(producerLibraryHandle);
4203 throw std::runtime_error(
"Library not loaded!");
4209 auto& inst = instance();
4210 if(inst.m_PEAK_SystemDescriptor_ToModuleDescriptor)
4212 return inst.m_PEAK_SystemDescriptor_ToModuleDescriptor(systemDescriptorHandle, moduleDescriptorHandle);
4216 throw std::runtime_error(
"Library not loaded!");
4222 auto& inst = instance();
4223 if(inst.m_PEAK_SystemDescriptor_GetKey)
4225 return inst.m_PEAK_SystemDescriptor_GetKey(systemDescriptorHandle, key, keySize);
4229 throw std::runtime_error(
"Library not loaded!");
4235 auto& inst = instance();
4236 if(inst.m_PEAK_SystemDescriptor_GetInfo)
4238 return inst.m_PEAK_SystemDescriptor_GetInfo(systemDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4242 throw std::runtime_error(
"Library not loaded!");
4248 auto& inst = instance();
4249 if(inst.m_PEAK_SystemDescriptor_GetDisplayName)
4251 return inst.m_PEAK_SystemDescriptor_GetDisplayName(systemDescriptorHandle, displayName, displayNameSize);
4255 throw std::runtime_error(
"Library not loaded!");
4261 auto& inst = instance();
4262 if(inst.m_PEAK_SystemDescriptor_GetVendorName)
4264 return inst.m_PEAK_SystemDescriptor_GetVendorName(systemDescriptorHandle, vendorName, vendorNameSize);
4268 throw std::runtime_error(
"Library not loaded!");
4274 auto& inst = instance();
4275 if(inst.m_PEAK_SystemDescriptor_GetModelName)
4277 return inst.m_PEAK_SystemDescriptor_GetModelName(systemDescriptorHandle, modelName, modelNameSize);
4281 throw std::runtime_error(
"Library not loaded!");
4287 auto& inst = instance();
4288 if(inst.m_PEAK_SystemDescriptor_GetVersion)
4290 return inst.m_PEAK_SystemDescriptor_GetVersion(systemDescriptorHandle, version, versionSize);
4294 throw std::runtime_error(
"Library not loaded!");
4300 auto& inst = instance();
4301 if(inst.m_PEAK_SystemDescriptor_GetTLType)
4303 return inst.m_PEAK_SystemDescriptor_GetTLType(systemDescriptorHandle, tlType, tlTypeSize);
4307 throw std::runtime_error(
"Library not loaded!");
4313 auto& inst = instance();
4314 if(inst.m_PEAK_SystemDescriptor_GetCTIFileName)
4316 return inst.m_PEAK_SystemDescriptor_GetCTIFileName(systemDescriptorHandle, ctiFileName, ctiFileNameSize);
4320 throw std::runtime_error(
"Library not loaded!");
4326 auto& inst = instance();
4327 if(inst.m_PEAK_SystemDescriptor_GetCTIFullPath)
4329 return inst.m_PEAK_SystemDescriptor_GetCTIFullPath(systemDescriptorHandle, ctiFullPath, ctiFullPathSize);
4333 throw std::runtime_error(
"Library not loaded!");
4339 auto& inst = instance();
4340 if(inst.m_PEAK_SystemDescriptor_GetGenTLVersionMajor)
4342 return inst.m_PEAK_SystemDescriptor_GetGenTLVersionMajor(systemDescriptorHandle, gentlVersionMajor);
4346 throw std::runtime_error(
"Library not loaded!");
4352 auto& inst = instance();
4353 if(inst.m_PEAK_SystemDescriptor_GetGenTLVersionMinor)
4355 return inst.m_PEAK_SystemDescriptor_GetGenTLVersionMinor(systemDescriptorHandle, gentlVersionMinor);
4359 throw std::runtime_error(
"Library not loaded!");
4365 auto& inst = instance();
4366 if(inst.m_PEAK_SystemDescriptor_GetCharacterEncoding)
4368 return inst.m_PEAK_SystemDescriptor_GetCharacterEncoding(systemDescriptorHandle, characterEncoding);
4372 throw std::runtime_error(
"Library not loaded!");
4378 auto& inst = instance();
4379 if(inst.m_PEAK_SystemDescriptor_GetParentLibrary)
4381 return inst.m_PEAK_SystemDescriptor_GetParentLibrary(systemDescriptorHandle, producerLibraryHandle);
4385 throw std::runtime_error(
"Library not loaded!");
4391 auto& inst = instance();
4392 if(inst.m_PEAK_SystemDescriptor_OpenSystem)
4394 return inst.m_PEAK_SystemDescriptor_OpenSystem(systemDescriptorHandle, systemHandle);
4398 throw std::runtime_error(
"Library not loaded!");
4404 auto& inst = instance();
4405 if(inst.m_PEAK_System_ToModule)
4407 return inst.m_PEAK_System_ToModule(systemHandle, moduleHandle);
4411 throw std::runtime_error(
"Library not loaded!");
4417 auto& inst = instance();
4418 if(inst.m_PEAK_System_ToEventSupportingModule)
4420 return inst.m_PEAK_System_ToEventSupportingModule(systemHandle, eventSupportingModuleHandle);
4424 throw std::runtime_error(
"Library not loaded!");
4430 auto& inst = instance();
4431 if(inst.m_PEAK_System_GetKey)
4433 return inst.m_PEAK_System_GetKey(systemHandle, key, keySize);
4437 throw std::runtime_error(
"Library not loaded!");
4443 auto& inst = instance();
4444 if(inst.m_PEAK_System_GetInfo)
4446 return inst.m_PEAK_System_GetInfo(systemHandle, infoCommand, infoDataType, info, infoSize);
4450 throw std::runtime_error(
"Library not loaded!");
4456 auto& inst = instance();
4457 if(inst.m_PEAK_System_GetID)
4459 return inst.m_PEAK_System_GetID(systemHandle,
id, idSize);
4463 throw std::runtime_error(
"Library not loaded!");
4469 auto& inst = instance();
4470 if(inst.m_PEAK_System_GetDisplayName)
4472 return inst.m_PEAK_System_GetDisplayName(systemHandle, displayName, displayNameSize);
4476 throw std::runtime_error(
"Library not loaded!");
4482 auto& inst = instance();
4483 if(inst.m_PEAK_System_GetVendorName)
4485 return inst.m_PEAK_System_GetVendorName(systemHandle, vendorName, vendorNameSize);
4489 throw std::runtime_error(
"Library not loaded!");
4495 auto& inst = instance();
4496 if(inst.m_PEAK_System_GetModelName)
4498 return inst.m_PEAK_System_GetModelName(systemHandle, modelName, modelNameSize);
4502 throw std::runtime_error(
"Library not loaded!");
4508 auto& inst = instance();
4509 if(inst.m_PEAK_System_GetVersion)
4511 return inst.m_PEAK_System_GetVersion(systemHandle, version, versionSize);
4515 throw std::runtime_error(
"Library not loaded!");
4521 auto& inst = instance();
4522 if(inst.m_PEAK_System_GetTLType)
4524 return inst.m_PEAK_System_GetTLType(systemHandle, tlType, tlTypeSize);
4528 throw std::runtime_error(
"Library not loaded!");
4534 auto& inst = instance();
4535 if(inst.m_PEAK_System_GetCTIFileName)
4537 return inst.m_PEAK_System_GetCTIFileName(systemHandle, ctiFileName, ctiFileNameSize);
4541 throw std::runtime_error(
"Library not loaded!");
4547 auto& inst = instance();
4548 if(inst.m_PEAK_System_GetCTIFullPath)
4550 return inst.m_PEAK_System_GetCTIFullPath(systemHandle, ctiFullPath, ctiFullPathSize);
4554 throw std::runtime_error(
"Library not loaded!");
4560 auto& inst = instance();
4561 if(inst.m_PEAK_System_GetGenTLVersionMajor)
4563 return inst.m_PEAK_System_GetGenTLVersionMajor(systemHandle, gentlVersionMajor);
4567 throw std::runtime_error(
"Library not loaded!");
4573 auto& inst = instance();
4574 if(inst.m_PEAK_System_GetGenTLVersionMinor)
4576 return inst.m_PEAK_System_GetGenTLVersionMinor(systemHandle, gentlVersionMinor);
4580 throw std::runtime_error(
"Library not loaded!");
4586 auto& inst = instance();
4587 if(inst.m_PEAK_System_GetCharacterEncoding)
4589 return inst.m_PEAK_System_GetCharacterEncoding(systemHandle, characterEncoding);
4593 throw std::runtime_error(
"Library not loaded!");
4599 auto& inst = instance();
4600 if(inst.m_PEAK_System_GetParentLibrary)
4602 return inst.m_PEAK_System_GetParentLibrary(systemHandle, producerLibraryHandle);
4606 throw std::runtime_error(
"Library not loaded!");
4612 auto& inst = instance();
4613 if(inst.m_PEAK_System_UpdateInterfaces)
4615 return inst.m_PEAK_System_UpdateInterfaces(systemHandle, timeout_ms);
4619 throw std::runtime_error(
"Library not loaded!");
4625 auto& inst = instance();
4626 if(inst.m_PEAK_System_GetNumInterfaces)
4628 return inst.m_PEAK_System_GetNumInterfaces(systemHandle, numInterfaces);
4632 throw std::runtime_error(
"Library not loaded!");
4638 auto& inst = instance();
4639 if(inst.m_PEAK_System_GetInterface)
4641 return inst.m_PEAK_System_GetInterface(systemHandle, index, interfaceDescriptorHandle);
4645 throw std::runtime_error(
"Library not loaded!");
4651 auto& inst = instance();
4652 if(inst.m_PEAK_System_RegisterInterfaceFoundCallback)
4654 return inst.m_PEAK_System_RegisterInterfaceFoundCallback(systemHandle, callback, callbackContext, callbackHandle);
4658 throw std::runtime_error(
"Library not loaded!");
4664 auto& inst = instance();
4665 if(inst.m_PEAK_System_UnregisterInterfaceFoundCallback)
4667 return inst.m_PEAK_System_UnregisterInterfaceFoundCallback(systemHandle, callbackHandle);
4671 throw std::runtime_error(
"Library not loaded!");
4677 auto& inst = instance();
4678 if(inst.m_PEAK_System_RegisterInterfaceLostCallback)
4680 return inst.m_PEAK_System_RegisterInterfaceLostCallback(systemHandle, callback, callbackContext, callbackHandle);
4684 throw std::runtime_error(
"Library not loaded!");
4690 auto& inst = instance();
4691 if(inst.m_PEAK_System_UnregisterInterfaceLostCallback)
4693 return inst.m_PEAK_System_UnregisterInterfaceLostCallback(systemHandle, callbackHandle);
4697 throw std::runtime_error(
"Library not loaded!");
4703 auto& inst = instance();
4704 if(inst.m_PEAK_System_Destruct)
4706 return inst.m_PEAK_System_Destruct(systemHandle);
4710 throw std::runtime_error(
"Library not loaded!");
4716 auto& inst = instance();
4717 if(inst.m_PEAK_InterfaceDescriptor_ToModuleDescriptor)
4719 return inst.m_PEAK_InterfaceDescriptor_ToModuleDescriptor(interfaceDescriptorHandle, moduleDescriptorHandle);
4723 throw std::runtime_error(
"Library not loaded!");
4729 auto& inst = instance();
4730 if(inst.m_PEAK_InterfaceDescriptor_GetKey)
4732 return inst.m_PEAK_InterfaceDescriptor_GetKey(interfaceDescriptorHandle, key, keySize);
4736 throw std::runtime_error(
"Library not loaded!");
4742 auto& inst = instance();
4743 if(inst.m_PEAK_InterfaceDescriptor_GetInfo)
4745 return inst.m_PEAK_InterfaceDescriptor_GetInfo(interfaceDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4749 throw std::runtime_error(
"Library not loaded!");
4755 auto& inst = instance();
4756 if(inst.m_PEAK_InterfaceDescriptor_GetDisplayName)
4758 return inst.m_PEAK_InterfaceDescriptor_GetDisplayName(interfaceDescriptorHandle, displayName, displayNameSize);
4762 throw std::runtime_error(
"Library not loaded!");
4768 auto& inst = instance();
4769 if(inst.m_PEAK_InterfaceDescriptor_GetTLType)
4771 return inst.m_PEAK_InterfaceDescriptor_GetTLType(interfaceDescriptorHandle, tlType, tlTypeSize);
4775 throw std::runtime_error(
"Library not loaded!");
4781 auto& inst = instance();
4782 if(inst.m_PEAK_InterfaceDescriptor_GetParentSystem)
4784 return inst.m_PEAK_InterfaceDescriptor_GetParentSystem(interfaceDescriptorHandle, systemHandle);
4788 throw std::runtime_error(
"Library not loaded!");
4794 auto& inst = instance();
4795 if(inst.m_PEAK_InterfaceDescriptor_OpenInterface)
4797 return inst.m_PEAK_InterfaceDescriptor_OpenInterface(interfaceDescriptorHandle, interfaceHandle);
4801 throw std::runtime_error(
"Library not loaded!");
4807 auto& inst = instance();
4808 if(inst.m_PEAK_Interface_ToModule)
4810 return inst.m_PEAK_Interface_ToModule(interfaceHandle, moduleHandle);
4814 throw std::runtime_error(
"Library not loaded!");
4820 auto& inst = instance();
4821 if(inst.m_PEAK_Interface_ToEventSupportingModule)
4823 return inst.m_PEAK_Interface_ToEventSupportingModule(interfaceHandle, eventSupportingModuleHandle);
4827 throw std::runtime_error(
"Library not loaded!");
4833 auto& inst = instance();
4834 if(inst.m_PEAK_Interface_GetKey)
4836 return inst.m_PEAK_Interface_GetKey(interfaceHandle, key, keySize);
4840 throw std::runtime_error(
"Library not loaded!");
4846 auto& inst = instance();
4847 if(inst.m_PEAK_Interface_GetInfo)
4849 return inst.m_PEAK_Interface_GetInfo(interfaceHandle, infoCommand, infoDataType, info, infoSize);
4853 throw std::runtime_error(
"Library not loaded!");
4859 auto& inst = instance();
4860 if(inst.m_PEAK_Interface_GetID)
4862 return inst.m_PEAK_Interface_GetID(interfaceHandle,
id, idSize);
4866 throw std::runtime_error(
"Library not loaded!");
4872 auto& inst = instance();
4873 if(inst.m_PEAK_Interface_GetDisplayName)
4875 return inst.m_PEAK_Interface_GetDisplayName(interfaceHandle, displayName, displayNameSize);
4879 throw std::runtime_error(
"Library not loaded!");
4885 auto& inst = instance();
4886 if(inst.m_PEAK_Interface_GetTLType)
4888 return inst.m_PEAK_Interface_GetTLType(interfaceHandle, tlType, tlTypeSize);
4892 throw std::runtime_error(
"Library not loaded!");
4898 auto& inst = instance();
4899 if(inst.m_PEAK_Interface_GetParentSystem)
4901 return inst.m_PEAK_Interface_GetParentSystem(interfaceHandle, systemHandle);
4905 throw std::runtime_error(
"Library not loaded!");
4911 auto& inst = instance();
4912 if(inst.m_PEAK_Interface_UpdateDevices)
4914 return inst.m_PEAK_Interface_UpdateDevices(interfaceHandle, timeout_ms);
4918 throw std::runtime_error(
"Library not loaded!");
4924 auto& inst = instance();
4925 if(inst.m_PEAK_Interface_GetNumDevices)
4927 return inst.m_PEAK_Interface_GetNumDevices(interfaceHandle, numDevices);
4931 throw std::runtime_error(
"Library not loaded!");
4937 auto& inst = instance();
4938 if(inst.m_PEAK_Interface_GetDevice)
4940 return inst.m_PEAK_Interface_GetDevice(interfaceHandle, index, deviceDescriptorHandle);
4944 throw std::runtime_error(
"Library not loaded!");
4950 auto& inst = instance();
4951 if(inst.m_PEAK_Interface_RegisterDeviceFoundCallback)
4953 return inst.m_PEAK_Interface_RegisterDeviceFoundCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4957 throw std::runtime_error(
"Library not loaded!");
4963 auto& inst = instance();
4964 if(inst.m_PEAK_Interface_UnregisterDeviceFoundCallback)
4966 return inst.m_PEAK_Interface_UnregisterDeviceFoundCallback(interfaceHandle, callbackHandle);
4970 throw std::runtime_error(
"Library not loaded!");
4976 auto& inst = instance();
4977 if(inst.m_PEAK_Interface_RegisterDeviceReconnectedCallback)
4979 return inst.m_PEAK_Interface_RegisterDeviceReconnectedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4983 throw std::runtime_error(
"Library not loaded!");
4989 auto& inst = instance();
4990 if(inst.m_PEAK_Interface_UnregisterDeviceReconnectedCallback)
4992 return inst.m_PEAK_Interface_UnregisterDeviceReconnectedCallback(interfaceHandle, callbackHandle);
4996 throw std::runtime_error(
"Library not loaded!");
5002 auto& inst = instance();
5003 if(inst.m_PEAK_Interface_RegisterDeviceDisconnectedCallback)
5005 return inst.m_PEAK_Interface_RegisterDeviceDisconnectedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
5009 throw std::runtime_error(
"Library not loaded!");
5015 auto& inst = instance();
5016 if(inst.m_PEAK_Interface_UnregisterDeviceDisconnectedCallback)
5018 return inst.m_PEAK_Interface_UnregisterDeviceDisconnectedCallback(interfaceHandle, callbackHandle);
5022 throw std::runtime_error(
"Library not loaded!");
5028 auto& inst = instance();
5029 if(inst.m_PEAK_Interface_RegisterDeviceLostCallback)
5031 return inst.m_PEAK_Interface_RegisterDeviceLostCallback(interfaceHandle, callback, callbackContext, callbackHandle);
5035 throw std::runtime_error(
"Library not loaded!");
5041 auto& inst = instance();
5042 if(inst.m_PEAK_Interface_UnregisterDeviceLostCallback)
5044 return inst.m_PEAK_Interface_UnregisterDeviceLostCallback(interfaceHandle, callbackHandle);
5048 throw std::runtime_error(
"Library not loaded!");
5054 auto& inst = instance();
5055 if(inst.m_PEAK_Interface_RegisterDeviceListChangedCallback)
5057 return inst.m_PEAK_Interface_RegisterDeviceListChangedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
5061 throw std::runtime_error(
"Library not loaded!");
5067 auto& inst = instance();
5068 if(inst.m_PEAK_Interface_UnregisterDeviceListChangedCallback)
5070 return inst.m_PEAK_Interface_UnregisterDeviceListChangedCallback(interfaceHandle, callbackHandle);
5074 throw std::runtime_error(
"Library not loaded!");
5080 auto& inst = instance();
5081 if(inst.m_PEAK_Interface_Destruct)
5083 return inst.m_PEAK_Interface_Destruct(interfaceHandle);
5087 throw std::runtime_error(
"Library not loaded!");
5093 auto& inst = instance();
5094 if(inst.m_PEAK_DeviceDescriptor_ToModuleDescriptor)
5096 return inst.m_PEAK_DeviceDescriptor_ToModuleDescriptor(deviceDescriptorHandle, moduleDescriptorHandle);
5100 throw std::runtime_error(
"Library not loaded!");
5106 auto& inst = instance();
5107 if(inst.m_PEAK_DeviceDescriptor_GetKey)
5109 return inst.m_PEAK_DeviceDescriptor_GetKey(deviceDescriptorHandle, key, keySize);
5113 throw std::runtime_error(
"Library not loaded!");
5119 auto& inst = instance();
5120 if(inst.m_PEAK_DeviceDescriptor_GetInfo)
5122 return inst.m_PEAK_DeviceDescriptor_GetInfo(deviceDescriptorHandle, infoCommand, infoDataType, info, infoSize);
5126 throw std::runtime_error(
"Library not loaded!");
5132 auto& inst = instance();
5133 if(inst.m_PEAK_DeviceDescriptor_GetDisplayName)
5135 return inst.m_PEAK_DeviceDescriptor_GetDisplayName(deviceDescriptorHandle, displayName, displayNameSize);
5139 throw std::runtime_error(
"Library not loaded!");
5145 auto& inst = instance();
5146 if(inst.m_PEAK_DeviceDescriptor_GetVendorName)
5148 return inst.m_PEAK_DeviceDescriptor_GetVendorName(deviceDescriptorHandle, vendorName, vendorNameSize);
5152 throw std::runtime_error(
"Library not loaded!");
5158 auto& inst = instance();
5159 if(inst.m_PEAK_DeviceDescriptor_GetModelName)
5161 return inst.m_PEAK_DeviceDescriptor_GetModelName(deviceDescriptorHandle, modelName, modelNameSize);
5165 throw std::runtime_error(
"Library not loaded!");
5171 auto& inst = instance();
5172 if(inst.m_PEAK_DeviceDescriptor_GetVersion)
5174 return inst.m_PEAK_DeviceDescriptor_GetVersion(deviceDescriptorHandle, version, versionSize);
5178 throw std::runtime_error(
"Library not loaded!");
5184 auto& inst = instance();
5185 if(inst.m_PEAK_DeviceDescriptor_GetTLType)
5187 return inst.m_PEAK_DeviceDescriptor_GetTLType(deviceDescriptorHandle, tlType, tlTypeSize);
5191 throw std::runtime_error(
"Library not loaded!");
5197 auto& inst = instance();
5198 if(inst.m_PEAK_DeviceDescriptor_GetUserDefinedName)
5200 return inst.m_PEAK_DeviceDescriptor_GetUserDefinedName(deviceDescriptorHandle, userDefinedName, userDefinedNameSize);
5204 throw std::runtime_error(
"Library not loaded!");
5210 auto& inst = instance();
5211 if(inst.m_PEAK_DeviceDescriptor_GetSerialNumber)
5213 return inst.m_PEAK_DeviceDescriptor_GetSerialNumber(deviceDescriptorHandle, serialNumber, serialNumberSize);
5217 throw std::runtime_error(
"Library not loaded!");
5223 auto& inst = instance();
5224 if(inst.m_PEAK_DeviceDescriptor_GetAccessStatus)
5226 return inst.m_PEAK_DeviceDescriptor_GetAccessStatus(deviceDescriptorHandle, accessStatus);
5230 throw std::runtime_error(
"Library not loaded!");
5236 auto& inst = instance();
5237 if(inst.m_PEAK_DeviceDescriptor_GetTimestampTickFrequency)
5239 return inst.m_PEAK_DeviceDescriptor_GetTimestampTickFrequency(deviceDescriptorHandle, timestampTickFrequency);
5243 throw std::runtime_error(
"Library not loaded!");
5249 auto& inst = instance();
5250 if(inst.m_PEAK_DeviceDescriptor_GetIsOpenableExclusive)
5252 return inst.m_PEAK_DeviceDescriptor_GetIsOpenableExclusive(deviceDescriptorHandle, isOpenable);
5256 throw std::runtime_error(
"Library not loaded!");
5262 auto& inst = instance();
5263 if(inst.m_PEAK_DeviceDescriptor_GetIsOpenable)
5265 return inst.m_PEAK_DeviceDescriptor_GetIsOpenable(deviceDescriptorHandle, accessType, isOpenable);
5269 throw std::runtime_error(
"Library not loaded!");
5275 auto& inst = instance();
5276 if(inst.m_PEAK_DeviceDescriptor_OpenDevice)
5278 return inst.m_PEAK_DeviceDescriptor_OpenDevice(deviceDescriptorHandle, accessType, deviceHandle);
5282 throw std::runtime_error(
"Library not loaded!");
5288 auto& inst = instance();
5289 if(inst.m_PEAK_DeviceDescriptor_GetParentInterface)
5291 return inst.m_PEAK_DeviceDescriptor_GetParentInterface(deviceDescriptorHandle, interfaceHandle);
5295 throw std::runtime_error(
"Library not loaded!");
5301 auto& inst = instance();
5302 if(inst.m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval)
5304 return inst.m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(deviceDescriptorHandle, monitoringUpdateInterval_ms);
5308 throw std::runtime_error(
"Library not loaded!");
5314 auto& inst = instance();
5315 if(inst.m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval)
5317 return inst.m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(deviceDescriptorHandle, monitoringUpdateInterval_ms);
5321 throw std::runtime_error(
"Library not loaded!");
5327 auto& inst = instance();
5328 if(inst.m_PEAK_DeviceDescriptor_IsInformationRoleMonitored)
5330 return inst.m_PEAK_DeviceDescriptor_IsInformationRoleMonitored(deviceDescriptorHandle, informationRole, isInformationRoleMonitored);
5334 throw std::runtime_error(
"Library not loaded!");
5340 auto& inst = instance();
5341 if(inst.m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring)
5343 return inst.m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(deviceDescriptorHandle, informationRole);
5347 throw std::runtime_error(
"Library not loaded!");
5353 auto& inst = instance();
5354 if(inst.m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring)
5356 return inst.m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(deviceDescriptorHandle, informationRole);
5360 throw std::runtime_error(
"Library not loaded!");
5366 auto& inst = instance();
5367 if(inst.m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback)
5369 return inst.m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback(deviceDescriptorHandle, callback, callbackContext, callbackHandle);
5373 throw std::runtime_error(
"Library not loaded!");
5379 auto& inst = instance();
5380 if(inst.m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback)
5382 return inst.m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(deviceDescriptorHandle, callbackHandle);
5386 throw std::runtime_error(
"Library not loaded!");
5392 auto& inst = instance();
5393 if(inst.m_PEAK_Device_ToModule)
5395 return inst.m_PEAK_Device_ToModule(deviceHandle, moduleHandle);
5399 throw std::runtime_error(
"Library not loaded!");
5405 auto& inst = instance();
5406 if(inst.m_PEAK_Device_ToEventSupportingModule)
5408 return inst.m_PEAK_Device_ToEventSupportingModule(deviceHandle, eventSupportingModuleHandle);
5412 throw std::runtime_error(
"Library not loaded!");
5418 auto& inst = instance();
5419 if(inst.m_PEAK_Device_GetKey)
5421 return inst.m_PEAK_Device_GetKey(deviceHandle, key, keySize);
5425 throw std::runtime_error(
"Library not loaded!");
5431 auto& inst = instance();
5432 if(inst.m_PEAK_Device_GetInfo)
5434 return inst.m_PEAK_Device_GetInfo(deviceHandle, infoCommand, infoDataType, info, infoSize);
5438 throw std::runtime_error(
"Library not loaded!");
5444 auto& inst = instance();
5445 if(inst.m_PEAK_Device_GetID)
5447 return inst.m_PEAK_Device_GetID(deviceHandle,
id, idSize);
5451 throw std::runtime_error(
"Library not loaded!");
5457 auto& inst = instance();
5458 if(inst.m_PEAK_Device_GetDisplayName)
5460 return inst.m_PEAK_Device_GetDisplayName(deviceHandle, displayName, displayNameSize);
5464 throw std::runtime_error(
"Library not loaded!");
5470 auto& inst = instance();
5471 if(inst.m_PEAK_Device_GetVendorName)
5473 return inst.m_PEAK_Device_GetVendorName(deviceHandle, vendorName, vendorNameSize);
5477 throw std::runtime_error(
"Library not loaded!");
5483 auto& inst = instance();
5484 if(inst.m_PEAK_Device_GetModelName)
5486 return inst.m_PEAK_Device_GetModelName(deviceHandle, modelName, modelNameSize);
5490 throw std::runtime_error(
"Library not loaded!");
5496 auto& inst = instance();
5497 if(inst.m_PEAK_Device_GetVersion)
5499 return inst.m_PEAK_Device_GetVersion(deviceHandle, version, versionSize);
5503 throw std::runtime_error(
"Library not loaded!");
5509 auto& inst = instance();
5510 if(inst.m_PEAK_Device_GetTLType)
5512 return inst.m_PEAK_Device_GetTLType(deviceHandle, tlType, tlTypeSize);
5516 throw std::runtime_error(
"Library not loaded!");
5522 auto& inst = instance();
5523 if(inst.m_PEAK_Device_GetUserDefinedName)
5525 return inst.m_PEAK_Device_GetUserDefinedName(deviceHandle, userDefinedName, userDefinedNameSize);
5529 throw std::runtime_error(
"Library not loaded!");
5535 auto& inst = instance();
5536 if(inst.m_PEAK_Device_GetSerialNumber)
5538 return inst.m_PEAK_Device_GetSerialNumber(deviceHandle, serialNumber, serialNumberSize);
5542 throw std::runtime_error(
"Library not loaded!");
5548 auto& inst = instance();
5549 if(inst.m_PEAK_Device_GetAccessStatus)
5551 return inst.m_PEAK_Device_GetAccessStatus(deviceHandle, accessStatus);
5555 throw std::runtime_error(
"Library not loaded!");
5561 auto& inst = instance();
5562 if(inst.m_PEAK_Device_GetTimestampTickFrequency)
5564 return inst.m_PEAK_Device_GetTimestampTickFrequency(deviceHandle, timestampTickFrequency);
5568 throw std::runtime_error(
"Library not loaded!");
5574 auto& inst = instance();
5575 if(inst.m_PEAK_Device_GetParentInterface)
5577 return inst.m_PEAK_Device_GetParentInterface(deviceHandle, interfaceHandle);
5581 throw std::runtime_error(
"Library not loaded!");
5587 auto& inst = instance();
5588 if(inst.m_PEAK_Device_GetRemoteDevice)
5590 return inst.m_PEAK_Device_GetRemoteDevice(deviceHandle, remoteDeviceHandle);
5594 throw std::runtime_error(
"Library not loaded!");
5600 auto& inst = instance();
5601 if(inst.m_PEAK_Device_GetNumDataStreams)
5603 return inst.m_PEAK_Device_GetNumDataStreams(deviceHandle, numDataStreams);
5607 throw std::runtime_error(
"Library not loaded!");
5613 auto& inst = instance();
5614 if(inst.m_PEAK_Device_GetDataStream)
5616 return inst.m_PEAK_Device_GetDataStream(deviceHandle, index, dataStreamDescriptorHandle);
5620 throw std::runtime_error(
"Library not loaded!");
5626 auto& inst = instance();
5627 if(inst.m_PEAK_Device_Destruct)
5629 return inst.m_PEAK_Device_Destruct(deviceHandle);
5633 throw std::runtime_error(
"Library not loaded!");
5639 auto& inst = instance();
5640 if(inst.m_PEAK_RemoteDevice_ToModule)
5642 return inst.m_PEAK_RemoteDevice_ToModule(remoteDeviceHandle, moduleHandle);
5646 throw std::runtime_error(
"Library not loaded!");
5652 auto& inst = instance();
5653 if(inst.m_PEAK_RemoteDevice_GetLocalDevice)
5655 return inst.m_PEAK_RemoteDevice_GetLocalDevice(remoteDeviceHandle, deviceHandle);
5659 throw std::runtime_error(
"Library not loaded!");
5665 auto& inst = instance();
5666 if(inst.m_PEAK_DataStreamDescriptor_ToModuleDescriptor)
5668 return inst.m_PEAK_DataStreamDescriptor_ToModuleDescriptor(dataStreamDescriptorHandle, moduleDescriptorHandle);
5672 throw std::runtime_error(
"Library not loaded!");
5678 auto& inst = instance();
5679 if(inst.m_PEAK_DataStreamDescriptor_GetKey)
5681 return inst.m_PEAK_DataStreamDescriptor_GetKey(dataStreamDescriptorHandle, key, keySize);
5685 throw std::runtime_error(
"Library not loaded!");
5691 auto& inst = instance();
5692 if(inst.m_PEAK_DataStreamDescriptor_GetParentDevice)
5694 return inst.m_PEAK_DataStreamDescriptor_GetParentDevice(dataStreamDescriptorHandle, deviceHandle);
5698 throw std::runtime_error(
"Library not loaded!");
5704 auto& inst = instance();
5705 if(inst.m_PEAK_DataStreamDescriptor_OpenDataStream)
5707 return inst.m_PEAK_DataStreamDescriptor_OpenDataStream(dataStreamDescriptorHandle, dataStreamHandle);
5711 throw std::runtime_error(
"Library not loaded!");
5717 auto& inst = instance();
5718 if(inst.m_PEAK_DataStream_ToModule)
5720 return inst.m_PEAK_DataStream_ToModule(dataStreamHandle, moduleHandle);
5724 throw std::runtime_error(
"Library not loaded!");
5730 auto& inst = instance();
5731 if(inst.m_PEAK_DataStream_ToEventSupportingModule)
5733 return inst.m_PEAK_DataStream_ToEventSupportingModule(dataStreamHandle, eventSupportingModuleHandle);
5737 throw std::runtime_error(
"Library not loaded!");
5743 auto& inst = instance();
5744 if(inst.m_PEAK_DataStream_GetKey)
5746 return inst.m_PEAK_DataStream_GetKey(dataStreamHandle, key, keySize);
5750 throw std::runtime_error(
"Library not loaded!");
5756 auto& inst = instance();
5757 if(inst.m_PEAK_DataStream_GetInfo)
5759 return inst.m_PEAK_DataStream_GetInfo(dataStreamHandle, infoCommand, infoDataType, info, infoSize);
5763 throw std::runtime_error(
"Library not loaded!");
5769 auto& inst = instance();
5770 if(inst.m_PEAK_DataStream_GetID)
5772 return inst.m_PEAK_DataStream_GetID(dataStreamHandle,
id, idSize);
5776 throw std::runtime_error(
"Library not loaded!");
5782 auto& inst = instance();
5783 if(inst.m_PEAK_DataStream_GetTLType)
5785 return inst.m_PEAK_DataStream_GetTLType(dataStreamHandle, tlType, tlTypeSize);
5789 throw std::runtime_error(
"Library not loaded!");
5795 auto& inst = instance();
5796 if(inst.m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired)
5798 return inst.m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(dataStreamHandle, numBuffersAnnouncedMinRequired);
5802 throw std::runtime_error(
"Library not loaded!");
5808 auto& inst = instance();
5809 if(inst.m_PEAK_DataStream_GetNumBuffersAnnounced)
5811 return inst.m_PEAK_DataStream_GetNumBuffersAnnounced(dataStreamHandle, numBuffersAnnounced);
5815 throw std::runtime_error(
"Library not loaded!");
5821 auto& inst = instance();
5822 if(inst.m_PEAK_DataStream_GetNumBuffersQueued)
5824 return inst.m_PEAK_DataStream_GetNumBuffersQueued(dataStreamHandle, numBuffersQueued);
5828 throw std::runtime_error(
"Library not loaded!");
5834 auto& inst = instance();
5835 if(inst.m_PEAK_DataStream_GetNumBuffersAwaitDelivery)
5837 return inst.m_PEAK_DataStream_GetNumBuffersAwaitDelivery(dataStreamHandle, numBuffersAwaitDelivery);
5841 throw std::runtime_error(
"Library not loaded!");
5847 auto& inst = instance();
5848 if(inst.m_PEAK_DataStream_GetNumBuffersDelivered)
5850 return inst.m_PEAK_DataStream_GetNumBuffersDelivered(dataStreamHandle, numBuffersDelivered);
5854 throw std::runtime_error(
"Library not loaded!");
5860 auto& inst = instance();
5861 if(inst.m_PEAK_DataStream_GetNumBuffersStarted)
5863 return inst.m_PEAK_DataStream_GetNumBuffersStarted(dataStreamHandle, numBuffersStarted);
5867 throw std::runtime_error(
"Library not loaded!");
5873 auto& inst = instance();
5874 if(inst.m_PEAK_DataStream_GetNumUnderruns)
5876 return inst.m_PEAK_DataStream_GetNumUnderruns(dataStreamHandle, numUnderruns);
5880 throw std::runtime_error(
"Library not loaded!");
5886 auto& inst = instance();
5887 if(inst.m_PEAK_DataStream_GetNumChunksPerBufferMax)
5889 return inst.m_PEAK_DataStream_GetNumChunksPerBufferMax(dataStreamHandle, numChunksPerBufferMax);
5893 throw std::runtime_error(
"Library not loaded!");
5899 auto& inst = instance();
5900 if(inst.m_PEAK_DataStream_GetBufferAlignment)
5902 return inst.m_PEAK_DataStream_GetBufferAlignment(dataStreamHandle, bufferAlignment);
5906 throw std::runtime_error(
"Library not loaded!");
5912 auto& inst = instance();
5913 if(inst.m_PEAK_DataStream_GetPayloadSize)
5915 return inst.m_PEAK_DataStream_GetPayloadSize(dataStreamHandle, payloadSize);
5919 throw std::runtime_error(
"Library not loaded!");
5925 auto& inst = instance();
5926 if(inst.m_PEAK_DataStream_GetDefinesPayloadSize)
5928 return inst.m_PEAK_DataStream_GetDefinesPayloadSize(dataStreamHandle, definesPayloadSize);
5932 throw std::runtime_error(
"Library not loaded!");
5938 auto& inst = instance();
5939 if(inst.m_PEAK_DataStream_GetIsGrabbing)
5941 return inst.m_PEAK_DataStream_GetIsGrabbing(dataStreamHandle, isGrabbing);
5945 throw std::runtime_error(
"Library not loaded!");
5951 auto& inst = instance();
5952 if(inst.m_PEAK_DataStream_GetParentDevice)
5954 return inst.m_PEAK_DataStream_GetParentDevice(dataStreamHandle, deviceHandle);
5958 throw std::runtime_error(
"Library not loaded!");
5964 auto& inst = instance();
5965 if(inst.m_PEAK_DataStream_AnnounceBuffer)
5967 return inst.m_PEAK_DataStream_AnnounceBuffer(dataStreamHandle, buffer, bufferSize, userPtr, revocationCallback, callbackContext, bufferHandle);
5971 throw std::runtime_error(
"Library not loaded!");
5977 auto& inst = instance();
5978 if(inst.m_PEAK_DataStream_AllocAndAnnounceBuffer)
5980 return inst.m_PEAK_DataStream_AllocAndAnnounceBuffer(dataStreamHandle, bufferSize, userPtr, bufferHandle);
5984 throw std::runtime_error(
"Library not loaded!");
5990 auto& inst = instance();
5991 if(inst.m_PEAK_DataStream_QueueBuffer)
5993 return inst.m_PEAK_DataStream_QueueBuffer(dataStreamHandle, bufferHandle);
5997 throw std::runtime_error(
"Library not loaded!");
6003 auto& inst = instance();
6004 if(inst.m_PEAK_DataStream_RevokeBuffer)
6006 return inst.m_PEAK_DataStream_RevokeBuffer(dataStreamHandle, bufferHandle);
6010 throw std::runtime_error(
"Library not loaded!");
6016 auto& inst = instance();
6017 if(inst.m_PEAK_DataStream_WaitForFinishedBuffer)
6019 return inst.m_PEAK_DataStream_WaitForFinishedBuffer(dataStreamHandle, timeout_ms, bufferHandle);
6023 throw std::runtime_error(
"Library not loaded!");
6029 auto& inst = instance();
6030 if(inst.m_PEAK_DataStream_KillWait)
6032 return inst.m_PEAK_DataStream_KillWait(dataStreamHandle);
6036 throw std::runtime_error(
"Library not loaded!");
6042 auto& inst = instance();
6043 if(inst.m_PEAK_DataStream_FlushPendingKillWaits)
6045 return inst.m_PEAK_DataStream_FlushPendingKillWaits(dataStreamHandle);
6049 throw std::runtime_error(
"Library not loaded!");
6055 auto& inst = instance();
6056 if(inst.m_PEAK_DataStream_Flush)
6058 return inst.m_PEAK_DataStream_Flush(dataStreamHandle, flushMode);
6062 throw std::runtime_error(
"Library not loaded!");
6068 auto& inst = instance();
6069 if(inst.m_PEAK_DataStream_StartAcquisitionInfinite)
6071 return inst.m_PEAK_DataStream_StartAcquisitionInfinite(dataStreamHandle, startMode);
6075 throw std::runtime_error(
"Library not loaded!");
6081 auto& inst = instance();
6082 if(inst.m_PEAK_DataStream_StartAcquisition)
6084 return inst.m_PEAK_DataStream_StartAcquisition(dataStreamHandle, startMode, numToAcquire);
6088 throw std::runtime_error(
"Library not loaded!");
6094 auto& inst = instance();
6095 if(inst.m_PEAK_DataStream_StopAcquisition)
6097 return inst.m_PEAK_DataStream_StopAcquisition(dataStreamHandle, stopMode);
6101 throw std::runtime_error(
"Library not loaded!");
6107 auto& inst = instance();
6108 if(inst.m_PEAK_DataStream_Destruct)
6110 return inst.m_PEAK_DataStream_Destruct(dataStreamHandle);
6114 throw std::runtime_error(
"Library not loaded!");
6120 auto& inst = instance();
6121 if(inst.m_PEAK_Buffer_ToModule)
6123 return inst.m_PEAK_Buffer_ToModule(bufferHandle, moduleHandle);
6127 throw std::runtime_error(
"Library not loaded!");
6133 auto& inst = instance();
6134 if(inst.m_PEAK_Buffer_ToEventSupportingModule)
6136 return inst.m_PEAK_Buffer_ToEventSupportingModule(bufferHandle, eventSupportingModuleHandle);
6140 throw std::runtime_error(
"Library not loaded!");
6146 auto& inst = instance();
6147 if(inst.m_PEAK_Buffer_GetInfo)
6149 return inst.m_PEAK_Buffer_GetInfo(bufferHandle, infoCommand, infoDataType, info, infoSize);
6153 throw std::runtime_error(
"Library not loaded!");
6159 auto& inst = instance();
6160 if(inst.m_PEAK_Buffer_GetTLType)
6162 return inst.m_PEAK_Buffer_GetTLType(bufferHandle, tlType, tlTypeSize);
6166 throw std::runtime_error(
"Library not loaded!");
6172 auto& inst = instance();
6173 if(inst.m_PEAK_Buffer_GetBasePtr)
6175 return inst.m_PEAK_Buffer_GetBasePtr(bufferHandle, basePtr);
6179 throw std::runtime_error(
"Library not loaded!");
6185 auto& inst = instance();
6186 if(inst.m_PEAK_Buffer_GetSize)
6188 return inst.m_PEAK_Buffer_GetSize(bufferHandle, size);
6192 throw std::runtime_error(
"Library not loaded!");
6198 auto& inst = instance();
6199 if(inst.m_PEAK_Buffer_GetUserPtr)
6201 return inst.m_PEAK_Buffer_GetUserPtr(bufferHandle, userPtr);
6205 throw std::runtime_error(
"Library not loaded!");
6211 auto& inst = instance();
6212 if(inst.m_PEAK_Buffer_GetPayloadType)
6214 return inst.m_PEAK_Buffer_GetPayloadType(bufferHandle, payloadType);
6218 throw std::runtime_error(
"Library not loaded!");
6224 auto& inst = instance();
6225 if(inst.m_PEAK_Buffer_GetPixelFormat)
6227 return inst.m_PEAK_Buffer_GetPixelFormat(bufferHandle, pixelFormat);
6231 throw std::runtime_error(
"Library not loaded!");
6237 auto& inst = instance();
6238 if(inst.m_PEAK_Buffer_GetPixelFormatNamespace)
6240 return inst.m_PEAK_Buffer_GetPixelFormatNamespace(bufferHandle, pixelFormatNamespace);
6244 throw std::runtime_error(
"Library not loaded!");
6250 auto& inst = instance();
6251 if(inst.m_PEAK_Buffer_GetPixelEndianness)
6253 return inst.m_PEAK_Buffer_GetPixelEndianness(bufferHandle, pixelEndianness);
6257 throw std::runtime_error(
"Library not loaded!");
6263 auto& inst = instance();
6264 if(inst.m_PEAK_Buffer_GetExpectedDataSize)
6266 return inst.m_PEAK_Buffer_GetExpectedDataSize(bufferHandle, expectedDataSize);
6270 throw std::runtime_error(
"Library not loaded!");
6276 auto& inst = instance();
6277 if(inst.m_PEAK_Buffer_GetDeliveredDataSize)
6279 return inst.m_PEAK_Buffer_GetDeliveredDataSize(bufferHandle, deliveredDataSize);
6283 throw std::runtime_error(
"Library not loaded!");
6289 auto& inst = instance();
6290 if(inst.m_PEAK_Buffer_GetFrameID)
6292 return inst.m_PEAK_Buffer_GetFrameID(bufferHandle, frameId);
6296 throw std::runtime_error(
"Library not loaded!");
6302 auto& inst = instance();
6303 if(inst.m_PEAK_Buffer_GetImageOffset)
6305 return inst.m_PEAK_Buffer_GetImageOffset(bufferHandle, imageOffset);
6309 throw std::runtime_error(
"Library not loaded!");
6315 auto& inst = instance();
6316 if(inst.m_PEAK_Buffer_GetDeliveredImageHeight)
6318 return inst.m_PEAK_Buffer_GetDeliveredImageHeight(bufferHandle, deliveredImageHeight);
6322 throw std::runtime_error(
"Library not loaded!");
6328 auto& inst = instance();
6329 if(inst.m_PEAK_Buffer_GetDeliveredChunkPayloadSize)
6331 return inst.m_PEAK_Buffer_GetDeliveredChunkPayloadSize(bufferHandle, deliveredChunkPayloadSize);
6335 throw std::runtime_error(
"Library not loaded!");
6341 auto& inst = instance();
6342 if(inst.m_PEAK_Buffer_GetChunkLayoutID)
6344 return inst.m_PEAK_Buffer_GetChunkLayoutID(bufferHandle, chunkLayoutId);
6348 throw std::runtime_error(
"Library not loaded!");
6354 auto& inst = instance();
6355 if(inst.m_PEAK_Buffer_GetFileName)
6357 return inst.m_PEAK_Buffer_GetFileName(bufferHandle, fileName, fileNameSize);
6361 throw std::runtime_error(
"Library not loaded!");
6367 auto& inst = instance();
6368 if(inst.m_PEAK_Buffer_GetWidth)
6370 return inst.m_PEAK_Buffer_GetWidth(bufferHandle, width);
6374 throw std::runtime_error(
"Library not loaded!");
6380 auto& inst = instance();
6381 if(inst.m_PEAK_Buffer_GetHeight)
6383 return inst.m_PEAK_Buffer_GetHeight(bufferHandle, height);
6387 throw std::runtime_error(
"Library not loaded!");
6393 auto& inst = instance();
6394 if(inst.m_PEAK_Buffer_GetXOffset)
6396 return inst.m_PEAK_Buffer_GetXOffset(bufferHandle, xOffset);
6400 throw std::runtime_error(
"Library not loaded!");
6406 auto& inst = instance();
6407 if(inst.m_PEAK_Buffer_GetYOffset)
6409 return inst.m_PEAK_Buffer_GetYOffset(bufferHandle, yOffset);
6413 throw std::runtime_error(
"Library not loaded!");
6419 auto& inst = instance();
6420 if(inst.m_PEAK_Buffer_GetXPadding)
6422 return inst.m_PEAK_Buffer_GetXPadding(bufferHandle, xPadding);
6426 throw std::runtime_error(
"Library not loaded!");
6432 auto& inst = instance();
6433 if(inst.m_PEAK_Buffer_GetYPadding)
6435 return inst.m_PEAK_Buffer_GetYPadding(bufferHandle, yPadding);
6439 throw std::runtime_error(
"Library not loaded!");
6445 auto& inst = instance();
6446 if(inst.m_PEAK_Buffer_GetTimestamp_ticks)
6448 return inst.m_PEAK_Buffer_GetTimestamp_ticks(bufferHandle, timestamp_ticks);
6452 throw std::runtime_error(
"Library not loaded!");
6458 auto& inst = instance();
6459 if(inst.m_PEAK_Buffer_GetTimestamp_ns)
6461 return inst.m_PEAK_Buffer_GetTimestamp_ns(bufferHandle, timestamp_ns);
6465 throw std::runtime_error(
"Library not loaded!");
6471 auto& inst = instance();
6472 if(inst.m_PEAK_Buffer_GetIsQueued)
6474 return inst.m_PEAK_Buffer_GetIsQueued(bufferHandle, isQueued);
6478 throw std::runtime_error(
"Library not loaded!");
6484 auto& inst = instance();
6485 if(inst.m_PEAK_Buffer_GetIsAcquiring)
6487 return inst.m_PEAK_Buffer_GetIsAcquiring(bufferHandle, isAcquiring);
6491 throw std::runtime_error(
"Library not loaded!");
6497 auto& inst = instance();
6498 if(inst.m_PEAK_Buffer_GetIsIncomplete)
6500 return inst.m_PEAK_Buffer_GetIsIncomplete(bufferHandle, isIncomplete);
6504 throw std::runtime_error(
"Library not loaded!");
6510 auto& inst = instance();
6511 if(inst.m_PEAK_Buffer_GetHasNewData)
6513 return inst.m_PEAK_Buffer_GetHasNewData(bufferHandle, hasNewData);
6517 throw std::runtime_error(
"Library not loaded!");
6523 auto& inst = instance();
6524 if(inst.m_PEAK_Buffer_GetHasImage)
6526 return inst.m_PEAK_Buffer_GetHasImage(bufferHandle, hasImage);
6530 throw std::runtime_error(
"Library not loaded!");
6536 auto& inst = instance();
6537 if(inst.m_PEAK_Buffer_GetHasChunks)
6539 return inst.m_PEAK_Buffer_GetHasChunks(bufferHandle, hasChunks);
6543 throw std::runtime_error(
"Library not loaded!");
6549 auto& inst = instance();
6550 if(inst.m_PEAK_Buffer_GetHasParts)
6552 return inst.m_PEAK_Buffer_GetHasParts(bufferHandle, hasParts);
6556 throw std::runtime_error(
"Library not loaded!");
6562 auto& inst = instance();
6563 if(inst.m_PEAK_Buffer_UpdateChunks)
6565 return inst.m_PEAK_Buffer_UpdateChunks(bufferHandle);
6569 throw std::runtime_error(
"Library not loaded!");
6575 auto& inst = instance();
6576 if(inst.m_PEAK_Buffer_GetNumChunks)
6578 return inst.m_PEAK_Buffer_GetNumChunks(bufferHandle, numChunks);
6582 throw std::runtime_error(
"Library not loaded!");
6588 auto& inst = instance();
6589 if(inst.m_PEAK_Buffer_GetChunk)
6591 return inst.m_PEAK_Buffer_GetChunk(bufferHandle, index, bufferChunkHandle);
6595 throw std::runtime_error(
"Library not loaded!");
6601 auto& inst = instance();
6602 if(inst.m_PEAK_Buffer_UpdateParts)
6604 return inst.m_PEAK_Buffer_UpdateParts(bufferHandle);
6608 throw std::runtime_error(
"Library not loaded!");
6614 auto& inst = instance();
6615 if(inst.m_PEAK_Buffer_GetNumParts)
6617 return inst.m_PEAK_Buffer_GetNumParts(bufferHandle, numParts);
6621 throw std::runtime_error(
"Library not loaded!");
6627 auto& inst = instance();
6628 if(inst.m_PEAK_Buffer_GetPart)
6630 return inst.m_PEAK_Buffer_GetPart(bufferHandle, index, bufferPartHandle);
6634 throw std::runtime_error(
"Library not loaded!");
6640 auto& inst = instance();
6641 if(inst.m_PEAK_BufferChunk_GetID)
6643 return inst.m_PEAK_BufferChunk_GetID(bufferChunkHandle,
id);
6647 throw std::runtime_error(
"Library not loaded!");
6653 auto& inst = instance();
6654 if(inst.m_PEAK_BufferChunk_GetBasePtr)
6656 return inst.m_PEAK_BufferChunk_GetBasePtr(bufferChunkHandle, basePtr);
6660 throw std::runtime_error(
"Library not loaded!");
6666 auto& inst = instance();
6667 if(inst.m_PEAK_BufferChunk_GetSize)
6669 return inst.m_PEAK_BufferChunk_GetSize(bufferChunkHandle, size);
6673 throw std::runtime_error(
"Library not loaded!");
6679 auto& inst = instance();
6680 if(inst.m_PEAK_BufferChunk_GetParentBuffer)
6682 return inst.m_PEAK_BufferChunk_GetParentBuffer(bufferChunkHandle, bufferHandle);
6686 throw std::runtime_error(
"Library not loaded!");
6692 auto& inst = instance();
6693 if(inst.m_PEAK_BufferChunk_Destruct)
6695 return inst.m_PEAK_BufferChunk_Destruct(bufferChunkHandle);
6699 throw std::runtime_error(
"Library not loaded!");
6705 auto& inst = instance();
6706 if(inst.m_PEAK_BufferPart_GetInfo)
6708 return inst.m_PEAK_BufferPart_GetInfo(bufferPartHandle, infoCommand, infoDataType, info, infoSize);
6712 throw std::runtime_error(
"Library not loaded!");
6718 auto& inst = instance();
6719 if(inst.m_PEAK_BufferPart_GetSourceID)
6721 return inst.m_PEAK_BufferPart_GetSourceID(bufferPartHandle, sourceId);
6725 throw std::runtime_error(
"Library not loaded!");
6731 auto& inst = instance();
6732 if(inst.m_PEAK_BufferPart_GetBasePtr)
6734 return inst.m_PEAK_BufferPart_GetBasePtr(bufferPartHandle, basePtr);
6738 throw std::runtime_error(
"Library not loaded!");
6744 auto& inst = instance();
6745 if(inst.m_PEAK_BufferPart_GetSize)
6747 return inst.m_PEAK_BufferPart_GetSize(bufferPartHandle, size);
6751 throw std::runtime_error(
"Library not loaded!");
6757 auto& inst = instance();
6758 if(inst.m_PEAK_BufferPart_GetType)
6760 return inst.m_PEAK_BufferPart_GetType(bufferPartHandle, type);
6764 throw std::runtime_error(
"Library not loaded!");
6770 auto& inst = instance();
6771 if(inst.m_PEAK_BufferPart_GetFormat)
6773 return inst.m_PEAK_BufferPart_GetFormat(bufferPartHandle, format);
6777 throw std::runtime_error(
"Library not loaded!");
6783 auto& inst = instance();
6784 if(inst.m_PEAK_BufferPart_GetFormatNamespace)
6786 return inst.m_PEAK_BufferPart_GetFormatNamespace(bufferPartHandle, formatNamespace);
6790 throw std::runtime_error(
"Library not loaded!");
6796 auto& inst = instance();
6797 if(inst.m_PEAK_BufferPart_GetWidth)
6799 return inst.m_PEAK_BufferPart_GetWidth(bufferPartHandle, width);
6803 throw std::runtime_error(
"Library not loaded!");
6809 auto& inst = instance();
6810 if(inst.m_PEAK_BufferPart_GetHeight)
6812 return inst.m_PEAK_BufferPart_GetHeight(bufferPartHandle, height);
6816 throw std::runtime_error(
"Library not loaded!");
6822 auto& inst = instance();
6823 if(inst.m_PEAK_BufferPart_GetXOffset)
6825 return inst.m_PEAK_BufferPart_GetXOffset(bufferPartHandle, xOffset);
6829 throw std::runtime_error(
"Library not loaded!");
6835 auto& inst = instance();
6836 if(inst.m_PEAK_BufferPart_GetYOffset)
6838 return inst.m_PEAK_BufferPart_GetYOffset(bufferPartHandle, yOffset);
6842 throw std::runtime_error(
"Library not loaded!");
6848 auto& inst = instance();
6849 if(inst.m_PEAK_BufferPart_GetXPadding)
6851 return inst.m_PEAK_BufferPart_GetXPadding(bufferPartHandle, xPadding);
6855 throw std::runtime_error(
"Library not loaded!");
6861 auto& inst = instance();
6862 if(inst.m_PEAK_BufferPart_GetDeliveredImageHeight)
6864 return inst.m_PEAK_BufferPart_GetDeliveredImageHeight(bufferPartHandle, deliveredImageHeight);
6868 throw std::runtime_error(
"Library not loaded!");
6874 auto& inst = instance();
6875 if(inst.m_PEAK_BufferPart_GetParentBuffer)
6877 return inst.m_PEAK_BufferPart_GetParentBuffer(bufferPartHandle, bufferHandle);
6881 throw std::runtime_error(
"Library not loaded!");
6887 auto& inst = instance();
6888 if(inst.m_PEAK_BufferPart_Destruct)
6890 return inst.m_PEAK_BufferPart_Destruct(bufferPartHandle);
6894 throw std::runtime_error(
"Library not loaded!");
6900 auto& inst = instance();
6901 if(inst.m_PEAK_ModuleDescriptor_GetID)
6903 return inst.m_PEAK_ModuleDescriptor_GetID(moduleDescriptorHandle,
id, idSize);
6907 throw std::runtime_error(
"Library not loaded!");
6913 auto& inst = instance();
6914 if(inst.m_PEAK_Module_GetNumNodeMaps)
6916 return inst.m_PEAK_Module_GetNumNodeMaps(moduleHandle, numNodeMaps);
6920 throw std::runtime_error(
"Library not loaded!");
6926 auto& inst = instance();
6927 if(inst.m_PEAK_Module_GetNodeMap)
6929 return inst.m_PEAK_Module_GetNodeMap(moduleHandle, index, nodeMapHandle);
6933 throw std::runtime_error(
"Library not loaded!");
6939 auto& inst = instance();
6940 if(inst.m_PEAK_Module_GetPort)
6942 return inst.m_PEAK_Module_GetPort(moduleHandle, portHandle);
6946 throw std::runtime_error(
"Library not loaded!");
6952 auto& inst = instance();
6953 if(inst.m_PEAK_NodeMap_GetHasNode)
6955 return inst.m_PEAK_NodeMap_GetHasNode(nodeMapHandle, nodeName, nodeNameSize, hasNode);
6959 throw std::runtime_error(
"Library not loaded!");
6965 auto& inst = instance();
6966 if(inst.m_PEAK_NodeMap_FindNode)
6968 return inst.m_PEAK_NodeMap_FindNode(nodeMapHandle, nodeName, nodeNameSize, nodeHandle);
6972 throw std::runtime_error(
"Library not loaded!");
6978 auto& inst = instance();
6979 if(inst.m_PEAK_NodeMap_TryFindNode)
6981 return inst.m_PEAK_NodeMap_TryFindNode(nodeMapHandle, nodeName, nodeNameSize, nodeHandle);
6985 throw std::runtime_error(
"Library not loaded!");
6991 auto& inst = instance();
6992 if(inst.m_PEAK_NodeMap_InvalidateNodes)
6994 return inst.m_PEAK_NodeMap_InvalidateNodes(nodeMapHandle);
6998 throw std::runtime_error(
"Library not loaded!");
7004 auto& inst = instance();
7005 if(inst.m_PEAK_NodeMap_PollNodes)
7007 return inst.m_PEAK_NodeMap_PollNodes(nodeMapHandle, elapsedTime_ms);
7011 throw std::runtime_error(
"Library not loaded!");
7017 auto& inst = instance();
7018 if(inst.m_PEAK_NodeMap_GetNumNodes)
7020 return inst.m_PEAK_NodeMap_GetNumNodes(nodeMapHandle, numNodes);
7024 throw std::runtime_error(
"Library not loaded!");
7030 auto& inst = instance();
7031 if(inst.m_PEAK_NodeMap_GetNode)
7033 return inst.m_PEAK_NodeMap_GetNode(nodeMapHandle, index, nodeHandle);
7037 throw std::runtime_error(
"Library not loaded!");
7043 auto& inst = instance();
7044 if(inst.m_PEAK_NodeMap_GetHasBufferSupportedChunks)
7046 return inst.m_PEAK_NodeMap_GetHasBufferSupportedChunks(nodeMapHandle, bufferHandle, hasSupportedChunks);
7050 throw std::runtime_error(
"Library not loaded!");
7056 auto& inst = instance();
7057 if(inst.m_PEAK_NodeMap_UpdateChunkNodes)
7059 return inst.m_PEAK_NodeMap_UpdateChunkNodes(nodeMapHandle, bufferHandle);
7063 throw std::runtime_error(
"Library not loaded!");
7069 auto& inst = instance();
7070 if(inst.m_PEAK_NodeMap_GetHasEventSupportedData)
7072 return inst.m_PEAK_NodeMap_GetHasEventSupportedData(nodeMapHandle, eventHandle, hasSupportedData);
7076 throw std::runtime_error(
"Library not loaded!");
7082 auto& inst = instance();
7083 if(inst.m_PEAK_NodeMap_UpdateEventNodes)
7085 return inst.m_PEAK_NodeMap_UpdateEventNodes(nodeMapHandle, eventHandle);
7089 throw std::runtime_error(
"Library not loaded!");
7095 auto& inst = instance();
7096 if(inst.m_PEAK_NodeMap_StoreToFile)
7098 return inst.m_PEAK_NodeMap_StoreToFile(nodeMapHandle, filePath, filePathSize);
7102 throw std::runtime_error(
"Library not loaded!");
7108 auto& inst = instance();
7109 if(inst.m_PEAK_NodeMap_LoadFromFile)
7111 return inst.m_PEAK_NodeMap_LoadFromFile(nodeMapHandle, filePath, filePathSize);
7115 throw std::runtime_error(
"Library not loaded!");
7121 auto& inst = instance();
7122 if(inst.m_PEAK_NodeMap_Lock)
7124 return inst.m_PEAK_NodeMap_Lock(nodeMapHandle);
7128 throw std::runtime_error(
"Library not loaded!");
7134 auto& inst = instance();
7135 if(inst.m_PEAK_NodeMap_TryLock)
7137 return inst.m_PEAK_NodeMap_TryLock(nodeMapHandle, locked);
7141 throw std::runtime_error(
"Library not loaded!");
7147 auto& inst = instance();
7148 if(inst.m_PEAK_NodeMap_Unlock)
7150 return inst.m_PEAK_NodeMap_Unlock(nodeMapHandle);
7154 throw std::runtime_error(
"Library not loaded!");
7160 auto& inst = instance();
7161 if(inst.m_PEAK_Node_ToIntegerNode)
7163 return inst.m_PEAK_Node_ToIntegerNode(nodeHandle, integerNodeHandle);
7167 throw std::runtime_error(
"Library not loaded!");
7173 auto& inst = instance();
7174 if(inst.m_PEAK_Node_ToBooleanNode)
7176 return inst.m_PEAK_Node_ToBooleanNode(nodeHandle, booleanNodeHandle);
7180 throw std::runtime_error(
"Library not loaded!");
7186 auto& inst = instance();
7187 if(inst.m_PEAK_Node_ToCommandNode)
7189 return inst.m_PEAK_Node_ToCommandNode(nodeHandle, commandNodeHandle);
7193 throw std::runtime_error(
"Library not loaded!");
7199 auto& inst = instance();
7200 if(inst.m_PEAK_Node_ToFloatNode)
7202 return inst.m_PEAK_Node_ToFloatNode(nodeHandle, floatNodeHandle);
7206 throw std::runtime_error(
"Library not loaded!");
7212 auto& inst = instance();
7213 if(inst.m_PEAK_Node_ToStringNode)
7215 return inst.m_PEAK_Node_ToStringNode(nodeHandle, stringNodeHandle);
7219 throw std::runtime_error(
"Library not loaded!");
7225 auto& inst = instance();
7226 if(inst.m_PEAK_Node_ToRegisterNode)
7228 return inst.m_PEAK_Node_ToRegisterNode(nodeHandle, registerNodeHandle);
7232 throw std::runtime_error(
"Library not loaded!");
7238 auto& inst = instance();
7239 if(inst.m_PEAK_Node_ToCategoryNode)
7241 return inst.m_PEAK_Node_ToCategoryNode(nodeHandle, categoryNodeHandle);
7245 throw std::runtime_error(
"Library not loaded!");
7251 auto& inst = instance();
7252 if(inst.m_PEAK_Node_ToEnumerationNode)
7254 return inst.m_PEAK_Node_ToEnumerationNode(nodeHandle, enumerationNodeHandle);
7258 throw std::runtime_error(
"Library not loaded!");
7264 auto& inst = instance();
7265 if(inst.m_PEAK_Node_ToEnumerationEntryNode)
7267 return inst.m_PEAK_Node_ToEnumerationEntryNode(nodeHandle, enumerationEntryNodeHandle);
7271 throw std::runtime_error(
"Library not loaded!");
7277 auto& inst = instance();
7278 if(inst.m_PEAK_Node_GetName)
7280 return inst.m_PEAK_Node_GetName(nodeHandle, name, nameSize);
7284 throw std::runtime_error(
"Library not loaded!");
7290 auto& inst = instance();
7291 if(inst.m_PEAK_Node_GetDisplayName)
7293 return inst.m_PEAK_Node_GetDisplayName(nodeHandle, displayName, displayNameSize);
7297 throw std::runtime_error(
"Library not loaded!");
7303 auto& inst = instance();
7304 if(inst.m_PEAK_Node_GetNamespace)
7306 return inst.m_PEAK_Node_GetNamespace(nodeHandle, _namespace);
7310 throw std::runtime_error(
"Library not loaded!");
7316 auto& inst = instance();
7317 if(inst.m_PEAK_Node_GetVisibility)
7319 return inst.m_PEAK_Node_GetVisibility(nodeHandle, visibility);
7323 throw std::runtime_error(
"Library not loaded!");
7329 auto& inst = instance();
7330 if(inst.m_PEAK_Node_GetAccessStatus)
7332 return inst.m_PEAK_Node_GetAccessStatus(nodeHandle, accessStatus);
7336 throw std::runtime_error(
"Library not loaded!");
7342 auto& inst = instance();
7343 if(inst.m_PEAK_Node_GetIsCacheable)
7345 return inst.m_PEAK_Node_GetIsCacheable(nodeHandle, isCacheable);
7349 throw std::runtime_error(
"Library not loaded!");
7355 auto& inst = instance();
7356 if(inst.m_PEAK_Node_GetIsAccessStatusCacheable)
7358 return inst.m_PEAK_Node_GetIsAccessStatusCacheable(nodeHandle, isAccessStatusCacheable);
7362 throw std::runtime_error(
"Library not loaded!");
7368 auto& inst = instance();
7369 if(inst.m_PEAK_Node_GetIsStreamable)
7371 return inst.m_PEAK_Node_GetIsStreamable(nodeHandle, isStreamable);
7375 throw std::runtime_error(
"Library not loaded!");
7381 auto& inst = instance();
7382 if(inst.m_PEAK_Node_GetIsDeprecated)
7384 return inst.m_PEAK_Node_GetIsDeprecated(nodeHandle, isDeprecated);
7388 throw std::runtime_error(
"Library not loaded!");
7394 auto& inst = instance();
7395 if(inst.m_PEAK_Node_GetIsFeature)
7397 return inst.m_PEAK_Node_GetIsFeature(nodeHandle, isFeature);
7401 throw std::runtime_error(
"Library not loaded!");
7407 auto& inst = instance();
7408 if(inst.m_PEAK_Node_GetCachingMode)
7410 return inst.m_PEAK_Node_GetCachingMode(nodeHandle, cachingMode);
7414 throw std::runtime_error(
"Library not loaded!");
7420 auto& inst = instance();
7421 if(inst.m_PEAK_Node_GetPollingTime)
7423 return inst.m_PEAK_Node_GetPollingTime(nodeHandle, pollingTime_ms);
7427 throw std::runtime_error(
"Library not loaded!");
7433 auto& inst = instance();
7434 if(inst.m_PEAK_Node_GetToolTip)
7436 return inst.m_PEAK_Node_GetToolTip(nodeHandle, toolTip, toolTipSize);
7440 throw std::runtime_error(
"Library not loaded!");
7446 auto& inst = instance();
7447 if(inst.m_PEAK_Node_GetDescription)
7449 return inst.m_PEAK_Node_GetDescription(nodeHandle, description, descriptionSize);
7453 throw std::runtime_error(
"Library not loaded!");
7459 auto& inst = instance();
7460 if(inst.m_PEAK_Node_GetType)
7462 return inst.m_PEAK_Node_GetType(nodeHandle, type);
7466 throw std::runtime_error(
"Library not loaded!");
7472 auto& inst = instance();
7473 if(inst.m_PEAK_Node_GetParentNodeMap)
7475 return inst.m_PEAK_Node_GetParentNodeMap(nodeHandle, nodeMapHandle);
7479 throw std::runtime_error(
"Library not loaded!");
7485 auto& inst = instance();
7486 if(inst.m_PEAK_Node_FindInvalidatedNode)
7488 return inst.m_PEAK_Node_FindInvalidatedNode(nodeHandle, name, nameSize, invalidatedNodeHandle);
7492 throw std::runtime_error(
"Library not loaded!");
7498 auto& inst = instance();
7499 if(inst.m_PEAK_Node_GetNumInvalidatedNodes)
7501 return inst.m_PEAK_Node_GetNumInvalidatedNodes(nodeHandle, numInvalidatedNodes);
7505 throw std::runtime_error(
"Library not loaded!");
7511 auto& inst = instance();
7512 if(inst.m_PEAK_Node_GetInvalidatedNode)
7514 return inst.m_PEAK_Node_GetInvalidatedNode(nodeHandle, index, invalidatedNodeHandle);
7518 throw std::runtime_error(
"Library not loaded!");
7524 auto& inst = instance();
7525 if(inst.m_PEAK_Node_FindInvalidatingNode)
7527 return inst.m_PEAK_Node_FindInvalidatingNode(nodeHandle, name, nameSize, invalidatingNodeHandle);
7531 throw std::runtime_error(
"Library not loaded!");
7537 auto& inst = instance();
7538 if(inst.m_PEAK_Node_GetNumInvalidatingNodes)
7540 return inst.m_PEAK_Node_GetNumInvalidatingNodes(nodeHandle, numInvalidatingNodes);
7544 throw std::runtime_error(
"Library not loaded!");
7550 auto& inst = instance();
7551 if(inst.m_PEAK_Node_GetInvalidatingNode)
7553 return inst.m_PEAK_Node_GetInvalidatingNode(nodeHandle, index, invalidatingNodeHandle);
7557 throw std::runtime_error(
"Library not loaded!");
7563 auto& inst = instance();
7564 if(inst.m_PEAK_Node_FindSelectedNode)
7566 return inst.m_PEAK_Node_FindSelectedNode(nodeHandle, name, nameSize, selectedNodeHandle);
7570 throw std::runtime_error(
"Library not loaded!");
7576 auto& inst = instance();
7577 if(inst.m_PEAK_Node_GetNumSelectedNodes)
7579 return inst.m_PEAK_Node_GetNumSelectedNodes(nodeHandle, numSelectedNodes);
7583 throw std::runtime_error(
"Library not loaded!");
7589 auto& inst = instance();
7590 if(inst.m_PEAK_Node_GetSelectedNode)
7592 return inst.m_PEAK_Node_GetSelectedNode(nodeHandle, index, selectedNodeHandle);
7596 throw std::runtime_error(
"Library not loaded!");
7602 auto& inst = instance();
7603 if(inst.m_PEAK_Node_FindSelectingNode)
7605 return inst.m_PEAK_Node_FindSelectingNode(nodeHandle, name, nameSize, selectingNodeHandle);
7609 throw std::runtime_error(
"Library not loaded!");
7615 auto& inst = instance();
7616 if(inst.m_PEAK_Node_GetNumSelectingNodes)
7618 return inst.m_PEAK_Node_GetNumSelectingNodes(nodeHandle, numSelectingNodes);
7622 throw std::runtime_error(
"Library not loaded!");
7628 auto& inst = instance();
7629 if(inst.m_PEAK_Node_GetSelectingNode)
7631 return inst.m_PEAK_Node_GetSelectingNode(nodeHandle, index, selectingNodeHandle);
7635 throw std::runtime_error(
"Library not loaded!");
7641 auto& inst = instance();
7642 if(inst.m_PEAK_Node_RegisterChangedCallback)
7644 return inst.m_PEAK_Node_RegisterChangedCallback(nodeHandle, callback, callbackContext, callbackHandle);
7648 throw std::runtime_error(
"Library not loaded!");
7654 auto& inst = instance();
7655 if(inst.m_PEAK_Node_UnregisterChangedCallback)
7657 return inst.m_PEAK_Node_UnregisterChangedCallback(nodeHandle, callbackHandle);
7661 throw std::runtime_error(
"Library not loaded!");
7667 auto& inst = instance();
7668 if(inst.m_PEAK_IntegerNode_ToNode)
7670 return inst.m_PEAK_IntegerNode_ToNode(integerNodeHandle, nodeHandle);
7674 throw std::runtime_error(
"Library not loaded!");
7680 auto& inst = instance();
7681 if(inst.m_PEAK_IntegerNode_GetMinimum)
7683 return inst.m_PEAK_IntegerNode_GetMinimum(integerNodeHandle, minimum);
7687 throw std::runtime_error(
"Library not loaded!");
7693 auto& inst = instance();
7694 if(inst.m_PEAK_IntegerNode_GetMaximum)
7696 return inst.m_PEAK_IntegerNode_GetMaximum(integerNodeHandle, maximum);
7700 throw std::runtime_error(
"Library not loaded!");
7706 auto& inst = instance();
7707 if(inst.m_PEAK_IntegerNode_GetIncrement)
7709 return inst.m_PEAK_IntegerNode_GetIncrement(integerNodeHandle, increment);
7713 throw std::runtime_error(
"Library not loaded!");
7719 auto& inst = instance();
7720 if(inst.m_PEAK_IntegerNode_GetIncrementType)
7722 return inst.m_PEAK_IntegerNode_GetIncrementType(integerNodeHandle, incrementType);
7726 throw std::runtime_error(
"Library not loaded!");
7732 auto& inst = instance();
7733 if(inst.m_PEAK_IntegerNode_GetValidValues)
7735 return inst.m_PEAK_IntegerNode_GetValidValues(integerNodeHandle, validValues, validValuesSize);
7739 throw std::runtime_error(
"Library not loaded!");
7745 auto& inst = instance();
7746 if(inst.m_PEAK_IntegerNode_GetRepresentation)
7748 return inst.m_PEAK_IntegerNode_GetRepresentation(integerNodeHandle, representation);
7752 throw std::runtime_error(
"Library not loaded!");
7758 auto& inst = instance();
7759 if(inst.m_PEAK_IntegerNode_GetUnit)
7761 return inst.m_PEAK_IntegerNode_GetUnit(integerNodeHandle, unit, unitSize);
7765 throw std::runtime_error(
"Library not loaded!");
7771 auto& inst = instance();
7772 if(inst.m_PEAK_IntegerNode_GetValue)
7774 return inst.m_PEAK_IntegerNode_GetValue(integerNodeHandle, cacheUsePolicy, value);
7778 throw std::runtime_error(
"Library not loaded!");
7784 auto& inst = instance();
7785 if(inst.m_PEAK_IntegerNode_SetValue)
7787 return inst.m_PEAK_IntegerNode_SetValue(integerNodeHandle, value);
7791 throw std::runtime_error(
"Library not loaded!");
7797 auto& inst = instance();
7798 if(inst.m_PEAK_BooleanNode_ToNode)
7800 return inst.m_PEAK_BooleanNode_ToNode(booleanNodeHandle, nodeHandle);
7804 throw std::runtime_error(
"Library not loaded!");
7810 auto& inst = instance();
7811 if(inst.m_PEAK_BooleanNode_GetValue)
7813 return inst.m_PEAK_BooleanNode_GetValue(booleanNodeHandle, cacheUsePolicy, value);
7817 throw std::runtime_error(
"Library not loaded!");
7823 auto& inst = instance();
7824 if(inst.m_PEAK_BooleanNode_SetValue)
7826 return inst.m_PEAK_BooleanNode_SetValue(booleanNodeHandle, value);
7830 throw std::runtime_error(
"Library not loaded!");
7836 auto& inst = instance();
7837 if(inst.m_PEAK_CommandNode_ToNode)
7839 return inst.m_PEAK_CommandNode_ToNode(commandNodeHandle, nodeHandle);
7843 throw std::runtime_error(
"Library not loaded!");
7849 auto& inst = instance();
7850 if(inst.m_PEAK_CommandNode_GetIsDone)
7852 return inst.m_PEAK_CommandNode_GetIsDone(commandNodeHandle, isDone);
7856 throw std::runtime_error(
"Library not loaded!");
7862 auto& inst = instance();
7863 if(inst.m_PEAK_CommandNode_Execute)
7865 return inst.m_PEAK_CommandNode_Execute(commandNodeHandle);
7869 throw std::runtime_error(
"Library not loaded!");
7875 auto& inst = instance();
7876 if(inst.m_PEAK_CommandNode_WaitUntilDoneInfinite)
7878 return inst.m_PEAK_CommandNode_WaitUntilDoneInfinite(commandNodeHandle);
7882 throw std::runtime_error(
"Library not loaded!");
7888 auto& inst = instance();
7889 if(inst.m_PEAK_CommandNode_WaitUntilDone)
7891 return inst.m_PEAK_CommandNode_WaitUntilDone(commandNodeHandle, waitTimeout_ms);
7895 throw std::runtime_error(
"Library not loaded!");
7901 auto& inst = instance();
7902 if(inst.m_PEAK_FloatNode_ToNode)
7904 return inst.m_PEAK_FloatNode_ToNode(floatNodeHandle, nodeHandle);
7908 throw std::runtime_error(
"Library not loaded!");
7914 auto& inst = instance();
7915 if(inst.m_PEAK_FloatNode_GetMinimum)
7917 return inst.m_PEAK_FloatNode_GetMinimum(floatNodeHandle, minimum);
7921 throw std::runtime_error(
"Library not loaded!");
7927 auto& inst = instance();
7928 if(inst.m_PEAK_FloatNode_GetMaximum)
7930 return inst.m_PEAK_FloatNode_GetMaximum(floatNodeHandle, maximum);
7934 throw std::runtime_error(
"Library not loaded!");
7940 auto& inst = instance();
7941 if(inst.m_PEAK_FloatNode_GetIncrement)
7943 return inst.m_PEAK_FloatNode_GetIncrement(floatNodeHandle, increment);
7947 throw std::runtime_error(
"Library not loaded!");
7953 auto& inst = instance();
7954 if(inst.m_PEAK_FloatNode_GetIncrementType)
7956 return inst.m_PEAK_FloatNode_GetIncrementType(floatNodeHandle, incrementType);
7960 throw std::runtime_error(
"Library not loaded!");
7966 auto& inst = instance();
7967 if(inst.m_PEAK_FloatNode_GetValidValues)
7969 return inst.m_PEAK_FloatNode_GetValidValues(floatNodeHandle, validValues, validValuesSize);
7973 throw std::runtime_error(
"Library not loaded!");
7979 auto& inst = instance();
7980 if(inst.m_PEAK_FloatNode_GetRepresentation)
7982 return inst.m_PEAK_FloatNode_GetRepresentation(floatNodeHandle, representation);
7986 throw std::runtime_error(
"Library not loaded!");
7992 auto& inst = instance();
7993 if(inst.m_PEAK_FloatNode_GetUnit)
7995 return inst.m_PEAK_FloatNode_GetUnit(floatNodeHandle, unit, unitSize);
7999 throw std::runtime_error(
"Library not loaded!");
8005 auto& inst = instance();
8006 if(inst.m_PEAK_FloatNode_GetDisplayNotation)
8008 return inst.m_PEAK_FloatNode_GetDisplayNotation(floatNodeHandle, displayNotation);
8012 throw std::runtime_error(
"Library not loaded!");
8018 auto& inst = instance();
8019 if(inst.m_PEAK_FloatNode_GetDisplayPrecision)
8021 return inst.m_PEAK_FloatNode_GetDisplayPrecision(floatNodeHandle, displayPrecision);
8025 throw std::runtime_error(
"Library not loaded!");
8031 auto& inst = instance();
8032 if(inst.m_PEAK_FloatNode_GetHasConstantIncrement)
8034 return inst.m_PEAK_FloatNode_GetHasConstantIncrement(floatNodeHandle, hasConstantIncrement);
8038 throw std::runtime_error(
"Library not loaded!");
8044 auto& inst = instance();
8045 if(inst.m_PEAK_FloatNode_GetValue)
8047 return inst.m_PEAK_FloatNode_GetValue(floatNodeHandle, cacheUsePolicy, value);
8051 throw std::runtime_error(
"Library not loaded!");
8057 auto& inst = instance();
8058 if(inst.m_PEAK_FloatNode_SetValue)
8060 return inst.m_PEAK_FloatNode_SetValue(floatNodeHandle, value);
8064 throw std::runtime_error(
"Library not loaded!");
8070 auto& inst = instance();
8071 if(inst.m_PEAK_StringNode_ToNode)
8073 return inst.m_PEAK_StringNode_ToNode(stringNodeHandle, nodeHandle);
8077 throw std::runtime_error(
"Library not loaded!");
8083 auto& inst = instance();
8084 if(inst.m_PEAK_StringNode_GetMaximumLength)
8086 return inst.m_PEAK_StringNode_GetMaximumLength(stringNodeHandle, maximumLength);
8090 throw std::runtime_error(
"Library not loaded!");
8096 auto& inst = instance();
8097 if(inst.m_PEAK_StringNode_GetValue)
8099 return inst.m_PEAK_StringNode_GetValue(stringNodeHandle, cacheUsePolicy, value, valueSize);
8103 throw std::runtime_error(
"Library not loaded!");
8109 auto& inst = instance();
8110 if(inst.m_PEAK_StringNode_SetValue)
8112 return inst.m_PEAK_StringNode_SetValue(stringNodeHandle, value, valueSize);
8116 throw std::runtime_error(
"Library not loaded!");
8122 auto& inst = instance();
8123 if(inst.m_PEAK_RegisterNode_ToNode)
8125 return inst.m_PEAK_RegisterNode_ToNode(registerNodeHandle, nodeHandle);
8129 throw std::runtime_error(
"Library not loaded!");
8135 auto& inst = instance();
8136 if(inst.m_PEAK_RegisterNode_GetAddress)
8138 return inst.m_PEAK_RegisterNode_GetAddress(registerNodeHandle, address);
8142 throw std::runtime_error(
"Library not loaded!");
8148 auto& inst = instance();
8149 if(inst.m_PEAK_RegisterNode_GetLength)
8151 return inst.m_PEAK_RegisterNode_GetLength(registerNodeHandle, length);
8155 throw std::runtime_error(
"Library not loaded!");
8161 auto& inst = instance();
8162 if(inst.m_PEAK_RegisterNode_Read)
8164 return inst.m_PEAK_RegisterNode_Read(registerNodeHandle, cacheUsePolicy, bytesToRead, bytesToReadSize);
8168 throw std::runtime_error(
"Library not loaded!");
8174 auto& inst = instance();
8175 if(inst.m_PEAK_RegisterNode_Write)
8177 return inst.m_PEAK_RegisterNode_Write(registerNodeHandle, bytesToWrite, bytesToWriteSize);
8181 throw std::runtime_error(
"Library not loaded!");
8187 auto& inst = instance();
8188 if(inst.m_PEAK_CategoryNode_ToNode)
8190 return inst.m_PEAK_CategoryNode_ToNode(categoryNodeHandle, nodeHandle);
8194 throw std::runtime_error(
"Library not loaded!");
8200 auto& inst = instance();
8201 if(inst.m_PEAK_CategoryNode_GetNumSubNodes)
8203 return inst.m_PEAK_CategoryNode_GetNumSubNodes(categoryNodeHandle, numSubNodes);
8207 throw std::runtime_error(
"Library not loaded!");
8213 auto& inst = instance();
8214 if(inst.m_PEAK_CategoryNode_GetSubNode)
8216 return inst.m_PEAK_CategoryNode_GetSubNode(categoryNodeHandle, index, nodeHandle);
8220 throw std::runtime_error(
"Library not loaded!");
8226 auto& inst = instance();
8227 if(inst.m_PEAK_EnumerationNode_ToNode)
8229 return inst.m_PEAK_EnumerationNode_ToNode(enumerationNodeHandle, nodeHandle);
8233 throw std::runtime_error(
"Library not loaded!");
8239 auto& inst = instance();
8240 if(inst.m_PEAK_EnumerationNode_GetCurrentEntry)
8242 return inst.m_PEAK_EnumerationNode_GetCurrentEntry(enumerationNodeHandle, cacheUsePolicy, enumerationEntryNodeHandle);
8246 throw std::runtime_error(
"Library not loaded!");
8252 auto& inst = instance();
8253 if(inst.m_PEAK_EnumerationNode_SetCurrentEntry)
8255 return inst.m_PEAK_EnumerationNode_SetCurrentEntry(enumerationNodeHandle, enumerationEntryNodeHandle);
8259 throw std::runtime_error(
"Library not loaded!");
8265 auto& inst = instance();
8266 if(inst.m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue)
8268 return inst.m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize);
8272 throw std::runtime_error(
"Library not loaded!");
8278 auto& inst = instance();
8279 if(inst.m_PEAK_EnumerationNode_SetCurrentEntryByValue)
8281 return inst.m_PEAK_EnumerationNode_SetCurrentEntryByValue(enumerationNodeHandle, value);
8285 throw std::runtime_error(
"Library not loaded!");
8291 auto& inst = instance();
8292 if(inst.m_PEAK_EnumerationNode_GetHasEntryBySymbolicValue)
8294 return inst.m_PEAK_EnumerationNode_GetHasEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize, hasEntry);
8298 throw std::runtime_error(
"Library not loaded!");
8304 auto& inst = instance();
8305 if(inst.m_PEAK_EnumerationNode_GetHasEntryByValue)
8307 return inst.m_PEAK_EnumerationNode_GetHasEntryByValue(enumerationNodeHandle, value, hasEntry);
8311 throw std::runtime_error(
"Library not loaded!");
8317 auto& inst = instance();
8318 if(inst.m_PEAK_EnumerationNode_FindEntryBySymbolicValue)
8320 return inst.m_PEAK_EnumerationNode_FindEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize, enumerationEntryNodeHandle);
8324 throw std::runtime_error(
"Library not loaded!");
8330 auto& inst = instance();
8331 if(inst.m_PEAK_EnumerationNode_FindEntryByValue)
8333 return inst.m_PEAK_EnumerationNode_FindEntryByValue(enumerationNodeHandle, value, enumerationEntryNodeHandle);
8337 throw std::runtime_error(
"Library not loaded!");
8343 auto& inst = instance();
8344 if(inst.m_PEAK_EnumerationNode_TryFindEntryBySymbolicValue)
8346 return inst.m_PEAK_EnumerationNode_TryFindEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize, enumerationEntryNodeHandle);
8350 throw std::runtime_error(
"Library not loaded!");
8356 auto& inst = instance();
8357 if(inst.m_PEAK_EnumerationNode_TryFindEntryByValue)
8359 return inst.m_PEAK_EnumerationNode_TryFindEntryByValue(enumerationNodeHandle, value, enumerationEntryNodeHandle);
8363 throw std::runtime_error(
"Library not loaded!");
8369 auto& inst = instance();
8370 if(inst.m_PEAK_EnumerationNode_GetNumEntries)
8372 return inst.m_PEAK_EnumerationNode_GetNumEntries(enumerationNodeHandle, numEntries);
8376 throw std::runtime_error(
"Library not loaded!");
8382 auto& inst = instance();
8383 if(inst.m_PEAK_EnumerationNode_GetEntry)
8385 return inst.m_PEAK_EnumerationNode_GetEntry(enumerationNodeHandle, index, enumerationEntryNodeHandle);
8389 throw std::runtime_error(
"Library not loaded!");
8395 auto& inst = instance();
8396 if(inst.m_PEAK_EnumerationEntryNode_ToNode)
8398 return inst.m_PEAK_EnumerationEntryNode_ToNode(enumerationEntryNodeHandle, nodeHandle);
8402 throw std::runtime_error(
"Library not loaded!");
8408 auto& inst = instance();
8409 if(inst.m_PEAK_EnumerationEntryNode_GetIsSelfClearing)
8411 return inst.m_PEAK_EnumerationEntryNode_GetIsSelfClearing(enumerationEntryNodeHandle, isSelfClearing);
8415 throw std::runtime_error(
"Library not loaded!");
8421 auto& inst = instance();
8422 if(inst.m_PEAK_EnumerationEntryNode_GetSymbolicValue)
8424 return inst.m_PEAK_EnumerationEntryNode_GetSymbolicValue(enumerationEntryNodeHandle, symbolicValue, symbolicValueSize);
8428 throw std::runtime_error(
"Library not loaded!");
8434 auto& inst = instance();
8435 if(inst.m_PEAK_EnumerationEntryNode_GetValue)
8437 return inst.m_PEAK_EnumerationEntryNode_GetValue(enumerationEntryNodeHandle, value);
8441 throw std::runtime_error(
"Library not loaded!");
8447 auto& inst = instance();
8448 if(inst.m_PEAK_Port_GetInfo)
8450 return inst.m_PEAK_Port_GetInfo(portHandle, infoCommand, infoDataType, info, infoSize);
8454 throw std::runtime_error(
"Library not loaded!");
8460 auto& inst = instance();
8461 if(inst.m_PEAK_Port_GetID)
8463 return inst.m_PEAK_Port_GetID(portHandle,
id, idSize);
8467 throw std::runtime_error(
"Library not loaded!");
8473 auto& inst = instance();
8474 if(inst.m_PEAK_Port_GetName)
8476 return inst.m_PEAK_Port_GetName(portHandle, name, nameSize);
8480 throw std::runtime_error(
"Library not loaded!");
8486 auto& inst = instance();
8487 if(inst.m_PEAK_Port_GetVendorName)
8489 return inst.m_PEAK_Port_GetVendorName(portHandle, vendorName, vendorNameSize);
8493 throw std::runtime_error(
"Library not loaded!");
8499 auto& inst = instance();
8500 if(inst.m_PEAK_Port_GetModelName)
8502 return inst.m_PEAK_Port_GetModelName(portHandle, modelName, modelNameSize);
8506 throw std::runtime_error(
"Library not loaded!");
8512 auto& inst = instance();
8513 if(inst.m_PEAK_Port_GetVersion)
8515 return inst.m_PEAK_Port_GetVersion(portHandle, version, versionSize);
8519 throw std::runtime_error(
"Library not loaded!");
8525 auto& inst = instance();
8526 if(inst.m_PEAK_Port_GetTLType)
8528 return inst.m_PEAK_Port_GetTLType(portHandle, tlType, tlTypeSize);
8532 throw std::runtime_error(
"Library not loaded!");
8538 auto& inst = instance();
8539 if(inst.m_PEAK_Port_GetModuleName)
8541 return inst.m_PEAK_Port_GetModuleName(portHandle, moduleName, moduleNameSize);
8545 throw std::runtime_error(
"Library not loaded!");
8551 auto& inst = instance();
8552 if(inst.m_PEAK_Port_GetDataEndianness)
8554 return inst.m_PEAK_Port_GetDataEndianness(portHandle, dataEndianness);
8558 throw std::runtime_error(
"Library not loaded!");
8564 auto& inst = instance();
8565 if(inst.m_PEAK_Port_GetIsReadable)
8567 return inst.m_PEAK_Port_GetIsReadable(portHandle, isReadable);
8571 throw std::runtime_error(
"Library not loaded!");
8577 auto& inst = instance();
8578 if(inst.m_PEAK_Port_GetIsWritable)
8580 return inst.m_PEAK_Port_GetIsWritable(portHandle, isWritable);
8584 throw std::runtime_error(
"Library not loaded!");
8590 auto& inst = instance();
8591 if(inst.m_PEAK_Port_GetIsAvailable)
8593 return inst.m_PEAK_Port_GetIsAvailable(portHandle, isAvailable);
8597 throw std::runtime_error(
"Library not loaded!");
8603 auto& inst = instance();
8604 if(inst.m_PEAK_Port_GetIsImplemented)
8606 return inst.m_PEAK_Port_GetIsImplemented(portHandle, isImplemented);
8610 throw std::runtime_error(
"Library not loaded!");
8616 auto& inst = instance();
8617 if(inst.m_PEAK_Port_Read)
8619 return inst.m_PEAK_Port_Read(portHandle, address, bytesToRead, bytesToReadSize);
8623 throw std::runtime_error(
"Library not loaded!");
8629 auto& inst = instance();
8630 if(inst.m_PEAK_Port_Write)
8632 return inst.m_PEAK_Port_Write(portHandle, address, bytesToWrite, bytesToWriteSize);
8636 throw std::runtime_error(
"Library not loaded!");
8642 auto& inst = instance();
8643 if(inst.m_PEAK_Port_GetNumURLs)
8645 return inst.m_PEAK_Port_GetNumURLs(portHandle, numUrls);
8649 throw std::runtime_error(
"Library not loaded!");
8655 auto& inst = instance();
8656 if(inst.m_PEAK_Port_GetURL)
8658 return inst.m_PEAK_Port_GetURL(portHandle, index, portUrlHandle);
8662 throw std::runtime_error(
"Library not loaded!");
8668 auto& inst = instance();
8669 if(inst.m_PEAK_PortURL_GetInfo)
8671 return inst.m_PEAK_PortURL_GetInfo(portUrlHandle, infoCommand, infoDataType, info, infoSize);
8675 throw std::runtime_error(
"Library not loaded!");
8681 auto& inst = instance();
8682 if(inst.m_PEAK_PortURL_GetURL)
8684 return inst.m_PEAK_PortURL_GetURL(portUrlHandle, url, urlSize);
8688 throw std::runtime_error(
"Library not loaded!");
8694 auto& inst = instance();
8695 if(inst.m_PEAK_PortURL_GetScheme)
8697 return inst.m_PEAK_PortURL_GetScheme(portUrlHandle, scheme);
8701 throw std::runtime_error(
"Library not loaded!");
8707 auto& inst = instance();
8708 if(inst.m_PEAK_PortURL_GetFileName)
8710 return inst.m_PEAK_PortURL_GetFileName(portUrlHandle, fileName, fileNameSize);
8714 throw std::runtime_error(
"Library not loaded!");
8720 auto& inst = instance();
8721 if(inst.m_PEAK_PortURL_GetFileRegisterAddress)
8723 return inst.m_PEAK_PortURL_GetFileRegisterAddress(portUrlHandle, fileRegisterAddress);
8727 throw std::runtime_error(
"Library not loaded!");
8733 auto& inst = instance();
8734 if(inst.m_PEAK_PortURL_GetFileSize)
8736 return inst.m_PEAK_PortURL_GetFileSize(portUrlHandle, fileSize);
8740 throw std::runtime_error(
"Library not loaded!");
8746 auto& inst = instance();
8747 if(inst.m_PEAK_PortURL_GetFileSHA1Hash)
8749 return inst.m_PEAK_PortURL_GetFileSHA1Hash(portUrlHandle, fileSha1Hash, fileSha1HashSize);
8753 throw std::runtime_error(
"Library not loaded!");
8759 auto& inst = instance();
8760 if(inst.m_PEAK_PortURL_GetFileVersionMajor)
8762 return inst.m_PEAK_PortURL_GetFileVersionMajor(portUrlHandle, fileVersionMajor);
8766 throw std::runtime_error(
"Library not loaded!");
8772 auto& inst = instance();
8773 if(inst.m_PEAK_PortURL_GetFileVersionMinor)
8775 return inst.m_PEAK_PortURL_GetFileVersionMinor(portUrlHandle, fileVersionMinor);
8779 throw std::runtime_error(
"Library not loaded!");
8785 auto& inst = instance();
8786 if(inst.m_PEAK_PortURL_GetFileVersionSubminor)
8788 return inst.m_PEAK_PortURL_GetFileVersionSubminor(portUrlHandle, fileVersionSubminor);
8792 throw std::runtime_error(
"Library not loaded!");
8798 auto& inst = instance();
8799 if(inst.m_PEAK_PortURL_GetFileSchemaVersionMajor)
8801 return inst.m_PEAK_PortURL_GetFileSchemaVersionMajor(portUrlHandle, fileSchemaVersionMajor);
8805 throw std::runtime_error(
"Library not loaded!");
8811 auto& inst = instance();
8812 if(inst.m_PEAK_PortURL_GetFileSchemaVersionMinor)
8814 return inst.m_PEAK_PortURL_GetFileSchemaVersionMinor(portUrlHandle, fileSchemaVersionMinor);
8818 throw std::runtime_error(
"Library not loaded!");
8824 auto& inst = instance();
8825 if(inst.m_PEAK_PortURL_GetParentPort)
8827 return inst.m_PEAK_PortURL_GetParentPort(portUrlHandle, portHandle);
8831 throw std::runtime_error(
"Library not loaded!");
8837 auto& inst = instance();
8838 if(inst.m_PEAK_EventSupportingModule_EnableEvents)
8840 return inst.m_PEAK_EventSupportingModule_EnableEvents(eventSupportingModuleHandle, eventType, eventControllerHandle);
8844 throw std::runtime_error(
"Library not loaded!");
8850 auto& inst = instance();
8851 if(inst.m_PEAK_EventController_GetInfo)
8853 return inst.m_PEAK_EventController_GetInfo(eventControllerHandle, infoCommand, infoDataType, info, infoSize);
8857 throw std::runtime_error(
"Library not loaded!");
8863 auto& inst = instance();
8864 if(inst.m_PEAK_EventController_GetNumEventsInQueue)
8866 return inst.m_PEAK_EventController_GetNumEventsInQueue(eventControllerHandle, numEventsInQueue);
8870 throw std::runtime_error(
"Library not loaded!");
8876 auto& inst = instance();
8877 if(inst.m_PEAK_EventController_GetNumEventsFired)
8879 return inst.m_PEAK_EventController_GetNumEventsFired(eventControllerHandle, numEventsFired);
8883 throw std::runtime_error(
"Library not loaded!");
8889 auto& inst = instance();
8890 if(inst.m_PEAK_EventController_GetEventMaxSize)
8892 return inst.m_PEAK_EventController_GetEventMaxSize(eventControllerHandle, eventMaxSize);
8896 throw std::runtime_error(
"Library not loaded!");
8902 auto& inst = instance();
8903 if(inst.m_PEAK_EventController_GetEventDataMaxSize)
8905 return inst.m_PEAK_EventController_GetEventDataMaxSize(eventControllerHandle, eventDataMaxSize);
8909 throw std::runtime_error(
"Library not loaded!");
8915 auto& inst = instance();
8916 if(inst.m_PEAK_EventController_GetControlledEventType)
8918 return inst.m_PEAK_EventController_GetControlledEventType(eventControllerHandle, controlledEventType);
8922 throw std::runtime_error(
"Library not loaded!");
8928 auto& inst = instance();
8929 if(inst.m_PEAK_EventController_WaitForEvent)
8931 return inst.m_PEAK_EventController_WaitForEvent(eventControllerHandle, timeout_ms, eventHandle);
8935 throw std::runtime_error(
"Library not loaded!");
8941 auto& inst = instance();
8942 if(inst.m_PEAK_EventController_KillWait)
8944 return inst.m_PEAK_EventController_KillWait(eventControllerHandle);
8948 throw std::runtime_error(
"Library not loaded!");
8954 auto& inst = instance();
8955 if(inst.m_PEAK_EventController_FlushPendingKillWaits)
8957 return inst.m_PEAK_EventController_FlushPendingKillWaits(eventControllerHandle);
8961 throw std::runtime_error(
"Library not loaded!");
8967 auto& inst = instance();
8968 if(inst.m_PEAK_EventController_FlushEvents)
8970 return inst.m_PEAK_EventController_FlushEvents(eventControllerHandle);
8974 throw std::runtime_error(
"Library not loaded!");
8980 auto& inst = instance();
8981 if(inst.m_PEAK_EventController_Destruct)
8983 return inst.m_PEAK_EventController_Destruct(eventControllerHandle);
8987 throw std::runtime_error(
"Library not loaded!");
8993 auto& inst = instance();
8994 if(inst.m_PEAK_Event_GetInfo)
8996 return inst.m_PEAK_Event_GetInfo(eventHandle, infoCommand, infoDataType, info, infoSize);
9000 throw std::runtime_error(
"Library not loaded!");
9006 auto& inst = instance();
9007 if(inst.m_PEAK_Event_GetID)
9009 return inst.m_PEAK_Event_GetID(eventHandle,
id);
9013 throw std::runtime_error(
"Library not loaded!");
9019 auto& inst = instance();
9020 if(inst.m_PEAK_Event_GetData)
9022 return inst.m_PEAK_Event_GetData(eventHandle, data, dataSize);
9026 throw std::runtime_error(
"Library not loaded!");
9032 auto& inst = instance();
9033 if(inst.m_PEAK_Event_GetType)
9035 return inst.m_PEAK_Event_GetType(eventHandle, type);
9039 throw std::runtime_error(
"Library not loaded!");
9045 auto& inst = instance();
9046 if(inst.m_PEAK_Event_GetRawData)
9048 return inst.m_PEAK_Event_GetRawData(eventHandle, rawData, rawDataSize);
9052 throw std::runtime_error(
"Library not loaded!");
9058 auto& inst = instance();
9059 if(inst.m_PEAK_Event_Destruct)
9061 return inst.m_PEAK_Event_Destruct(eventHandle);
9065 throw std::runtime_error(
"Library not loaded!");
9071 auto& inst = instance();
9072 if(inst.m_PEAK_FirmwareUpdater_Construct)
9074 return inst.m_PEAK_FirmwareUpdater_Construct(firmwareUpdaterHandle);
9078 throw std::runtime_error(
"Library not loaded!");
9084 auto& inst = instance();
9085 if(inst.m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation)
9087 return inst.m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(firmwareUpdaterHandle, gufPath, gufPathSize);
9091 throw std::runtime_error(
"Library not loaded!");
9097 auto& inst = instance();
9098 if(inst.m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation)
9100 return inst.m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(firmwareUpdaterHandle, gufPath, gufPathSize, deviceDescriptorHandle);
9104 throw std::runtime_error(
"Library not loaded!");
9110 auto& inst = instance();
9111 if(inst.m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation)
9113 return inst.m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(firmwareUpdaterHandle, numFirmwareUpdateInformation);
9117 throw std::runtime_error(
"Library not loaded!");
9123 auto& inst = instance();
9124 if(inst.m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation)
9126 return inst.m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(firmwareUpdaterHandle, index, firmwareUpdateInformationHandle);
9130 throw std::runtime_error(
"Library not loaded!");
9136 auto& inst = instance();
9137 if(inst.m_PEAK_FirmwareUpdater_UpdateDevice)
9139 return inst.m_PEAK_FirmwareUpdater_UpdateDevice(firmwareUpdaterHandle, deviceDescriptorHandle, firmwareUpdateInformationHandle, firmwareUpdateProgressObserverHandle);
9143 throw std::runtime_error(
"Library not loaded!");
9149 auto& inst = instance();
9150 if(inst.m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout)
9152 return inst.m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(firmwareUpdaterHandle, deviceDescriptorHandle, firmwareUpdateInformationHandle, firmwareUpdateProgressObserverHandle, deviceResetDiscoveryTimeout_ms);
9156 throw std::runtime_error(
"Library not loaded!");
9162 auto& inst = instance();
9163 if(inst.m_PEAK_FirmwareUpdater_Destruct)
9165 return inst.m_PEAK_FirmwareUpdater_Destruct(firmwareUpdaterHandle);
9169 throw std::runtime_error(
"Library not loaded!");
9175 auto& inst = instance();
9176 if(inst.m_PEAK_FirmwareUpdateInformation_GetIsValid)
9178 return inst.m_PEAK_FirmwareUpdateInformation_GetIsValid(firmwareUpdateInformationHandle, isValid);
9182 throw std::runtime_error(
"Library not loaded!");
9188 auto& inst = instance();
9189 if(inst.m_PEAK_FirmwareUpdateInformation_GetFileName)
9191 return inst.m_PEAK_FirmwareUpdateInformation_GetFileName(firmwareUpdateInformationHandle, fileName, fileNameSize);
9195 throw std::runtime_error(
"Library not loaded!");
9201 auto& inst = instance();
9202 if(inst.m_PEAK_FirmwareUpdateInformation_GetDescription)
9204 return inst.m_PEAK_FirmwareUpdateInformation_GetDescription(firmwareUpdateInformationHandle, description, descriptionSize);
9208 throw std::runtime_error(
"Library not loaded!");
9214 auto& inst = instance();
9215 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersion)
9217 return inst.m_PEAK_FirmwareUpdateInformation_GetVersion(firmwareUpdateInformationHandle, version, versionSize);
9221 throw std::runtime_error(
"Library not loaded!");
9227 auto& inst = instance();
9228 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern)
9230 return inst.m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(firmwareUpdateInformationHandle, versionExtractionPattern, versionExtractionPatternSize);
9234 throw std::runtime_error(
"Library not loaded!");
9240 auto& inst = instance();
9241 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersionStyle)
9243 return inst.m_PEAK_FirmwareUpdateInformation_GetVersionStyle(firmwareUpdateInformationHandle, versionStyle);
9247 throw std::runtime_error(
"Library not loaded!");
9253 auto& inst = instance();
9254 if(inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotes)
9256 return inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotes(firmwareUpdateInformationHandle, releaseNotes, releaseNotesSize);
9260 throw std::runtime_error(
"Library not loaded!");
9266 auto& inst = instance();
9267 if(inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL)
9269 return inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(firmwareUpdateInformationHandle, releaseNotesUrl, releaseNotesUrlSize);
9273 throw std::runtime_error(
"Library not loaded!");
9279 auto& inst = instance();
9280 if(inst.m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence)
9282 return inst.m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence(firmwareUpdateInformationHandle, userSetPersistence);
9286 throw std::runtime_error(
"Library not loaded!");
9292 auto& inst = instance();
9293 if(inst.m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence)
9295 return inst.m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(firmwareUpdateInformationHandle, sequencerSetPersistence);
9299 throw std::runtime_error(
"Library not loaded!");
9305 auto& inst = instance();
9306 if(inst.m_PEAK_FirmwareUpdateProgressObserver_Construct)
9308 return inst.m_PEAK_FirmwareUpdateProgressObserver_Construct(firmwareUpdateProgressObserverHandle);
9312 throw std::runtime_error(
"Library not loaded!");
9318 auto& inst = instance();
9319 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback)
9321 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9325 throw std::runtime_error(
"Library not loaded!");
9331 auto& inst = instance();
9332 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback)
9334 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9338 throw std::runtime_error(
"Library not loaded!");
9344 auto& inst = instance();
9345 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback)
9347 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9351 throw std::runtime_error(
"Library not loaded!");
9357 auto& inst = instance();
9358 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback)
9360 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9364 throw std::runtime_error(
"Library not loaded!");
9370 auto& inst = instance();
9371 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback)
9373 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9377 throw std::runtime_error(
"Library not loaded!");
9383 auto& inst = instance();
9384 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback)
9386 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9390 throw std::runtime_error(
"Library not loaded!");
9396 auto& inst = instance();
9397 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback)
9399 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9403 throw std::runtime_error(
"Library not loaded!");
9409 auto& inst = instance();
9410 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback)
9412 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9416 throw std::runtime_error(
"Library not loaded!");
9422 auto& inst = instance();
9423 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback)
9425 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9429 throw std::runtime_error(
"Library not loaded!");
9435 auto& inst = instance();
9436 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback)
9438 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9442 throw std::runtime_error(
"Library not loaded!");
9448 auto& inst = instance();
9449 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback)
9451 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9455 throw std::runtime_error(
"Library not loaded!");
9461 auto& inst = instance();
9462 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback)
9464 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9468 throw std::runtime_error(
"Library not loaded!");
9474 auto& inst = instance();
9475 if(inst.m_PEAK_FirmwareUpdateProgressObserver_Destruct)
9477 return inst.m_PEAK_FirmwareUpdateProgressObserver_Destruct(firmwareUpdateProgressObserverHandle);
9481 throw std::runtime_error(
"Library not loaded!");
9487 auto& inst = instance();
9488 if(inst.m_PEAK_FileAdapter_Construct)
9490 return inst.m_PEAK_FileAdapter_Construct(nodeMapHandle, fileName, fileAdapterHandle);
9494 throw std::runtime_error(
"Library not loaded!");
9500 auto& inst = instance();
9501 if(inst.m_PEAK_FileAdapter_Destruct)
9503 return inst.m_PEAK_FileAdapter_Destruct(fileAdapterHandle);
9507 throw std::runtime_error(
"Library not loaded!");
9513 auto& inst = instance();
9514 if(inst.m_PEAK_FileAdapter_Read)
9516 return inst.m_PEAK_FileAdapter_Read(fileAdapterHandle, size, offset, data, dataSize);
9520 throw std::runtime_error(
"Library not loaded!");
9526 auto& inst = instance();
9527 if(inst.m_PEAK_FileAdapter_Write)
9529 return inst.m_PEAK_FileAdapter_Write(fileAdapterHandle, data, size, offset);
9533 throw std::runtime_error(
"Library not loaded!");
9539 auto& inst = instance();
9540 if(inst.m_PEAK_FileAdapter_Delete)
9542 return inst.m_PEAK_FileAdapter_Delete(fileAdapterHandle);
9546 throw std::runtime_error(
"Library not loaded!");
9552 auto& inst = instance();
9553 if(inst.m_PEAK_FileAdapter_GetSize)
9555 return inst.m_PEAK_FileAdapter_GetSize(fileAdapterHandle, size);
9559 throw std::runtime_error(
"Library not loaded!");
9565 auto& inst = instance();
9566 if(inst.m_PEAK_FileAdapter_GetMaxSize)
9568 return inst.m_PEAK_FileAdapter_GetMaxSize(fileAdapterHandle, maxSize);
9572 throw std::runtime_error(
"Library not loaded!");
static PEAK_C_API PEAK_Interface_Destruct(PEAK_INTERFACE_HANDLE interfaceHandle)
Definition peak_dynamic_loader.h:5078
static PEAK_C_API PEAK_BufferPart_GetWidth(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Definition peak_dynamic_loader.h:6794
static PEAK_C_API PEAK_DataStream_GetNumBuffersStarted(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Definition peak_dynamic_loader.h:5858
static PEAK_C_API PEAK_Interface_UnregisterDeviceListChangedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:5065
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:8159
static PEAK_C_API PEAK_PortURL_GetFileSHA1Hash(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Definition peak_dynamic_loader.h:8744
static PEAK_C_API PEAK_Buffer_GetTLType(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:6157
static PEAK_C_API PEAK_DataStream_GetKey(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5741
static PEAK_C_API PEAK_DataStream_StopAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Definition peak_dynamic_loader.h:6092
static PEAK_C_API PEAK_Buffer_ToModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:6118
static PEAK_C_API PEAK_Node_GetInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition peak_dynamic_loader.h:7509
static PEAK_C_API PEAK_SystemDescriptor_GetKey(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4220
static PEAK_C_API PEAK_Library_Initialize()
Definition peak_dynamic_loader.h:4025
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:7639
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:8926
static PEAK_C_API PEAK_DeviceDescriptor_GetKey(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5104
static PEAK_C_API PEAK_BufferChunk_GetBasePtr(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Definition peak_dynamic_loader.h:6651
static PEAK_C_API PEAK_Library_GetLastError(PEAK_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Definition peak_dynamic_loader.h:4103
static PEAK_C_API PEAK_BufferPart_GetSourceID(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Definition peak_dynamic_loader.h:6716
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:8042
static PEAK_C_API PEAK_EventController_FlushEvents(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8965
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:6014
static PEAK_C_API PEAK_Interface_UnregisterDeviceReconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4987
static PEAK_C_API PEAK_Node_ToEnumerationEntryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:7262
static PEAK_C_API PEAK_Buffer_GetPixelFormatNamespace(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Definition peak_dynamic_loader.h:6235
static PEAK_C_API PEAK_System_UpdateInterfaces(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:4610
static PEAK_C_API PEAK_BufferPart_GetFormatNamespace(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Definition peak_dynamic_loader.h:6781
static PEAK_C_API PEAK_System_GetNumInterfaces(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Definition peak_dynamic_loader.h:4623
static PEAK_C_API PEAK_System_GetVersion(PEAK_SYSTEM_HANDLE systemHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:4506
static bool isLoaded()
Definition peak_dynamic_loader.h:1400
static PEAK_C_API PEAK_System_GetCTIFullPath(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:4545
static PEAK_C_API PEAK_Library_GetVersionMinor(uint32_t *libraryVersionMinor)
Definition peak_dynamic_loader.h:4077
static PEAK_C_API PEAK_Node_UnregisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:7652
static PEAK_C_API PEAK_BufferChunk_GetParentBuffer(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:6677
static PEAK_C_API PEAK_DeviceDescriptor_GetVendorName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:5143
static PEAK_C_API PEAK_Node_GetCachingMode(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Definition peak_dynamic_loader.h:7405
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:7561
static PEAK_C_API PEAK_BufferPart_GetYOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:6833
static PEAK_C_API PEAK_FloatNode_GetIncrementType(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:7951
static PEAK_C_API PEAK_FloatNode_GetDisplayNotation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Definition peak_dynamic_loader.h:8003
static PEAK_C_API PEAK_Node_ToStringNode(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Definition peak_dynamic_loader.h:7210
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Destruct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:9472
static PEAK_C_API PEAK_NodeMap_GetHasBufferSupportedChunks(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Definition peak_dynamic_loader.h:7041
static PEAK_C_API PEAK_CategoryNode_GetNumSubNodes(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Definition peak_dynamic_loader.h:8198
static PEAK_C_API PEAK_Node_GetIsFeature(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Definition peak_dynamic_loader.h:7392
static PEAK_C_API PEAK_Interface_UnregisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4961
static PEAK_C_API PEAK_Buffer_GetIsIncomplete(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Definition peak_dynamic_loader.h:6495
static PEAK_C_API PEAK_Device_ToEventSupportingModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:5403
static PEAK_C_API PEAK_EnumerationEntryNode_ToNode(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8393
static PEAK_C_API PEAK_StringNode_SetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Definition peak_dynamic_loader.h:8107
static PEAK_C_API PEAK_PortURL_GetParentPort(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:8822
static PEAK_C_API PEAK_DataStream_GetIsGrabbing(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Definition peak_dynamic_loader.h:5936
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:8250
static PEAK_C_API PEAK_Device_GetVersion(PEAK_DEVICE_HANDLE deviceHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:5494
static PEAK_C_API PEAK_Device_Destruct(PEAK_DEVICE_HANDLE deviceHandle)
Definition peak_dynamic_loader.h:5624
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:8276
static PEAK_C_API PEAK_Node_GetIsStreamable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Definition peak_dynamic_loader.h:7366
static PEAK_C_API PEAK_CommandNode_WaitUntilDoneInfinite(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:7873
static PEAK_C_API PEAK_DataStream_QueueBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:5988
static PEAK_C_API PEAK_Device_GetTimestampTickFrequency(PEAK_DEVICE_HANDLE deviceHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:5559
static PEAK_C_API PEAK_Buffer_GetExpectedDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Definition peak_dynamic_loader.h:6261
static PEAK_C_API PEAK_Buffer_GetFrameID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Definition peak_dynamic_loader.h:6287
static PEAK_C_API PEAK_DeviceDescriptor_GetTimestampTickFrequency(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:5234
static PEAK_C_API PEAK_Node_ToCategoryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Definition peak_dynamic_loader.h:7236
static PEAK_C_API PEAK_EnumerationEntryNode_GetValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Definition peak_dynamic_loader.h:8432
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:5364
static PEAK_C_API PEAK_Node_ToCommandNode(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Definition peak_dynamic_loader.h:7184
static PEAK_C_API PEAK_Module_GetPort(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:6937
static PEAK_C_API PEAK_NodeMap_GetNumNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Definition peak_dynamic_loader.h:7015
static PEAK_C_API PEAK_Interface_UnregisterDeviceDisconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:5013
static PEAK_C_API PEAK_PortURL_GetScheme(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Definition peak_dynamic_loader.h:8692
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:7808
static PEAK_C_API PEAK_Port_GetDataEndianness(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Definition peak_dynamic_loader.h:8549
static PEAK_C_API PEAK_BufferChunk_GetSize(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Definition peak_dynamic_loader.h:6664
static PEAK_C_API PEAK_Port_GetIsAvailable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Definition peak_dynamic_loader.h:8588
static PEAK_C_API PEAK_BufferPart_GetHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Definition peak_dynamic_loader.h:6807
static PEAK_C_API PEAK_IntegerNode_SetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:7782
static PEAK_C_API PEAK_StringNode_GetMaximumLength(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Definition peak_dynamic_loader.h:8081
static PEAK_C_API PEAK_Buffer_GetXPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:6417
static PEAK_C_API PEAK_Device_GetModelName(PEAK_DEVICE_HANDLE deviceHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:5481
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetIsValid(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Definition peak_dynamic_loader.h:9173
static PEAK_C_API PEAK_CommandNode_GetIsDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Definition peak_dynamic_loader.h:7847
static PEAK_C_API PEAK_Device_GetKey(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5416
static PEAK_C_API PEAK_Port_GetID(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:8458
~DynamicLoader()
Definition peak_dynamic_loader.h:1392
static PEAK_C_API PEAK_DeviceDescriptor_GetAccessStatus(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:5221
static PEAK_C_API PEAK_SystemDescriptor_GetDisplayName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4246
static PEAK_C_API PEAK_SystemDescriptor_GetTLType(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4298
static PEAK_C_API PEAK_PortURL_GetURL(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Definition peak_dynamic_loader.h:8679
static PEAK_C_API PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition peak_dynamic_loader.h:5338
static PEAK_C_API PEAK_Device_GetID(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:5442
static PEAK_C_API PEAK_Buffer_GetHasNewData(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Definition peak_dynamic_loader.h:6508
static PEAK_C_API PEAK_RegisterNode_GetAddress(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Definition peak_dynamic_loader.h:8133
static PEAK_C_API PEAK_System_Destruct(PEAK_SYSTEM_HANDLE systemHandle)
Definition peak_dynamic_loader.h:4701
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:9381
static PEAK_C_API PEAK_EnumerationNode_GetHasEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_BOOL8 *hasEntry)
Definition peak_dynamic_loader.h:8302
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:9446
static PEAK_C_API PEAK_PortURL_GetFileVersionSubminor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Definition peak_dynamic_loader.h:8783
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:5429
static PEAK_C_API PEAK_Buffer_GetChunkLayoutID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Definition peak_dynamic_loader.h:6339
static PEAK_C_API PEAK_SystemDescriptor_GetCTIFullPath(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:4324
static PEAK_C_API PEAK_IntegerNode_GetRepresentation(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:7743
static PEAK_C_API PEAK_RegisterNode_ToNode(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8120
static PEAK_C_API PEAK_System_UnregisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4688
static PEAK_C_API PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition peak_dynamic_loader.h:5351
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:4974
static PEAK_C_API PEAK_FloatNode_SetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Definition peak_dynamic_loader.h:8055
static PEAK_C_API PEAK_FloatNode_GetDisplayPrecision(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Definition peak_dynamic_loader.h:8016
static PEAK_C_API PEAK_Buffer_GetDeliveredDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Definition peak_dynamic_loader.h:6274
static PEAK_C_API PEAK_System_GetCTIFileName(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:4532
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetUserSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Definition peak_dynamic_loader.h:9277
static PEAK_C_API PEAK_EnumerationNode_GetHasEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize, PEAK_BOOL8 *hasEntry)
Definition peak_dynamic_loader.h:8289
static PEAK_C_API PEAK_ProducerLibrary_GetSystem(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Definition peak_dynamic_loader.h:4181
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Definition peak_dynamic_loader.h:9225
static PEAK_C_API PEAK_Event_GetRawData(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Definition peak_dynamic_loader.h:9043
static PEAK_C_API PEAK_DataStream_ToModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5715
static PEAK_C_API PEAK_Port_GetModuleName(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Definition peak_dynamic_loader.h:8536
static PEAK_C_API PEAK_DeviceDescriptor_GetParentInterface(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:5286
static PEAK_C_API PEAK_DataStream_GetNumChunksPerBufferMax(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numChunksPerBufferMax)
Definition peak_dynamic_loader.h:5884
static PEAK_C_API PEAK_BufferPart_GetParentBuffer(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:6872
static PEAK_C_API PEAK_Interface_GetTLType(PEAK_INTERFACE_HANDLE interfaceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4883
static PEAK_C_API PEAK_Device_GetVendorName(PEAK_DEVICE_HANDLE deviceHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:5468
static PEAK_C_API PEAK_PortURL_GetFileRegisterAddress(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Definition peak_dynamic_loader.h:8718
static PEAK_C_API PEAK_Buffer_GetTimestamp_ns(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Definition peak_dynamic_loader.h:6456
static PEAK_C_API PEAK_Port_GetModelName(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:8497
static PEAK_C_API PEAK_FloatNode_GetRepresentation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:7977
static PEAK_C_API PEAK_EnvironmentInspector_UpdateCTIPaths()
Definition peak_dynamic_loader.h:4116
static PEAK_C_API PEAK_PortURL_GetFileVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Definition peak_dynamic_loader.h:8757
static PEAK_C_API PEAK_Interface_GetParentSystem(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4896
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:6963
static PEAK_C_API PEAK_NodeMap_TryFindNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:6976
static PEAK_C_API PEAK_System_ToModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:4402
static PEAK_C_API PEAK_ProducerLibrary_Construct(const char *ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4155
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotes(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Definition peak_dynamic_loader.h:9251
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:5377
static PEAK_C_API PEAK_BufferChunk_Destruct(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Definition peak_dynamic_loader.h:6690
static PEAK_C_API PEAK_NodeMap_UpdateEventNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:7080
static PEAK_C_API PEAK_DataStream_GetTLType(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5780
static PEAK_C_API PEAK_Port_GetVersion(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:8510
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:9407
static PEAK_C_API PEAK_Event_GetType(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Definition peak_dynamic_loader.h:9030
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:6144
static PEAK_C_API PEAK_FloatNode_ToNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7899
static PEAK_C_API PEAK_NodeMap_TryLock(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BOOL8 *locked)
Definition peak_dynamic_loader.h:7132
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:9433
static PEAK_C_API PEAK_Event_GetID(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Definition peak_dynamic_loader.h:9004
static PEAK_C_API PEAK_DataStream_GetNumBuffersQueued(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersQueued)
Definition peak_dynamic_loader.h:5819
static PEAK_C_API PEAK_Buffer_GetHasParts(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasParts)
Definition peak_dynamic_loader.h:6547
static PEAK_C_API PEAK_EventController_GetEventDataMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Definition peak_dynamic_loader.h:8900
static PEAK_C_API PEAK_ProducerLibrary_GetKey(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4168
static PEAK_C_API PEAK_IntegerNode_GetUnit(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:7756
static PEAK_C_API PEAK_BufferPart_GetSize(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Definition peak_dynamic_loader.h:6742
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:8094
static PEAK_C_API PEAK_DataStream_GetNumBuffersAnnounced(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnounced)
Definition peak_dynamic_loader.h:5806
static PEAK_C_API PEAK_Buffer_GetChunk(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Definition peak_dynamic_loader.h:6586
static PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenableExclusive(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Definition peak_dynamic_loader.h:5247
static PEAK_C_API PEAK_CommandNode_ToNode(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7834
static PEAK_C_API PEAK_PortURL_GetFileSize(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Definition peak_dynamic_loader.h:8731
static PEAK_C_API PEAK_DataStream_Flush(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Definition peak_dynamic_loader.h:6053
static PEAK_C_API PEAK_EnvironmentInspector_GetCTIPath(size_t index, char *ctiPath, size_t *ctiPathSize)
Definition peak_dynamic_loader.h:4142
static PEAK_C_API PEAK_Interface_GetKey(PEAK_INTERFACE_HANDLE interfaceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4831
static PEAK_C_API PEAK_Buffer_ToEventSupportingModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:6131
static PEAK_C_API PEAK_Device_GetNumDataStreams(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Definition peak_dynamic_loader.h:5598
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:9342
static PEAK_C_API PEAK_Device_ToModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5390
static PEAK_C_API PEAK_DataStreamDescriptor_GetParentDevice(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5689
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:8614
static PEAK_C_API PEAK_InterfaceDescriptor_ToModuleDescriptor(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:4714
static PEAK_C_API PEAK_FloatNode_GetIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Definition peak_dynamic_loader.h:7938
static PEAK_C_API PEAK_Interface_GetDevice(PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE *deviceDescriptorHandle)
Definition peak_dynamic_loader.h:4935
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:9329
static PEAK_C_API PEAK_FileAdapter_Write(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, const uint8_t *data, uint64_t size, uint64_t offset)
Definition peak_dynamic_loader.h:9524
static PEAK_C_API PEAK_Node_GetNumSelectingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Definition peak_dynamic_loader.h:7613
static PEAK_C_API PEAK_Buffer_UpdateParts(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6599
static PEAK_C_API PEAK_BufferPart_GetXPadding(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:6846
static PEAK_C_API PEAK_BufferPart_GetType(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Definition peak_dynamic_loader.h:6755
static PEAK_C_API PEAK_Node_GetNamespace(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Definition peak_dynamic_loader.h:7301
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:6079
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Definition peak_dynamic_loader.h:9290
static PEAK_C_API PEAK_DeviceDescriptor_GetTLType(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5182
static PEAK_C_API PEAK_Node_GetVisibility(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Definition peak_dynamic_loader.h:7314
static PEAK_C_API PEAK_Node_GetIsAccessStatusCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Definition peak_dynamic_loader.h:7353
static PEAK_C_API PEAK_DataStream_GetID(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:5767
static PEAK_C_API PEAK_SystemDescriptor_GetVersion(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:4285
static PEAK_C_API PEAK_IntegerNode_GetValidValues(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:7730
static PEAK_C_API PEAK_IntegerNode_GetMinimum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Definition peak_dynamic_loader.h:7678
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:4649
static PEAK_C_API PEAK_System_GetKey(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4428
static PEAK_C_API PEAK_EventController_Destruct(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8978
static PEAK_C_API PEAK_Port_GetNumURLs(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Definition peak_dynamic_loader.h:8640
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:8315
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:9121
static PEAK_C_API PEAK_PortURL_GetFileName(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:8705
static PEAK_C_API PEAK_Module_GetNodeMap(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:6924
static PEAK_C_API PEAK_Interface_UnregisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:5039
static PEAK_C_API PEAK_Event_GetData(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Definition peak_dynamic_loader.h:9017
static PEAK_C_API PEAK_DeviceDescriptor_GetDisplayName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:5130
static PEAK_C_API PEAK_FloatNode_GetUnit(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:7990
static PEAK_C_API PEAK_EventController_GetNumEventsInQueue(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Definition peak_dynamic_loader.h:8861
static PEAK_C_API PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:5312
static PEAK_C_API PEAK_EnumerationNode_ToNode(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8224
static PEAK_C_API PEAK_Module_GetNumNodeMaps(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Definition peak_dynamic_loader.h:6911
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:8991
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:8445
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:9355
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:8380
static PEAK_C_API PEAK_CommandNode_WaitUntilDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Definition peak_dynamic_loader.h:7886
static PEAK_C_API PEAK_Node_GetNumSelectedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Definition peak_dynamic_loader.h:7574
static PEAK_C_API PEAK_FirmwareUpdater_Destruct(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:9160
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:9147
static PEAK_C_API PEAK_DataStream_FlushPendingKillWaits(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:6040
static PEAK_C_API PEAK_System_GetID(PEAK_SYSTEM_HANDLE systemHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:4454
static PEAK_C_API PEAK_System_GetDisplayName(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4467
static PEAK_C_API PEAK_DeviceDescriptor_GetModelName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:5156
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionStyle(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Definition peak_dynamic_loader.h:9238
static PEAK_C_API PEAK_FloatNode_GetHasConstantIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Definition peak_dynamic_loader.h:8029
static PEAK_C_API PEAK_Node_GetToolTip(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Definition peak_dynamic_loader.h:7431
static PEAK_C_API PEAK_RemoteDevice_GetLocalDevice(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5650
static PEAK_C_API PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Definition peak_dynamic_loader.h:9108
static PEAK_C_API PEAK_Interface_GetNumDevices(PEAK_INTERFACE_HANDLE interfaceHandle, size_t *numDevices)
Definition peak_dynamic_loader.h:4922
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:9316
static PEAK_C_API PEAK_EventController_KillWait(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8939
static PEAK_C_API PEAK_EnumerationNode_TryFindEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:8354
static PEAK_C_API PEAK_Node_GetIsDeprecated(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Definition peak_dynamic_loader.h:7379
static PEAK_C_API PEAK_DataStream_Destruct(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:6105
static PEAK_C_API PEAK_Interface_UpdateDevices(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:4909
static PEAK_C_API PEAK_SystemDescriptor_GetCTIFileName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:4311
static PEAK_C_API PEAK_EventController_GetNumEventsFired(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Definition peak_dynamic_loader.h:8874
static PEAK_C_API PEAK_NodeMap_PollNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Definition peak_dynamic_loader.h:7002
static PEAK_C_API PEAK_Node_GetDisplayName(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:7288
static PEAK_C_API PEAK_NodeMap_StoreToFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:7093
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Definition peak_dynamic_loader.h:8263
static PEAK_C_API PEAK_ProducerLibrary_Destruct(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Definition peak_dynamic_loader.h:4194
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:7483
static PEAK_C_API PEAK_Library_GetVersionSubminor(uint32_t *libraryVersionSubminor)
Definition peak_dynamic_loader.h:4090
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetDescription(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:9199
static PEAK_C_API PEAK_DataStream_GetBufferAlignment(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *bufferAlignment)
Definition peak_dynamic_loader.h:5897
static PEAK_C_API PEAK_Buffer_GetIsAcquiring(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Definition peak_dynamic_loader.h:6482
static PEAK_C_API PEAK_Buffer_GetWidth(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Definition peak_dynamic_loader.h:6365
static PEAK_C_API PEAK_BufferPart_GetBasePtr(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Definition peak_dynamic_loader.h:6729
static PEAK_C_API PEAK_NodeMap_Unlock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:7145
static PEAK_C_API PEAK_Node_GetPollingTime(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Definition peak_dynamic_loader.h:7418
static PEAK_C_API PEAK_Buffer_GetYOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:6404
static PEAK_C_API PEAK_Buffer_GetDeliveredImageHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:6313
static PEAK_C_API PEAK_FloatNode_GetValidValues(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:7964
static PEAK_C_API PEAK_SystemDescriptor_ToModuleDescriptor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:4207
static PEAK_C_API PEAK_FileAdapter_Construct(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *fileName, PEAK_FILE_ADAPTER_HANDLE *fileAdapterHandle)
Definition peak_dynamic_loader.h:9485
static PEAK_C_API PEAK_System_GetModelName(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:4493
static PEAK_C_API PEAK_InterfaceDescriptor_GetTLType(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4766
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:4233
static PEAK_C_API PEAK_RemoteDevice_ToModule(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5637
static PEAK_C_API PEAK_InterfaceDescriptor_GetDisplayName(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4753
static PEAK_C_API PEAK_System_GetTLType(PEAK_SYSTEM_HANDLE systemHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4519
static PEAK_C_API PEAK_DataStreamDescriptor_ToModuleDescriptor(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:5663
static PEAK_C_API PEAK_System_GetGenTLVersionMinor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:4571
static PEAK_C_API PEAK_NodeMap_UpdateChunkNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:7054
static PEAK_C_API PEAK_Buffer_GetUserPtr(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Definition peak_dynamic_loader.h:6196
static PEAK_C_API PEAK_Interface_ToEventSupportingModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:4818
static PEAK_C_API PEAK_DeviceDescriptor_ToModuleDescriptor(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:5091
static PEAK_C_API PEAK_CategoryNode_ToNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8185
static PEAK_C_API PEAK_Port_GetIsWritable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Definition peak_dynamic_loader.h:8575
static PEAK_C_API PEAK_Device_GetRemoteDevice(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Definition peak_dynamic_loader.h:5585
static PEAK_C_API PEAK_CategoryNode_GetSubNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8211
static PEAK_C_API PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:5299
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:4441
static PEAK_C_API PEAK_System_ToEventSupportingModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:4415
static PEAK_C_API PEAK_CommandNode_Execute(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:7860
static PEAK_C_API PEAK_RegisterNode_GetLength(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Definition peak_dynamic_loader.h:8146
static PEAK_C_API PEAK_BufferPart_GetFormat(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Definition peak_dynamic_loader.h:6768
static PEAK_C_API PEAK_Node_ToBooleanNode(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Definition peak_dynamic_loader.h:7171
static PEAK_C_API PEAK_Device_GetSerialNumber(PEAK_DEVICE_HANDLE deviceHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:5533
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:9368
static PEAK_C_API PEAK_Buffer_GetIsQueued(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Definition peak_dynamic_loader.h:6469
static PEAK_C_API PEAK_NodeMap_GetNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7028
static PEAK_C_API PEAK_BooleanNode_ToNode(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7795
static PEAK_C_API PEAK_IntegerNode_GetIncrement(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Definition peak_dynamic_loader.h:7704
static PEAK_C_API PEAK_FirmwareUpdater_Construct(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:9069
static PEAK_C_API PEAK_Node_ToIntegerNode(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Definition peak_dynamic_loader.h:7158
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:8848
static PEAK_C_API PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Definition peak_dynamic_loader.h:9082
static PEAK_C_API PEAK_Interface_ToModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:4805
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:8237
static PEAK_C_API PEAK_Node_GetParentNodeMap(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:7470
static PEAK_C_API PEAK_Library_IsInitialized(PEAK_BOOL8 *isInitialized)
Definition peak_dynamic_loader.h:4051
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:5611
static PEAK_C_API PEAK_SystemDescriptor_GetParentLibrary(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4376
static PEAK_C_API PEAK_Buffer_GetTimestamp_ticks(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Definition peak_dynamic_loader.h:6443
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:9394
static PEAK_C_API PEAK_InterfaceDescriptor_GetParentSystem(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4779
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:5260
static PEAK_C_API PEAK_IntegerNode_GetMaximum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Definition peak_dynamic_loader.h:7691
static PEAK_C_API PEAK_System_GetParentLibrary(PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4597
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:5117
static PEAK_C_API PEAK_Buffer_GetPixelEndianness(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Definition peak_dynamic_loader.h:6248
static PEAK_C_API PEAK_Port_GetName(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:8471
static PEAK_C_API PEAK_Port_GetVendorName(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:8484
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:4844
static PEAK_C_API PEAK_InterfaceDescriptor_OpenInterface(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:4792
static PEAK_C_API PEAK_Device_GetAccessStatus(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:5546
static PEAK_C_API PEAK_NodeMap_Lock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:7119
static PEAK_C_API PEAK_BufferChunk_GetID(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Definition peak_dynamic_loader.h:6638
static PEAK_C_API PEAK_DataStream_GetParentDevice(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5949
static PEAK_C_API PEAK_FileAdapter_GetMaxSize(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t *maxSize)
Definition peak_dynamic_loader.h:9563
static PEAK_C_API PEAK_DataStream_GetNumBuffersAwaitDelivery(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAwaitDelivery)
Definition peak_dynamic_loader.h:5832
static PEAK_C_API PEAK_Node_GetNumInvalidatingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Definition peak_dynamic_loader.h:7535
static PEAK_C_API PEAK_NodeMap_GetHasEventSupportedData(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Definition peak_dynamic_loader.h:7067
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:5000
static PEAK_C_API PEAK_RegisterNode_Write(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition peak_dynamic_loader.h:8172
static PEAK_C_API PEAK_System_GetInterface(PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE *interfaceDescriptorHandle)
Definition peak_dynamic_loader.h:4636
static PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMajor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMajor)
Definition peak_dynamic_loader.h:4337
static PEAK_C_API PEAK_ModuleDescriptor_GetID(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:6898
static PEAK_C_API PEAK_Buffer_GetDeliveredChunkPayloadSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Definition peak_dynamic_loader.h:6326
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:5273
static PEAK_C_API PEAK_BufferPart_GetDeliveredImageHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:6859
static PEAK_C_API PEAK_Buffer_GetXOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:6391
static PEAK_C_API PEAK_Node_ToRegisterNode(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Definition peak_dynamic_loader.h:7223
static PEAK_C_API PEAK_Port_GetTLType(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:8523
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:5975
static PEAK_C_API PEAK_FileAdapter_Destruct(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle)
Definition peak_dynamic_loader.h:9498
static PEAK_C_API PEAK_Node_GetSelectingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition peak_dynamic_loader.h:7626
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:7600
static PEAK_C_API PEAK_EventController_GetControlledEventType(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Definition peak_dynamic_loader.h:8913
static PEAK_C_API PEAK_DeviceDescriptor_GetVersion(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:5169
static PEAK_C_API PEAK_DataStream_ToEventSupportingModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:5728
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:8835
static PEAK_C_API PEAK_System_UnregisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4662
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:7769
static PEAK_C_API PEAK_EventController_GetEventMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Definition peak_dynamic_loader.h:8887
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:6950
static PEAK_C_API PEAK_Device_GetDisplayName(PEAK_DEVICE_HANDLE deviceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:5455
static PEAK_C_API PEAK_Node_GetAccessStatus(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:7327
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:4740
static PEAK_C_API PEAK_Node_GetIsCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Definition peak_dynamic_loader.h:7340
static PEAK_C_API PEAK_DataStream_KillWait(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:6027
static PEAK_C_API PEAK_Buffer_GetPixelFormat(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Definition peak_dynamic_loader.h:6222
static PEAK_C_API PEAK_NodeMap_LoadFromFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:7106
static PEAK_C_API PEAK_Buffer_UpdateChunks(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6560
static PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMinor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:4350
static PEAK_C_API PEAK_EnumerationNode_TryFindEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:8341
static PEAK_C_API PEAK_DeviceDescriptor_GetSerialNumber(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:5208
static PEAK_C_API PEAK_Buffer_GetSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Definition peak_dynamic_loader.h:6183
static PEAK_C_API PEAK_Buffer_GetHasImage(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Definition peak_dynamic_loader.h:6521
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:7522
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:9459
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Construct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:9303
static PEAK_C_API PEAK_Device_GetTLType(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5507
static PEAK_C_API PEAK_Node_GetDescription(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:7444
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetFileName(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:9186
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersion(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:9212
static PEAK_C_API PEAK_DeviceDescriptor_GetUserDefinedName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:5195
static PEAK_C_API PEAK_EventController_FlushPendingKillWaits(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8952
static PEAK_C_API PEAK_FileAdapter_GetSize(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t *size)
Definition peak_dynamic_loader.h:9550
static PEAK_C_API PEAK_Buffer_GetNumParts(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Definition peak_dynamic_loader.h:6612
static PEAK_C_API PEAK_SystemDescriptor_GetVendorName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:4259
static PEAK_C_API PEAK_Buffer_GetFileName(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:6352
static PEAK_C_API PEAK_EnumerationNode_GetNumEntries(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Definition peak_dynamic_loader.h:8367
static PEAK_C_API PEAK_SystemDescriptor_OpenSystem(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4389
static PEAK_C_API PEAK_Device_GetParentInterface(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:5572
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:5962
static PEAK_C_API PEAK_Event_Destruct(PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:9056
static PEAK_C_API PEAK_System_GetVendorName(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:4480
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:5026
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:8666
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:9134
static PEAK_C_API PEAK_Buffer_GetImageOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Definition peak_dynamic_loader.h:6300
static PEAK_C_API PEAK_Port_GetIsReadable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Definition peak_dynamic_loader.h:8562
static PEAK_C_API PEAK_BufferPart_GetXOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:6820
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:5325
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:9095
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:8627
static PEAK_C_API PEAK_DataStream_GetNumBuffersDelivered(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersDelivered)
Definition peak_dynamic_loader.h:5845
static PEAK_C_API PEAK_BooleanNode_SetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Definition peak_dynamic_loader.h:7821
static PEAK_C_API PEAK_DataStream_GetDefinesPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *definesPayloadSize)
Definition peak_dynamic_loader.h:5923
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:6703
static PEAK_C_API PEAK_Buffer_GetYPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Definition peak_dynamic_loader.h:6430
static PEAK_C_API PEAK_DataStream_StartAcquisitionInfinite(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Definition peak_dynamic_loader.h:6066
static PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Definition peak_dynamic_loader.h:8809
static PEAK_C_API PEAK_Interface_GetDisplayName(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4870
static PEAK_C_API PEAK_Library_GetVersionMajor(uint32_t *libraryVersionMajor)
Definition peak_dynamic_loader.h:4064
static PEAK_C_API PEAK_DataStream_RevokeBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6001
static PEAK_C_API PEAK_EnumerationEntryNode_GetSymbolicValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Definition peak_dynamic_loader.h:8419
static PEAK_C_API PEAK_DataStreamDescriptor_GetKey(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5676
static PEAK_C_API PEAK_Buffer_GetPart(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Definition peak_dynamic_loader.h:6625
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:5052
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:5754
static PEAK_C_API PEAK_System_GetGenTLVersionMajor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMajor)
Definition peak_dynamic_loader.h:4558
static PEAK_C_API PEAK_EnvironmentInspector_GetNumCTIPaths(size_t *numCtiPaths)
Definition peak_dynamic_loader.h:4129
static PEAK_C_API PEAK_FileAdapter_Read(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t size, uint64_t offset, uint8_t *data, uint64_t *dataSize)
Definition peak_dynamic_loader.h:9511
static PEAK_C_API PEAK_StringNode_ToNode(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8068
static PEAK_C_API PEAK_EnumerationEntryNode_GetIsSelfClearing(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Definition peak_dynamic_loader.h:8406
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Definition peak_dynamic_loader.h:9264
static PEAK_C_API PEAK_NodeMap_InvalidateNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:6989
static PEAK_C_API PEAK_System_GetCharacterEncoding(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:4584
static PEAK_C_API PEAK_InterfaceDescriptor_GetKey(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4727
static PEAK_C_API PEAK_SystemDescriptor_GetCharacterEncoding(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:4363
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:8328
static PEAK_C_API PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnouncedMinRequired)
Definition peak_dynamic_loader.h:5793
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:4675
static PEAK_C_API PEAK_Node_GetType(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Definition peak_dynamic_loader.h:7457
static PEAK_C_API PEAK_BufferPart_Destruct(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Definition peak_dynamic_loader.h:6885
static PEAK_C_API PEAK_Node_ToEnumerationNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Definition peak_dynamic_loader.h:7249
static PEAK_C_API PEAK_IntegerNode_GetIncrementType(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:7717
static PEAK_C_API PEAK_DataStreamDescriptor_OpenDataStream(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Definition peak_dynamic_loader.h:5702
static PEAK_C_API PEAK_FileAdapter_Delete(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle)
Definition peak_dynamic_loader.h:9537
static PEAK_C_API PEAK_Buffer_GetPayloadType(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Definition peak_dynamic_loader.h:6209
static PEAK_C_API PEAK_Library_Close()
Definition peak_dynamic_loader.h:4038
static PEAK_C_API PEAK_DataStream_GetNumUnderruns(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Definition peak_dynamic_loader.h:5871
static PEAK_C_API PEAK_Node_GetInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition peak_dynamic_loader.h:7548
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:4948
static PEAK_C_API PEAK_Buffer_GetHasChunks(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Definition peak_dynamic_loader.h:6534
static PEAK_C_API PEAK_PortURL_GetFileVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Definition peak_dynamic_loader.h:8770
static PEAK_C_API PEAK_FloatNode_GetMinimum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Definition peak_dynamic_loader.h:7912
static PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Definition peak_dynamic_loader.h:8796
static PEAK_C_API PEAK_Buffer_GetHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Definition peak_dynamic_loader.h:6378
static PEAK_C_API PEAK_Buffer_GetBasePtr(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Definition peak_dynamic_loader.h:6170
static PEAK_C_API PEAK_Buffer_GetNumChunks(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Definition peak_dynamic_loader.h:6573
static PEAK_C_API PEAK_Node_GetNumInvalidatedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Definition peak_dynamic_loader.h:7496
static PEAK_C_API PEAK_DataStream_GetPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Definition peak_dynamic_loader.h:5910
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:9420
static PEAK_C_API PEAK_FloatNode_GetMaximum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Definition peak_dynamic_loader.h:7925
static PEAK_C_API PEAK_Node_GetName(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:7275
static PEAK_C_API PEAK_IntegerNode_ToNode(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7665
static PEAK_C_API PEAK_Port_GetIsImplemented(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Definition peak_dynamic_loader.h:8601
static PEAK_C_API PEAK_SystemDescriptor_GetModelName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:4272
static PEAK_C_API PEAK_Port_GetURL(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Definition peak_dynamic_loader.h:8653
static PEAK_C_API PEAK_Device_GetUserDefinedName(PEAK_DEVICE_HANDLE deviceHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:5520
static PEAK_C_API PEAK_Node_ToFloatNode(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Definition peak_dynamic_loader.h:7197
static PEAK_C_API PEAK_Interface_GetID(PEAK_INTERFACE_HANDLE interfaceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:4857
static PEAK_C_API PEAK_Node_GetSelectedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition peak_dynamic_loader.h:7587
Definition peak_dynamic_loader.h:466
Definition peak_dynamic_loader.h:35
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_GetNumCTIPaths)(size_t *numCtiPaths)
Definition peak_dynamic_loader.h:45
PEAK_C_API(* dyn_PEAK_Buffer_GetIsAcquiring)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Definition peak_dynamic_loader.h:226
PEAK_C_API(* dyn_PEAK_BooleanNode_SetValue)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Definition peak_dynamic_loader.h:329
PEAK_C_API(* dyn_PEAK_Buffer_GetExpectedDataSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Definition peak_dynamic_loader.h:209
PEAK_C_API(* dyn_PEAK_Port_GetID)(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:378
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_System_GetInfo)(PEAK_SYSTEM_HANDLE systemHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition peak_dynamic_loader.h:69
PEAK_C_API(* dyn_PEAK_PortURL_GetFileName)(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:397
PEAK_C_API(* dyn_PEAK_Node_ToBooleanNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Definition peak_dynamic_loader.h:279
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
PEAK_C_API(* dyn_PEAK_Node_GetNumSelectedNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Definition peak_dynamic_loader.h:310
PEAK_C_API(* dyn_PEAK_Event_Destruct)(PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:424
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:427
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_Node_ToFloatNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Definition peak_dynamic_loader.h:281
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_BufferPart_GetWidth)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Definition peak_dynamic_loader.h:250
PEAK_C_API(* dyn_PEAK_CategoryNode_ToNode)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:357
PEAK_C_API(* dyn_PEAK_DataStream_ToEventSupportingModule)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:168
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:361
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:391
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_IntegerNode_GetValue)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, int64_t *value)
Definition peak_dynamic_loader.h:325
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_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_Port_GetIsImplemented)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Definition peak_dynamic_loader.h:389
PEAK_C_API(* dyn_PEAK_FileAdapter_Destruct)(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle)
Definition peak_dynamic_loader.h:458
PEAK_C_API(* dyn_PEAK_Interface_ToModule)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:97
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetValue)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Definition peak_dynamic_loader.h:376
PEAK_C_API(* dyn_PEAK_IntegerNode_GetIncrementType)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:321
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_DeviceDescriptor_GetDisplayName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:122
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredDataSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Definition peak_dynamic_loader.h:210
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
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_Buffer_GetPart)(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Definition peak_dynamic_loader.h:237
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSchemaVersionMinor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Definition peak_dynamic_loader.h:405
PEAK_C_API(* dyn_PEAK_System_Destruct)(PEAK_SYSTEM_HANDLE systemHandle)
Definition peak_dynamic_loader.h:89
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:455
PEAK_C_API(* dyn_PEAK_Port_GetModelName)(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:381
PEAK_C_API(* dyn_PEAK_System_UpdateInterfaces)(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:82
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_RemoteDevice_GetLocalDevice)(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:162
PEAK_C_API(* dyn_PEAK_Library_Close)()
Definition peak_dynamic_loader.h:38
PEAK_C_API(* dyn_PEAK_Module_GetNodeMap)(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:260
PEAK_C_API(* dyn_PEAK_Buffer_GetUserPtr)(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Definition peak_dynamic_loader.h:204
PEAK_C_API(* dyn_PEAK_FileAdapter_Construct)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *fileName, PEAK_FILE_ADAPTER_HANDLE *fileAdapterHandle)
Definition peak_dynamic_loader.h:457
PEAK_C_API(* dyn_PEAK_StringNode_ToNode)(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:348
PEAK_C_API(* dyn_PEAK_FloatNode_GetValidValues)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:340
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_UpdateCTIPaths)()
Definition peak_dynamic_loader.h:44
PEAK_C_API(* dyn_PEAK_CommandNode_WaitUntilDoneInfinite)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:333
PEAK_C_API(* dyn_PEAK_Node_GetName)(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:287
PEAK_C_API(* dyn_PEAK_Buffer_GetXOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:219
PEAK_C_API(* dyn_PEAK_BufferPart_GetBasePtr)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Definition peak_dynamic_loader.h:245
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetTLType)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:126
PEAK_C_API(* dyn_PEAK_Buffer_UpdateChunks)(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:232
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelEndianness)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Definition peak_dynamic_loader.h:208
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_FloatNode_GetRepresentation)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:341
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_NodeMap_StoreToFile)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:273
PEAK_C_API(* dyn_PEAK_NodeMap_TryFindNode)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *nodeName, size_t nodeNameSize, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:264
PEAK_C_API(* dyn_PEAK_FloatNode_ToNode)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:335
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:447
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Definition peak_dynamic_loader.h:437
PEAK_C_API(* dyn_PEAK_Buffer_GetTLType)(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:201
PEAK_C_API(* dyn_PEAK_Buffer_GetHasChunks)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Definition peak_dynamic_loader.h:230
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:263
PEAK_C_API(* dyn_PEAK_Node_GetNamespace)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Definition peak_dynamic_loader.h:289
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_StopAcquisition)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Definition peak_dynamic_loader.h:196
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_GetCTIPath)(size_t index, char *ctiPath, size_t *ctiPathSize)
Definition peak_dynamic_loader.h:46
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_PortURL_GetInfo)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition peak_dynamic_loader.h:394
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_EventController_WaitForEvent)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t timeout_ms, PEAK_EVENT_HANDLE *eventHandle)
Definition peak_dynamic_loader.h:414
PEAK_C_API(* dyn_PEAK_Node_ToCommandNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Definition peak_dynamic_loader.h:280
PEAK_C_API(* dyn_PEAK_EnumerationNode_TryFindEntryBySymbolicValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:369
PEAK_C_API(* dyn_PEAK_Device_GetRemoteDevice)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Definition peak_dynamic_loader.h:157
PEAK_C_API(* dyn_PEAK_SystemDescriptor_ToModuleDescriptor)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:51
PEAK_C_API(* dyn_PEAK_Node_ToRegisterNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Definition peak_dynamic_loader.h:283
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetGenTLVersionMinor)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:62
PEAK_C_API(* dyn_PEAK_Node_GetParentNodeMap)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:302
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetCharacterEncoding)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:63
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetTLType)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:94
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetUserDefinedName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:127
PEAK_C_API(* dyn_PEAK_Buffer_GetYOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:220
PEAK_C_API(* dyn_PEAK_ProducerLibrary_GetKey)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:48
PEAK_C_API(* dyn_PEAK_Node_ToStringNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Definition peak_dynamic_loader.h:282
PEAK_C_API(* dyn_PEAK_DataStream_GetNumUnderruns)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Definition peak_dynamic_loader.h:179
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_Destruct)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:432
PEAK_C_API(* dyn_PEAK_NodeMap_GetNumNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Definition peak_dynamic_loader.h:267
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_Buffer_GetHasParts)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasParts)
Definition peak_dynamic_loader.h:231
PEAK_C_API(* dyn_PEAK_Device_GetParentInterface)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:156
PEAK_C_API(* dyn_PEAK_Interface_Destruct)(PEAK_INTERFACE_HANDLE interfaceHandle)
Definition peak_dynamic_loader.h:118
PEAK_C_API(* dyn_PEAK_DataStream_Flush)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Definition peak_dynamic_loader.h:193
PEAK_C_API(* dyn_PEAK_System_UnregisterInterfaceFoundCallback)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:86
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_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_DataStream_FlushPendingKillWaits)(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:192
PEAK_C_API(* dyn_PEAK_Device_GetTLType)(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:151
PEAK_C_API(* dyn_PEAK_CommandNode_ToNode)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:330
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetFileName)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:434
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_StringNode_SetValue)(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Definition peak_dynamic_loader.h:351
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:350
PEAK_C_API(* dyn_PEAK_EnumerationNode_GetNumEntries)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Definition peak_dynamic_loader.h:371
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
PEAK_C_API(* dyn_PEAK_FloatNode_GetMinimum)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Definition peak_dynamic_loader.h:336
PEAK_C_API(* dyn_PEAK_Buffer_GetChunkLayoutID)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Definition peak_dynamic_loader.h:215
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:200
PEAK_C_API(* dyn_PEAK_BufferPart_GetFormatNamespace)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Definition peak_dynamic_loader.h:249
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:303
PEAK_C_API(* dyn_PEAK_Device_GetAccessStatus)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:154
PEAK_C_API(* dyn_PEAK_FileAdapter_GetSize)(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t *size)
Definition peak_dynamic_loader.h:462
PEAK_C_API(* dyn_PEAK_Node_GetVisibility)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Definition peak_dynamic_loader.h:290
PEAK_C_API(* dyn_PEAK_Node_GetInvalidatedNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition peak_dynamic_loader.h:305
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_Buffer_GetYPadding)(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Definition peak_dynamic_loader.h:222
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_Node_GetDescription)(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:300
PEAK_C_API(* dyn_PEAK_Node_GetIsStreamable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Definition peak_dynamic_loader.h:294
PEAK_C_API(* dyn_PEAK_Event_GetType)(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Definition peak_dynamic_loader.h:422
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredChunkPayloadSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Definition peak_dynamic_loader.h:214
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:309
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Definition peak_dynamic_loader.h:426
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionMinor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Definition peak_dynamic_loader.h:402
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersStarted)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Definition peak_dynamic_loader.h:178
PEAK_C_API(* dyn_PEAK_BufferChunk_GetID)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Definition peak_dynamic_loader.h:238
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:367
PEAK_C_API(* dyn_PEAK_Buffer_UpdateParts)(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:235
PEAK_C_API(* dyn_PEAK_NodeMap_InvalidateNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:265
PEAK_C_API(* dyn_PEAK_Node_GetIsCacheable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Definition peak_dynamic_loader.h:292
PEAK_C_API(* dyn_PEAK_IntegerNode_GetUnit)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:324
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_ToNode)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:373
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntryByValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:364
PEAK_C_API(* dyn_PEAK_NodeMap_Unlock)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:277
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_DataStream_KillWait)(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:191
PEAK_C_API(* dyn_PEAK_Node_UnregisterChangedCallback)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:316
PEAK_C_API(* dyn_PEAK_Node_GetSelectingNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition peak_dynamic_loader.h:314
PEAK_C_API(* dyn_PEAK_FileAdapter_GetMaxSize)(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t *maxSize)
Definition peak_dynamic_loader.h:463
PEAK_C_API(* dyn_PEAK_Library_GetVersionMinor)(uint32_t *libraryVersionMinor)
Definition peak_dynamic_loader.h:41
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_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
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_Node_GetType)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Definition peak_dynamic_loader.h:301
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_FirmwareUpdater_GetNumFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Definition peak_dynamic_loader.h:428
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_SetValue)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Definition peak_dynamic_loader.h:347
PEAK_C_API(* dyn_PEAK_Node_GetCachingMode)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Definition peak_dynamic_loader.h:297
PEAK_C_API(* dyn_PEAK_Interface_GetDisplayName)(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:102
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Definition peak_dynamic_loader.h:440
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:243
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_Node_GetIsDeprecated)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Definition peak_dynamic_loader.h:295
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:445
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_CommandNode_WaitUntilDone)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Definition peak_dynamic_loader.h:334
PEAK_C_API(* dyn_PEAK_NodeMap_GetNode)(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:268
PEAK_C_API(* dyn_PEAK_Port_GetURL)(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Definition peak_dynamic_loader.h:393
PEAK_C_API(* dyn_PEAK_FloatNode_GetDisplayNotation)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Definition peak_dynamic_loader.h:343
PEAK_C_API(* dyn_PEAK_System_GetKey)(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:68
PEAK_C_API(* dyn_PEAK_CategoryNode_GetNumSubNodes)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Definition peak_dynamic_loader.h:358
PEAK_C_API(* dyn_PEAK_Port_GetIsAvailable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Definition peak_dynamic_loader.h:388
PEAK_C_API(* dyn_PEAK_EnumerationNode_GetHasEntryBySymbolicValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize, PEAK_BOOL8 *hasEntry)
Definition peak_dynamic_loader.h:365
PEAK_C_API(* dyn_PEAK_RegisterNode_GetLength)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Definition peak_dynamic_loader.h:354
PEAK_C_API(* dyn_PEAK_Buffer_GetFrameID)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Definition peak_dynamic_loader.h:211
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:448
PEAK_C_API(* dyn_PEAK_Port_GetModuleName)(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Definition peak_dynamic_loader.h:384
PEAK_C_API(* dyn_PEAK_FloatNode_GetDisplayPrecision)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Definition peak_dynamic_loader.h:344
PEAK_C_API(* dyn_PEAK_NodeMap_PollNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Definition peak_dynamic_loader.h:266
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_Buffer_GetHeight)(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Definition peak_dynamic_loader.h:218
PEAK_C_API(* dyn_PEAK_Device_Destruct)(PEAK_DEVICE_HANDLE deviceHandle)
Definition peak_dynamic_loader.h:160
PEAK_C_API(* dyn_PEAK_DataStream_GetPayloadSize)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Definition peak_dynamic_loader.h:182
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetCTIFileName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:59
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersion)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:436
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_DeviceDescriptor_GetMonitoringUpdateInterval)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:135
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_Port_GetInfo)(PEAK_PORT_HANDLE portHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition peak_dynamic_loader.h:377
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetModelName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:124
PEAK_C_API(* dyn_PEAK_BufferPart_GetHeight)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Definition peak_dynamic_loader.h:251
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_Device_GetInfo)(PEAK_DEVICE_HANDLE deviceHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition peak_dynamic_loader.h:145
PEAK_C_API(* dyn_PEAK_NodeMap_Lock)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:275
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetSymbolicValue)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Definition peak_dynamic_loader.h:375
PEAK_C_API(* dyn_PEAK_FileAdapter_Write)(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, const uint8_t *data, uint64_t size, uint64_t offset)
Definition peak_dynamic_loader.h:460
PEAK_C_API(* dyn_PEAK_EnumerationNode_TryFindEntryByValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:370
PEAK_C_API(* dyn_PEAK_System_GetDisplayName)(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:71
PEAK_C_API(* dyn_PEAK_EventController_GetControlledEventType)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Definition peak_dynamic_loader.h:413
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_DataStream_GetID)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:171
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:262
PEAK_C_API(* dyn_PEAK_Port_GetIsReadable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Definition peak_dynamic_loader.h:386
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetIsSelfClearing)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Definition peak_dynamic_loader.h:374
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_System_GetCharacterEncoding)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:80
PEAK_C_API(* dyn_PEAK_DataStream_StartAcquisitionInfinite)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Definition peak_dynamic_loader.h:194
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:430
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionMajor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Definition peak_dynamic_loader.h:401
PEAK_C_API(* dyn_PEAK_DataStream_GetParentDevice)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:185
PEAK_C_API(* dyn_PEAK_PortURL_GetFileRegisterAddress)(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Definition peak_dynamic_loader.h:398
PEAK_C_API(* dyn_PEAK_System_ToModule)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:66
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetIsValid)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Definition peak_dynamic_loader.h:433
PEAK_C_API(* dyn_PEAK_Buffer_GetPayloadType)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Definition peak_dynamic_loader.h:205
PEAK_C_API(* dyn_PEAK_EnumerationNode_ToNode)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:360
PEAK_C_API(* dyn_PEAK_NodeMap_TryLock)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BOOL8 *locked)
Definition peak_dynamic_loader.h:276
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
PEAK_C_API(* dyn_PEAK_IntegerNode_GetMaximum)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Definition peak_dynamic_loader.h:319
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_Destruct)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:456
PEAK_C_API(* dyn_PEAK_EventController_GetEventDataMaxSize)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Definition peak_dynamic_loader.h:412
PEAK_C_API(* dyn_PEAK_IntegerNode_GetMinimum)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Definition peak_dynamic_loader.h:318
PEAK_C_API(* dyn_PEAK_BufferPart_GetYOffset)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:253
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_GetParentDevice)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:165
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_EventSupportingModule_EnableEvents)(PEAK_EVENT_SUPPORTING_MODULE_HANDLE eventSupportingModuleHandle, PEAK_EVENT_TYPE eventType, PEAK_EVENT_CONTROLLER_HANDLE *eventControllerHandle)
Definition peak_dynamic_loader.h:407
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_Node_GetInvalidatingNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition peak_dynamic_loader.h:308
PEAK_C_API(* dyn_PEAK_Node_GetNumSelectingNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Definition peak_dynamic_loader.h:313
PEAK_C_API(* dyn_PEAK_Port_GetNumURLs)(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Definition peak_dynamic_loader.h:392
PEAK_C_API(* dyn_PEAK_Port_GetVendorName)(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:380
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
PEAK_C_API(* dyn_PEAK_BufferChunk_GetParentBuffer)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:241
PEAK_C_API(* dyn_PEAK_RegisterNode_ToNode)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:352
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredImageHeight)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:213
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_FirmwareUpdateInformation_GetVersionStyle)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Definition peak_dynamic_loader.h:438
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_FileAdapter_Read)(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle, uint64_t size, uint64_t offset, uint8_t *data, uint64_t *dataSize)
Definition peak_dynamic_loader.h:459
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_Construct)(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:425
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_Buffer_GetNumChunks)(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Definition peak_dynamic_loader.h:233
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetDescription)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:435
PEAK_C_API(* dyn_PEAK_BufferPart_GetSize)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Definition peak_dynamic_loader.h:246
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:431
PEAK_C_API(* dyn_PEAK_ProducerLibrary_Destruct)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Definition peak_dynamic_loader.h:50
void * import_function(void *module, const char *proc_name)
Definition peak_dynamic_loader.h:1349
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelFormatNamespace)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Definition peak_dynamic_loader.h:207
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_SystemDescriptor_GetParentLibrary)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:64
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_Device_GetID)(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:146
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetReleaseNotes)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Definition peak_dynamic_loader.h:439
PEAK_C_API(* dyn_PEAK_FloatNode_GetMaximum)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Definition peak_dynamic_loader.h:337
PEAK_C_API(* dyn_PEAK_BufferPart_GetXOffset)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:252
PEAK_C_API(* dyn_PEAK_PortURL_GetURL)(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Definition peak_dynamic_loader.h:395
PEAK_C_API(* dyn_PEAK_Buffer_GetFileName)(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:216
PEAK_C_API(* dyn_PEAK_Buffer_GetImageOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Definition peak_dynamic_loader.h:212
PEAK_C_API(* dyn_PEAK_EventController_FlushPendingKillWaits)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:416
PEAK_C_API(* dyn_PEAK_NodeMap_GetHasEventSupportedData)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Definition peak_dynamic_loader.h:271
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntry)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:362
PEAK_C_API(* dyn_PEAK_Node_GetIsFeature)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Definition peak_dynamic_loader.h:296
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:315
PEAK_C_API(* dyn_PEAK_Node_GetSelectedNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition peak_dynamic_loader.h:311
PEAK_C_API(* dyn_PEAK_DataStream_GetIsGrabbing)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Definition peak_dynamic_loader.h:184
PEAK_C_API(* dyn_PEAK_PortURL_GetParentPort)(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:406
PEAK_C_API(* dyn_PEAK_IntegerNode_SetValue)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:326
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_DeviceDescriptor_GetVendorName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:123
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_Node_GetAccessStatus)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:291
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetUserSetPersistence)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Definition peak_dynamic_loader.h:441
PEAK_C_API(* dyn_PEAK_Event_GetData)(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Definition peak_dynamic_loader.h:421
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_FloatNode_GetHasConstantIncrement)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Definition peak_dynamic_loader.h:345
PEAK_C_API(* dyn_PEAK_Port_GetVersion)(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:382
PEAK_C_API(* dyn_PEAK_IntegerNode_GetRepresentation)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:323
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
PEAK_C_API(* dyn_PEAK_NodeMap_UpdateEventNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:272
PEAK_C_API(* dyn_PEAK_Module_GetNumNodeMaps)(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Definition peak_dynamic_loader.h:259
PEAK_C_API(* dyn_PEAK_Interface_ToEventSupportingModule)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:98
PEAK_C_API(* dyn_PEAK_Buffer_GetWidth)(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Definition peak_dynamic_loader.h:217
PEAK_C_API(* dyn_PEAK_EventController_GetEventMaxSize)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Definition peak_dynamic_loader.h:411
PEAK_C_API(* dyn_PEAK_ProducerLibrary_GetSystem)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Definition peak_dynamic_loader.h:49
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:390
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:419
PEAK_C_API(* dyn_PEAK_Event_GetRawData)(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Definition peak_dynamic_loader.h:423
PEAK_C_API(* dyn_PEAK_ModuleDescriptor_GetID)(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:258
PEAK_C_API(* dyn_PEAK_RegisterNode_GetAddress)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Definition peak_dynamic_loader.h:353
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_OpenInterface)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:96
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_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_DataStream_RevokeBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:189
PEAK_C_API(* dyn_PEAK_Buffer_GetChunk)(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Definition peak_dynamic_loader.h:234
PEAK_C_API(* dyn_PEAK_Port_GetDataEndianness)(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Definition peak_dynamic_loader.h:385
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_SystemDescriptor_OpenSystem)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:65
PEAK_C_API(* dyn_PEAK_EnumerationNode_GetHasEntryByValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value, PEAK_BOOL8 *hasEntry)
Definition peak_dynamic_loader.h:366
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSchemaVersionMajor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Definition peak_dynamic_loader.h:404
PEAK_C_API(* dyn_PEAK_Library_Initialize)()
Definition peak_dynamic_loader.h:37
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceReconnectedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:111
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_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle, PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:451
PEAK_C_API(* dyn_PEAK_BufferChunk_Destruct)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Definition peak_dynamic_loader.h:242
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetParentInterface)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:134
PEAK_C_API(* dyn_PEAK_BufferChunk_GetSize)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Definition peak_dynamic_loader.h:240
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:408
PEAK_C_API(* dyn_PEAK_BufferPart_GetSourceID)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Definition peak_dynamic_loader.h:244
PEAK_C_API(* dyn_PEAK_DataStream_GetKey)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:169
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:452
PEAK_C_API(* dyn_PEAK_PortURL_GetScheme)(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Definition peak_dynamic_loader.h:396
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_Construct)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:443
PEAK_C_API(* dyn_PEAK_Library_GetVersionSubminor)(uint32_t *libraryVersionSubminor)
Definition peak_dynamic_loader.h:42
PEAK_C_API(* dyn_PEAK_Buffer_GetNumParts)(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Definition peak_dynamic_loader.h:236
PEAK_C_API(* dyn_PEAK_Node_ToCategoryNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Definition peak_dynamic_loader.h:284
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceListChangedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:117
PEAK_C_API(* dyn_PEAK_CategoryNode_GetSubNode)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:359
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_Device_ToModule)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:142
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetIsOpenableExclusive)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Definition peak_dynamic_loader.h:131
PEAK_C_API(* dyn_PEAK_EventController_GetNumEventsInQueue)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Definition peak_dynamic_loader.h:409
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_Node_GetNumInvalidatingNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Definition peak_dynamic_loader.h:307
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:328
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:450
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:454
PEAK_C_API(* dyn_PEAK_NodeMap_LoadFromFile)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:274
PEAK_C_API(* dyn_PEAK_Buffer_GetXPadding)(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:221
PEAK_C_API(* dyn_PEAK_System_GetGenTLVersionMinor)(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:79
PEAK_C_API(* dyn_PEAK_System_GetCTIFullPath)(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:77
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetKey)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:52
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_Node_FindInvalidatingNode)(PEAK_NODE_HANDLE nodeHandle, const char *name, size_t nameSize, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition peak_dynamic_loader.h:306
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:449
PEAK_C_API(* dyn_PEAK_Port_GetIsWritable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Definition peak_dynamic_loader.h:387
PEAK_C_API(* dyn_PEAK_BufferPart_GetParentBuffer)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:256
PEAK_C_API(* dyn_PEAK_BufferPart_Destruct)(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Definition peak_dynamic_loader.h:257
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_CommandNode_GetIsDone)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Definition peak_dynamic_loader.h:331
PEAK_C_API(* dyn_PEAK_DataStream_Destruct)(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:197
PEAK_C_API(* dyn_PEAK_EventController_Destruct)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:418
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_Port_GetName)(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:379
PEAK_C_API(* dyn_PEAK_Device_GetKey)(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:144
PEAK_C_API(* dyn_PEAK_Node_GetIsAccessStatusCacheable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Definition peak_dynamic_loader.h:293
PEAK_C_API(* dyn_PEAK_NodeMap_UpdateChunkNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:270
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetKey)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:120
PEAK_C_API(* dyn_PEAK_Library_IsInitialized)(PEAK_BOOL8 *isInitialized)
Definition peak_dynamic_loader.h:39
PEAK_C_API(* dyn_PEAK_Library_GetVersionMajor)(uint32_t *libraryVersionMajor)
Definition peak_dynamic_loader.h:40
PEAK_C_API(* dyn_PEAK_NodeMap_GetHasBufferSupportedChunks)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Definition peak_dynamic_loader.h:269
PEAK_C_API(* dyn_PEAK_Node_GetToolTip)(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Definition peak_dynamic_loader.h:299
PEAK_C_API(* dyn_PEAK_StringNode_GetMaximumLength)(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Definition peak_dynamic_loader.h:349
PEAK_C_API(* dyn_PEAK_BufferPart_GetFormat)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Definition peak_dynamic_loader.h:248
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:312
PEAK_C_API(* dyn_PEAK_System_UnregisterInterfaceLostCallback)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:88
PEAK_C_API(* dyn_PEAK_CommandNode_Execute)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:332
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceDisconnectedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:113
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_System_GetNumInterfaces)(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Definition peak_dynamic_loader.h:83
PEAK_C_API(* dyn_PEAK_Buffer_GetHasNewData)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Definition peak_dynamic_loader.h:228
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_EventController_KillWait)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:415
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_DataStream_QueueBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:188
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelFormat)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Definition peak_dynamic_loader.h:206
PEAK_C_API(* dyn_PEAK_Device_GetNumDataStreams)(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Definition peak_dynamic_loader.h:158
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_FloatNode_GetValue)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, double *value)
Definition peak_dynamic_loader.h:346
PEAK_C_API(* dyn_PEAK_IntegerNode_ToNode)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:317
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_ToModuleDescriptor)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:163
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_DataStream_StartAcquisition)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode, uint64_t numToAcquire)
Definition peak_dynamic_loader.h:195
PEAK_C_API(* dyn_PEAK_FloatNode_GetIncrement)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Definition peak_dynamic_loader.h:338
PEAK_C_API(* dyn_PEAK_System_GetVendorName)(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:72
PEAK_C_API(* dyn_PEAK_Port_GetTLType)(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:383
PEAK_C_API(* dyn_PEAK_BufferPart_GetType)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Definition peak_dynamic_loader.h:247
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_DataStreamDescriptor_OpenDataStream)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Definition peak_dynamic_loader.h:166
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_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:444
PEAK_C_API(* dyn_PEAK_IntegerNode_GetIncrement)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Definition peak_dynamic_loader.h:320
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:368
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_IntegerNode_GetValidValues)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:322
PEAK_C_API(* dyn_PEAK_FloatNode_GetUnit)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:342
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:453
PEAK_C_API(* dyn_PEAK_Node_GetNumInvalidatedNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Definition peak_dynamic_loader.h:304
PEAK_C_API(* dyn_PEAK_Event_GetID)(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Definition peak_dynamic_loader.h:420
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetSerialNumber)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:128
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_SystemDescriptor_GetCTIFullPath)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:60
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Definition peak_dynamic_loader.h:442
PEAK_C_API(* dyn_PEAK_Buffer_GetHasImage)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Definition peak_dynamic_loader.h:229
PEAK_C_API(* dyn_PEAK_Buffer_GetTimestamp_ns)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Definition peak_dynamic_loader.h:224
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_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:446
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSize)(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Definition peak_dynamic_loader.h:399
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_RegisterNode_Read)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, uint8_t *bytesToRead, size_t bytesToReadSize)
Definition peak_dynamic_loader.h:355
PEAK_C_API(* dyn_PEAK_Buffer_GetIsQueued)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Definition peak_dynamic_loader.h:225
PEAK_C_API(* dyn_PEAK_EventController_FlushEvents)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:417
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_DeviceDescriptor_GetTimestampTickFrequency)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:130
PEAK_C_API(* dyn_PEAK_Buffer_GetTimestamp_ticks)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Definition peak_dynamic_loader.h:223
PEAK_C_API(* dyn_PEAK_Buffer_ToModule)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:198
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_Buffer_ToEventSupportingModule)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:199
PEAK_C_API(* dyn_PEAK_BooleanNode_ToNode)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:327
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetDisplayName)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:93
PEAK_C_API(* dyn_PEAK_Node_ToEnumerationNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Definition peak_dynamic_loader.h:285
PEAK_C_API(* dyn_PEAK_EventController_GetNumEventsFired)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Definition peak_dynamic_loader.h:410
PEAK_C_API(* dyn_PEAK_Node_ToEnumerationEntryNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:286
PEAK_C_API(* dyn_PEAK_Buffer_GetIsIncomplete)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Definition peak_dynamic_loader.h:227
PEAK_C_API(* dyn_PEAK_BufferPart_GetDeliveredImageHeight)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:255
PEAK_C_API(* dyn_PEAK_Node_ToIntegerNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Definition peak_dynamic_loader.h:278
PEAK_C_API(* dyn_PEAK_Node_GetPollingTime)(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Definition peak_dynamic_loader.h:298
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSHA1Hash)(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Definition peak_dynamic_loader.h:400
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_FileAdapter_Delete)(PEAK_FILE_ADAPTER_HANDLE fileAdapterHandle)
Definition peak_dynamic_loader.h:461
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionSubminor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Definition peak_dynamic_loader.h:403
PEAK_C_API(* dyn_PEAK_FloatNode_GetIncrementType)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:339
PEAK_C_API(* dyn_PEAK_BufferPart_GetXPadding)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:254
PEAK_C_API(* dyn_PEAK_Node_GetDisplayName)(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:288
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:429
PEAK_C_API(* dyn_PEAK_RegisterNode_Write)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition peak_dynamic_loader.h:356
PEAK_C_API(* dyn_PEAK_DataStream_ToModule)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:167
PEAK_C_API(* dyn_PEAK_Module_GetPort)(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:261
PEAK_C_API(* dyn_PEAK_BufferChunk_GetBasePtr)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Definition peak_dynamic_loader.h:239
PEAK_C_API(* dyn_PEAK_Buffer_GetBasePtr)(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Definition peak_dynamic_loader.h:202
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Definition peak_dynamic_loader.h:363
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_System_GetModelName)(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:73
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:372
PEAK_C_API(* dyn_PEAK_Buffer_GetSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Definition peak_dynamic_loader.h:203
The "peak" namespace directly contains convenience functionality like the DeviceManager as well as th...
Definition peak_dynamic_loader.h:33
struct PEAK_DATA_STREAM * PEAK_DATA_STREAM_HANDLE
Definition peak_backend.h:401
void(PEAK_CALL_CONV * PEAK_DEVICE_DISCONNETED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE disconnectedDevice, void *context)
Definition peak_backend.h:561
PEAK_INTERFACE_LOST_CALLBACK * PEAK_INTERFACE_LOST_CALLBACK_HANDLE
Definition peak_backend.h:515
struct PEAK_PORT_URL * PEAK_PORT_URL_HANDLE
Definition peak_backend.h:473
struct PEAK_SYSTEM_DESCRIPTOR * PEAK_SYSTEM_DESCRIPTOR_HANDLE
Definition peak_backend.h:369
struct PEAK_MODULE_DESCRIPTOR * PEAK_MODULE_DESCRIPTOR_HANDLE
Definition peak_backend.h:417
struct PEAK_EVENT * PEAK_EVENT_HANDLE
Definition peak_backend.h:485
struct PEAK_MODULE * PEAK_MODULE_HANDLE
Definition peak_backend.h:421
PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE
Definition peak_backend.h:596
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:585
struct PEAK_INTERFACE_DESCRIPTOR * PEAK_INTERFACE_DESCRIPTOR_HANDLE
Definition peak_backend.h:377
struct PEAK_DATA_STREAM_DESCRIPTOR * PEAK_DATA_STREAM_DESCRIPTOR_HANDLE
Definition peak_backend.h:397
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK)(void *context)
Definition peak_backend.h:614
PEAK_NODE_CHANGED_CALLBACK * PEAK_NODE_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:582
struct PEAK_PORT * PEAK_PORT_HANDLE
Definition peak_backend.h:469
int32_t PEAK_EVENT_TYPE
Definition peak_backend.h:185
struct PEAK_ENUMERATION_NODE * PEAK_ENUMERATION_NODE_HANDLE
Definition peak_backend.h:461
struct PEAK_COMMAND_NODE * PEAK_COMMAND_NODE_HANDLE
Definition peak_backend.h:441
int32_t PEAK_NODE_INCREMENT_TYPE
Definition peak_backend.h:260
int32_t PEAK_BUFFER_PART_TYPE
Definition peak_backend.h:80
struct PEAK_STRING_NODE * PEAK_STRING_NODE_HANDLE
Definition peak_backend.h:449
struct PEAK_NODE * PEAK_NODE_HANDLE
Definition peak_backend.h:429
struct PEAK_BUFFER_CHUNK * PEAK_BUFFER_CHUNK_HANDLE
Definition peak_backend.h:409
struct PEAK_INTERFACE * PEAK_INTERFACE_HANDLE
Definition peak_backend.h:381
PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:589
PEAK_DEVICE_DISCONNETED_CALLBACK * PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE
Definition peak_backend.h:570
struct PEAK_PRODUCER_LIBRARY * PEAK_PRODUCER_LIBRARY_HANDLE
Definition peak_backend.h:365
struct PEAK_BUFFER * PEAK_BUFFER_HANDLE
Definition peak_backend.h:405
PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE
Definition peak_backend.h:616
int32_t PEAK_NODE_REPRESENTATION
Definition peak_backend.h:281
void(PEAK_CALL_CONV * PEAK_BUFFER_REVOCATION_CALLBACK)(void *buffer, void *userPtr, void *context)
Definition peak_backend.h:577
int32_t PEAK_NODE_ACCESS_STATUS
Definition peak_backend.h:225
struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER * PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE
Definition peak_backend.h:501
int32_t PEAK_NODE_TYPE
Definition peak_backend.h:296
struct PEAK_EVENT_SUPPORTING_MODULE * PEAK_EVENT_SUPPORTING_MODULE_HANDLE
Definition peak_backend.h:477
int32_t PEAK_FIRMWARE_UPDATE_PERSISTENCE
Definition peak_backend.h:193
PEAK_DEVICE_LOST_CALLBACK * PEAK_DEVICE_LOST_CALLBACK_HANDLE
Definition peak_backend.h:572
#define PEAK_C_API
Definition peak_backend.h:624
struct PEAK_EVENT_CONTROLLER * PEAK_EVENT_CONTROLLER_HANDLE
Definition peak_backend.h:481
struct PEAK_REMOTE_DEVICE * PEAK_REMOTE_DEVICE_HANDLE
Definition peak_backend.h:393
PEAK_DEVICE_RECONNECTED_CALLBACK * PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE
Definition peak_backend.h:568
PEAK_DEVICE_FOUND_CALLBACK * PEAK_DEVICE_FOUND_CALLBACK_HANDLE
Definition peak_backend.h:566
struct PEAK_BUFFER_PART * PEAK_BUFFER_PART_HANDLE
Definition peak_backend.h:413
struct PEAK_SYSTEM * PEAK_SYSTEM_HANDLE
Definition peak_backend.h:373
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, double progressPercentage, void *context)
Definition peak_backend.h:603
PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:607
void(PEAK_CALL_CONV * PEAK_NODE_CHANGED_CALLBACK)(PEAK_NODE_HANDLE changedNode, void *context)
Definition peak_backend.h:580
struct PEAK_FIRMWARE_UPDATE_INFORMATION * PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE
Definition peak_backend.h:497
struct PEAK_FLOAT_NODE * PEAK_FLOAT_NODE_HANDLE
Definition peak_backend.h:445
PEAK_DEVICE_LIST_CHANGED_CALLBACK * PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:574
int32_t PEAK_NODE_CACHE_USE_POLICY
Definition peak_backend.h:242
struct PEAK_FIRMWARE_UPDATER * PEAK_FIRMWARE_UPDATER_HANDLE
Definition peak_backend.h:493
int32_t PEAK_FIRMWARE_UPDATE_VERSION_STYLE
Definition peak_backend.h:214
int32_t PEAK_ACQUISITION_START_MODE
Definition peak_backend.h:52
int8_t PEAK_BOOL8
Definition peak_backend.h:43
PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE
Definition peak_backend.h:621
int32_t PEAK_ENDIANNESS
Definition peak_backend.h:172
struct PEAK_NODE_MAP * PEAK_NODE_MAP_HANDLE
Definition peak_backend.h:425
int32_t PEAK_RETURN_CODE
Definition peak_backend.h:355
int32_t PEAK_NODE_CACHING_MODE
Definition peak_backend.h:234
int32_t PEAK_PORT_URL_SCHEME
Definition peak_backend.h:329
struct PEAK_ENUMERATION_ENTRY_NODE * PEAK_ENUMERATION_ENTRY_NODE_HANDLE
Definition peak_backend.h:465
void(PEAK_CALL_CONV * PEAK_DEVICE_LIST_CHANGED_CALLBACK)(void *context)
Definition peak_backend.h:564
int32_t PEAK_ACQUISITION_STOP_MODE
Definition peak_backend.h:62
void(PEAK_CALL_CONV * PEAK_DEVICE_RECONNECTED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE reconnectedDevice, PEAK_DEVICE_RECONNECT_INFORMATION reconnectInformation, void *context)
Definition peak_backend.h:555
void(PEAK_CALL_CONV * PEAK_DEVICE_FOUND_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void *context)
Definition peak_backend.h:552
struct PEAK_CATEGORY_NODE * PEAK_CATEGORY_NODE_HANDLE
Definition peak_backend.h:457
struct PEAK_REGISTER_NODE * PEAK_REGISTER_NODE_HANDLE
Definition peak_backend.h:453
int32_t PEAK_PIXEL_FORMAT_NAMESPACE
Definition peak_backend.h:318
int32_t PEAK_DATA_STREAM_FLUSH_MODE
Definition peak_backend.h:120
void(PEAK_CALL_CONV * PEAK_INTERFACE_LOST_CALLBACK)(const char *lostInterfaceId, size_t lostInterfaceIdSize, void *context)
Definition peak_backend.h:508
PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE
Definition peak_backend.h:601
int32_t PEAK_DEVICE_INFORMATION_ROLE
Definition peak_backend.h:163
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, void *context)
Definition peak_backend.h:609
int32_t PEAK_DEVICE_ACCESS_TYPE
Definition peak_backend.h:145
int32_t PEAK_NODE_NAMESPACE
Definition peak_backend.h:268
struct PEAK_FILE_ADAPTER * PEAK_FILE_ADAPTER_HANDLE
Definition peak_backend.h:489
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:592
struct PEAK_DEVICE_DESCRIPTOR * PEAK_DEVICE_DESCRIPTOR_HANDLE
Definition peak_backend.h:385
int32_t PEAK_CHARACTER_ENCODING
Definition peak_backend.h:107
int32_t PEAK_BUFFER_PAYLOAD_TYPE
Definition peak_backend.h:99
void(PEAK_CALL_CONV * PEAK_INTERFACE_FOUND_CALLBACK)(PEAK_INTERFACE_DESCRIPTOR_HANDLE foundInterface, void *context)
Definition peak_backend.h:505
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK)(const char *errorDescription, size_t errorDescriptionSize, void *context)
Definition peak_backend.h:618
int32_t PEAK_NODE_VISIBILITY
Definition peak_backend.h:306
void(PEAK_CALL_CONV * PEAK_DEVICE_LOST_CALLBACK)(const char *lostDeviceId, size_t lostDeviceIdSize, void *context)
Definition peak_backend.h:558
struct PEAK_BOOLEAN_NODE * PEAK_BOOLEAN_NODE_HANDLE
Definition peak_backend.h:437
struct PEAK_INTEGER_NODE * PEAK_INTEGER_NODE_HANDLE
Definition peak_backend.h:433
int32_t PEAK_NODE_DISPLAY_NOTATION
Definition peak_backend.h:251
PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE
Definition peak_backend.h:612
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:598
struct PEAK_DEVICE * PEAK_DEVICE_HANDLE
Definition peak_backend.h:389
PEAK_INTERFACE_FOUND_CALLBACK * PEAK_INTERFACE_FOUND_CALLBACK_HANDLE
Definition peak_backend.h:513
int32_t PEAK_DEVICE_ACCESS_STATUS
Definition peak_backend.h:134
