459 return dynamicLoader;
461 bool loadLib(
const char* file);
463 bool setPointers(
bool load);
884 void* m_handle =
nullptr;
1303 return dlsym(module, proc_name);
1305 return reinterpret_cast<void*
>(GetProcAddress(
static_cast<HMODULE
>(module), proc_name));
1309inline DynamicLoader::DynamicLoader()
1311#if defined _WIN32 || defined _WIN64
1313 if (_wgetenv_s(&sz, NULL, 0, L
"IDS_PEAK_GENERIC_SDK_PATH") == 0
1316 std::vector<wchar_t> env_ids_peak(sz);
1317 if (_wgetenv_s(&sz, env_ids_peak.data(), sz, L
"IDS_PEAK_GENERIC_SDK_PATH") == 0)
1319 if (_wgetenv_s(&sz, NULL, 0, L
"PATH") == 0
1322 std::vector<wchar_t> env_path(sz);
1323 if (_wgetenv_s(&sz, env_path.data(), sz, L
"PATH") == 0)
1325 std::wstring ids_peak_path(env_ids_peak.data());
1327 ids_peak_path.append(L
"\\api\\lib\\x86_64");
1329 ids_peak_path.append(L
"\\api\\lib\\x86_32");
1331 AddDllDirectory(ids_peak_path.c_str());
1337 loadLib(
"ids_peak.dll");
1339 loadLib(
"libids_peak.so");
1345 if(m_handle !=
nullptr)
1353 auto&& inst = instance();
1354 return inst.m_handle !=
nullptr;
1357inline void DynamicLoader::unload()
1361 if (m_handle !=
nullptr)
1366 FreeLibrary(
static_cast<HMODULE
>(m_handle));
1373inline bool DynamicLoader::loadLib(
const char* file)
1380 m_handle = dlopen(file, RTLD_NOW);
1382 m_handle = LoadLibraryExA(file,
nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
1384 if (m_handle !=
nullptr)
1389 }
catch (
const std::exception&) {
1396 throw std::runtime_error(std::string(
"Lib load failed: ") + file);
1401 throw std::runtime_error(
"Filename empty");
1407inline bool DynamicLoader::setPointers(
bool load)
1411 if(m_PEAK_Library_Initialize ==
nullptr && load)
1413 throw std::runtime_error(
"Failed to load PEAK_Library_Initialize");
1417 if(m_PEAK_Library_Close ==
nullptr && load)
1419 throw std::runtime_error(
"Failed to load PEAK_Library_Close");
1423 if(m_PEAK_Library_IsInitialized ==
nullptr && load)
1425 throw std::runtime_error(
"Failed to load PEAK_Library_IsInitialized");
1429 if(m_PEAK_Library_GetVersionMajor ==
nullptr && load)
1431 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionMajor");
1435 if(m_PEAK_Library_GetVersionMinor ==
nullptr && load)
1437 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionMinor");
1441 if(m_PEAK_Library_GetVersionSubminor ==
nullptr && load)
1443 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionSubminor");
1447 if(m_PEAK_Library_GetLastError ==
nullptr && load)
1449 throw std::runtime_error(
"Failed to load PEAK_Library_GetLastError");
1453 if(m_PEAK_EnvironmentInspector_UpdateCTIPaths ==
nullptr && load)
1455 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_UpdateCTIPaths");
1459 if(m_PEAK_EnvironmentInspector_GetNumCTIPaths ==
nullptr && load)
1461 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_GetNumCTIPaths");
1465 if(m_PEAK_EnvironmentInspector_GetCTIPath ==
nullptr && load)
1467 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_GetCTIPath");
1471 if(m_PEAK_ProducerLibrary_Construct ==
nullptr && load)
1473 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_Construct");
1477 if(m_PEAK_ProducerLibrary_GetKey ==
nullptr && load)
1479 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_GetKey");
1483 if(m_PEAK_ProducerLibrary_GetSystem ==
nullptr && load)
1485 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_GetSystem");
1489 if(m_PEAK_ProducerLibrary_Destruct ==
nullptr && load)
1491 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_Destruct");
1495 if(m_PEAK_SystemDescriptor_ToModuleDescriptor ==
nullptr && load)
1497 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_ToModuleDescriptor");
1501 if(m_PEAK_SystemDescriptor_GetKey ==
nullptr && load)
1503 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetKey");
1507 if(m_PEAK_SystemDescriptor_GetInfo ==
nullptr && load)
1509 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetInfo");
1513 if(m_PEAK_SystemDescriptor_GetDisplayName ==
nullptr && load)
1515 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetDisplayName");
1519 if(m_PEAK_SystemDescriptor_GetVendorName ==
nullptr && load)
1521 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetVendorName");
1525 if(m_PEAK_SystemDescriptor_GetModelName ==
nullptr && load)
1527 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetModelName");
1531 if(m_PEAK_SystemDescriptor_GetVersion ==
nullptr && load)
1533 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetVersion");
1537 if(m_PEAK_SystemDescriptor_GetTLType ==
nullptr && load)
1539 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetTLType");
1543 if(m_PEAK_SystemDescriptor_GetCTIFileName ==
nullptr && load)
1545 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCTIFileName");
1549 if(m_PEAK_SystemDescriptor_GetCTIFullPath ==
nullptr && load)
1551 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCTIFullPath");
1555 if(m_PEAK_SystemDescriptor_GetGenTLVersionMajor ==
nullptr && load)
1557 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetGenTLVersionMajor");
1561 if(m_PEAK_SystemDescriptor_GetGenTLVersionMinor ==
nullptr && load)
1563 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetGenTLVersionMinor");
1567 if(m_PEAK_SystemDescriptor_GetCharacterEncoding ==
nullptr && load)
1569 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCharacterEncoding");
1573 if(m_PEAK_SystemDescriptor_GetParentLibrary ==
nullptr && load)
1575 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetParentLibrary");
1579 if(m_PEAK_SystemDescriptor_OpenSystem ==
nullptr && load)
1581 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_OpenSystem");
1585 if(m_PEAK_System_ToModule ==
nullptr && load)
1587 throw std::runtime_error(
"Failed to load PEAK_System_ToModule");
1591 if(m_PEAK_System_ToEventSupportingModule ==
nullptr && load)
1593 throw std::runtime_error(
"Failed to load PEAK_System_ToEventSupportingModule");
1597 if(m_PEAK_System_GetKey ==
nullptr && load)
1599 throw std::runtime_error(
"Failed to load PEAK_System_GetKey");
1603 if(m_PEAK_System_GetInfo ==
nullptr && load)
1605 throw std::runtime_error(
"Failed to load PEAK_System_GetInfo");
1609 if(m_PEAK_System_GetID ==
nullptr && load)
1611 throw std::runtime_error(
"Failed to load PEAK_System_GetID");
1615 if(m_PEAK_System_GetDisplayName ==
nullptr && load)
1617 throw std::runtime_error(
"Failed to load PEAK_System_GetDisplayName");
1621 if(m_PEAK_System_GetVendorName ==
nullptr && load)
1623 throw std::runtime_error(
"Failed to load PEAK_System_GetVendorName");
1627 if(m_PEAK_System_GetModelName ==
nullptr && load)
1629 throw std::runtime_error(
"Failed to load PEAK_System_GetModelName");
1633 if(m_PEAK_System_GetVersion ==
nullptr && load)
1635 throw std::runtime_error(
"Failed to load PEAK_System_GetVersion");
1639 if(m_PEAK_System_GetTLType ==
nullptr && load)
1641 throw std::runtime_error(
"Failed to load PEAK_System_GetTLType");
1645 if(m_PEAK_System_GetCTIFileName ==
nullptr && load)
1647 throw std::runtime_error(
"Failed to load PEAK_System_GetCTIFileName");
1651 if(m_PEAK_System_GetCTIFullPath ==
nullptr && load)
1653 throw std::runtime_error(
"Failed to load PEAK_System_GetCTIFullPath");
1657 if(m_PEAK_System_GetGenTLVersionMajor ==
nullptr && load)
1659 throw std::runtime_error(
"Failed to load PEAK_System_GetGenTLVersionMajor");
1663 if(m_PEAK_System_GetGenTLVersionMinor ==
nullptr && load)
1665 throw std::runtime_error(
"Failed to load PEAK_System_GetGenTLVersionMinor");
1669 if(m_PEAK_System_GetCharacterEncoding ==
nullptr && load)
1671 throw std::runtime_error(
"Failed to load PEAK_System_GetCharacterEncoding");
1675 if(m_PEAK_System_GetParentLibrary ==
nullptr && load)
1677 throw std::runtime_error(
"Failed to load PEAK_System_GetParentLibrary");
1681 if(m_PEAK_System_UpdateInterfaces ==
nullptr && load)
1683 throw std::runtime_error(
"Failed to load PEAK_System_UpdateInterfaces");
1687 if(m_PEAK_System_GetNumInterfaces ==
nullptr && load)
1689 throw std::runtime_error(
"Failed to load PEAK_System_GetNumInterfaces");
1693 if(m_PEAK_System_GetInterface ==
nullptr && load)
1695 throw std::runtime_error(
"Failed to load PEAK_System_GetInterface");
1699 if(m_PEAK_System_RegisterInterfaceFoundCallback ==
nullptr && load)
1701 throw std::runtime_error(
"Failed to load PEAK_System_RegisterInterfaceFoundCallback");
1705 if(m_PEAK_System_UnregisterInterfaceFoundCallback ==
nullptr && load)
1707 throw std::runtime_error(
"Failed to load PEAK_System_UnregisterInterfaceFoundCallback");
1711 if(m_PEAK_System_RegisterInterfaceLostCallback ==
nullptr && load)
1713 throw std::runtime_error(
"Failed to load PEAK_System_RegisterInterfaceLostCallback");
1717 if(m_PEAK_System_UnregisterInterfaceLostCallback ==
nullptr && load)
1719 throw std::runtime_error(
"Failed to load PEAK_System_UnregisterInterfaceLostCallback");
1723 if(m_PEAK_System_Destruct ==
nullptr && load)
1725 throw std::runtime_error(
"Failed to load PEAK_System_Destruct");
1729 if(m_PEAK_InterfaceDescriptor_ToModuleDescriptor ==
nullptr && load)
1731 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_ToModuleDescriptor");
1735 if(m_PEAK_InterfaceDescriptor_GetKey ==
nullptr && load)
1737 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetKey");
1741 if(m_PEAK_InterfaceDescriptor_GetInfo ==
nullptr && load)
1743 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetInfo");
1747 if(m_PEAK_InterfaceDescriptor_GetDisplayName ==
nullptr && load)
1749 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetDisplayName");
1753 if(m_PEAK_InterfaceDescriptor_GetTLType ==
nullptr && load)
1755 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetTLType");
1759 if(m_PEAK_InterfaceDescriptor_GetParentSystem ==
nullptr && load)
1761 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetParentSystem");
1765 if(m_PEAK_InterfaceDescriptor_OpenInterface ==
nullptr && load)
1767 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_OpenInterface");
1771 if(m_PEAK_Interface_ToModule ==
nullptr && load)
1773 throw std::runtime_error(
"Failed to load PEAK_Interface_ToModule");
1777 if(m_PEAK_Interface_ToEventSupportingModule ==
nullptr && load)
1779 throw std::runtime_error(
"Failed to load PEAK_Interface_ToEventSupportingModule");
1783 if(m_PEAK_Interface_GetKey ==
nullptr && load)
1785 throw std::runtime_error(
"Failed to load PEAK_Interface_GetKey");
1789 if(m_PEAK_Interface_GetInfo ==
nullptr && load)
1791 throw std::runtime_error(
"Failed to load PEAK_Interface_GetInfo");
1795 if(m_PEAK_Interface_GetID ==
nullptr && load)
1797 throw std::runtime_error(
"Failed to load PEAK_Interface_GetID");
1801 if(m_PEAK_Interface_GetDisplayName ==
nullptr && load)
1803 throw std::runtime_error(
"Failed to load PEAK_Interface_GetDisplayName");
1807 if(m_PEAK_Interface_GetTLType ==
nullptr && load)
1809 throw std::runtime_error(
"Failed to load PEAK_Interface_GetTLType");
1813 if(m_PEAK_Interface_GetParentSystem ==
nullptr && load)
1815 throw std::runtime_error(
"Failed to load PEAK_Interface_GetParentSystem");
1819 if(m_PEAK_Interface_UpdateDevices ==
nullptr && load)
1821 throw std::runtime_error(
"Failed to load PEAK_Interface_UpdateDevices");
1825 if(m_PEAK_Interface_GetNumDevices ==
nullptr && load)
1827 throw std::runtime_error(
"Failed to load PEAK_Interface_GetNumDevices");
1831 if(m_PEAK_Interface_GetDevice ==
nullptr && load)
1833 throw std::runtime_error(
"Failed to load PEAK_Interface_GetDevice");
1837 if(m_PEAK_Interface_RegisterDeviceFoundCallback ==
nullptr && load)
1839 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceFoundCallback");
1843 if(m_PEAK_Interface_UnregisterDeviceFoundCallback ==
nullptr && load)
1845 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceFoundCallback");
1849 if(m_PEAK_Interface_RegisterDeviceReconnectedCallback ==
nullptr && load)
1851 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceReconnectedCallback");
1855 if(m_PEAK_Interface_UnregisterDeviceReconnectedCallback ==
nullptr && load)
1857 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceReconnectedCallback");
1861 if(m_PEAK_Interface_RegisterDeviceDisconnectedCallback ==
nullptr && load)
1863 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceDisconnectedCallback");
1867 if(m_PEAK_Interface_UnregisterDeviceDisconnectedCallback ==
nullptr && load)
1869 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceDisconnectedCallback");
1873 if(m_PEAK_Interface_RegisterDeviceLostCallback ==
nullptr && load)
1875 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceLostCallback");
1879 if(m_PEAK_Interface_UnregisterDeviceLostCallback ==
nullptr && load)
1881 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceLostCallback");
1885 if(m_PEAK_Interface_RegisterDeviceListChangedCallback ==
nullptr && load)
1887 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceListChangedCallback");
1891 if(m_PEAK_Interface_UnregisterDeviceListChangedCallback ==
nullptr && load)
1893 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceListChangedCallback");
1897 if(m_PEAK_Interface_Destruct ==
nullptr && load)
1899 throw std::runtime_error(
"Failed to load PEAK_Interface_Destruct");
1903 if(m_PEAK_DeviceDescriptor_ToModuleDescriptor ==
nullptr && load)
1905 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_ToModuleDescriptor");
1909 if(m_PEAK_DeviceDescriptor_GetKey ==
nullptr && load)
1911 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetKey");
1915 if(m_PEAK_DeviceDescriptor_GetInfo ==
nullptr && load)
1917 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetInfo");
1921 if(m_PEAK_DeviceDescriptor_GetDisplayName ==
nullptr && load)
1923 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetDisplayName");
1927 if(m_PEAK_DeviceDescriptor_GetVendorName ==
nullptr && load)
1929 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetVendorName");
1933 if(m_PEAK_DeviceDescriptor_GetModelName ==
nullptr && load)
1935 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetModelName");
1939 if(m_PEAK_DeviceDescriptor_GetVersion ==
nullptr && load)
1941 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetVersion");
1945 if(m_PEAK_DeviceDescriptor_GetTLType ==
nullptr && load)
1947 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetTLType");
1951 if(m_PEAK_DeviceDescriptor_GetUserDefinedName ==
nullptr && load)
1953 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetUserDefinedName");
1957 if(m_PEAK_DeviceDescriptor_GetSerialNumber ==
nullptr && load)
1959 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetSerialNumber");
1963 if(m_PEAK_DeviceDescriptor_GetAccessStatus ==
nullptr && load)
1965 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetAccessStatus");
1969 if(m_PEAK_DeviceDescriptor_GetTimestampTickFrequency ==
nullptr && load)
1971 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetTimestampTickFrequency");
1975 if(m_PEAK_DeviceDescriptor_GetIsOpenableExclusive ==
nullptr && load)
1977 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetIsOpenableExclusive");
1981 if(m_PEAK_DeviceDescriptor_GetIsOpenable ==
nullptr && load)
1983 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetIsOpenable");
1987 if(m_PEAK_DeviceDescriptor_OpenDevice ==
nullptr && load)
1989 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_OpenDevice");
1993 if(m_PEAK_DeviceDescriptor_GetParentInterface ==
nullptr && load)
1995 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetParentInterface");
1999 if(m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval ==
nullptr && load)
2001 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetMonitoringUpdateInterval");
2005 if(m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval ==
nullptr && load)
2007 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_SetMonitoringUpdateInterval");
2011 if(m_PEAK_DeviceDescriptor_IsInformationRoleMonitored ==
nullptr && load)
2013 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_IsInformationRoleMonitored");
2017 if(m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring ==
nullptr && load)
2019 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_AddInformationRoleToMonitoring");
2023 if(m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring ==
nullptr && load)
2025 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring");
2029 if(m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback ==
nullptr && load)
2031 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_RegisterInformationChangedCallback");
2035 if(m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback ==
nullptr && load)
2037 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_UnregisterInformationChangedCallback");
2041 if(m_PEAK_Device_ToModule ==
nullptr && load)
2043 throw std::runtime_error(
"Failed to load PEAK_Device_ToModule");
2047 if(m_PEAK_Device_ToEventSupportingModule ==
nullptr && load)
2049 throw std::runtime_error(
"Failed to load PEAK_Device_ToEventSupportingModule");
2053 if(m_PEAK_Device_GetKey ==
nullptr && load)
2055 throw std::runtime_error(
"Failed to load PEAK_Device_GetKey");
2059 if(m_PEAK_Device_GetInfo ==
nullptr && load)
2061 throw std::runtime_error(
"Failed to load PEAK_Device_GetInfo");
2065 if(m_PEAK_Device_GetID ==
nullptr && load)
2067 throw std::runtime_error(
"Failed to load PEAK_Device_GetID");
2071 if(m_PEAK_Device_GetDisplayName ==
nullptr && load)
2073 throw std::runtime_error(
"Failed to load PEAK_Device_GetDisplayName");
2077 if(m_PEAK_Device_GetVendorName ==
nullptr && load)
2079 throw std::runtime_error(
"Failed to load PEAK_Device_GetVendorName");
2083 if(m_PEAK_Device_GetModelName ==
nullptr && load)
2085 throw std::runtime_error(
"Failed to load PEAK_Device_GetModelName");
2089 if(m_PEAK_Device_GetVersion ==
nullptr && load)
2091 throw std::runtime_error(
"Failed to load PEAK_Device_GetVersion");
2095 if(m_PEAK_Device_GetTLType ==
nullptr && load)
2097 throw std::runtime_error(
"Failed to load PEAK_Device_GetTLType");
2101 if(m_PEAK_Device_GetUserDefinedName ==
nullptr && load)
2103 throw std::runtime_error(
"Failed to load PEAK_Device_GetUserDefinedName");
2107 if(m_PEAK_Device_GetSerialNumber ==
nullptr && load)
2109 throw std::runtime_error(
"Failed to load PEAK_Device_GetSerialNumber");
2113 if(m_PEAK_Device_GetAccessStatus ==
nullptr && load)
2115 throw std::runtime_error(
"Failed to load PEAK_Device_GetAccessStatus");
2119 if(m_PEAK_Device_GetTimestampTickFrequency ==
nullptr && load)
2121 throw std::runtime_error(
"Failed to load PEAK_Device_GetTimestampTickFrequency");
2125 if(m_PEAK_Device_GetParentInterface ==
nullptr && load)
2127 throw std::runtime_error(
"Failed to load PEAK_Device_GetParentInterface");
2131 if(m_PEAK_Device_GetRemoteDevice ==
nullptr && load)
2133 throw std::runtime_error(
"Failed to load PEAK_Device_GetRemoteDevice");
2137 if(m_PEAK_Device_GetNumDataStreams ==
nullptr && load)
2139 throw std::runtime_error(
"Failed to load PEAK_Device_GetNumDataStreams");
2143 if(m_PEAK_Device_GetDataStream ==
nullptr && load)
2145 throw std::runtime_error(
"Failed to load PEAK_Device_GetDataStream");
2149 if(m_PEAK_Device_Destruct ==
nullptr && load)
2151 throw std::runtime_error(
"Failed to load PEAK_Device_Destruct");
2155 if(m_PEAK_RemoteDevice_ToModule ==
nullptr && load)
2157 throw std::runtime_error(
"Failed to load PEAK_RemoteDevice_ToModule");
2161 if(m_PEAK_RemoteDevice_GetLocalDevice ==
nullptr && load)
2163 throw std::runtime_error(
"Failed to load PEAK_RemoteDevice_GetLocalDevice");
2167 if(m_PEAK_DataStreamDescriptor_ToModuleDescriptor ==
nullptr && load)
2169 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_ToModuleDescriptor");
2173 if(m_PEAK_DataStreamDescriptor_GetKey ==
nullptr && load)
2175 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_GetKey");
2179 if(m_PEAK_DataStreamDescriptor_GetParentDevice ==
nullptr && load)
2181 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_GetParentDevice");
2185 if(m_PEAK_DataStreamDescriptor_OpenDataStream ==
nullptr && load)
2187 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_OpenDataStream");
2191 if(m_PEAK_DataStream_ToModule ==
nullptr && load)
2193 throw std::runtime_error(
"Failed to load PEAK_DataStream_ToModule");
2197 if(m_PEAK_DataStream_ToEventSupportingModule ==
nullptr && load)
2199 throw std::runtime_error(
"Failed to load PEAK_DataStream_ToEventSupportingModule");
2203 if(m_PEAK_DataStream_GetKey ==
nullptr && load)
2205 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetKey");
2209 if(m_PEAK_DataStream_GetInfo ==
nullptr && load)
2211 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetInfo");
2215 if(m_PEAK_DataStream_GetID ==
nullptr && load)
2217 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetID");
2221 if(m_PEAK_DataStream_GetTLType ==
nullptr && load)
2223 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetTLType");
2227 if(m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired ==
nullptr && load)
2229 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAnnouncedMinRequired");
2233 if(m_PEAK_DataStream_GetNumBuffersAnnounced ==
nullptr && load)
2235 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAnnounced");
2239 if(m_PEAK_DataStream_GetNumBuffersQueued ==
nullptr && load)
2241 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersQueued");
2245 if(m_PEAK_DataStream_GetNumBuffersAwaitDelivery ==
nullptr && load)
2247 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAwaitDelivery");
2251 if(m_PEAK_DataStream_GetNumBuffersDelivered ==
nullptr && load)
2253 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersDelivered");
2257 if(m_PEAK_DataStream_GetNumBuffersStarted ==
nullptr && load)
2259 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersStarted");
2263 if(m_PEAK_DataStream_GetNumUnderruns ==
nullptr && load)
2265 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumUnderruns");
2269 if(m_PEAK_DataStream_GetNumChunksPerBufferMax ==
nullptr && load)
2271 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumChunksPerBufferMax");
2275 if(m_PEAK_DataStream_GetBufferAlignment ==
nullptr && load)
2277 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetBufferAlignment");
2281 if(m_PEAK_DataStream_GetPayloadSize ==
nullptr && load)
2283 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetPayloadSize");
2287 if(m_PEAK_DataStream_GetDefinesPayloadSize ==
nullptr && load)
2289 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetDefinesPayloadSize");
2293 if(m_PEAK_DataStream_GetIsGrabbing ==
nullptr && load)
2295 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetIsGrabbing");
2299 if(m_PEAK_DataStream_GetParentDevice ==
nullptr && load)
2301 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetParentDevice");
2305 if(m_PEAK_DataStream_AnnounceBuffer ==
nullptr && load)
2307 throw std::runtime_error(
"Failed to load PEAK_DataStream_AnnounceBuffer");
2311 if(m_PEAK_DataStream_AllocAndAnnounceBuffer ==
nullptr && load)
2313 throw std::runtime_error(
"Failed to load PEAK_DataStream_AllocAndAnnounceBuffer");
2317 if(m_PEAK_DataStream_QueueBuffer ==
nullptr && load)
2319 throw std::runtime_error(
"Failed to load PEAK_DataStream_QueueBuffer");
2323 if(m_PEAK_DataStream_RevokeBuffer ==
nullptr && load)
2325 throw std::runtime_error(
"Failed to load PEAK_DataStream_RevokeBuffer");
2329 if(m_PEAK_DataStream_WaitForFinishedBuffer ==
nullptr && load)
2331 throw std::runtime_error(
"Failed to load PEAK_DataStream_WaitForFinishedBuffer");
2335 if(m_PEAK_DataStream_KillWait ==
nullptr && load)
2337 throw std::runtime_error(
"Failed to load PEAK_DataStream_KillWait");
2341 if(m_PEAK_DataStream_Flush ==
nullptr && load)
2343 throw std::runtime_error(
"Failed to load PEAK_DataStream_Flush");
2347 if(m_PEAK_DataStream_StartAcquisitionInfinite ==
nullptr && load)
2349 throw std::runtime_error(
"Failed to load PEAK_DataStream_StartAcquisitionInfinite");
2353 if(m_PEAK_DataStream_StartAcquisition ==
nullptr && load)
2355 throw std::runtime_error(
"Failed to load PEAK_DataStream_StartAcquisition");
2359 if(m_PEAK_DataStream_StopAcquisition ==
nullptr && load)
2361 throw std::runtime_error(
"Failed to load PEAK_DataStream_StopAcquisition");
2365 if(m_PEAK_DataStream_Destruct ==
nullptr && load)
2367 throw std::runtime_error(
"Failed to load PEAK_DataStream_Destruct");
2371 if(m_PEAK_Buffer_ToModule ==
nullptr && load)
2373 throw std::runtime_error(
"Failed to load PEAK_Buffer_ToModule");
2377 if(m_PEAK_Buffer_ToEventSupportingModule ==
nullptr && load)
2379 throw std::runtime_error(
"Failed to load PEAK_Buffer_ToEventSupportingModule");
2383 if(m_PEAK_Buffer_GetInfo ==
nullptr && load)
2385 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetInfo");
2389 if(m_PEAK_Buffer_GetTLType ==
nullptr && load)
2391 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTLType");
2395 if(m_PEAK_Buffer_GetBasePtr ==
nullptr && load)
2397 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetBasePtr");
2401 if(m_PEAK_Buffer_GetSize ==
nullptr && load)
2403 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetSize");
2407 if(m_PEAK_Buffer_GetUserPtr ==
nullptr && load)
2409 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetUserPtr");
2413 if(m_PEAK_Buffer_GetPayloadType ==
nullptr && load)
2415 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPayloadType");
2419 if(m_PEAK_Buffer_GetPixelFormat ==
nullptr && load)
2421 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelFormat");
2425 if(m_PEAK_Buffer_GetPixelFormatNamespace ==
nullptr && load)
2427 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelFormatNamespace");
2431 if(m_PEAK_Buffer_GetPixelEndianness ==
nullptr && load)
2433 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelEndianness");
2437 if(m_PEAK_Buffer_GetExpectedDataSize ==
nullptr && load)
2439 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetExpectedDataSize");
2443 if(m_PEAK_Buffer_GetDeliveredDataSize ==
nullptr && load)
2445 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredDataSize");
2449 if(m_PEAK_Buffer_GetFrameID ==
nullptr && load)
2451 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetFrameID");
2455 if(m_PEAK_Buffer_GetImageOffset ==
nullptr && load)
2457 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetImageOffset");
2461 if(m_PEAK_Buffer_GetDeliveredImageHeight ==
nullptr && load)
2463 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredImageHeight");
2467 if(m_PEAK_Buffer_GetDeliveredChunkPayloadSize ==
nullptr && load)
2469 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredChunkPayloadSize");
2473 if(m_PEAK_Buffer_GetChunkLayoutID ==
nullptr && load)
2475 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetChunkLayoutID");
2479 if(m_PEAK_Buffer_GetFileName ==
nullptr && load)
2481 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetFileName");
2485 if(m_PEAK_Buffer_GetWidth ==
nullptr && load)
2487 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetWidth");
2491 if(m_PEAK_Buffer_GetHeight ==
nullptr && load)
2493 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHeight");
2497 if(m_PEAK_Buffer_GetXOffset ==
nullptr && load)
2499 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetXOffset");
2503 if(m_PEAK_Buffer_GetYOffset ==
nullptr && load)
2505 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetYOffset");
2509 if(m_PEAK_Buffer_GetXPadding ==
nullptr && load)
2511 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetXPadding");
2515 if(m_PEAK_Buffer_GetYPadding ==
nullptr && load)
2517 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetYPadding");
2521 if(m_PEAK_Buffer_GetTimestamp_ticks ==
nullptr && load)
2523 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTimestamp_ticks");
2527 if(m_PEAK_Buffer_GetTimestamp_ns ==
nullptr && load)
2529 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTimestamp_ns");
2533 if(m_PEAK_Buffer_GetIsQueued ==
nullptr && load)
2535 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsQueued");
2539 if(m_PEAK_Buffer_GetIsAcquiring ==
nullptr && load)
2541 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsAcquiring");
2545 if(m_PEAK_Buffer_GetIsIncomplete ==
nullptr && load)
2547 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsIncomplete");
2551 if(m_PEAK_Buffer_GetHasNewData ==
nullptr && load)
2553 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasNewData");
2557 if(m_PEAK_Buffer_GetHasImage ==
nullptr && load)
2559 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasImage");
2563 if(m_PEAK_Buffer_GetHasChunks ==
nullptr && load)
2565 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasChunks");
2569 if(m_PEAK_Buffer_GetHasParts ==
nullptr && load)
2571 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasParts");
2575 if(m_PEAK_Buffer_UpdateChunks ==
nullptr && load)
2577 throw std::runtime_error(
"Failed to load PEAK_Buffer_UpdateChunks");
2581 if(m_PEAK_Buffer_GetNumChunks ==
nullptr && load)
2583 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetNumChunks");
2587 if(m_PEAK_Buffer_GetChunk ==
nullptr && load)
2589 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetChunk");
2593 if(m_PEAK_Buffer_UpdateParts ==
nullptr && load)
2595 throw std::runtime_error(
"Failed to load PEAK_Buffer_UpdateParts");
2599 if(m_PEAK_Buffer_GetNumParts ==
nullptr && load)
2601 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetNumParts");
2605 if(m_PEAK_Buffer_GetPart ==
nullptr && load)
2607 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPart");
2611 if(m_PEAK_BufferChunk_GetID ==
nullptr && load)
2613 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetID");
2617 if(m_PEAK_BufferChunk_GetBasePtr ==
nullptr && load)
2619 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetBasePtr");
2623 if(m_PEAK_BufferChunk_GetSize ==
nullptr && load)
2625 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetSize");
2629 if(m_PEAK_BufferChunk_GetParentBuffer ==
nullptr && load)
2631 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetParentBuffer");
2635 if(m_PEAK_BufferChunk_Destruct ==
nullptr && load)
2637 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_Destruct");
2641 if(m_PEAK_BufferPart_GetInfo ==
nullptr && load)
2643 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetInfo");
2647 if(m_PEAK_BufferPart_GetSourceID ==
nullptr && load)
2649 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetSourceID");
2653 if(m_PEAK_BufferPart_GetBasePtr ==
nullptr && load)
2655 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetBasePtr");
2659 if(m_PEAK_BufferPart_GetSize ==
nullptr && load)
2661 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetSize");
2665 if(m_PEAK_BufferPart_GetType ==
nullptr && load)
2667 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetType");
2671 if(m_PEAK_BufferPart_GetFormat ==
nullptr && load)
2673 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetFormat");
2677 if(m_PEAK_BufferPart_GetFormatNamespace ==
nullptr && load)
2679 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetFormatNamespace");
2683 if(m_PEAK_BufferPart_GetWidth ==
nullptr && load)
2685 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetWidth");
2689 if(m_PEAK_BufferPart_GetHeight ==
nullptr && load)
2691 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetHeight");
2695 if(m_PEAK_BufferPart_GetXOffset ==
nullptr && load)
2697 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetXOffset");
2701 if(m_PEAK_BufferPart_GetYOffset ==
nullptr && load)
2703 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetYOffset");
2707 if(m_PEAK_BufferPart_GetXPadding ==
nullptr && load)
2709 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetXPadding");
2713 if(m_PEAK_BufferPart_GetDeliveredImageHeight ==
nullptr && load)
2715 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetDeliveredImageHeight");
2719 if(m_PEAK_BufferPart_GetParentBuffer ==
nullptr && load)
2721 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetParentBuffer");
2725 if(m_PEAK_BufferPart_Destruct ==
nullptr && load)
2727 throw std::runtime_error(
"Failed to load PEAK_BufferPart_Destruct");
2731 if(m_PEAK_ModuleDescriptor_GetID ==
nullptr && load)
2733 throw std::runtime_error(
"Failed to load PEAK_ModuleDescriptor_GetID");
2737 if(m_PEAK_Module_GetNumNodeMaps ==
nullptr && load)
2739 throw std::runtime_error(
"Failed to load PEAK_Module_GetNumNodeMaps");
2743 if(m_PEAK_Module_GetNodeMap ==
nullptr && load)
2745 throw std::runtime_error(
"Failed to load PEAK_Module_GetNodeMap");
2749 if(m_PEAK_Module_GetPort ==
nullptr && load)
2751 throw std::runtime_error(
"Failed to load PEAK_Module_GetPort");
2755 if(m_PEAK_NodeMap_GetHasNode ==
nullptr && load)
2757 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasNode");
2761 if(m_PEAK_NodeMap_FindNode ==
nullptr && load)
2763 throw std::runtime_error(
"Failed to load PEAK_NodeMap_FindNode");
2767 if(m_PEAK_NodeMap_InvalidateNodes ==
nullptr && load)
2769 throw std::runtime_error(
"Failed to load PEAK_NodeMap_InvalidateNodes");
2773 if(m_PEAK_NodeMap_PollNodes ==
nullptr && load)
2775 throw std::runtime_error(
"Failed to load PEAK_NodeMap_PollNodes");
2779 if(m_PEAK_NodeMap_GetNumNodes ==
nullptr && load)
2781 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetNumNodes");
2785 if(m_PEAK_NodeMap_GetNode ==
nullptr && load)
2787 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetNode");
2791 if(m_PEAK_NodeMap_GetHasBufferSupportedChunks ==
nullptr && load)
2793 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasBufferSupportedChunks");
2797 if(m_PEAK_NodeMap_UpdateChunkNodes ==
nullptr && load)
2799 throw std::runtime_error(
"Failed to load PEAK_NodeMap_UpdateChunkNodes");
2803 if(m_PEAK_NodeMap_GetHasEventSupportedData ==
nullptr && load)
2805 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasEventSupportedData");
2809 if(m_PEAK_NodeMap_UpdateEventNodes ==
nullptr && load)
2811 throw std::runtime_error(
"Failed to load PEAK_NodeMap_UpdateEventNodes");
2815 if(m_PEAK_NodeMap_StoreToFile ==
nullptr && load)
2817 throw std::runtime_error(
"Failed to load PEAK_NodeMap_StoreToFile");
2821 if(m_PEAK_NodeMap_LoadFromFile ==
nullptr && load)
2823 throw std::runtime_error(
"Failed to load PEAK_NodeMap_LoadFromFile");
2827 if(m_PEAK_NodeMap_Lock ==
nullptr && load)
2829 throw std::runtime_error(
"Failed to load PEAK_NodeMap_Lock");
2833 if(m_PEAK_NodeMap_Unlock ==
nullptr && load)
2835 throw std::runtime_error(
"Failed to load PEAK_NodeMap_Unlock");
2839 if(m_PEAK_Node_ToIntegerNode ==
nullptr && load)
2841 throw std::runtime_error(
"Failed to load PEAK_Node_ToIntegerNode");
2845 if(m_PEAK_Node_ToBooleanNode ==
nullptr && load)
2847 throw std::runtime_error(
"Failed to load PEAK_Node_ToBooleanNode");
2851 if(m_PEAK_Node_ToCommandNode ==
nullptr && load)
2853 throw std::runtime_error(
"Failed to load PEAK_Node_ToCommandNode");
2857 if(m_PEAK_Node_ToFloatNode ==
nullptr && load)
2859 throw std::runtime_error(
"Failed to load PEAK_Node_ToFloatNode");
2863 if(m_PEAK_Node_ToStringNode ==
nullptr && load)
2865 throw std::runtime_error(
"Failed to load PEAK_Node_ToStringNode");
2869 if(m_PEAK_Node_ToRegisterNode ==
nullptr && load)
2871 throw std::runtime_error(
"Failed to load PEAK_Node_ToRegisterNode");
2875 if(m_PEAK_Node_ToCategoryNode ==
nullptr && load)
2877 throw std::runtime_error(
"Failed to load PEAK_Node_ToCategoryNode");
2881 if(m_PEAK_Node_ToEnumerationNode ==
nullptr && load)
2883 throw std::runtime_error(
"Failed to load PEAK_Node_ToEnumerationNode");
2887 if(m_PEAK_Node_ToEnumerationEntryNode ==
nullptr && load)
2889 throw std::runtime_error(
"Failed to load PEAK_Node_ToEnumerationEntryNode");
2893 if(m_PEAK_Node_GetName ==
nullptr && load)
2895 throw std::runtime_error(
"Failed to load PEAK_Node_GetName");
2899 if(m_PEAK_Node_GetDisplayName ==
nullptr && load)
2901 throw std::runtime_error(
"Failed to load PEAK_Node_GetDisplayName");
2905 if(m_PEAK_Node_GetNamespace ==
nullptr && load)
2907 throw std::runtime_error(
"Failed to load PEAK_Node_GetNamespace");
2911 if(m_PEAK_Node_GetVisibility ==
nullptr && load)
2913 throw std::runtime_error(
"Failed to load PEAK_Node_GetVisibility");
2917 if(m_PEAK_Node_GetAccessStatus ==
nullptr && load)
2919 throw std::runtime_error(
"Failed to load PEAK_Node_GetAccessStatus");
2923 if(m_PEAK_Node_GetIsCacheable ==
nullptr && load)
2925 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsCacheable");
2929 if(m_PEAK_Node_GetIsAccessStatusCacheable ==
nullptr && load)
2931 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsAccessStatusCacheable");
2935 if(m_PEAK_Node_GetIsStreamable ==
nullptr && load)
2937 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsStreamable");
2941 if(m_PEAK_Node_GetIsDeprecated ==
nullptr && load)
2943 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsDeprecated");
2947 if(m_PEAK_Node_GetIsFeature ==
nullptr && load)
2949 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsFeature");
2953 if(m_PEAK_Node_GetCachingMode ==
nullptr && load)
2955 throw std::runtime_error(
"Failed to load PEAK_Node_GetCachingMode");
2959 if(m_PEAK_Node_GetPollingTime ==
nullptr && load)
2961 throw std::runtime_error(
"Failed to load PEAK_Node_GetPollingTime");
2965 if(m_PEAK_Node_GetToolTip ==
nullptr && load)
2967 throw std::runtime_error(
"Failed to load PEAK_Node_GetToolTip");
2971 if(m_PEAK_Node_GetDescription ==
nullptr && load)
2973 throw std::runtime_error(
"Failed to load PEAK_Node_GetDescription");
2977 if(m_PEAK_Node_GetType ==
nullptr && load)
2979 throw std::runtime_error(
"Failed to load PEAK_Node_GetType");
2983 if(m_PEAK_Node_GetParentNodeMap ==
nullptr && load)
2985 throw std::runtime_error(
"Failed to load PEAK_Node_GetParentNodeMap");
2989 if(m_PEAK_Node_FindInvalidatedNode ==
nullptr && load)
2991 throw std::runtime_error(
"Failed to load PEAK_Node_FindInvalidatedNode");
2995 if(m_PEAK_Node_GetNumInvalidatedNodes ==
nullptr && load)
2997 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumInvalidatedNodes");
3001 if(m_PEAK_Node_GetInvalidatedNode ==
nullptr && load)
3003 throw std::runtime_error(
"Failed to load PEAK_Node_GetInvalidatedNode");
3007 if(m_PEAK_Node_FindInvalidatingNode ==
nullptr && load)
3009 throw std::runtime_error(
"Failed to load PEAK_Node_FindInvalidatingNode");
3013 if(m_PEAK_Node_GetNumInvalidatingNodes ==
nullptr && load)
3015 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumInvalidatingNodes");
3019 if(m_PEAK_Node_GetInvalidatingNode ==
nullptr && load)
3021 throw std::runtime_error(
"Failed to load PEAK_Node_GetInvalidatingNode");
3025 if(m_PEAK_Node_FindSelectedNode ==
nullptr && load)
3027 throw std::runtime_error(
"Failed to load PEAK_Node_FindSelectedNode");
3031 if(m_PEAK_Node_GetNumSelectedNodes ==
nullptr && load)
3033 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumSelectedNodes");
3037 if(m_PEAK_Node_GetSelectedNode ==
nullptr && load)
3039 throw std::runtime_error(
"Failed to load PEAK_Node_GetSelectedNode");
3043 if(m_PEAK_Node_FindSelectingNode ==
nullptr && load)
3045 throw std::runtime_error(
"Failed to load PEAK_Node_FindSelectingNode");
3049 if(m_PEAK_Node_GetNumSelectingNodes ==
nullptr && load)
3051 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumSelectingNodes");
3055 if(m_PEAK_Node_GetSelectingNode ==
nullptr && load)
3057 throw std::runtime_error(
"Failed to load PEAK_Node_GetSelectingNode");
3061 if(m_PEAK_Node_RegisterChangedCallback ==
nullptr && load)
3063 throw std::runtime_error(
"Failed to load PEAK_Node_RegisterChangedCallback");
3067 if(m_PEAK_Node_UnregisterChangedCallback ==
nullptr && load)
3069 throw std::runtime_error(
"Failed to load PEAK_Node_UnregisterChangedCallback");
3073 if(m_PEAK_IntegerNode_ToNode ==
nullptr && load)
3075 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_ToNode");
3079 if(m_PEAK_IntegerNode_GetMinimum ==
nullptr && load)
3081 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetMinimum");
3085 if(m_PEAK_IntegerNode_GetMaximum ==
nullptr && load)
3087 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetMaximum");
3091 if(m_PEAK_IntegerNode_GetIncrement ==
nullptr && load)
3093 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetIncrement");
3097 if(m_PEAK_IntegerNode_GetIncrementType ==
nullptr && load)
3099 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetIncrementType");
3103 if(m_PEAK_IntegerNode_GetValidValues ==
nullptr && load)
3105 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetValidValues");
3109 if(m_PEAK_IntegerNode_GetRepresentation ==
nullptr && load)
3111 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetRepresentation");
3115 if(m_PEAK_IntegerNode_GetUnit ==
nullptr && load)
3117 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetUnit");
3121 if(m_PEAK_IntegerNode_GetValue ==
nullptr && load)
3123 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetValue");
3127 if(m_PEAK_IntegerNode_SetValue ==
nullptr && load)
3129 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_SetValue");
3133 if(m_PEAK_BooleanNode_ToNode ==
nullptr && load)
3135 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_ToNode");
3139 if(m_PEAK_BooleanNode_GetValue ==
nullptr && load)
3141 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_GetValue");
3145 if(m_PEAK_BooleanNode_SetValue ==
nullptr && load)
3147 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_SetValue");
3151 if(m_PEAK_CommandNode_ToNode ==
nullptr && load)
3153 throw std::runtime_error(
"Failed to load PEAK_CommandNode_ToNode");
3157 if(m_PEAK_CommandNode_GetIsDone ==
nullptr && load)
3159 throw std::runtime_error(
"Failed to load PEAK_CommandNode_GetIsDone");
3163 if(m_PEAK_CommandNode_Execute ==
nullptr && load)
3165 throw std::runtime_error(
"Failed to load PEAK_CommandNode_Execute");
3169 if(m_PEAK_CommandNode_WaitUntilDoneInfinite ==
nullptr && load)
3171 throw std::runtime_error(
"Failed to load PEAK_CommandNode_WaitUntilDoneInfinite");
3175 if(m_PEAK_CommandNode_WaitUntilDone ==
nullptr && load)
3177 throw std::runtime_error(
"Failed to load PEAK_CommandNode_WaitUntilDone");
3181 if(m_PEAK_FloatNode_ToNode ==
nullptr && load)
3183 throw std::runtime_error(
"Failed to load PEAK_FloatNode_ToNode");
3187 if(m_PEAK_FloatNode_GetMinimum ==
nullptr && load)
3189 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetMinimum");
3193 if(m_PEAK_FloatNode_GetMaximum ==
nullptr && load)
3195 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetMaximum");
3199 if(m_PEAK_FloatNode_GetIncrement ==
nullptr && load)
3201 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetIncrement");
3205 if(m_PEAK_FloatNode_GetIncrementType ==
nullptr && load)
3207 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetIncrementType");
3211 if(m_PEAK_FloatNode_GetValidValues ==
nullptr && load)
3213 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetValidValues");
3217 if(m_PEAK_FloatNode_GetRepresentation ==
nullptr && load)
3219 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetRepresentation");
3223 if(m_PEAK_FloatNode_GetUnit ==
nullptr && load)
3225 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetUnit");
3229 if(m_PEAK_FloatNode_GetDisplayNotation ==
nullptr && load)
3231 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetDisplayNotation");
3235 if(m_PEAK_FloatNode_GetDisplayPrecision ==
nullptr && load)
3237 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetDisplayPrecision");
3241 if(m_PEAK_FloatNode_GetHasConstantIncrement ==
nullptr && load)
3243 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetHasConstantIncrement");
3247 if(m_PEAK_FloatNode_GetValue ==
nullptr && load)
3249 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetValue");
3253 if(m_PEAK_FloatNode_SetValue ==
nullptr && load)
3255 throw std::runtime_error(
"Failed to load PEAK_FloatNode_SetValue");
3259 if(m_PEAK_StringNode_ToNode ==
nullptr && load)
3261 throw std::runtime_error(
"Failed to load PEAK_StringNode_ToNode");
3265 if(m_PEAK_StringNode_GetMaximumLength ==
nullptr && load)
3267 throw std::runtime_error(
"Failed to load PEAK_StringNode_GetMaximumLength");
3271 if(m_PEAK_StringNode_GetValue ==
nullptr && load)
3273 throw std::runtime_error(
"Failed to load PEAK_StringNode_GetValue");
3277 if(m_PEAK_StringNode_SetValue ==
nullptr && load)
3279 throw std::runtime_error(
"Failed to load PEAK_StringNode_SetValue");
3283 if(m_PEAK_RegisterNode_ToNode ==
nullptr && load)
3285 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_ToNode");
3289 if(m_PEAK_RegisterNode_GetAddress ==
nullptr && load)
3291 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_GetAddress");
3295 if(m_PEAK_RegisterNode_GetLength ==
nullptr && load)
3297 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_GetLength");
3301 if(m_PEAK_RegisterNode_Read ==
nullptr && load)
3303 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_Read");
3307 if(m_PEAK_RegisterNode_Write ==
nullptr && load)
3309 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_Write");
3313 if(m_PEAK_CategoryNode_ToNode ==
nullptr && load)
3315 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_ToNode");
3319 if(m_PEAK_CategoryNode_GetNumSubNodes ==
nullptr && load)
3321 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_GetNumSubNodes");
3325 if(m_PEAK_CategoryNode_GetSubNode ==
nullptr && load)
3327 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_GetSubNode");
3331 if(m_PEAK_EnumerationNode_ToNode ==
nullptr && load)
3333 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_ToNode");
3337 if(m_PEAK_EnumerationNode_GetCurrentEntry ==
nullptr && load)
3339 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetCurrentEntry");
3343 if(m_PEAK_EnumerationNode_SetCurrentEntry ==
nullptr && load)
3345 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntry");
3349 if(m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue ==
nullptr && load)
3351 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue");
3355 if(m_PEAK_EnumerationNode_SetCurrentEntryByValue ==
nullptr && load)
3357 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntryByValue");
3361 if(m_PEAK_EnumerationNode_FindEntryBySymbolicValue ==
nullptr && load)
3363 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_FindEntryBySymbolicValue");
3367 if(m_PEAK_EnumerationNode_FindEntryByValue ==
nullptr && load)
3369 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_FindEntryByValue");
3373 if(m_PEAK_EnumerationNode_GetNumEntries ==
nullptr && load)
3375 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetNumEntries");
3379 if(m_PEAK_EnumerationNode_GetEntry ==
nullptr && load)
3381 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetEntry");
3385 if(m_PEAK_EnumerationEntryNode_ToNode ==
nullptr && load)
3387 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_ToNode");
3391 if(m_PEAK_EnumerationEntryNode_GetIsSelfClearing ==
nullptr && load)
3393 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetIsSelfClearing");
3397 if(m_PEAK_EnumerationEntryNode_GetSymbolicValue ==
nullptr && load)
3399 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetSymbolicValue");
3403 if(m_PEAK_EnumerationEntryNode_GetValue ==
nullptr && load)
3405 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetValue");
3409 if(m_PEAK_Port_GetInfo ==
nullptr && load)
3411 throw std::runtime_error(
"Failed to load PEAK_Port_GetInfo");
3415 if(m_PEAK_Port_GetID ==
nullptr && load)
3417 throw std::runtime_error(
"Failed to load PEAK_Port_GetID");
3421 if(m_PEAK_Port_GetName ==
nullptr && load)
3423 throw std::runtime_error(
"Failed to load PEAK_Port_GetName");
3427 if(m_PEAK_Port_GetVendorName ==
nullptr && load)
3429 throw std::runtime_error(
"Failed to load PEAK_Port_GetVendorName");
3433 if(m_PEAK_Port_GetModelName ==
nullptr && load)
3435 throw std::runtime_error(
"Failed to load PEAK_Port_GetModelName");
3439 if(m_PEAK_Port_GetVersion ==
nullptr && load)
3441 throw std::runtime_error(
"Failed to load PEAK_Port_GetVersion");
3445 if(m_PEAK_Port_GetTLType ==
nullptr && load)
3447 throw std::runtime_error(
"Failed to load PEAK_Port_GetTLType");
3451 if(m_PEAK_Port_GetModuleName ==
nullptr && load)
3453 throw std::runtime_error(
"Failed to load PEAK_Port_GetModuleName");
3457 if(m_PEAK_Port_GetDataEndianness ==
nullptr && load)
3459 throw std::runtime_error(
"Failed to load PEAK_Port_GetDataEndianness");
3463 if(m_PEAK_Port_GetIsReadable ==
nullptr && load)
3465 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsReadable");
3469 if(m_PEAK_Port_GetIsWritable ==
nullptr && load)
3471 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsWritable");
3475 if(m_PEAK_Port_GetIsAvailable ==
nullptr && load)
3477 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsAvailable");
3481 if(m_PEAK_Port_GetIsImplemented ==
nullptr && load)
3483 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsImplemented");
3487 if(m_PEAK_Port_Read ==
nullptr && load)
3489 throw std::runtime_error(
"Failed to load PEAK_Port_Read");
3493 if(m_PEAK_Port_Write ==
nullptr && load)
3495 throw std::runtime_error(
"Failed to load PEAK_Port_Write");
3499 if(m_PEAK_Port_GetNumURLs ==
nullptr && load)
3501 throw std::runtime_error(
"Failed to load PEAK_Port_GetNumURLs");
3505 if(m_PEAK_Port_GetURL ==
nullptr && load)
3507 throw std::runtime_error(
"Failed to load PEAK_Port_GetURL");
3511 if(m_PEAK_PortURL_GetInfo ==
nullptr && load)
3513 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetInfo");
3517 if(m_PEAK_PortURL_GetURL ==
nullptr && load)
3519 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetURL");
3523 if(m_PEAK_PortURL_GetScheme ==
nullptr && load)
3525 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetScheme");
3529 if(m_PEAK_PortURL_GetFileName ==
nullptr && load)
3531 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileName");
3535 if(m_PEAK_PortURL_GetFileRegisterAddress ==
nullptr && load)
3537 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileRegisterAddress");
3541 if(m_PEAK_PortURL_GetFileSize ==
nullptr && load)
3543 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSize");
3547 if(m_PEAK_PortURL_GetFileSHA1Hash ==
nullptr && load)
3549 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSHA1Hash");
3553 if(m_PEAK_PortURL_GetFileVersionMajor ==
nullptr && load)
3555 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionMajor");
3559 if(m_PEAK_PortURL_GetFileVersionMinor ==
nullptr && load)
3561 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionMinor");
3565 if(m_PEAK_PortURL_GetFileVersionSubminor ==
nullptr && load)
3567 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionSubminor");
3571 if(m_PEAK_PortURL_GetFileSchemaVersionMajor ==
nullptr && load)
3573 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSchemaVersionMajor");
3577 if(m_PEAK_PortURL_GetFileSchemaVersionMinor ==
nullptr && load)
3579 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSchemaVersionMinor");
3583 if(m_PEAK_PortURL_GetParentPort ==
nullptr && load)
3585 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetParentPort");
3589 if(m_PEAK_EventSupportingModule_EnableEvents ==
nullptr && load)
3591 throw std::runtime_error(
"Failed to load PEAK_EventSupportingModule_EnableEvents");
3595 if(m_PEAK_EventController_GetInfo ==
nullptr && load)
3597 throw std::runtime_error(
"Failed to load PEAK_EventController_GetInfo");
3601 if(m_PEAK_EventController_GetNumEventsInQueue ==
nullptr && load)
3603 throw std::runtime_error(
"Failed to load PEAK_EventController_GetNumEventsInQueue");
3607 if(m_PEAK_EventController_GetNumEventsFired ==
nullptr && load)
3609 throw std::runtime_error(
"Failed to load PEAK_EventController_GetNumEventsFired");
3613 if(m_PEAK_EventController_GetEventMaxSize ==
nullptr && load)
3615 throw std::runtime_error(
"Failed to load PEAK_EventController_GetEventMaxSize");
3619 if(m_PEAK_EventController_GetEventDataMaxSize ==
nullptr && load)
3621 throw std::runtime_error(
"Failed to load PEAK_EventController_GetEventDataMaxSize");
3625 if(m_PEAK_EventController_GetControlledEventType ==
nullptr && load)
3627 throw std::runtime_error(
"Failed to load PEAK_EventController_GetControlledEventType");
3631 if(m_PEAK_EventController_WaitForEvent ==
nullptr && load)
3633 throw std::runtime_error(
"Failed to load PEAK_EventController_WaitForEvent");
3637 if(m_PEAK_EventController_KillWait ==
nullptr && load)
3639 throw std::runtime_error(
"Failed to load PEAK_EventController_KillWait");
3643 if(m_PEAK_EventController_FlushEvents ==
nullptr && load)
3645 throw std::runtime_error(
"Failed to load PEAK_EventController_FlushEvents");
3649 if(m_PEAK_EventController_Destruct ==
nullptr && load)
3651 throw std::runtime_error(
"Failed to load PEAK_EventController_Destruct");
3655 if(m_PEAK_Event_GetInfo ==
nullptr && load)
3657 throw std::runtime_error(
"Failed to load PEAK_Event_GetInfo");
3661 if(m_PEAK_Event_GetID ==
nullptr && load)
3663 throw std::runtime_error(
"Failed to load PEAK_Event_GetID");
3667 if(m_PEAK_Event_GetData ==
nullptr && load)
3669 throw std::runtime_error(
"Failed to load PEAK_Event_GetData");
3673 if(m_PEAK_Event_GetType ==
nullptr && load)
3675 throw std::runtime_error(
"Failed to load PEAK_Event_GetType");
3679 if(m_PEAK_Event_GetRawData ==
nullptr && load)
3681 throw std::runtime_error(
"Failed to load PEAK_Event_GetRawData");
3685 if(m_PEAK_Event_Destruct ==
nullptr && load)
3687 throw std::runtime_error(
"Failed to load PEAK_Event_Destruct");
3691 if(m_PEAK_FirmwareUpdater_Construct ==
nullptr && load)
3693 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_Construct");
3697 if(m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation ==
nullptr && load)
3699 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation");
3703 if(m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation ==
nullptr && load)
3705 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation");
3709 if(m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation ==
nullptr && load)
3711 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation");
3715 if(m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation ==
nullptr && load)
3717 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_GetFirmwareUpdateInformation");
3721 if(m_PEAK_FirmwareUpdater_UpdateDevice ==
nullptr && load)
3723 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_UpdateDevice");
3727 if(m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout ==
nullptr && load)
3729 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout");
3733 if(m_PEAK_FirmwareUpdater_Destruct ==
nullptr && load)
3735 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_Destruct");
3739 if(m_PEAK_FirmwareUpdateInformation_GetIsValid ==
nullptr && load)
3741 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetIsValid");
3745 if(m_PEAK_FirmwareUpdateInformation_GetFileName ==
nullptr && load)
3747 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetFileName");
3751 if(m_PEAK_FirmwareUpdateInformation_GetDescription ==
nullptr && load)
3753 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetDescription");
3757 if(m_PEAK_FirmwareUpdateInformation_GetVersion ==
nullptr && load)
3759 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersion");
3763 if(m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern ==
nullptr && load)
3765 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern");
3769 if(m_PEAK_FirmwareUpdateInformation_GetVersionStyle ==
nullptr && load)
3771 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersionStyle");
3775 if(m_PEAK_FirmwareUpdateInformation_GetReleaseNotes ==
nullptr && load)
3777 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetReleaseNotes");
3781 if(m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL ==
nullptr && load)
3783 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetReleaseNotesURL");
3787 if(m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence ==
nullptr && load)
3789 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetUserSetPersistence");
3793 if(m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence ==
nullptr && load)
3795 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence");
3799 if(m_PEAK_FirmwareUpdateProgressObserver_Construct ==
nullptr && load)
3801 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_Construct");
3805 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback ==
nullptr && load)
3807 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback");
3811 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback ==
nullptr && load)
3813 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback");
3817 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback ==
nullptr && load)
3819 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback");
3823 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback ==
nullptr && load)
3825 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback");
3829 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback ==
nullptr && load)
3831 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback");
3835 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback ==
nullptr && load)
3837 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback");
3841 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback ==
nullptr && load)
3843 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback");
3847 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback ==
nullptr && load)
3849 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback");
3853 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback ==
nullptr && load)
3855 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback");
3859 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback ==
nullptr && load)
3861 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback");
3865 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback ==
nullptr && load)
3867 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback");
3871 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback ==
nullptr && load)
3873 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback");
3877 if(m_PEAK_FirmwareUpdateProgressObserver_Destruct ==
nullptr && load)
3879 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_Destruct");
3888 auto& inst = instance();
3889 if(inst.m_PEAK_Library_Initialize)
3891 return inst.m_PEAK_Library_Initialize();
3895 throw std::runtime_error(
"Library not loaded!");
3901 auto& inst = instance();
3902 if(inst.m_PEAK_Library_Close)
3904 return inst.m_PEAK_Library_Close();
3908 throw std::runtime_error(
"Library not loaded!");
3914 auto& inst = instance();
3915 if(inst.m_PEAK_Library_IsInitialized)
3917 return inst.m_PEAK_Library_IsInitialized(isInitialized);
3921 throw std::runtime_error(
"Library not loaded!");
3927 auto& inst = instance();
3928 if(inst.m_PEAK_Library_GetVersionMajor)
3930 return inst.m_PEAK_Library_GetVersionMajor(libraryVersionMajor);
3934 throw std::runtime_error(
"Library not loaded!");
3940 auto& inst = instance();
3941 if(inst.m_PEAK_Library_GetVersionMinor)
3943 return inst.m_PEAK_Library_GetVersionMinor(libraryVersionMinor);
3947 throw std::runtime_error(
"Library not loaded!");
3953 auto& inst = instance();
3954 if(inst.m_PEAK_Library_GetVersionSubminor)
3956 return inst.m_PEAK_Library_GetVersionSubminor(libraryVersionSubminor);
3960 throw std::runtime_error(
"Library not loaded!");
3966 auto& inst = instance();
3967 if(inst.m_PEAK_Library_GetLastError)
3969 return inst.m_PEAK_Library_GetLastError(lastErrorCode, lastErrorDescription, lastErrorDescriptionSize);
3973 throw std::runtime_error(
"Library not loaded!");
3979 auto& inst = instance();
3980 if(inst.m_PEAK_EnvironmentInspector_UpdateCTIPaths)
3982 return inst.m_PEAK_EnvironmentInspector_UpdateCTIPaths();
3986 throw std::runtime_error(
"Library not loaded!");
3992 auto& inst = instance();
3993 if(inst.m_PEAK_EnvironmentInspector_GetNumCTIPaths)
3995 return inst.m_PEAK_EnvironmentInspector_GetNumCTIPaths(numCtiPaths);
3999 throw std::runtime_error(
"Library not loaded!");
4005 auto& inst = instance();
4006 if(inst.m_PEAK_EnvironmentInspector_GetCTIPath)
4008 return inst.m_PEAK_EnvironmentInspector_GetCTIPath(index, ctiPath, ctiPathSize);
4012 throw std::runtime_error(
"Library not loaded!");
4018 auto& inst = instance();
4019 if(inst.m_PEAK_ProducerLibrary_Construct)
4021 return inst.m_PEAK_ProducerLibrary_Construct(ctiPath, ctiPathSize, producerLibraryHandle);
4025 throw std::runtime_error(
"Library not loaded!");
4031 auto& inst = instance();
4032 if(inst.m_PEAK_ProducerLibrary_GetKey)
4034 return inst.m_PEAK_ProducerLibrary_GetKey(producerLibraryHandle, key, keySize);
4038 throw std::runtime_error(
"Library not loaded!");
4044 auto& inst = instance();
4045 if(inst.m_PEAK_ProducerLibrary_GetSystem)
4047 return inst.m_PEAK_ProducerLibrary_GetSystem(producerLibraryHandle, systemDescriptorHandle);
4051 throw std::runtime_error(
"Library not loaded!");
4057 auto& inst = instance();
4058 if(inst.m_PEAK_ProducerLibrary_Destruct)
4060 return inst.m_PEAK_ProducerLibrary_Destruct(producerLibraryHandle);
4064 throw std::runtime_error(
"Library not loaded!");
4070 auto& inst = instance();
4071 if(inst.m_PEAK_SystemDescriptor_ToModuleDescriptor)
4073 return inst.m_PEAK_SystemDescriptor_ToModuleDescriptor(systemDescriptorHandle, moduleDescriptorHandle);
4077 throw std::runtime_error(
"Library not loaded!");
4083 auto& inst = instance();
4084 if(inst.m_PEAK_SystemDescriptor_GetKey)
4086 return inst.m_PEAK_SystemDescriptor_GetKey(systemDescriptorHandle, key, keySize);
4090 throw std::runtime_error(
"Library not loaded!");
4096 auto& inst = instance();
4097 if(inst.m_PEAK_SystemDescriptor_GetInfo)
4099 return inst.m_PEAK_SystemDescriptor_GetInfo(systemDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4103 throw std::runtime_error(
"Library not loaded!");
4109 auto& inst = instance();
4110 if(inst.m_PEAK_SystemDescriptor_GetDisplayName)
4112 return inst.m_PEAK_SystemDescriptor_GetDisplayName(systemDescriptorHandle, displayName, displayNameSize);
4116 throw std::runtime_error(
"Library not loaded!");
4122 auto& inst = instance();
4123 if(inst.m_PEAK_SystemDescriptor_GetVendorName)
4125 return inst.m_PEAK_SystemDescriptor_GetVendorName(systemDescriptorHandle, vendorName, vendorNameSize);
4129 throw std::runtime_error(
"Library not loaded!");
4135 auto& inst = instance();
4136 if(inst.m_PEAK_SystemDescriptor_GetModelName)
4138 return inst.m_PEAK_SystemDescriptor_GetModelName(systemDescriptorHandle, modelName, modelNameSize);
4142 throw std::runtime_error(
"Library not loaded!");
4148 auto& inst = instance();
4149 if(inst.m_PEAK_SystemDescriptor_GetVersion)
4151 return inst.m_PEAK_SystemDescriptor_GetVersion(systemDescriptorHandle, version, versionSize);
4155 throw std::runtime_error(
"Library not loaded!");
4161 auto& inst = instance();
4162 if(inst.m_PEAK_SystemDescriptor_GetTLType)
4164 return inst.m_PEAK_SystemDescriptor_GetTLType(systemDescriptorHandle, tlType, tlTypeSize);
4168 throw std::runtime_error(
"Library not loaded!");
4174 auto& inst = instance();
4175 if(inst.m_PEAK_SystemDescriptor_GetCTIFileName)
4177 return inst.m_PEAK_SystemDescriptor_GetCTIFileName(systemDescriptorHandle, ctiFileName, ctiFileNameSize);
4181 throw std::runtime_error(
"Library not loaded!");
4187 auto& inst = instance();
4188 if(inst.m_PEAK_SystemDescriptor_GetCTIFullPath)
4190 return inst.m_PEAK_SystemDescriptor_GetCTIFullPath(systemDescriptorHandle, ctiFullPath, ctiFullPathSize);
4194 throw std::runtime_error(
"Library not loaded!");
4200 auto& inst = instance();
4201 if(inst.m_PEAK_SystemDescriptor_GetGenTLVersionMajor)
4203 return inst.m_PEAK_SystemDescriptor_GetGenTLVersionMajor(systemDescriptorHandle, gentlVersionMajor);
4207 throw std::runtime_error(
"Library not loaded!");
4213 auto& inst = instance();
4214 if(inst.m_PEAK_SystemDescriptor_GetGenTLVersionMinor)
4216 return inst.m_PEAK_SystemDescriptor_GetGenTLVersionMinor(systemDescriptorHandle, gentlVersionMinor);
4220 throw std::runtime_error(
"Library not loaded!");
4226 auto& inst = instance();
4227 if(inst.m_PEAK_SystemDescriptor_GetCharacterEncoding)
4229 return inst.m_PEAK_SystemDescriptor_GetCharacterEncoding(systemDescriptorHandle, characterEncoding);
4233 throw std::runtime_error(
"Library not loaded!");
4239 auto& inst = instance();
4240 if(inst.m_PEAK_SystemDescriptor_GetParentLibrary)
4242 return inst.m_PEAK_SystemDescriptor_GetParentLibrary(systemDescriptorHandle, producerLibraryHandle);
4246 throw std::runtime_error(
"Library not loaded!");
4252 auto& inst = instance();
4253 if(inst.m_PEAK_SystemDescriptor_OpenSystem)
4255 return inst.m_PEAK_SystemDescriptor_OpenSystem(systemDescriptorHandle, systemHandle);
4259 throw std::runtime_error(
"Library not loaded!");
4265 auto& inst = instance();
4266 if(inst.m_PEAK_System_ToModule)
4268 return inst.m_PEAK_System_ToModule(systemHandle, moduleHandle);
4272 throw std::runtime_error(
"Library not loaded!");
4278 auto& inst = instance();
4279 if(inst.m_PEAK_System_ToEventSupportingModule)
4281 return inst.m_PEAK_System_ToEventSupportingModule(systemHandle, eventSupportingModuleHandle);
4285 throw std::runtime_error(
"Library not loaded!");
4291 auto& inst = instance();
4292 if(inst.m_PEAK_System_GetKey)
4294 return inst.m_PEAK_System_GetKey(systemHandle, key, keySize);
4298 throw std::runtime_error(
"Library not loaded!");
4304 auto& inst = instance();
4305 if(inst.m_PEAK_System_GetInfo)
4307 return inst.m_PEAK_System_GetInfo(systemHandle, infoCommand, infoDataType, info, infoSize);
4311 throw std::runtime_error(
"Library not loaded!");
4317 auto& inst = instance();
4318 if(inst.m_PEAK_System_GetID)
4320 return inst.m_PEAK_System_GetID(systemHandle,
id, idSize);
4324 throw std::runtime_error(
"Library not loaded!");
4330 auto& inst = instance();
4331 if(inst.m_PEAK_System_GetDisplayName)
4333 return inst.m_PEAK_System_GetDisplayName(systemHandle, displayName, displayNameSize);
4337 throw std::runtime_error(
"Library not loaded!");
4343 auto& inst = instance();
4344 if(inst.m_PEAK_System_GetVendorName)
4346 return inst.m_PEAK_System_GetVendorName(systemHandle, vendorName, vendorNameSize);
4350 throw std::runtime_error(
"Library not loaded!");
4356 auto& inst = instance();
4357 if(inst.m_PEAK_System_GetModelName)
4359 return inst.m_PEAK_System_GetModelName(systemHandle, modelName, modelNameSize);
4363 throw std::runtime_error(
"Library not loaded!");
4369 auto& inst = instance();
4370 if(inst.m_PEAK_System_GetVersion)
4372 return inst.m_PEAK_System_GetVersion(systemHandle, version, versionSize);
4376 throw std::runtime_error(
"Library not loaded!");
4382 auto& inst = instance();
4383 if(inst.m_PEAK_System_GetTLType)
4385 return inst.m_PEAK_System_GetTLType(systemHandle, tlType, tlTypeSize);
4389 throw std::runtime_error(
"Library not loaded!");
4395 auto& inst = instance();
4396 if(inst.m_PEAK_System_GetCTIFileName)
4398 return inst.m_PEAK_System_GetCTIFileName(systemHandle, ctiFileName, ctiFileNameSize);
4402 throw std::runtime_error(
"Library not loaded!");
4408 auto& inst = instance();
4409 if(inst.m_PEAK_System_GetCTIFullPath)
4411 return inst.m_PEAK_System_GetCTIFullPath(systemHandle, ctiFullPath, ctiFullPathSize);
4415 throw std::runtime_error(
"Library not loaded!");
4421 auto& inst = instance();
4422 if(inst.m_PEAK_System_GetGenTLVersionMajor)
4424 return inst.m_PEAK_System_GetGenTLVersionMajor(systemHandle, gentlVersionMajor);
4428 throw std::runtime_error(
"Library not loaded!");
4434 auto& inst = instance();
4435 if(inst.m_PEAK_System_GetGenTLVersionMinor)
4437 return inst.m_PEAK_System_GetGenTLVersionMinor(systemHandle, gentlVersionMinor);
4441 throw std::runtime_error(
"Library not loaded!");
4447 auto& inst = instance();
4448 if(inst.m_PEAK_System_GetCharacterEncoding)
4450 return inst.m_PEAK_System_GetCharacterEncoding(systemHandle, characterEncoding);
4454 throw std::runtime_error(
"Library not loaded!");
4460 auto& inst = instance();
4461 if(inst.m_PEAK_System_GetParentLibrary)
4463 return inst.m_PEAK_System_GetParentLibrary(systemHandle, producerLibraryHandle);
4467 throw std::runtime_error(
"Library not loaded!");
4473 auto& inst = instance();
4474 if(inst.m_PEAK_System_UpdateInterfaces)
4476 return inst.m_PEAK_System_UpdateInterfaces(systemHandle, timeout_ms);
4480 throw std::runtime_error(
"Library not loaded!");
4486 auto& inst = instance();
4487 if(inst.m_PEAK_System_GetNumInterfaces)
4489 return inst.m_PEAK_System_GetNumInterfaces(systemHandle, numInterfaces);
4493 throw std::runtime_error(
"Library not loaded!");
4499 auto& inst = instance();
4500 if(inst.m_PEAK_System_GetInterface)
4502 return inst.m_PEAK_System_GetInterface(systemHandle, index, interfaceDescriptorHandle);
4506 throw std::runtime_error(
"Library not loaded!");
4512 auto& inst = instance();
4513 if(inst.m_PEAK_System_RegisterInterfaceFoundCallback)
4515 return inst.m_PEAK_System_RegisterInterfaceFoundCallback(systemHandle, callback, callbackContext, callbackHandle);
4519 throw std::runtime_error(
"Library not loaded!");
4525 auto& inst = instance();
4526 if(inst.m_PEAK_System_UnregisterInterfaceFoundCallback)
4528 return inst.m_PEAK_System_UnregisterInterfaceFoundCallback(systemHandle, callbackHandle);
4532 throw std::runtime_error(
"Library not loaded!");
4538 auto& inst = instance();
4539 if(inst.m_PEAK_System_RegisterInterfaceLostCallback)
4541 return inst.m_PEAK_System_RegisterInterfaceLostCallback(systemHandle, callback, callbackContext, callbackHandle);
4545 throw std::runtime_error(
"Library not loaded!");
4551 auto& inst = instance();
4552 if(inst.m_PEAK_System_UnregisterInterfaceLostCallback)
4554 return inst.m_PEAK_System_UnregisterInterfaceLostCallback(systemHandle, callbackHandle);
4558 throw std::runtime_error(
"Library not loaded!");
4564 auto& inst = instance();
4565 if(inst.m_PEAK_System_Destruct)
4567 return inst.m_PEAK_System_Destruct(systemHandle);
4571 throw std::runtime_error(
"Library not loaded!");
4577 auto& inst = instance();
4578 if(inst.m_PEAK_InterfaceDescriptor_ToModuleDescriptor)
4580 return inst.m_PEAK_InterfaceDescriptor_ToModuleDescriptor(interfaceDescriptorHandle, moduleDescriptorHandle);
4584 throw std::runtime_error(
"Library not loaded!");
4590 auto& inst = instance();
4591 if(inst.m_PEAK_InterfaceDescriptor_GetKey)
4593 return inst.m_PEAK_InterfaceDescriptor_GetKey(interfaceDescriptorHandle, key, keySize);
4597 throw std::runtime_error(
"Library not loaded!");
4603 auto& inst = instance();
4604 if(inst.m_PEAK_InterfaceDescriptor_GetInfo)
4606 return inst.m_PEAK_InterfaceDescriptor_GetInfo(interfaceDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4610 throw std::runtime_error(
"Library not loaded!");
4616 auto& inst = instance();
4617 if(inst.m_PEAK_InterfaceDescriptor_GetDisplayName)
4619 return inst.m_PEAK_InterfaceDescriptor_GetDisplayName(interfaceDescriptorHandle, displayName, displayNameSize);
4623 throw std::runtime_error(
"Library not loaded!");
4629 auto& inst = instance();
4630 if(inst.m_PEAK_InterfaceDescriptor_GetTLType)
4632 return inst.m_PEAK_InterfaceDescriptor_GetTLType(interfaceDescriptorHandle, tlType, tlTypeSize);
4636 throw std::runtime_error(
"Library not loaded!");
4642 auto& inst = instance();
4643 if(inst.m_PEAK_InterfaceDescriptor_GetParentSystem)
4645 return inst.m_PEAK_InterfaceDescriptor_GetParentSystem(interfaceDescriptorHandle, systemHandle);
4649 throw std::runtime_error(
"Library not loaded!");
4655 auto& inst = instance();
4656 if(inst.m_PEAK_InterfaceDescriptor_OpenInterface)
4658 return inst.m_PEAK_InterfaceDescriptor_OpenInterface(interfaceDescriptorHandle, interfaceHandle);
4662 throw std::runtime_error(
"Library not loaded!");
4668 auto& inst = instance();
4669 if(inst.m_PEAK_Interface_ToModule)
4671 return inst.m_PEAK_Interface_ToModule(interfaceHandle, moduleHandle);
4675 throw std::runtime_error(
"Library not loaded!");
4681 auto& inst = instance();
4682 if(inst.m_PEAK_Interface_ToEventSupportingModule)
4684 return inst.m_PEAK_Interface_ToEventSupportingModule(interfaceHandle, eventSupportingModuleHandle);
4688 throw std::runtime_error(
"Library not loaded!");
4694 auto& inst = instance();
4695 if(inst.m_PEAK_Interface_GetKey)
4697 return inst.m_PEAK_Interface_GetKey(interfaceHandle, key, keySize);
4701 throw std::runtime_error(
"Library not loaded!");
4707 auto& inst = instance();
4708 if(inst.m_PEAK_Interface_GetInfo)
4710 return inst.m_PEAK_Interface_GetInfo(interfaceHandle, infoCommand, infoDataType, info, infoSize);
4714 throw std::runtime_error(
"Library not loaded!");
4720 auto& inst = instance();
4721 if(inst.m_PEAK_Interface_GetID)
4723 return inst.m_PEAK_Interface_GetID(interfaceHandle,
id, idSize);
4727 throw std::runtime_error(
"Library not loaded!");
4733 auto& inst = instance();
4734 if(inst.m_PEAK_Interface_GetDisplayName)
4736 return inst.m_PEAK_Interface_GetDisplayName(interfaceHandle, displayName, displayNameSize);
4740 throw std::runtime_error(
"Library not loaded!");
4746 auto& inst = instance();
4747 if(inst.m_PEAK_Interface_GetTLType)
4749 return inst.m_PEAK_Interface_GetTLType(interfaceHandle, tlType, tlTypeSize);
4753 throw std::runtime_error(
"Library not loaded!");
4759 auto& inst = instance();
4760 if(inst.m_PEAK_Interface_GetParentSystem)
4762 return inst.m_PEAK_Interface_GetParentSystem(interfaceHandle, systemHandle);
4766 throw std::runtime_error(
"Library not loaded!");
4772 auto& inst = instance();
4773 if(inst.m_PEAK_Interface_UpdateDevices)
4775 return inst.m_PEAK_Interface_UpdateDevices(interfaceHandle, timeout_ms);
4779 throw std::runtime_error(
"Library not loaded!");
4785 auto& inst = instance();
4786 if(inst.m_PEAK_Interface_GetNumDevices)
4788 return inst.m_PEAK_Interface_GetNumDevices(interfaceHandle, numDevices);
4792 throw std::runtime_error(
"Library not loaded!");
4798 auto& inst = instance();
4799 if(inst.m_PEAK_Interface_GetDevice)
4801 return inst.m_PEAK_Interface_GetDevice(interfaceHandle, index, deviceDescriptorHandle);
4805 throw std::runtime_error(
"Library not loaded!");
4811 auto& inst = instance();
4812 if(inst.m_PEAK_Interface_RegisterDeviceFoundCallback)
4814 return inst.m_PEAK_Interface_RegisterDeviceFoundCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4818 throw std::runtime_error(
"Library not loaded!");
4824 auto& inst = instance();
4825 if(inst.m_PEAK_Interface_UnregisterDeviceFoundCallback)
4827 return inst.m_PEAK_Interface_UnregisterDeviceFoundCallback(interfaceHandle, callbackHandle);
4831 throw std::runtime_error(
"Library not loaded!");
4837 auto& inst = instance();
4838 if(inst.m_PEAK_Interface_RegisterDeviceReconnectedCallback)
4840 return inst.m_PEAK_Interface_RegisterDeviceReconnectedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4844 throw std::runtime_error(
"Library not loaded!");
4850 auto& inst = instance();
4851 if(inst.m_PEAK_Interface_UnregisterDeviceReconnectedCallback)
4853 return inst.m_PEAK_Interface_UnregisterDeviceReconnectedCallback(interfaceHandle, callbackHandle);
4857 throw std::runtime_error(
"Library not loaded!");
4863 auto& inst = instance();
4864 if(inst.m_PEAK_Interface_RegisterDeviceDisconnectedCallback)
4866 return inst.m_PEAK_Interface_RegisterDeviceDisconnectedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4870 throw std::runtime_error(
"Library not loaded!");
4876 auto& inst = instance();
4877 if(inst.m_PEAK_Interface_UnregisterDeviceDisconnectedCallback)
4879 return inst.m_PEAK_Interface_UnregisterDeviceDisconnectedCallback(interfaceHandle, callbackHandle);
4883 throw std::runtime_error(
"Library not loaded!");
4889 auto& inst = instance();
4890 if(inst.m_PEAK_Interface_RegisterDeviceLostCallback)
4892 return inst.m_PEAK_Interface_RegisterDeviceLostCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4896 throw std::runtime_error(
"Library not loaded!");
4902 auto& inst = instance();
4903 if(inst.m_PEAK_Interface_UnregisterDeviceLostCallback)
4905 return inst.m_PEAK_Interface_UnregisterDeviceLostCallback(interfaceHandle, callbackHandle);
4909 throw std::runtime_error(
"Library not loaded!");
4915 auto& inst = instance();
4916 if(inst.m_PEAK_Interface_RegisterDeviceListChangedCallback)
4918 return inst.m_PEAK_Interface_RegisterDeviceListChangedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4922 throw std::runtime_error(
"Library not loaded!");
4928 auto& inst = instance();
4929 if(inst.m_PEAK_Interface_UnregisterDeviceListChangedCallback)
4931 return inst.m_PEAK_Interface_UnregisterDeviceListChangedCallback(interfaceHandle, callbackHandle);
4935 throw std::runtime_error(
"Library not loaded!");
4941 auto& inst = instance();
4942 if(inst.m_PEAK_Interface_Destruct)
4944 return inst.m_PEAK_Interface_Destruct(interfaceHandle);
4948 throw std::runtime_error(
"Library not loaded!");
4954 auto& inst = instance();
4955 if(inst.m_PEAK_DeviceDescriptor_ToModuleDescriptor)
4957 return inst.m_PEAK_DeviceDescriptor_ToModuleDescriptor(deviceDescriptorHandle, moduleDescriptorHandle);
4961 throw std::runtime_error(
"Library not loaded!");
4967 auto& inst = instance();
4968 if(inst.m_PEAK_DeviceDescriptor_GetKey)
4970 return inst.m_PEAK_DeviceDescriptor_GetKey(deviceDescriptorHandle, key, keySize);
4974 throw std::runtime_error(
"Library not loaded!");
4980 auto& inst = instance();
4981 if(inst.m_PEAK_DeviceDescriptor_GetInfo)
4983 return inst.m_PEAK_DeviceDescriptor_GetInfo(deviceDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4987 throw std::runtime_error(
"Library not loaded!");
4993 auto& inst = instance();
4994 if(inst.m_PEAK_DeviceDescriptor_GetDisplayName)
4996 return inst.m_PEAK_DeviceDescriptor_GetDisplayName(deviceDescriptorHandle, displayName, displayNameSize);
5000 throw std::runtime_error(
"Library not loaded!");
5006 auto& inst = instance();
5007 if(inst.m_PEAK_DeviceDescriptor_GetVendorName)
5009 return inst.m_PEAK_DeviceDescriptor_GetVendorName(deviceDescriptorHandle, vendorName, vendorNameSize);
5013 throw std::runtime_error(
"Library not loaded!");
5019 auto& inst = instance();
5020 if(inst.m_PEAK_DeviceDescriptor_GetModelName)
5022 return inst.m_PEAK_DeviceDescriptor_GetModelName(deviceDescriptorHandle, modelName, modelNameSize);
5026 throw std::runtime_error(
"Library not loaded!");
5032 auto& inst = instance();
5033 if(inst.m_PEAK_DeviceDescriptor_GetVersion)
5035 return inst.m_PEAK_DeviceDescriptor_GetVersion(deviceDescriptorHandle, version, versionSize);
5039 throw std::runtime_error(
"Library not loaded!");
5045 auto& inst = instance();
5046 if(inst.m_PEAK_DeviceDescriptor_GetTLType)
5048 return inst.m_PEAK_DeviceDescriptor_GetTLType(deviceDescriptorHandle, tlType, tlTypeSize);
5052 throw std::runtime_error(
"Library not loaded!");
5058 auto& inst = instance();
5059 if(inst.m_PEAK_DeviceDescriptor_GetUserDefinedName)
5061 return inst.m_PEAK_DeviceDescriptor_GetUserDefinedName(deviceDescriptorHandle, userDefinedName, userDefinedNameSize);
5065 throw std::runtime_error(
"Library not loaded!");
5071 auto& inst = instance();
5072 if(inst.m_PEAK_DeviceDescriptor_GetSerialNumber)
5074 return inst.m_PEAK_DeviceDescriptor_GetSerialNumber(deviceDescriptorHandle, serialNumber, serialNumberSize);
5078 throw std::runtime_error(
"Library not loaded!");
5084 auto& inst = instance();
5085 if(inst.m_PEAK_DeviceDescriptor_GetAccessStatus)
5087 return inst.m_PEAK_DeviceDescriptor_GetAccessStatus(deviceDescriptorHandle, accessStatus);
5091 throw std::runtime_error(
"Library not loaded!");
5097 auto& inst = instance();
5098 if(inst.m_PEAK_DeviceDescriptor_GetTimestampTickFrequency)
5100 return inst.m_PEAK_DeviceDescriptor_GetTimestampTickFrequency(deviceDescriptorHandle, timestampTickFrequency);
5104 throw std::runtime_error(
"Library not loaded!");
5110 auto& inst = instance();
5111 if(inst.m_PEAK_DeviceDescriptor_GetIsOpenableExclusive)
5113 return inst.m_PEAK_DeviceDescriptor_GetIsOpenableExclusive(deviceDescriptorHandle, isOpenable);
5117 throw std::runtime_error(
"Library not loaded!");
5123 auto& inst = instance();
5124 if(inst.m_PEAK_DeviceDescriptor_GetIsOpenable)
5126 return inst.m_PEAK_DeviceDescriptor_GetIsOpenable(deviceDescriptorHandle, accessType, isOpenable);
5130 throw std::runtime_error(
"Library not loaded!");
5136 auto& inst = instance();
5137 if(inst.m_PEAK_DeviceDescriptor_OpenDevice)
5139 return inst.m_PEAK_DeviceDescriptor_OpenDevice(deviceDescriptorHandle, accessType, deviceHandle);
5143 throw std::runtime_error(
"Library not loaded!");
5149 auto& inst = instance();
5150 if(inst.m_PEAK_DeviceDescriptor_GetParentInterface)
5152 return inst.m_PEAK_DeviceDescriptor_GetParentInterface(deviceDescriptorHandle, interfaceHandle);
5156 throw std::runtime_error(
"Library not loaded!");
5162 auto& inst = instance();
5163 if(inst.m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval)
5165 return inst.m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(deviceDescriptorHandle, monitoringUpdateInterval_ms);
5169 throw std::runtime_error(
"Library not loaded!");
5175 auto& inst = instance();
5176 if(inst.m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval)
5178 return inst.m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(deviceDescriptorHandle, monitoringUpdateInterval_ms);
5182 throw std::runtime_error(
"Library not loaded!");
5188 auto& inst = instance();
5189 if(inst.m_PEAK_DeviceDescriptor_IsInformationRoleMonitored)
5191 return inst.m_PEAK_DeviceDescriptor_IsInformationRoleMonitored(deviceDescriptorHandle, informationRole, isInformationRoleMonitored);
5195 throw std::runtime_error(
"Library not loaded!");
5201 auto& inst = instance();
5202 if(inst.m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring)
5204 return inst.m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(deviceDescriptorHandle, informationRole);
5208 throw std::runtime_error(
"Library not loaded!");
5214 auto& inst = instance();
5215 if(inst.m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring)
5217 return inst.m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(deviceDescriptorHandle, informationRole);
5221 throw std::runtime_error(
"Library not loaded!");
5227 auto& inst = instance();
5228 if(inst.m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback)
5230 return inst.m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback(deviceDescriptorHandle, callback, callbackContext, callbackHandle);
5234 throw std::runtime_error(
"Library not loaded!");
5240 auto& inst = instance();
5241 if(inst.m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback)
5243 return inst.m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(deviceDescriptorHandle, callbackHandle);
5247 throw std::runtime_error(
"Library not loaded!");
5253 auto& inst = instance();
5254 if(inst.m_PEAK_Device_ToModule)
5256 return inst.m_PEAK_Device_ToModule(deviceHandle, moduleHandle);
5260 throw std::runtime_error(
"Library not loaded!");
5266 auto& inst = instance();
5267 if(inst.m_PEAK_Device_ToEventSupportingModule)
5269 return inst.m_PEAK_Device_ToEventSupportingModule(deviceHandle, eventSupportingModuleHandle);
5273 throw std::runtime_error(
"Library not loaded!");
5279 auto& inst = instance();
5280 if(inst.m_PEAK_Device_GetKey)
5282 return inst.m_PEAK_Device_GetKey(deviceHandle, key, keySize);
5286 throw std::runtime_error(
"Library not loaded!");
5292 auto& inst = instance();
5293 if(inst.m_PEAK_Device_GetInfo)
5295 return inst.m_PEAK_Device_GetInfo(deviceHandle, infoCommand, infoDataType, info, infoSize);
5299 throw std::runtime_error(
"Library not loaded!");
5305 auto& inst = instance();
5306 if(inst.m_PEAK_Device_GetID)
5308 return inst.m_PEAK_Device_GetID(deviceHandle,
id, idSize);
5312 throw std::runtime_error(
"Library not loaded!");
5318 auto& inst = instance();
5319 if(inst.m_PEAK_Device_GetDisplayName)
5321 return inst.m_PEAK_Device_GetDisplayName(deviceHandle, displayName, displayNameSize);
5325 throw std::runtime_error(
"Library not loaded!");
5331 auto& inst = instance();
5332 if(inst.m_PEAK_Device_GetVendorName)
5334 return inst.m_PEAK_Device_GetVendorName(deviceHandle, vendorName, vendorNameSize);
5338 throw std::runtime_error(
"Library not loaded!");
5344 auto& inst = instance();
5345 if(inst.m_PEAK_Device_GetModelName)
5347 return inst.m_PEAK_Device_GetModelName(deviceHandle, modelName, modelNameSize);
5351 throw std::runtime_error(
"Library not loaded!");
5357 auto& inst = instance();
5358 if(inst.m_PEAK_Device_GetVersion)
5360 return inst.m_PEAK_Device_GetVersion(deviceHandle, version, versionSize);
5364 throw std::runtime_error(
"Library not loaded!");
5370 auto& inst = instance();
5371 if(inst.m_PEAK_Device_GetTLType)
5373 return inst.m_PEAK_Device_GetTLType(deviceHandle, tlType, tlTypeSize);
5377 throw std::runtime_error(
"Library not loaded!");
5383 auto& inst = instance();
5384 if(inst.m_PEAK_Device_GetUserDefinedName)
5386 return inst.m_PEAK_Device_GetUserDefinedName(deviceHandle, userDefinedName, userDefinedNameSize);
5390 throw std::runtime_error(
"Library not loaded!");
5396 auto& inst = instance();
5397 if(inst.m_PEAK_Device_GetSerialNumber)
5399 return inst.m_PEAK_Device_GetSerialNumber(deviceHandle, serialNumber, serialNumberSize);
5403 throw std::runtime_error(
"Library not loaded!");
5409 auto& inst = instance();
5410 if(inst.m_PEAK_Device_GetAccessStatus)
5412 return inst.m_PEAK_Device_GetAccessStatus(deviceHandle, accessStatus);
5416 throw std::runtime_error(
"Library not loaded!");
5422 auto& inst = instance();
5423 if(inst.m_PEAK_Device_GetTimestampTickFrequency)
5425 return inst.m_PEAK_Device_GetTimestampTickFrequency(deviceHandle, timestampTickFrequency);
5429 throw std::runtime_error(
"Library not loaded!");
5435 auto& inst = instance();
5436 if(inst.m_PEAK_Device_GetParentInterface)
5438 return inst.m_PEAK_Device_GetParentInterface(deviceHandle, interfaceHandle);
5442 throw std::runtime_error(
"Library not loaded!");
5448 auto& inst = instance();
5449 if(inst.m_PEAK_Device_GetRemoteDevice)
5451 return inst.m_PEAK_Device_GetRemoteDevice(deviceHandle, remoteDeviceHandle);
5455 throw std::runtime_error(
"Library not loaded!");
5461 auto& inst = instance();
5462 if(inst.m_PEAK_Device_GetNumDataStreams)
5464 return inst.m_PEAK_Device_GetNumDataStreams(deviceHandle, numDataStreams);
5468 throw std::runtime_error(
"Library not loaded!");
5474 auto& inst = instance();
5475 if(inst.m_PEAK_Device_GetDataStream)
5477 return inst.m_PEAK_Device_GetDataStream(deviceHandle, index, dataStreamDescriptorHandle);
5481 throw std::runtime_error(
"Library not loaded!");
5487 auto& inst = instance();
5488 if(inst.m_PEAK_Device_Destruct)
5490 return inst.m_PEAK_Device_Destruct(deviceHandle);
5494 throw std::runtime_error(
"Library not loaded!");
5500 auto& inst = instance();
5501 if(inst.m_PEAK_RemoteDevice_ToModule)
5503 return inst.m_PEAK_RemoteDevice_ToModule(remoteDeviceHandle, moduleHandle);
5507 throw std::runtime_error(
"Library not loaded!");
5513 auto& inst = instance();
5514 if(inst.m_PEAK_RemoteDevice_GetLocalDevice)
5516 return inst.m_PEAK_RemoteDevice_GetLocalDevice(remoteDeviceHandle, deviceHandle);
5520 throw std::runtime_error(
"Library not loaded!");
5526 auto& inst = instance();
5527 if(inst.m_PEAK_DataStreamDescriptor_ToModuleDescriptor)
5529 return inst.m_PEAK_DataStreamDescriptor_ToModuleDescriptor(dataStreamDescriptorHandle, moduleDescriptorHandle);
5533 throw std::runtime_error(
"Library not loaded!");
5539 auto& inst = instance();
5540 if(inst.m_PEAK_DataStreamDescriptor_GetKey)
5542 return inst.m_PEAK_DataStreamDescriptor_GetKey(dataStreamDescriptorHandle, key, keySize);
5546 throw std::runtime_error(
"Library not loaded!");
5552 auto& inst = instance();
5553 if(inst.m_PEAK_DataStreamDescriptor_GetParentDevice)
5555 return inst.m_PEAK_DataStreamDescriptor_GetParentDevice(dataStreamDescriptorHandle, deviceHandle);
5559 throw std::runtime_error(
"Library not loaded!");
5565 auto& inst = instance();
5566 if(inst.m_PEAK_DataStreamDescriptor_OpenDataStream)
5568 return inst.m_PEAK_DataStreamDescriptor_OpenDataStream(dataStreamDescriptorHandle, dataStreamHandle);
5572 throw std::runtime_error(
"Library not loaded!");
5578 auto& inst = instance();
5579 if(inst.m_PEAK_DataStream_ToModule)
5581 return inst.m_PEAK_DataStream_ToModule(dataStreamHandle, moduleHandle);
5585 throw std::runtime_error(
"Library not loaded!");
5591 auto& inst = instance();
5592 if(inst.m_PEAK_DataStream_ToEventSupportingModule)
5594 return inst.m_PEAK_DataStream_ToEventSupportingModule(dataStreamHandle, eventSupportingModuleHandle);
5598 throw std::runtime_error(
"Library not loaded!");
5604 auto& inst = instance();
5605 if(inst.m_PEAK_DataStream_GetKey)
5607 return inst.m_PEAK_DataStream_GetKey(dataStreamHandle, key, keySize);
5611 throw std::runtime_error(
"Library not loaded!");
5617 auto& inst = instance();
5618 if(inst.m_PEAK_DataStream_GetInfo)
5620 return inst.m_PEAK_DataStream_GetInfo(dataStreamHandle, infoCommand, infoDataType, info, infoSize);
5624 throw std::runtime_error(
"Library not loaded!");
5630 auto& inst = instance();
5631 if(inst.m_PEAK_DataStream_GetID)
5633 return inst.m_PEAK_DataStream_GetID(dataStreamHandle,
id, idSize);
5637 throw std::runtime_error(
"Library not loaded!");
5643 auto& inst = instance();
5644 if(inst.m_PEAK_DataStream_GetTLType)
5646 return inst.m_PEAK_DataStream_GetTLType(dataStreamHandle, tlType, tlTypeSize);
5650 throw std::runtime_error(
"Library not loaded!");
5656 auto& inst = instance();
5657 if(inst.m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired)
5659 return inst.m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(dataStreamHandle, numBuffersAnnouncedMinRequired);
5663 throw std::runtime_error(
"Library not loaded!");
5669 auto& inst = instance();
5670 if(inst.m_PEAK_DataStream_GetNumBuffersAnnounced)
5672 return inst.m_PEAK_DataStream_GetNumBuffersAnnounced(dataStreamHandle, numBuffersAnnounced);
5676 throw std::runtime_error(
"Library not loaded!");
5682 auto& inst = instance();
5683 if(inst.m_PEAK_DataStream_GetNumBuffersQueued)
5685 return inst.m_PEAK_DataStream_GetNumBuffersQueued(dataStreamHandle, numBuffersQueued);
5689 throw std::runtime_error(
"Library not loaded!");
5695 auto& inst = instance();
5696 if(inst.m_PEAK_DataStream_GetNumBuffersAwaitDelivery)
5698 return inst.m_PEAK_DataStream_GetNumBuffersAwaitDelivery(dataStreamHandle, numBuffersAwaitDelivery);
5702 throw std::runtime_error(
"Library not loaded!");
5708 auto& inst = instance();
5709 if(inst.m_PEAK_DataStream_GetNumBuffersDelivered)
5711 return inst.m_PEAK_DataStream_GetNumBuffersDelivered(dataStreamHandle, numBuffersDelivered);
5715 throw std::runtime_error(
"Library not loaded!");
5721 auto& inst = instance();
5722 if(inst.m_PEAK_DataStream_GetNumBuffersStarted)
5724 return inst.m_PEAK_DataStream_GetNumBuffersStarted(dataStreamHandle, numBuffersStarted);
5728 throw std::runtime_error(
"Library not loaded!");
5734 auto& inst = instance();
5735 if(inst.m_PEAK_DataStream_GetNumUnderruns)
5737 return inst.m_PEAK_DataStream_GetNumUnderruns(dataStreamHandle, numUnderruns);
5741 throw std::runtime_error(
"Library not loaded!");
5747 auto& inst = instance();
5748 if(inst.m_PEAK_DataStream_GetNumChunksPerBufferMax)
5750 return inst.m_PEAK_DataStream_GetNumChunksPerBufferMax(dataStreamHandle, numChunksPerBufferMax);
5754 throw std::runtime_error(
"Library not loaded!");
5760 auto& inst = instance();
5761 if(inst.m_PEAK_DataStream_GetBufferAlignment)
5763 return inst.m_PEAK_DataStream_GetBufferAlignment(dataStreamHandle, bufferAlignment);
5767 throw std::runtime_error(
"Library not loaded!");
5773 auto& inst = instance();
5774 if(inst.m_PEAK_DataStream_GetPayloadSize)
5776 return inst.m_PEAK_DataStream_GetPayloadSize(dataStreamHandle, payloadSize);
5780 throw std::runtime_error(
"Library not loaded!");
5786 auto& inst = instance();
5787 if(inst.m_PEAK_DataStream_GetDefinesPayloadSize)
5789 return inst.m_PEAK_DataStream_GetDefinesPayloadSize(dataStreamHandle, definesPayloadSize);
5793 throw std::runtime_error(
"Library not loaded!");
5799 auto& inst = instance();
5800 if(inst.m_PEAK_DataStream_GetIsGrabbing)
5802 return inst.m_PEAK_DataStream_GetIsGrabbing(dataStreamHandle, isGrabbing);
5806 throw std::runtime_error(
"Library not loaded!");
5812 auto& inst = instance();
5813 if(inst.m_PEAK_DataStream_GetParentDevice)
5815 return inst.m_PEAK_DataStream_GetParentDevice(dataStreamHandle, deviceHandle);
5819 throw std::runtime_error(
"Library not loaded!");
5825 auto& inst = instance();
5826 if(inst.m_PEAK_DataStream_AnnounceBuffer)
5828 return inst.m_PEAK_DataStream_AnnounceBuffer(dataStreamHandle, buffer, bufferSize, userPtr, revocationCallback, callbackContext, bufferHandle);
5832 throw std::runtime_error(
"Library not loaded!");
5838 auto& inst = instance();
5839 if(inst.m_PEAK_DataStream_AllocAndAnnounceBuffer)
5841 return inst.m_PEAK_DataStream_AllocAndAnnounceBuffer(dataStreamHandle, bufferSize, userPtr, bufferHandle);
5845 throw std::runtime_error(
"Library not loaded!");
5851 auto& inst = instance();
5852 if(inst.m_PEAK_DataStream_QueueBuffer)
5854 return inst.m_PEAK_DataStream_QueueBuffer(dataStreamHandle, bufferHandle);
5858 throw std::runtime_error(
"Library not loaded!");
5864 auto& inst = instance();
5865 if(inst.m_PEAK_DataStream_RevokeBuffer)
5867 return inst.m_PEAK_DataStream_RevokeBuffer(dataStreamHandle, bufferHandle);
5871 throw std::runtime_error(
"Library not loaded!");
5877 auto& inst = instance();
5878 if(inst.m_PEAK_DataStream_WaitForFinishedBuffer)
5880 return inst.m_PEAK_DataStream_WaitForFinishedBuffer(dataStreamHandle, timeout_ms, bufferHandle);
5884 throw std::runtime_error(
"Library not loaded!");
5890 auto& inst = instance();
5891 if(inst.m_PEAK_DataStream_KillWait)
5893 return inst.m_PEAK_DataStream_KillWait(dataStreamHandle);
5897 throw std::runtime_error(
"Library not loaded!");
5903 auto& inst = instance();
5904 if(inst.m_PEAK_DataStream_Flush)
5906 return inst.m_PEAK_DataStream_Flush(dataStreamHandle, flushMode);
5910 throw std::runtime_error(
"Library not loaded!");
5916 auto& inst = instance();
5917 if(inst.m_PEAK_DataStream_StartAcquisitionInfinite)
5919 return inst.m_PEAK_DataStream_StartAcquisitionInfinite(dataStreamHandle, startMode);
5923 throw std::runtime_error(
"Library not loaded!");
5929 auto& inst = instance();
5930 if(inst.m_PEAK_DataStream_StartAcquisition)
5932 return inst.m_PEAK_DataStream_StartAcquisition(dataStreamHandle, startMode, numToAcquire);
5936 throw std::runtime_error(
"Library not loaded!");
5942 auto& inst = instance();
5943 if(inst.m_PEAK_DataStream_StopAcquisition)
5945 return inst.m_PEAK_DataStream_StopAcquisition(dataStreamHandle, stopMode);
5949 throw std::runtime_error(
"Library not loaded!");
5955 auto& inst = instance();
5956 if(inst.m_PEAK_DataStream_Destruct)
5958 return inst.m_PEAK_DataStream_Destruct(dataStreamHandle);
5962 throw std::runtime_error(
"Library not loaded!");
5968 auto& inst = instance();
5969 if(inst.m_PEAK_Buffer_ToModule)
5971 return inst.m_PEAK_Buffer_ToModule(bufferHandle, moduleHandle);
5975 throw std::runtime_error(
"Library not loaded!");
5981 auto& inst = instance();
5982 if(inst.m_PEAK_Buffer_ToEventSupportingModule)
5984 return inst.m_PEAK_Buffer_ToEventSupportingModule(bufferHandle, eventSupportingModuleHandle);
5988 throw std::runtime_error(
"Library not loaded!");
5994 auto& inst = instance();
5995 if(inst.m_PEAK_Buffer_GetInfo)
5997 return inst.m_PEAK_Buffer_GetInfo(bufferHandle, infoCommand, infoDataType, info, infoSize);
6001 throw std::runtime_error(
"Library not loaded!");
6007 auto& inst = instance();
6008 if(inst.m_PEAK_Buffer_GetTLType)
6010 return inst.m_PEAK_Buffer_GetTLType(bufferHandle, tlType, tlTypeSize);
6014 throw std::runtime_error(
"Library not loaded!");
6020 auto& inst = instance();
6021 if(inst.m_PEAK_Buffer_GetBasePtr)
6023 return inst.m_PEAK_Buffer_GetBasePtr(bufferHandle, basePtr);
6027 throw std::runtime_error(
"Library not loaded!");
6033 auto& inst = instance();
6034 if(inst.m_PEAK_Buffer_GetSize)
6036 return inst.m_PEAK_Buffer_GetSize(bufferHandle, size);
6040 throw std::runtime_error(
"Library not loaded!");
6046 auto& inst = instance();
6047 if(inst.m_PEAK_Buffer_GetUserPtr)
6049 return inst.m_PEAK_Buffer_GetUserPtr(bufferHandle, userPtr);
6053 throw std::runtime_error(
"Library not loaded!");
6059 auto& inst = instance();
6060 if(inst.m_PEAK_Buffer_GetPayloadType)
6062 return inst.m_PEAK_Buffer_GetPayloadType(bufferHandle, payloadType);
6066 throw std::runtime_error(
"Library not loaded!");
6072 auto& inst = instance();
6073 if(inst.m_PEAK_Buffer_GetPixelFormat)
6075 return inst.m_PEAK_Buffer_GetPixelFormat(bufferHandle, pixelFormat);
6079 throw std::runtime_error(
"Library not loaded!");
6085 auto& inst = instance();
6086 if(inst.m_PEAK_Buffer_GetPixelFormatNamespace)
6088 return inst.m_PEAK_Buffer_GetPixelFormatNamespace(bufferHandle, pixelFormatNamespace);
6092 throw std::runtime_error(
"Library not loaded!");
6098 auto& inst = instance();
6099 if(inst.m_PEAK_Buffer_GetPixelEndianness)
6101 return inst.m_PEAK_Buffer_GetPixelEndianness(bufferHandle, pixelEndianness);
6105 throw std::runtime_error(
"Library not loaded!");
6111 auto& inst = instance();
6112 if(inst.m_PEAK_Buffer_GetExpectedDataSize)
6114 return inst.m_PEAK_Buffer_GetExpectedDataSize(bufferHandle, expectedDataSize);
6118 throw std::runtime_error(
"Library not loaded!");
6124 auto& inst = instance();
6125 if(inst.m_PEAK_Buffer_GetDeliveredDataSize)
6127 return inst.m_PEAK_Buffer_GetDeliveredDataSize(bufferHandle, deliveredDataSize);
6131 throw std::runtime_error(
"Library not loaded!");
6137 auto& inst = instance();
6138 if(inst.m_PEAK_Buffer_GetFrameID)
6140 return inst.m_PEAK_Buffer_GetFrameID(bufferHandle, frameId);
6144 throw std::runtime_error(
"Library not loaded!");
6150 auto& inst = instance();
6151 if(inst.m_PEAK_Buffer_GetImageOffset)
6153 return inst.m_PEAK_Buffer_GetImageOffset(bufferHandle, imageOffset);
6157 throw std::runtime_error(
"Library not loaded!");
6163 auto& inst = instance();
6164 if(inst.m_PEAK_Buffer_GetDeliveredImageHeight)
6166 return inst.m_PEAK_Buffer_GetDeliveredImageHeight(bufferHandle, deliveredImageHeight);
6170 throw std::runtime_error(
"Library not loaded!");
6176 auto& inst = instance();
6177 if(inst.m_PEAK_Buffer_GetDeliveredChunkPayloadSize)
6179 return inst.m_PEAK_Buffer_GetDeliveredChunkPayloadSize(bufferHandle, deliveredChunkPayloadSize);
6183 throw std::runtime_error(
"Library not loaded!");
6189 auto& inst = instance();
6190 if(inst.m_PEAK_Buffer_GetChunkLayoutID)
6192 return inst.m_PEAK_Buffer_GetChunkLayoutID(bufferHandle, chunkLayoutId);
6196 throw std::runtime_error(
"Library not loaded!");
6202 auto& inst = instance();
6203 if(inst.m_PEAK_Buffer_GetFileName)
6205 return inst.m_PEAK_Buffer_GetFileName(bufferHandle, fileName, fileNameSize);
6209 throw std::runtime_error(
"Library not loaded!");
6215 auto& inst = instance();
6216 if(inst.m_PEAK_Buffer_GetWidth)
6218 return inst.m_PEAK_Buffer_GetWidth(bufferHandle, width);
6222 throw std::runtime_error(
"Library not loaded!");
6228 auto& inst = instance();
6229 if(inst.m_PEAK_Buffer_GetHeight)
6231 return inst.m_PEAK_Buffer_GetHeight(bufferHandle, height);
6235 throw std::runtime_error(
"Library not loaded!");
6241 auto& inst = instance();
6242 if(inst.m_PEAK_Buffer_GetXOffset)
6244 return inst.m_PEAK_Buffer_GetXOffset(bufferHandle, xOffset);
6248 throw std::runtime_error(
"Library not loaded!");
6254 auto& inst = instance();
6255 if(inst.m_PEAK_Buffer_GetYOffset)
6257 return inst.m_PEAK_Buffer_GetYOffset(bufferHandle, yOffset);
6261 throw std::runtime_error(
"Library not loaded!");
6267 auto& inst = instance();
6268 if(inst.m_PEAK_Buffer_GetXPadding)
6270 return inst.m_PEAK_Buffer_GetXPadding(bufferHandle, xPadding);
6274 throw std::runtime_error(
"Library not loaded!");
6280 auto& inst = instance();
6281 if(inst.m_PEAK_Buffer_GetYPadding)
6283 return inst.m_PEAK_Buffer_GetYPadding(bufferHandle, yPadding);
6287 throw std::runtime_error(
"Library not loaded!");
6293 auto& inst = instance();
6294 if(inst.m_PEAK_Buffer_GetTimestamp_ticks)
6296 return inst.m_PEAK_Buffer_GetTimestamp_ticks(bufferHandle, timestamp_ticks);
6300 throw std::runtime_error(
"Library not loaded!");
6306 auto& inst = instance();
6307 if(inst.m_PEAK_Buffer_GetTimestamp_ns)
6309 return inst.m_PEAK_Buffer_GetTimestamp_ns(bufferHandle, timestamp_ns);
6313 throw std::runtime_error(
"Library not loaded!");
6319 auto& inst = instance();
6320 if(inst.m_PEAK_Buffer_GetIsQueued)
6322 return inst.m_PEAK_Buffer_GetIsQueued(bufferHandle, isQueued);
6326 throw std::runtime_error(
"Library not loaded!");
6332 auto& inst = instance();
6333 if(inst.m_PEAK_Buffer_GetIsAcquiring)
6335 return inst.m_PEAK_Buffer_GetIsAcquiring(bufferHandle, isAcquiring);
6339 throw std::runtime_error(
"Library not loaded!");
6345 auto& inst = instance();
6346 if(inst.m_PEAK_Buffer_GetIsIncomplete)
6348 return inst.m_PEAK_Buffer_GetIsIncomplete(bufferHandle, isIncomplete);
6352 throw std::runtime_error(
"Library not loaded!");
6358 auto& inst = instance();
6359 if(inst.m_PEAK_Buffer_GetHasNewData)
6361 return inst.m_PEAK_Buffer_GetHasNewData(bufferHandle, hasNewData);
6365 throw std::runtime_error(
"Library not loaded!");
6371 auto& inst = instance();
6372 if(inst.m_PEAK_Buffer_GetHasImage)
6374 return inst.m_PEAK_Buffer_GetHasImage(bufferHandle, hasImage);
6378 throw std::runtime_error(
"Library not loaded!");
6384 auto& inst = instance();
6385 if(inst.m_PEAK_Buffer_GetHasChunks)
6387 return inst.m_PEAK_Buffer_GetHasChunks(bufferHandle, hasChunks);
6391 throw std::runtime_error(
"Library not loaded!");
6397 auto& inst = instance();
6398 if(inst.m_PEAK_Buffer_GetHasParts)
6400 return inst.m_PEAK_Buffer_GetHasParts(bufferHandle, hasParts);
6404 throw std::runtime_error(
"Library not loaded!");
6410 auto& inst = instance();
6411 if(inst.m_PEAK_Buffer_UpdateChunks)
6413 return inst.m_PEAK_Buffer_UpdateChunks(bufferHandle);
6417 throw std::runtime_error(
"Library not loaded!");
6423 auto& inst = instance();
6424 if(inst.m_PEAK_Buffer_GetNumChunks)
6426 return inst.m_PEAK_Buffer_GetNumChunks(bufferHandle, numChunks);
6430 throw std::runtime_error(
"Library not loaded!");
6436 auto& inst = instance();
6437 if(inst.m_PEAK_Buffer_GetChunk)
6439 return inst.m_PEAK_Buffer_GetChunk(bufferHandle, index, bufferChunkHandle);
6443 throw std::runtime_error(
"Library not loaded!");
6449 auto& inst = instance();
6450 if(inst.m_PEAK_Buffer_UpdateParts)
6452 return inst.m_PEAK_Buffer_UpdateParts(bufferHandle);
6456 throw std::runtime_error(
"Library not loaded!");
6462 auto& inst = instance();
6463 if(inst.m_PEAK_Buffer_GetNumParts)
6465 return inst.m_PEAK_Buffer_GetNumParts(bufferHandle, numParts);
6469 throw std::runtime_error(
"Library not loaded!");
6475 auto& inst = instance();
6476 if(inst.m_PEAK_Buffer_GetPart)
6478 return inst.m_PEAK_Buffer_GetPart(bufferHandle, index, bufferPartHandle);
6482 throw std::runtime_error(
"Library not loaded!");
6488 auto& inst = instance();
6489 if(inst.m_PEAK_BufferChunk_GetID)
6491 return inst.m_PEAK_BufferChunk_GetID(bufferChunkHandle,
id);
6495 throw std::runtime_error(
"Library not loaded!");
6501 auto& inst = instance();
6502 if(inst.m_PEAK_BufferChunk_GetBasePtr)
6504 return inst.m_PEAK_BufferChunk_GetBasePtr(bufferChunkHandle, basePtr);
6508 throw std::runtime_error(
"Library not loaded!");
6514 auto& inst = instance();
6515 if(inst.m_PEAK_BufferChunk_GetSize)
6517 return inst.m_PEAK_BufferChunk_GetSize(bufferChunkHandle, size);
6521 throw std::runtime_error(
"Library not loaded!");
6527 auto& inst = instance();
6528 if(inst.m_PEAK_BufferChunk_GetParentBuffer)
6530 return inst.m_PEAK_BufferChunk_GetParentBuffer(bufferChunkHandle, bufferHandle);
6534 throw std::runtime_error(
"Library not loaded!");
6540 auto& inst = instance();
6541 if(inst.m_PEAK_BufferChunk_Destruct)
6543 return inst.m_PEAK_BufferChunk_Destruct(bufferChunkHandle);
6547 throw std::runtime_error(
"Library not loaded!");
6553 auto& inst = instance();
6554 if(inst.m_PEAK_BufferPart_GetInfo)
6556 return inst.m_PEAK_BufferPart_GetInfo(bufferPartHandle, infoCommand, infoDataType, info, infoSize);
6560 throw std::runtime_error(
"Library not loaded!");
6566 auto& inst = instance();
6567 if(inst.m_PEAK_BufferPart_GetSourceID)
6569 return inst.m_PEAK_BufferPart_GetSourceID(bufferPartHandle, sourceId);
6573 throw std::runtime_error(
"Library not loaded!");
6579 auto& inst = instance();
6580 if(inst.m_PEAK_BufferPart_GetBasePtr)
6582 return inst.m_PEAK_BufferPart_GetBasePtr(bufferPartHandle, basePtr);
6586 throw std::runtime_error(
"Library not loaded!");
6592 auto& inst = instance();
6593 if(inst.m_PEAK_BufferPart_GetSize)
6595 return inst.m_PEAK_BufferPart_GetSize(bufferPartHandle, size);
6599 throw std::runtime_error(
"Library not loaded!");
6605 auto& inst = instance();
6606 if(inst.m_PEAK_BufferPart_GetType)
6608 return inst.m_PEAK_BufferPart_GetType(bufferPartHandle, type);
6612 throw std::runtime_error(
"Library not loaded!");
6618 auto& inst = instance();
6619 if(inst.m_PEAK_BufferPart_GetFormat)
6621 return inst.m_PEAK_BufferPart_GetFormat(bufferPartHandle, format);
6625 throw std::runtime_error(
"Library not loaded!");
6631 auto& inst = instance();
6632 if(inst.m_PEAK_BufferPart_GetFormatNamespace)
6634 return inst.m_PEAK_BufferPart_GetFormatNamespace(bufferPartHandle, formatNamespace);
6638 throw std::runtime_error(
"Library not loaded!");
6644 auto& inst = instance();
6645 if(inst.m_PEAK_BufferPart_GetWidth)
6647 return inst.m_PEAK_BufferPart_GetWidth(bufferPartHandle, width);
6651 throw std::runtime_error(
"Library not loaded!");
6657 auto& inst = instance();
6658 if(inst.m_PEAK_BufferPart_GetHeight)
6660 return inst.m_PEAK_BufferPart_GetHeight(bufferPartHandle, height);
6664 throw std::runtime_error(
"Library not loaded!");
6670 auto& inst = instance();
6671 if(inst.m_PEAK_BufferPart_GetXOffset)
6673 return inst.m_PEAK_BufferPart_GetXOffset(bufferPartHandle, xOffset);
6677 throw std::runtime_error(
"Library not loaded!");
6683 auto& inst = instance();
6684 if(inst.m_PEAK_BufferPart_GetYOffset)
6686 return inst.m_PEAK_BufferPart_GetYOffset(bufferPartHandle, yOffset);
6690 throw std::runtime_error(
"Library not loaded!");
6696 auto& inst = instance();
6697 if(inst.m_PEAK_BufferPart_GetXPadding)
6699 return inst.m_PEAK_BufferPart_GetXPadding(bufferPartHandle, xPadding);
6703 throw std::runtime_error(
"Library not loaded!");
6709 auto& inst = instance();
6710 if(inst.m_PEAK_BufferPart_GetDeliveredImageHeight)
6712 return inst.m_PEAK_BufferPart_GetDeliveredImageHeight(bufferPartHandle, deliveredImageHeight);
6716 throw std::runtime_error(
"Library not loaded!");
6722 auto& inst = instance();
6723 if(inst.m_PEAK_BufferPart_GetParentBuffer)
6725 return inst.m_PEAK_BufferPart_GetParentBuffer(bufferPartHandle, bufferHandle);
6729 throw std::runtime_error(
"Library not loaded!");
6735 auto& inst = instance();
6736 if(inst.m_PEAK_BufferPart_Destruct)
6738 return inst.m_PEAK_BufferPart_Destruct(bufferPartHandle);
6742 throw std::runtime_error(
"Library not loaded!");
6748 auto& inst = instance();
6749 if(inst.m_PEAK_ModuleDescriptor_GetID)
6751 return inst.m_PEAK_ModuleDescriptor_GetID(moduleDescriptorHandle,
id, idSize);
6755 throw std::runtime_error(
"Library not loaded!");
6761 auto& inst = instance();
6762 if(inst.m_PEAK_Module_GetNumNodeMaps)
6764 return inst.m_PEAK_Module_GetNumNodeMaps(moduleHandle, numNodeMaps);
6768 throw std::runtime_error(
"Library not loaded!");
6774 auto& inst = instance();
6775 if(inst.m_PEAK_Module_GetNodeMap)
6777 return inst.m_PEAK_Module_GetNodeMap(moduleHandle, index, nodeMapHandle);
6781 throw std::runtime_error(
"Library not loaded!");
6787 auto& inst = instance();
6788 if(inst.m_PEAK_Module_GetPort)
6790 return inst.m_PEAK_Module_GetPort(moduleHandle, portHandle);
6794 throw std::runtime_error(
"Library not loaded!");
6800 auto& inst = instance();
6801 if(inst.m_PEAK_NodeMap_GetHasNode)
6803 return inst.m_PEAK_NodeMap_GetHasNode(nodeMapHandle, nodeName, nodeNameSize, hasNode);
6807 throw std::runtime_error(
"Library not loaded!");
6813 auto& inst = instance();
6814 if(inst.m_PEAK_NodeMap_FindNode)
6816 return inst.m_PEAK_NodeMap_FindNode(nodeMapHandle, nodeName, nodeNameSize, nodeHandle);
6820 throw std::runtime_error(
"Library not loaded!");
6826 auto& inst = instance();
6827 if(inst.m_PEAK_NodeMap_InvalidateNodes)
6829 return inst.m_PEAK_NodeMap_InvalidateNodes(nodeMapHandle);
6833 throw std::runtime_error(
"Library not loaded!");
6839 auto& inst = instance();
6840 if(inst.m_PEAK_NodeMap_PollNodes)
6842 return inst.m_PEAK_NodeMap_PollNodes(nodeMapHandle, elapsedTime_ms);
6846 throw std::runtime_error(
"Library not loaded!");
6852 auto& inst = instance();
6853 if(inst.m_PEAK_NodeMap_GetNumNodes)
6855 return inst.m_PEAK_NodeMap_GetNumNodes(nodeMapHandle, numNodes);
6859 throw std::runtime_error(
"Library not loaded!");
6865 auto& inst = instance();
6866 if(inst.m_PEAK_NodeMap_GetNode)
6868 return inst.m_PEAK_NodeMap_GetNode(nodeMapHandle, index, nodeHandle);
6872 throw std::runtime_error(
"Library not loaded!");
6878 auto& inst = instance();
6879 if(inst.m_PEAK_NodeMap_GetHasBufferSupportedChunks)
6881 return inst.m_PEAK_NodeMap_GetHasBufferSupportedChunks(nodeMapHandle, bufferHandle, hasSupportedChunks);
6885 throw std::runtime_error(
"Library not loaded!");
6891 auto& inst = instance();
6892 if(inst.m_PEAK_NodeMap_UpdateChunkNodes)
6894 return inst.m_PEAK_NodeMap_UpdateChunkNodes(nodeMapHandle, bufferHandle);
6898 throw std::runtime_error(
"Library not loaded!");
6904 auto& inst = instance();
6905 if(inst.m_PEAK_NodeMap_GetHasEventSupportedData)
6907 return inst.m_PEAK_NodeMap_GetHasEventSupportedData(nodeMapHandle, eventHandle, hasSupportedData);
6911 throw std::runtime_error(
"Library not loaded!");
6917 auto& inst = instance();
6918 if(inst.m_PEAK_NodeMap_UpdateEventNodes)
6920 return inst.m_PEAK_NodeMap_UpdateEventNodes(nodeMapHandle, eventHandle);
6924 throw std::runtime_error(
"Library not loaded!");
6930 auto& inst = instance();
6931 if(inst.m_PEAK_NodeMap_StoreToFile)
6933 return inst.m_PEAK_NodeMap_StoreToFile(nodeMapHandle, filePath, filePathSize);
6937 throw std::runtime_error(
"Library not loaded!");
6943 auto& inst = instance();
6944 if(inst.m_PEAK_NodeMap_LoadFromFile)
6946 return inst.m_PEAK_NodeMap_LoadFromFile(nodeMapHandle, filePath, filePathSize);
6950 throw std::runtime_error(
"Library not loaded!");
6956 auto& inst = instance();
6957 if(inst.m_PEAK_NodeMap_Lock)
6959 return inst.m_PEAK_NodeMap_Lock(nodeMapHandle);
6963 throw std::runtime_error(
"Library not loaded!");
6969 auto& inst = instance();
6970 if(inst.m_PEAK_NodeMap_Unlock)
6972 return inst.m_PEAK_NodeMap_Unlock(nodeMapHandle);
6976 throw std::runtime_error(
"Library not loaded!");
6982 auto& inst = instance();
6983 if(inst.m_PEAK_Node_ToIntegerNode)
6985 return inst.m_PEAK_Node_ToIntegerNode(nodeHandle, integerNodeHandle);
6989 throw std::runtime_error(
"Library not loaded!");
6995 auto& inst = instance();
6996 if(inst.m_PEAK_Node_ToBooleanNode)
6998 return inst.m_PEAK_Node_ToBooleanNode(nodeHandle, booleanNodeHandle);
7002 throw std::runtime_error(
"Library not loaded!");
7008 auto& inst = instance();
7009 if(inst.m_PEAK_Node_ToCommandNode)
7011 return inst.m_PEAK_Node_ToCommandNode(nodeHandle, commandNodeHandle);
7015 throw std::runtime_error(
"Library not loaded!");
7021 auto& inst = instance();
7022 if(inst.m_PEAK_Node_ToFloatNode)
7024 return inst.m_PEAK_Node_ToFloatNode(nodeHandle, floatNodeHandle);
7028 throw std::runtime_error(
"Library not loaded!");
7034 auto& inst = instance();
7035 if(inst.m_PEAK_Node_ToStringNode)
7037 return inst.m_PEAK_Node_ToStringNode(nodeHandle, stringNodeHandle);
7041 throw std::runtime_error(
"Library not loaded!");
7047 auto& inst = instance();
7048 if(inst.m_PEAK_Node_ToRegisterNode)
7050 return inst.m_PEAK_Node_ToRegisterNode(nodeHandle, registerNodeHandle);
7054 throw std::runtime_error(
"Library not loaded!");
7060 auto& inst = instance();
7061 if(inst.m_PEAK_Node_ToCategoryNode)
7063 return inst.m_PEAK_Node_ToCategoryNode(nodeHandle, categoryNodeHandle);
7067 throw std::runtime_error(
"Library not loaded!");
7073 auto& inst = instance();
7074 if(inst.m_PEAK_Node_ToEnumerationNode)
7076 return inst.m_PEAK_Node_ToEnumerationNode(nodeHandle, enumerationNodeHandle);
7080 throw std::runtime_error(
"Library not loaded!");
7086 auto& inst = instance();
7087 if(inst.m_PEAK_Node_ToEnumerationEntryNode)
7089 return inst.m_PEAK_Node_ToEnumerationEntryNode(nodeHandle, enumerationEntryNodeHandle);
7093 throw std::runtime_error(
"Library not loaded!");
7099 auto& inst = instance();
7100 if(inst.m_PEAK_Node_GetName)
7102 return inst.m_PEAK_Node_GetName(nodeHandle, name, nameSize);
7106 throw std::runtime_error(
"Library not loaded!");
7112 auto& inst = instance();
7113 if(inst.m_PEAK_Node_GetDisplayName)
7115 return inst.m_PEAK_Node_GetDisplayName(nodeHandle, displayName, displayNameSize);
7119 throw std::runtime_error(
"Library not loaded!");
7125 auto& inst = instance();
7126 if(inst.m_PEAK_Node_GetNamespace)
7128 return inst.m_PEAK_Node_GetNamespace(nodeHandle, _namespace);
7132 throw std::runtime_error(
"Library not loaded!");
7138 auto& inst = instance();
7139 if(inst.m_PEAK_Node_GetVisibility)
7141 return inst.m_PEAK_Node_GetVisibility(nodeHandle, visibility);
7145 throw std::runtime_error(
"Library not loaded!");
7151 auto& inst = instance();
7152 if(inst.m_PEAK_Node_GetAccessStatus)
7154 return inst.m_PEAK_Node_GetAccessStatus(nodeHandle, accessStatus);
7158 throw std::runtime_error(
"Library not loaded!");
7164 auto& inst = instance();
7165 if(inst.m_PEAK_Node_GetIsCacheable)
7167 return inst.m_PEAK_Node_GetIsCacheable(nodeHandle, isCacheable);
7171 throw std::runtime_error(
"Library not loaded!");
7177 auto& inst = instance();
7178 if(inst.m_PEAK_Node_GetIsAccessStatusCacheable)
7180 return inst.m_PEAK_Node_GetIsAccessStatusCacheable(nodeHandle, isAccessStatusCacheable);
7184 throw std::runtime_error(
"Library not loaded!");
7190 auto& inst = instance();
7191 if(inst.m_PEAK_Node_GetIsStreamable)
7193 return inst.m_PEAK_Node_GetIsStreamable(nodeHandle, isStreamable);
7197 throw std::runtime_error(
"Library not loaded!");
7203 auto& inst = instance();
7204 if(inst.m_PEAK_Node_GetIsDeprecated)
7206 return inst.m_PEAK_Node_GetIsDeprecated(nodeHandle, isDeprecated);
7210 throw std::runtime_error(
"Library not loaded!");
7216 auto& inst = instance();
7217 if(inst.m_PEAK_Node_GetIsFeature)
7219 return inst.m_PEAK_Node_GetIsFeature(nodeHandle, isFeature);
7223 throw std::runtime_error(
"Library not loaded!");
7229 auto& inst = instance();
7230 if(inst.m_PEAK_Node_GetCachingMode)
7232 return inst.m_PEAK_Node_GetCachingMode(nodeHandle, cachingMode);
7236 throw std::runtime_error(
"Library not loaded!");
7242 auto& inst = instance();
7243 if(inst.m_PEAK_Node_GetPollingTime)
7245 return inst.m_PEAK_Node_GetPollingTime(nodeHandle, pollingTime_ms);
7249 throw std::runtime_error(
"Library not loaded!");
7255 auto& inst = instance();
7256 if(inst.m_PEAK_Node_GetToolTip)
7258 return inst.m_PEAK_Node_GetToolTip(nodeHandle, toolTip, toolTipSize);
7262 throw std::runtime_error(
"Library not loaded!");
7268 auto& inst = instance();
7269 if(inst.m_PEAK_Node_GetDescription)
7271 return inst.m_PEAK_Node_GetDescription(nodeHandle, description, descriptionSize);
7275 throw std::runtime_error(
"Library not loaded!");
7281 auto& inst = instance();
7282 if(inst.m_PEAK_Node_GetType)
7284 return inst.m_PEAK_Node_GetType(nodeHandle, type);
7288 throw std::runtime_error(
"Library not loaded!");
7294 auto& inst = instance();
7295 if(inst.m_PEAK_Node_GetParentNodeMap)
7297 return inst.m_PEAK_Node_GetParentNodeMap(nodeHandle, nodeMapHandle);
7301 throw std::runtime_error(
"Library not loaded!");
7307 auto& inst = instance();
7308 if(inst.m_PEAK_Node_FindInvalidatedNode)
7310 return inst.m_PEAK_Node_FindInvalidatedNode(nodeHandle, name, nameSize, invalidatedNodeHandle);
7314 throw std::runtime_error(
"Library not loaded!");
7320 auto& inst = instance();
7321 if(inst.m_PEAK_Node_GetNumInvalidatedNodes)
7323 return inst.m_PEAK_Node_GetNumInvalidatedNodes(nodeHandle, numInvalidatedNodes);
7327 throw std::runtime_error(
"Library not loaded!");
7333 auto& inst = instance();
7334 if(inst.m_PEAK_Node_GetInvalidatedNode)
7336 return inst.m_PEAK_Node_GetInvalidatedNode(nodeHandle, index, invalidatedNodeHandle);
7340 throw std::runtime_error(
"Library not loaded!");
7346 auto& inst = instance();
7347 if(inst.m_PEAK_Node_FindInvalidatingNode)
7349 return inst.m_PEAK_Node_FindInvalidatingNode(nodeHandle, name, nameSize, invalidatingNodeHandle);
7353 throw std::runtime_error(
"Library not loaded!");
7359 auto& inst = instance();
7360 if(inst.m_PEAK_Node_GetNumInvalidatingNodes)
7362 return inst.m_PEAK_Node_GetNumInvalidatingNodes(nodeHandle, numInvalidatingNodes);
7366 throw std::runtime_error(
"Library not loaded!");
7372 auto& inst = instance();
7373 if(inst.m_PEAK_Node_GetInvalidatingNode)
7375 return inst.m_PEAK_Node_GetInvalidatingNode(nodeHandle, index, invalidatingNodeHandle);
7379 throw std::runtime_error(
"Library not loaded!");
7385 auto& inst = instance();
7386 if(inst.m_PEAK_Node_FindSelectedNode)
7388 return inst.m_PEAK_Node_FindSelectedNode(nodeHandle, name, nameSize, selectedNodeHandle);
7392 throw std::runtime_error(
"Library not loaded!");
7398 auto& inst = instance();
7399 if(inst.m_PEAK_Node_GetNumSelectedNodes)
7401 return inst.m_PEAK_Node_GetNumSelectedNodes(nodeHandle, numSelectedNodes);
7405 throw std::runtime_error(
"Library not loaded!");
7411 auto& inst = instance();
7412 if(inst.m_PEAK_Node_GetSelectedNode)
7414 return inst.m_PEAK_Node_GetSelectedNode(nodeHandle, index, selectedNodeHandle);
7418 throw std::runtime_error(
"Library not loaded!");
7424 auto& inst = instance();
7425 if(inst.m_PEAK_Node_FindSelectingNode)
7427 return inst.m_PEAK_Node_FindSelectingNode(nodeHandle, name, nameSize, selectingNodeHandle);
7431 throw std::runtime_error(
"Library not loaded!");
7437 auto& inst = instance();
7438 if(inst.m_PEAK_Node_GetNumSelectingNodes)
7440 return inst.m_PEAK_Node_GetNumSelectingNodes(nodeHandle, numSelectingNodes);
7444 throw std::runtime_error(
"Library not loaded!");
7450 auto& inst = instance();
7451 if(inst.m_PEAK_Node_GetSelectingNode)
7453 return inst.m_PEAK_Node_GetSelectingNode(nodeHandle, index, selectingNodeHandle);
7457 throw std::runtime_error(
"Library not loaded!");
7463 auto& inst = instance();
7464 if(inst.m_PEAK_Node_RegisterChangedCallback)
7466 return inst.m_PEAK_Node_RegisterChangedCallback(nodeHandle, callback, callbackContext, callbackHandle);
7470 throw std::runtime_error(
"Library not loaded!");
7476 auto& inst = instance();
7477 if(inst.m_PEAK_Node_UnregisterChangedCallback)
7479 return inst.m_PEAK_Node_UnregisterChangedCallback(nodeHandle, callbackHandle);
7483 throw std::runtime_error(
"Library not loaded!");
7489 auto& inst = instance();
7490 if(inst.m_PEAK_IntegerNode_ToNode)
7492 return inst.m_PEAK_IntegerNode_ToNode(integerNodeHandle, nodeHandle);
7496 throw std::runtime_error(
"Library not loaded!");
7502 auto& inst = instance();
7503 if(inst.m_PEAK_IntegerNode_GetMinimum)
7505 return inst.m_PEAK_IntegerNode_GetMinimum(integerNodeHandle, minimum);
7509 throw std::runtime_error(
"Library not loaded!");
7515 auto& inst = instance();
7516 if(inst.m_PEAK_IntegerNode_GetMaximum)
7518 return inst.m_PEAK_IntegerNode_GetMaximum(integerNodeHandle, maximum);
7522 throw std::runtime_error(
"Library not loaded!");
7528 auto& inst = instance();
7529 if(inst.m_PEAK_IntegerNode_GetIncrement)
7531 return inst.m_PEAK_IntegerNode_GetIncrement(integerNodeHandle, increment);
7535 throw std::runtime_error(
"Library not loaded!");
7541 auto& inst = instance();
7542 if(inst.m_PEAK_IntegerNode_GetIncrementType)
7544 return inst.m_PEAK_IntegerNode_GetIncrementType(integerNodeHandle, incrementType);
7548 throw std::runtime_error(
"Library not loaded!");
7554 auto& inst = instance();
7555 if(inst.m_PEAK_IntegerNode_GetValidValues)
7557 return inst.m_PEAK_IntegerNode_GetValidValues(integerNodeHandle, validValues, validValuesSize);
7561 throw std::runtime_error(
"Library not loaded!");
7567 auto& inst = instance();
7568 if(inst.m_PEAK_IntegerNode_GetRepresentation)
7570 return inst.m_PEAK_IntegerNode_GetRepresentation(integerNodeHandle, representation);
7574 throw std::runtime_error(
"Library not loaded!");
7580 auto& inst = instance();
7581 if(inst.m_PEAK_IntegerNode_GetUnit)
7583 return inst.m_PEAK_IntegerNode_GetUnit(integerNodeHandle, unit, unitSize);
7587 throw std::runtime_error(
"Library not loaded!");
7593 auto& inst = instance();
7594 if(inst.m_PEAK_IntegerNode_GetValue)
7596 return inst.m_PEAK_IntegerNode_GetValue(integerNodeHandle, cacheUsePolicy, value);
7600 throw std::runtime_error(
"Library not loaded!");
7606 auto& inst = instance();
7607 if(inst.m_PEAK_IntegerNode_SetValue)
7609 return inst.m_PEAK_IntegerNode_SetValue(integerNodeHandle, value);
7613 throw std::runtime_error(
"Library not loaded!");
7619 auto& inst = instance();
7620 if(inst.m_PEAK_BooleanNode_ToNode)
7622 return inst.m_PEAK_BooleanNode_ToNode(booleanNodeHandle, nodeHandle);
7626 throw std::runtime_error(
"Library not loaded!");
7632 auto& inst = instance();
7633 if(inst.m_PEAK_BooleanNode_GetValue)
7635 return inst.m_PEAK_BooleanNode_GetValue(booleanNodeHandle, cacheUsePolicy, value);
7639 throw std::runtime_error(
"Library not loaded!");
7645 auto& inst = instance();
7646 if(inst.m_PEAK_BooleanNode_SetValue)
7648 return inst.m_PEAK_BooleanNode_SetValue(booleanNodeHandle, value);
7652 throw std::runtime_error(
"Library not loaded!");
7658 auto& inst = instance();
7659 if(inst.m_PEAK_CommandNode_ToNode)
7661 return inst.m_PEAK_CommandNode_ToNode(commandNodeHandle, nodeHandle);
7665 throw std::runtime_error(
"Library not loaded!");
7671 auto& inst = instance();
7672 if(inst.m_PEAK_CommandNode_GetIsDone)
7674 return inst.m_PEAK_CommandNode_GetIsDone(commandNodeHandle, isDone);
7678 throw std::runtime_error(
"Library not loaded!");
7684 auto& inst = instance();
7685 if(inst.m_PEAK_CommandNode_Execute)
7687 return inst.m_PEAK_CommandNode_Execute(commandNodeHandle);
7691 throw std::runtime_error(
"Library not loaded!");
7697 auto& inst = instance();
7698 if(inst.m_PEAK_CommandNode_WaitUntilDoneInfinite)
7700 return inst.m_PEAK_CommandNode_WaitUntilDoneInfinite(commandNodeHandle);
7704 throw std::runtime_error(
"Library not loaded!");
7710 auto& inst = instance();
7711 if(inst.m_PEAK_CommandNode_WaitUntilDone)
7713 return inst.m_PEAK_CommandNode_WaitUntilDone(commandNodeHandle, waitTimeout_ms);
7717 throw std::runtime_error(
"Library not loaded!");
7723 auto& inst = instance();
7724 if(inst.m_PEAK_FloatNode_ToNode)
7726 return inst.m_PEAK_FloatNode_ToNode(floatNodeHandle, nodeHandle);
7730 throw std::runtime_error(
"Library not loaded!");
7736 auto& inst = instance();
7737 if(inst.m_PEAK_FloatNode_GetMinimum)
7739 return inst.m_PEAK_FloatNode_GetMinimum(floatNodeHandle, minimum);
7743 throw std::runtime_error(
"Library not loaded!");
7749 auto& inst = instance();
7750 if(inst.m_PEAK_FloatNode_GetMaximum)
7752 return inst.m_PEAK_FloatNode_GetMaximum(floatNodeHandle, maximum);
7756 throw std::runtime_error(
"Library not loaded!");
7762 auto& inst = instance();
7763 if(inst.m_PEAK_FloatNode_GetIncrement)
7765 return inst.m_PEAK_FloatNode_GetIncrement(floatNodeHandle, increment);
7769 throw std::runtime_error(
"Library not loaded!");
7775 auto& inst = instance();
7776 if(inst.m_PEAK_FloatNode_GetIncrementType)
7778 return inst.m_PEAK_FloatNode_GetIncrementType(floatNodeHandle, incrementType);
7782 throw std::runtime_error(
"Library not loaded!");
7788 auto& inst = instance();
7789 if(inst.m_PEAK_FloatNode_GetValidValues)
7791 return inst.m_PEAK_FloatNode_GetValidValues(floatNodeHandle, validValues, validValuesSize);
7795 throw std::runtime_error(
"Library not loaded!");
7801 auto& inst = instance();
7802 if(inst.m_PEAK_FloatNode_GetRepresentation)
7804 return inst.m_PEAK_FloatNode_GetRepresentation(floatNodeHandle, representation);
7808 throw std::runtime_error(
"Library not loaded!");
7814 auto& inst = instance();
7815 if(inst.m_PEAK_FloatNode_GetUnit)
7817 return inst.m_PEAK_FloatNode_GetUnit(floatNodeHandle, unit, unitSize);
7821 throw std::runtime_error(
"Library not loaded!");
7827 auto& inst = instance();
7828 if(inst.m_PEAK_FloatNode_GetDisplayNotation)
7830 return inst.m_PEAK_FloatNode_GetDisplayNotation(floatNodeHandle, displayNotation);
7834 throw std::runtime_error(
"Library not loaded!");
7840 auto& inst = instance();
7841 if(inst.m_PEAK_FloatNode_GetDisplayPrecision)
7843 return inst.m_PEAK_FloatNode_GetDisplayPrecision(floatNodeHandle, displayPrecision);
7847 throw std::runtime_error(
"Library not loaded!");
7853 auto& inst = instance();
7854 if(inst.m_PEAK_FloatNode_GetHasConstantIncrement)
7856 return inst.m_PEAK_FloatNode_GetHasConstantIncrement(floatNodeHandle, hasConstantIncrement);
7860 throw std::runtime_error(
"Library not loaded!");
7866 auto& inst = instance();
7867 if(inst.m_PEAK_FloatNode_GetValue)
7869 return inst.m_PEAK_FloatNode_GetValue(floatNodeHandle, cacheUsePolicy, value);
7873 throw std::runtime_error(
"Library not loaded!");
7879 auto& inst = instance();
7880 if(inst.m_PEAK_FloatNode_SetValue)
7882 return inst.m_PEAK_FloatNode_SetValue(floatNodeHandle, value);
7886 throw std::runtime_error(
"Library not loaded!");
7892 auto& inst = instance();
7893 if(inst.m_PEAK_StringNode_ToNode)
7895 return inst.m_PEAK_StringNode_ToNode(stringNodeHandle, nodeHandle);
7899 throw std::runtime_error(
"Library not loaded!");
7905 auto& inst = instance();
7906 if(inst.m_PEAK_StringNode_GetMaximumLength)
7908 return inst.m_PEAK_StringNode_GetMaximumLength(stringNodeHandle, maximumLength);
7912 throw std::runtime_error(
"Library not loaded!");
7918 auto& inst = instance();
7919 if(inst.m_PEAK_StringNode_GetValue)
7921 return inst.m_PEAK_StringNode_GetValue(stringNodeHandle, cacheUsePolicy, value, valueSize);
7925 throw std::runtime_error(
"Library not loaded!");
7931 auto& inst = instance();
7932 if(inst.m_PEAK_StringNode_SetValue)
7934 return inst.m_PEAK_StringNode_SetValue(stringNodeHandle, value, valueSize);
7938 throw std::runtime_error(
"Library not loaded!");
7944 auto& inst = instance();
7945 if(inst.m_PEAK_RegisterNode_ToNode)
7947 return inst.m_PEAK_RegisterNode_ToNode(registerNodeHandle, nodeHandle);
7951 throw std::runtime_error(
"Library not loaded!");
7957 auto& inst = instance();
7958 if(inst.m_PEAK_RegisterNode_GetAddress)
7960 return inst.m_PEAK_RegisterNode_GetAddress(registerNodeHandle, address);
7964 throw std::runtime_error(
"Library not loaded!");
7970 auto& inst = instance();
7971 if(inst.m_PEAK_RegisterNode_GetLength)
7973 return inst.m_PEAK_RegisterNode_GetLength(registerNodeHandle, length);
7977 throw std::runtime_error(
"Library not loaded!");
7983 auto& inst = instance();
7984 if(inst.m_PEAK_RegisterNode_Read)
7986 return inst.m_PEAK_RegisterNode_Read(registerNodeHandle, cacheUsePolicy, bytesToRead, bytesToReadSize);
7990 throw std::runtime_error(
"Library not loaded!");
7996 auto& inst = instance();
7997 if(inst.m_PEAK_RegisterNode_Write)
7999 return inst.m_PEAK_RegisterNode_Write(registerNodeHandle, bytesToWrite, bytesToWriteSize);
8003 throw std::runtime_error(
"Library not loaded!");
8009 auto& inst = instance();
8010 if(inst.m_PEAK_CategoryNode_ToNode)
8012 return inst.m_PEAK_CategoryNode_ToNode(categoryNodeHandle, nodeHandle);
8016 throw std::runtime_error(
"Library not loaded!");
8022 auto& inst = instance();
8023 if(inst.m_PEAK_CategoryNode_GetNumSubNodes)
8025 return inst.m_PEAK_CategoryNode_GetNumSubNodes(categoryNodeHandle, numSubNodes);
8029 throw std::runtime_error(
"Library not loaded!");
8035 auto& inst = instance();
8036 if(inst.m_PEAK_CategoryNode_GetSubNode)
8038 return inst.m_PEAK_CategoryNode_GetSubNode(categoryNodeHandle, index, nodeHandle);
8042 throw std::runtime_error(
"Library not loaded!");
8048 auto& inst = instance();
8049 if(inst.m_PEAK_EnumerationNode_ToNode)
8051 return inst.m_PEAK_EnumerationNode_ToNode(enumerationNodeHandle, nodeHandle);
8055 throw std::runtime_error(
"Library not loaded!");
8061 auto& inst = instance();
8062 if(inst.m_PEAK_EnumerationNode_GetCurrentEntry)
8064 return inst.m_PEAK_EnumerationNode_GetCurrentEntry(enumerationNodeHandle, cacheUsePolicy, enumerationEntryNodeHandle);
8068 throw std::runtime_error(
"Library not loaded!");
8074 auto& inst = instance();
8075 if(inst.m_PEAK_EnumerationNode_SetCurrentEntry)
8077 return inst.m_PEAK_EnumerationNode_SetCurrentEntry(enumerationNodeHandle, enumerationEntryNodeHandle);
8081 throw std::runtime_error(
"Library not loaded!");
8087 auto& inst = instance();
8088 if(inst.m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue)
8090 return inst.m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize);
8094 throw std::runtime_error(
"Library not loaded!");
8100 auto& inst = instance();
8101 if(inst.m_PEAK_EnumerationNode_SetCurrentEntryByValue)
8103 return inst.m_PEAK_EnumerationNode_SetCurrentEntryByValue(enumerationNodeHandle, value);
8107 throw std::runtime_error(
"Library not loaded!");
8113 auto& inst = instance();
8114 if(inst.m_PEAK_EnumerationNode_FindEntryBySymbolicValue)
8116 return inst.m_PEAK_EnumerationNode_FindEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize, enumerationEntryNodeHandle);
8120 throw std::runtime_error(
"Library not loaded!");
8126 auto& inst = instance();
8127 if(inst.m_PEAK_EnumerationNode_FindEntryByValue)
8129 return inst.m_PEAK_EnumerationNode_FindEntryByValue(enumerationNodeHandle, value, enumerationEntryNodeHandle);
8133 throw std::runtime_error(
"Library not loaded!");
8139 auto& inst = instance();
8140 if(inst.m_PEAK_EnumerationNode_GetNumEntries)
8142 return inst.m_PEAK_EnumerationNode_GetNumEntries(enumerationNodeHandle, numEntries);
8146 throw std::runtime_error(
"Library not loaded!");
8152 auto& inst = instance();
8153 if(inst.m_PEAK_EnumerationNode_GetEntry)
8155 return inst.m_PEAK_EnumerationNode_GetEntry(enumerationNodeHandle, index, enumerationEntryNodeHandle);
8159 throw std::runtime_error(
"Library not loaded!");
8165 auto& inst = instance();
8166 if(inst.m_PEAK_EnumerationEntryNode_ToNode)
8168 return inst.m_PEAK_EnumerationEntryNode_ToNode(enumerationEntryNodeHandle, nodeHandle);
8172 throw std::runtime_error(
"Library not loaded!");
8178 auto& inst = instance();
8179 if(inst.m_PEAK_EnumerationEntryNode_GetIsSelfClearing)
8181 return inst.m_PEAK_EnumerationEntryNode_GetIsSelfClearing(enumerationEntryNodeHandle, isSelfClearing);
8185 throw std::runtime_error(
"Library not loaded!");
8191 auto& inst = instance();
8192 if(inst.m_PEAK_EnumerationEntryNode_GetSymbolicValue)
8194 return inst.m_PEAK_EnumerationEntryNode_GetSymbolicValue(enumerationEntryNodeHandle, symbolicValue, symbolicValueSize);
8198 throw std::runtime_error(
"Library not loaded!");
8204 auto& inst = instance();
8205 if(inst.m_PEAK_EnumerationEntryNode_GetValue)
8207 return inst.m_PEAK_EnumerationEntryNode_GetValue(enumerationEntryNodeHandle, value);
8211 throw std::runtime_error(
"Library not loaded!");
8217 auto& inst = instance();
8218 if(inst.m_PEAK_Port_GetInfo)
8220 return inst.m_PEAK_Port_GetInfo(portHandle, infoCommand, infoDataType, info, infoSize);
8224 throw std::runtime_error(
"Library not loaded!");
8230 auto& inst = instance();
8231 if(inst.m_PEAK_Port_GetID)
8233 return inst.m_PEAK_Port_GetID(portHandle,
id, idSize);
8237 throw std::runtime_error(
"Library not loaded!");
8243 auto& inst = instance();
8244 if(inst.m_PEAK_Port_GetName)
8246 return inst.m_PEAK_Port_GetName(portHandle, name, nameSize);
8250 throw std::runtime_error(
"Library not loaded!");
8256 auto& inst = instance();
8257 if(inst.m_PEAK_Port_GetVendorName)
8259 return inst.m_PEAK_Port_GetVendorName(portHandle, vendorName, vendorNameSize);
8263 throw std::runtime_error(
"Library not loaded!");
8269 auto& inst = instance();
8270 if(inst.m_PEAK_Port_GetModelName)
8272 return inst.m_PEAK_Port_GetModelName(portHandle, modelName, modelNameSize);
8276 throw std::runtime_error(
"Library not loaded!");
8282 auto& inst = instance();
8283 if(inst.m_PEAK_Port_GetVersion)
8285 return inst.m_PEAK_Port_GetVersion(portHandle, version, versionSize);
8289 throw std::runtime_error(
"Library not loaded!");
8295 auto& inst = instance();
8296 if(inst.m_PEAK_Port_GetTLType)
8298 return inst.m_PEAK_Port_GetTLType(portHandle, tlType, tlTypeSize);
8302 throw std::runtime_error(
"Library not loaded!");
8308 auto& inst = instance();
8309 if(inst.m_PEAK_Port_GetModuleName)
8311 return inst.m_PEAK_Port_GetModuleName(portHandle, moduleName, moduleNameSize);
8315 throw std::runtime_error(
"Library not loaded!");
8321 auto& inst = instance();
8322 if(inst.m_PEAK_Port_GetDataEndianness)
8324 return inst.m_PEAK_Port_GetDataEndianness(portHandle, dataEndianness);
8328 throw std::runtime_error(
"Library not loaded!");
8334 auto& inst = instance();
8335 if(inst.m_PEAK_Port_GetIsReadable)
8337 return inst.m_PEAK_Port_GetIsReadable(portHandle, isReadable);
8341 throw std::runtime_error(
"Library not loaded!");
8347 auto& inst = instance();
8348 if(inst.m_PEAK_Port_GetIsWritable)
8350 return inst.m_PEAK_Port_GetIsWritable(portHandle, isWritable);
8354 throw std::runtime_error(
"Library not loaded!");
8360 auto& inst = instance();
8361 if(inst.m_PEAK_Port_GetIsAvailable)
8363 return inst.m_PEAK_Port_GetIsAvailable(portHandle, isAvailable);
8367 throw std::runtime_error(
"Library not loaded!");
8373 auto& inst = instance();
8374 if(inst.m_PEAK_Port_GetIsImplemented)
8376 return inst.m_PEAK_Port_GetIsImplemented(portHandle, isImplemented);
8380 throw std::runtime_error(
"Library not loaded!");
8386 auto& inst = instance();
8387 if(inst.m_PEAK_Port_Read)
8389 return inst.m_PEAK_Port_Read(portHandle, address, bytesToRead, bytesToReadSize);
8393 throw std::runtime_error(
"Library not loaded!");
8399 auto& inst = instance();
8400 if(inst.m_PEAK_Port_Write)
8402 return inst.m_PEAK_Port_Write(portHandle, address, bytesToWrite, bytesToWriteSize);
8406 throw std::runtime_error(
"Library not loaded!");
8412 auto& inst = instance();
8413 if(inst.m_PEAK_Port_GetNumURLs)
8415 return inst.m_PEAK_Port_GetNumURLs(portHandle, numUrls);
8419 throw std::runtime_error(
"Library not loaded!");
8425 auto& inst = instance();
8426 if(inst.m_PEAK_Port_GetURL)
8428 return inst.m_PEAK_Port_GetURL(portHandle, index, portUrlHandle);
8432 throw std::runtime_error(
"Library not loaded!");
8438 auto& inst = instance();
8439 if(inst.m_PEAK_PortURL_GetInfo)
8441 return inst.m_PEAK_PortURL_GetInfo(portUrlHandle, infoCommand, infoDataType, info, infoSize);
8445 throw std::runtime_error(
"Library not loaded!");
8451 auto& inst = instance();
8452 if(inst.m_PEAK_PortURL_GetURL)
8454 return inst.m_PEAK_PortURL_GetURL(portUrlHandle, url, urlSize);
8458 throw std::runtime_error(
"Library not loaded!");
8464 auto& inst = instance();
8465 if(inst.m_PEAK_PortURL_GetScheme)
8467 return inst.m_PEAK_PortURL_GetScheme(portUrlHandle, scheme);
8471 throw std::runtime_error(
"Library not loaded!");
8477 auto& inst = instance();
8478 if(inst.m_PEAK_PortURL_GetFileName)
8480 return inst.m_PEAK_PortURL_GetFileName(portUrlHandle, fileName, fileNameSize);
8484 throw std::runtime_error(
"Library not loaded!");
8490 auto& inst = instance();
8491 if(inst.m_PEAK_PortURL_GetFileRegisterAddress)
8493 return inst.m_PEAK_PortURL_GetFileRegisterAddress(portUrlHandle, fileRegisterAddress);
8497 throw std::runtime_error(
"Library not loaded!");
8503 auto& inst = instance();
8504 if(inst.m_PEAK_PortURL_GetFileSize)
8506 return inst.m_PEAK_PortURL_GetFileSize(portUrlHandle, fileSize);
8510 throw std::runtime_error(
"Library not loaded!");
8516 auto& inst = instance();
8517 if(inst.m_PEAK_PortURL_GetFileSHA1Hash)
8519 return inst.m_PEAK_PortURL_GetFileSHA1Hash(portUrlHandle, fileSha1Hash, fileSha1HashSize);
8523 throw std::runtime_error(
"Library not loaded!");
8529 auto& inst = instance();
8530 if(inst.m_PEAK_PortURL_GetFileVersionMajor)
8532 return inst.m_PEAK_PortURL_GetFileVersionMajor(portUrlHandle, fileVersionMajor);
8536 throw std::runtime_error(
"Library not loaded!");
8542 auto& inst = instance();
8543 if(inst.m_PEAK_PortURL_GetFileVersionMinor)
8545 return inst.m_PEAK_PortURL_GetFileVersionMinor(portUrlHandle, fileVersionMinor);
8549 throw std::runtime_error(
"Library not loaded!");
8555 auto& inst = instance();
8556 if(inst.m_PEAK_PortURL_GetFileVersionSubminor)
8558 return inst.m_PEAK_PortURL_GetFileVersionSubminor(portUrlHandle, fileVersionSubminor);
8562 throw std::runtime_error(
"Library not loaded!");
8568 auto& inst = instance();
8569 if(inst.m_PEAK_PortURL_GetFileSchemaVersionMajor)
8571 return inst.m_PEAK_PortURL_GetFileSchemaVersionMajor(portUrlHandle, fileSchemaVersionMajor);
8575 throw std::runtime_error(
"Library not loaded!");
8581 auto& inst = instance();
8582 if(inst.m_PEAK_PortURL_GetFileSchemaVersionMinor)
8584 return inst.m_PEAK_PortURL_GetFileSchemaVersionMinor(portUrlHandle, fileSchemaVersionMinor);
8588 throw std::runtime_error(
"Library not loaded!");
8594 auto& inst = instance();
8595 if(inst.m_PEAK_PortURL_GetParentPort)
8597 return inst.m_PEAK_PortURL_GetParentPort(portUrlHandle, portHandle);
8601 throw std::runtime_error(
"Library not loaded!");
8607 auto& inst = instance();
8608 if(inst.m_PEAK_EventSupportingModule_EnableEvents)
8610 return inst.m_PEAK_EventSupportingModule_EnableEvents(eventSupportingModuleHandle, eventType, eventControllerHandle);
8614 throw std::runtime_error(
"Library not loaded!");
8620 auto& inst = instance();
8621 if(inst.m_PEAK_EventController_GetInfo)
8623 return inst.m_PEAK_EventController_GetInfo(eventControllerHandle, infoCommand, infoDataType, info, infoSize);
8627 throw std::runtime_error(
"Library not loaded!");
8633 auto& inst = instance();
8634 if(inst.m_PEAK_EventController_GetNumEventsInQueue)
8636 return inst.m_PEAK_EventController_GetNumEventsInQueue(eventControllerHandle, numEventsInQueue);
8640 throw std::runtime_error(
"Library not loaded!");
8646 auto& inst = instance();
8647 if(inst.m_PEAK_EventController_GetNumEventsFired)
8649 return inst.m_PEAK_EventController_GetNumEventsFired(eventControllerHandle, numEventsFired);
8653 throw std::runtime_error(
"Library not loaded!");
8659 auto& inst = instance();
8660 if(inst.m_PEAK_EventController_GetEventMaxSize)
8662 return inst.m_PEAK_EventController_GetEventMaxSize(eventControllerHandle, eventMaxSize);
8666 throw std::runtime_error(
"Library not loaded!");
8672 auto& inst = instance();
8673 if(inst.m_PEAK_EventController_GetEventDataMaxSize)
8675 return inst.m_PEAK_EventController_GetEventDataMaxSize(eventControllerHandle, eventDataMaxSize);
8679 throw std::runtime_error(
"Library not loaded!");
8685 auto& inst = instance();
8686 if(inst.m_PEAK_EventController_GetControlledEventType)
8688 return inst.m_PEAK_EventController_GetControlledEventType(eventControllerHandle, controlledEventType);
8692 throw std::runtime_error(
"Library not loaded!");
8698 auto& inst = instance();
8699 if(inst.m_PEAK_EventController_WaitForEvent)
8701 return inst.m_PEAK_EventController_WaitForEvent(eventControllerHandle, timeout_ms, eventHandle);
8705 throw std::runtime_error(
"Library not loaded!");
8711 auto& inst = instance();
8712 if(inst.m_PEAK_EventController_KillWait)
8714 return inst.m_PEAK_EventController_KillWait(eventControllerHandle);
8718 throw std::runtime_error(
"Library not loaded!");
8724 auto& inst = instance();
8725 if(inst.m_PEAK_EventController_FlushEvents)
8727 return inst.m_PEAK_EventController_FlushEvents(eventControllerHandle);
8731 throw std::runtime_error(
"Library not loaded!");
8737 auto& inst = instance();
8738 if(inst.m_PEAK_EventController_Destruct)
8740 return inst.m_PEAK_EventController_Destruct(eventControllerHandle);
8744 throw std::runtime_error(
"Library not loaded!");
8750 auto& inst = instance();
8751 if(inst.m_PEAK_Event_GetInfo)
8753 return inst.m_PEAK_Event_GetInfo(eventHandle, infoCommand, infoDataType, info, infoSize);
8757 throw std::runtime_error(
"Library not loaded!");
8763 auto& inst = instance();
8764 if(inst.m_PEAK_Event_GetID)
8766 return inst.m_PEAK_Event_GetID(eventHandle,
id);
8770 throw std::runtime_error(
"Library not loaded!");
8776 auto& inst = instance();
8777 if(inst.m_PEAK_Event_GetData)
8779 return inst.m_PEAK_Event_GetData(eventHandle, data, dataSize);
8783 throw std::runtime_error(
"Library not loaded!");
8789 auto& inst = instance();
8790 if(inst.m_PEAK_Event_GetType)
8792 return inst.m_PEAK_Event_GetType(eventHandle, type);
8796 throw std::runtime_error(
"Library not loaded!");
8802 auto& inst = instance();
8803 if(inst.m_PEAK_Event_GetRawData)
8805 return inst.m_PEAK_Event_GetRawData(eventHandle, rawData, rawDataSize);
8809 throw std::runtime_error(
"Library not loaded!");
8815 auto& inst = instance();
8816 if(inst.m_PEAK_Event_Destruct)
8818 return inst.m_PEAK_Event_Destruct(eventHandle);
8822 throw std::runtime_error(
"Library not loaded!");
8828 auto& inst = instance();
8829 if(inst.m_PEAK_FirmwareUpdater_Construct)
8831 return inst.m_PEAK_FirmwareUpdater_Construct(firmwareUpdaterHandle);
8835 throw std::runtime_error(
"Library not loaded!");
8841 auto& inst = instance();
8842 if(inst.m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation)
8844 return inst.m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(firmwareUpdaterHandle, gufPath, gufPathSize);
8848 throw std::runtime_error(
"Library not loaded!");
8854 auto& inst = instance();
8855 if(inst.m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation)
8857 return inst.m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(firmwareUpdaterHandle, gufPath, gufPathSize, deviceDescriptorHandle);
8861 throw std::runtime_error(
"Library not loaded!");
8867 auto& inst = instance();
8868 if(inst.m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation)
8870 return inst.m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(firmwareUpdaterHandle, numFirmwareUpdateInformation);
8874 throw std::runtime_error(
"Library not loaded!");
8880 auto& inst = instance();
8881 if(inst.m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation)
8883 return inst.m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(firmwareUpdaterHandle, index, firmwareUpdateInformationHandle);
8887 throw std::runtime_error(
"Library not loaded!");
8893 auto& inst = instance();
8894 if(inst.m_PEAK_FirmwareUpdater_UpdateDevice)
8896 return inst.m_PEAK_FirmwareUpdater_UpdateDevice(firmwareUpdaterHandle, deviceDescriptorHandle, firmwareUpdateInformationHandle, firmwareUpdateProgressObserverHandle);
8900 throw std::runtime_error(
"Library not loaded!");
8906 auto& inst = instance();
8907 if(inst.m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout)
8909 return inst.m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(firmwareUpdaterHandle, deviceDescriptorHandle, firmwareUpdateInformationHandle, firmwareUpdateProgressObserverHandle, deviceResetDiscoveryTimeout_ms);
8913 throw std::runtime_error(
"Library not loaded!");
8919 auto& inst = instance();
8920 if(inst.m_PEAK_FirmwareUpdater_Destruct)
8922 return inst.m_PEAK_FirmwareUpdater_Destruct(firmwareUpdaterHandle);
8926 throw std::runtime_error(
"Library not loaded!");
8932 auto& inst = instance();
8933 if(inst.m_PEAK_FirmwareUpdateInformation_GetIsValid)
8935 return inst.m_PEAK_FirmwareUpdateInformation_GetIsValid(firmwareUpdateInformationHandle, isValid);
8939 throw std::runtime_error(
"Library not loaded!");
8945 auto& inst = instance();
8946 if(inst.m_PEAK_FirmwareUpdateInformation_GetFileName)
8948 return inst.m_PEAK_FirmwareUpdateInformation_GetFileName(firmwareUpdateInformationHandle, fileName, fileNameSize);
8952 throw std::runtime_error(
"Library not loaded!");
8958 auto& inst = instance();
8959 if(inst.m_PEAK_FirmwareUpdateInformation_GetDescription)
8961 return inst.m_PEAK_FirmwareUpdateInformation_GetDescription(firmwareUpdateInformationHandle, description, descriptionSize);
8965 throw std::runtime_error(
"Library not loaded!");
8971 auto& inst = instance();
8972 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersion)
8974 return inst.m_PEAK_FirmwareUpdateInformation_GetVersion(firmwareUpdateInformationHandle, version, versionSize);
8978 throw std::runtime_error(
"Library not loaded!");
8984 auto& inst = instance();
8985 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern)
8987 return inst.m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(firmwareUpdateInformationHandle, versionExtractionPattern, versionExtractionPatternSize);
8991 throw std::runtime_error(
"Library not loaded!");
8997 auto& inst = instance();
8998 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersionStyle)
9000 return inst.m_PEAK_FirmwareUpdateInformation_GetVersionStyle(firmwareUpdateInformationHandle, versionStyle);
9004 throw std::runtime_error(
"Library not loaded!");
9010 auto& inst = instance();
9011 if(inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotes)
9013 return inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotes(firmwareUpdateInformationHandle, releaseNotes, releaseNotesSize);
9017 throw std::runtime_error(
"Library not loaded!");
9023 auto& inst = instance();
9024 if(inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL)
9026 return inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(firmwareUpdateInformationHandle, releaseNotesUrl, releaseNotesUrlSize);
9030 throw std::runtime_error(
"Library not loaded!");
9036 auto& inst = instance();
9037 if(inst.m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence)
9039 return inst.m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence(firmwareUpdateInformationHandle, userSetPersistence);
9043 throw std::runtime_error(
"Library not loaded!");
9049 auto& inst = instance();
9050 if(inst.m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence)
9052 return inst.m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(firmwareUpdateInformationHandle, sequencerSetPersistence);
9056 throw std::runtime_error(
"Library not loaded!");
9062 auto& inst = instance();
9063 if(inst.m_PEAK_FirmwareUpdateProgressObserver_Construct)
9065 return inst.m_PEAK_FirmwareUpdateProgressObserver_Construct(firmwareUpdateProgressObserverHandle);
9069 throw std::runtime_error(
"Library not loaded!");
9075 auto& inst = instance();
9076 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback)
9078 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9082 throw std::runtime_error(
"Library not loaded!");
9088 auto& inst = instance();
9089 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback)
9091 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9095 throw std::runtime_error(
"Library not loaded!");
9101 auto& inst = instance();
9102 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback)
9104 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9108 throw std::runtime_error(
"Library not loaded!");
9114 auto& inst = instance();
9115 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback)
9117 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9121 throw std::runtime_error(
"Library not loaded!");
9127 auto& inst = instance();
9128 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback)
9130 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9134 throw std::runtime_error(
"Library not loaded!");
9140 auto& inst = instance();
9141 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback)
9143 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9147 throw std::runtime_error(
"Library not loaded!");
9153 auto& inst = instance();
9154 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback)
9156 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9160 throw std::runtime_error(
"Library not loaded!");
9166 auto& inst = instance();
9167 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback)
9169 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9173 throw std::runtime_error(
"Library not loaded!");
9179 auto& inst = instance();
9180 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback)
9182 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9186 throw std::runtime_error(
"Library not loaded!");
9192 auto& inst = instance();
9193 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback)
9195 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9199 throw std::runtime_error(
"Library not loaded!");
9205 auto& inst = instance();
9206 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback)
9208 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9212 throw std::runtime_error(
"Library not loaded!");
9218 auto& inst = instance();
9219 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback)
9221 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9225 throw std::runtime_error(
"Library not loaded!");
9231 auto& inst = instance();
9232 if(inst.m_PEAK_FirmwareUpdateProgressObserver_Destruct)
9234 return inst.m_PEAK_FirmwareUpdateProgressObserver_Destruct(firmwareUpdateProgressObserverHandle);
9238 throw std::runtime_error(
"Library not loaded!");
Definition peak_dynamic_loader.h:452
static PEAK_C_API PEAK_Interface_Destruct(PEAK_INTERFACE_HANDLE interfaceHandle)
Definition peak_dynamic_loader.h:4939
static PEAK_C_API PEAK_BufferPart_GetWidth(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Definition peak_dynamic_loader.h:6642
static PEAK_C_API PEAK_DataStream_GetNumBuffersStarted(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Definition peak_dynamic_loader.h:5719
static PEAK_C_API PEAK_Interface_UnregisterDeviceListChangedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4926
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:7981
static PEAK_C_API PEAK_PortURL_GetFileSHA1Hash(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Definition peak_dynamic_loader.h:8514
static PEAK_C_API PEAK_Buffer_GetTLType(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:6005
static PEAK_C_API PEAK_DataStream_GetKey(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5602
static PEAK_C_API PEAK_DataStream_StopAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Definition peak_dynamic_loader.h:5940
static PEAK_C_API PEAK_Buffer_ToModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5966
static PEAK_C_API PEAK_Node_GetInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition peak_dynamic_loader.h:7331
static PEAK_C_API PEAK_SystemDescriptor_GetKey(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4081
static PEAK_C_API PEAK_Library_Initialize()
Definition peak_dynamic_loader.h:3886
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:7461
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:8696
static PEAK_C_API PEAK_DeviceDescriptor_GetKey(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4965
static PEAK_C_API PEAK_BufferChunk_GetBasePtr(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Definition peak_dynamic_loader.h:6499
static PEAK_C_API PEAK_Library_GetLastError(PEAK_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Definition peak_dynamic_loader.h:3964
static PEAK_C_API PEAK_BufferPart_GetSourceID(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Definition peak_dynamic_loader.h:6564
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:7864
static PEAK_C_API PEAK_EventController_FlushEvents(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8722
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:5875
static PEAK_C_API PEAK_Interface_UnregisterDeviceReconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4848
static PEAK_C_API PEAK_Node_ToEnumerationEntryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:7084
static PEAK_C_API PEAK_Buffer_GetPixelFormatNamespace(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Definition peak_dynamic_loader.h:6083
static PEAK_C_API PEAK_System_UpdateInterfaces(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:4471
static PEAK_C_API PEAK_BufferPart_GetFormatNamespace(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Definition peak_dynamic_loader.h:6629
static PEAK_C_API PEAK_System_GetNumInterfaces(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Definition peak_dynamic_loader.h:4484
static PEAK_C_API PEAK_System_GetVersion(PEAK_SYSTEM_HANDLE systemHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:4367
static bool isLoaded()
Definition peak_dynamic_loader.h:1351
static PEAK_C_API PEAK_System_GetCTIFullPath(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:4406
static PEAK_C_API PEAK_Library_GetVersionMinor(uint32_t *libraryVersionMinor)
Definition peak_dynamic_loader.h:3938
static PEAK_C_API PEAK_Node_UnregisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:7474
static PEAK_C_API PEAK_BufferChunk_GetParentBuffer(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:6525
static PEAK_C_API PEAK_DeviceDescriptor_GetVendorName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:5004
static PEAK_C_API PEAK_Node_GetCachingMode(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Definition peak_dynamic_loader.h:7227
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:7383
static PEAK_C_API PEAK_BufferPart_GetYOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:6681
static PEAK_C_API PEAK_FloatNode_GetIncrementType(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:7773
static PEAK_C_API PEAK_FloatNode_GetDisplayNotation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Definition peak_dynamic_loader.h:7825
static PEAK_C_API PEAK_Node_ToStringNode(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Definition peak_dynamic_loader.h:7032
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Destruct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:9229
static PEAK_C_API PEAK_NodeMap_GetHasBufferSupportedChunks(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Definition peak_dynamic_loader.h:6876
static PEAK_C_API PEAK_CategoryNode_GetNumSubNodes(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Definition peak_dynamic_loader.h:8020
static PEAK_C_API PEAK_Node_GetIsFeature(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Definition peak_dynamic_loader.h:7214
static PEAK_C_API PEAK_Interface_UnregisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4822
static PEAK_C_API PEAK_Buffer_GetIsIncomplete(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Definition peak_dynamic_loader.h:6343
static PEAK_C_API PEAK_Device_ToEventSupportingModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:5264
static PEAK_C_API PEAK_EnumerationEntryNode_ToNode(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8163
static PEAK_C_API PEAK_StringNode_SetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Definition peak_dynamic_loader.h:7929
static PEAK_C_API PEAK_PortURL_GetParentPort(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:8592
static PEAK_C_API PEAK_DataStream_GetIsGrabbing(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Definition peak_dynamic_loader.h:5797
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:8072
static PEAK_C_API PEAK_Device_GetVersion(PEAK_DEVICE_HANDLE deviceHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:5355
static PEAK_C_API PEAK_Device_Destruct(PEAK_DEVICE_HANDLE deviceHandle)
Definition peak_dynamic_loader.h:5485
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:8098
static PEAK_C_API PEAK_Node_GetIsStreamable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Definition peak_dynamic_loader.h:7188
static PEAK_C_API PEAK_CommandNode_WaitUntilDoneInfinite(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:7695
static PEAK_C_API PEAK_DataStream_QueueBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:5849
static PEAK_C_API PEAK_Device_GetTimestampTickFrequency(PEAK_DEVICE_HANDLE deviceHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:5420
static PEAK_C_API PEAK_Buffer_GetExpectedDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Definition peak_dynamic_loader.h:6109
static PEAK_C_API PEAK_Buffer_GetFrameID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Definition peak_dynamic_loader.h:6135
static PEAK_C_API PEAK_DeviceDescriptor_GetTimestampTickFrequency(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:5095
static PEAK_C_API PEAK_Node_ToCategoryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Definition peak_dynamic_loader.h:7058
static PEAK_C_API PEAK_EnumerationEntryNode_GetValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Definition peak_dynamic_loader.h:8202
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:5225
static PEAK_C_API PEAK_Node_ToCommandNode(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Definition peak_dynamic_loader.h:7006
static PEAK_C_API PEAK_Module_GetPort(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:6785
static PEAK_C_API PEAK_NodeMap_GetNumNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Definition peak_dynamic_loader.h:6850
static PEAK_C_API PEAK_Interface_UnregisterDeviceDisconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4874
static PEAK_C_API PEAK_PortURL_GetScheme(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Definition peak_dynamic_loader.h:8462
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:7630
static PEAK_C_API PEAK_Port_GetDataEndianness(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Definition peak_dynamic_loader.h:8319
static PEAK_C_API PEAK_BufferChunk_GetSize(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Definition peak_dynamic_loader.h:6512
static PEAK_C_API PEAK_Port_GetIsAvailable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Definition peak_dynamic_loader.h:8358
static PEAK_C_API PEAK_BufferPart_GetHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Definition peak_dynamic_loader.h:6655
static PEAK_C_API PEAK_IntegerNode_SetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:7604
static PEAK_C_API PEAK_StringNode_GetMaximumLength(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Definition peak_dynamic_loader.h:7903
static PEAK_C_API PEAK_Buffer_GetXPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:6265
static PEAK_C_API PEAK_Device_GetModelName(PEAK_DEVICE_HANDLE deviceHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:5342
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetIsValid(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Definition peak_dynamic_loader.h:8930
static PEAK_C_API PEAK_CommandNode_GetIsDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Definition peak_dynamic_loader.h:7669
static PEAK_C_API PEAK_Device_GetKey(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5277
static PEAK_C_API PEAK_Port_GetID(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:8228
~DynamicLoader()
Definition peak_dynamic_loader.h:1343
static PEAK_C_API PEAK_DeviceDescriptor_GetAccessStatus(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:5082
static PEAK_C_API PEAK_SystemDescriptor_GetDisplayName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4107
static PEAK_C_API PEAK_SystemDescriptor_GetTLType(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4159
static PEAK_C_API PEAK_PortURL_GetURL(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Definition peak_dynamic_loader.h:8449
static PEAK_C_API PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition peak_dynamic_loader.h:5199
static PEAK_C_API PEAK_Device_GetID(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:5303
static PEAK_C_API PEAK_Buffer_GetHasNewData(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Definition peak_dynamic_loader.h:6356
static PEAK_C_API PEAK_RegisterNode_GetAddress(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Definition peak_dynamic_loader.h:7955
static PEAK_C_API PEAK_System_Destruct(PEAK_SYSTEM_HANDLE systemHandle)
Definition peak_dynamic_loader.h:4562
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:9138
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:9203
static PEAK_C_API PEAK_PortURL_GetFileVersionSubminor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Definition peak_dynamic_loader.h:8553
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:5290
static PEAK_C_API PEAK_Buffer_GetChunkLayoutID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Definition peak_dynamic_loader.h:6187
static PEAK_C_API PEAK_SystemDescriptor_GetCTIFullPath(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:4185
static PEAK_C_API PEAK_IntegerNode_GetRepresentation(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:7565
static PEAK_C_API PEAK_RegisterNode_ToNode(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7942
static PEAK_C_API PEAK_System_UnregisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4549
static PEAK_C_API PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition peak_dynamic_loader.h:5212
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:4835
static PEAK_C_API PEAK_FloatNode_SetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Definition peak_dynamic_loader.h:7877
static PEAK_C_API PEAK_FloatNode_GetDisplayPrecision(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Definition peak_dynamic_loader.h:7838
static PEAK_C_API PEAK_Buffer_GetDeliveredDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Definition peak_dynamic_loader.h:6122
static PEAK_C_API PEAK_System_GetCTIFileName(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:4393
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetUserSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Definition peak_dynamic_loader.h:9034
static PEAK_C_API PEAK_ProducerLibrary_GetSystem(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Definition peak_dynamic_loader.h:4042
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Definition peak_dynamic_loader.h:8982
static PEAK_C_API PEAK_Event_GetRawData(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Definition peak_dynamic_loader.h:8800
static PEAK_C_API PEAK_DataStream_ToModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5576
static PEAK_C_API PEAK_Port_GetModuleName(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Definition peak_dynamic_loader.h:8306
static PEAK_C_API PEAK_DeviceDescriptor_GetParentInterface(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:5147
static PEAK_C_API PEAK_DataStream_GetNumChunksPerBufferMax(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numChunksPerBufferMax)
Definition peak_dynamic_loader.h:5745
static PEAK_C_API PEAK_BufferPart_GetParentBuffer(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:6720
static PEAK_C_API PEAK_Interface_GetTLType(PEAK_INTERFACE_HANDLE interfaceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4744
static PEAK_C_API PEAK_Device_GetVendorName(PEAK_DEVICE_HANDLE deviceHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:5329
static PEAK_C_API PEAK_PortURL_GetFileRegisterAddress(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Definition peak_dynamic_loader.h:8488
static PEAK_C_API PEAK_Buffer_GetTimestamp_ns(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Definition peak_dynamic_loader.h:6304
static PEAK_C_API PEAK_Port_GetModelName(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:8267
static PEAK_C_API PEAK_FloatNode_GetRepresentation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:7799
static PEAK_C_API PEAK_EnvironmentInspector_UpdateCTIPaths()
Definition peak_dynamic_loader.h:3977
static PEAK_C_API PEAK_PortURL_GetFileVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Definition peak_dynamic_loader.h:8527
static PEAK_C_API PEAK_Interface_GetParentSystem(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4757
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:6811
static PEAK_C_API PEAK_System_ToModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:4263
static PEAK_C_API PEAK_ProducerLibrary_Construct(const char *ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4016
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotes(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Definition peak_dynamic_loader.h:9008
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:5238
static PEAK_C_API PEAK_BufferChunk_Destruct(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Definition peak_dynamic_loader.h:6538
static PEAK_C_API PEAK_NodeMap_UpdateEventNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:6915
static PEAK_C_API PEAK_DataStream_GetTLType(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5641
static PEAK_C_API PEAK_Port_GetVersion(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:8280
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:9164
static PEAK_C_API PEAK_Event_GetType(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Definition peak_dynamic_loader.h:8787
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:5992
static PEAK_C_API PEAK_FloatNode_ToNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7721
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:9190
static PEAK_C_API PEAK_Event_GetID(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Definition peak_dynamic_loader.h:8761
static PEAK_C_API PEAK_DataStream_GetNumBuffersQueued(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersQueued)
Definition peak_dynamic_loader.h:5680
static PEAK_C_API PEAK_Buffer_GetHasParts(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasParts)
Definition peak_dynamic_loader.h:6395
static PEAK_C_API PEAK_EventController_GetEventDataMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Definition peak_dynamic_loader.h:8670
static PEAK_C_API PEAK_ProducerLibrary_GetKey(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4029
static PEAK_C_API PEAK_IntegerNode_GetUnit(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:7578
static PEAK_C_API PEAK_BufferPart_GetSize(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Definition peak_dynamic_loader.h:6590
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:7916
static PEAK_C_API PEAK_DataStream_GetNumBuffersAnnounced(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnounced)
Definition peak_dynamic_loader.h:5667
static PEAK_C_API PEAK_Buffer_GetChunk(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Definition peak_dynamic_loader.h:6434
static PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenableExclusive(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Definition peak_dynamic_loader.h:5108
static PEAK_C_API PEAK_CommandNode_ToNode(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7656
static PEAK_C_API PEAK_PortURL_GetFileSize(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Definition peak_dynamic_loader.h:8501
static PEAK_C_API PEAK_DataStream_Flush(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Definition peak_dynamic_loader.h:5901
static PEAK_C_API PEAK_EnvironmentInspector_GetCTIPath(size_t index, char *ctiPath, size_t *ctiPathSize)
Definition peak_dynamic_loader.h:4003
static PEAK_C_API PEAK_Interface_GetKey(PEAK_INTERFACE_HANDLE interfaceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4692
static PEAK_C_API PEAK_Buffer_ToEventSupportingModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:5979
static PEAK_C_API PEAK_Device_GetNumDataStreams(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Definition peak_dynamic_loader.h:5459
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:9099
static PEAK_C_API PEAK_Device_ToModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5251
static PEAK_C_API PEAK_DataStreamDescriptor_GetParentDevice(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5550
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:8384
static PEAK_C_API PEAK_InterfaceDescriptor_ToModuleDescriptor(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:4575
static PEAK_C_API PEAK_FloatNode_GetIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Definition peak_dynamic_loader.h:7760
static PEAK_C_API PEAK_Interface_GetDevice(PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE *deviceDescriptorHandle)
Definition peak_dynamic_loader.h:4796
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:9086
static PEAK_C_API PEAK_Node_GetNumSelectingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Definition peak_dynamic_loader.h:7435
static PEAK_C_API PEAK_Buffer_UpdateParts(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6447
static PEAK_C_API PEAK_BufferPart_GetXPadding(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:6694
static PEAK_C_API PEAK_BufferPart_GetType(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Definition peak_dynamic_loader.h:6603
static PEAK_C_API PEAK_Node_GetNamespace(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Definition peak_dynamic_loader.h:7123
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:5927
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Definition peak_dynamic_loader.h:9047
static PEAK_C_API PEAK_DeviceDescriptor_GetTLType(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5043
static PEAK_C_API PEAK_Node_GetVisibility(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Definition peak_dynamic_loader.h:7136
static PEAK_C_API PEAK_Node_GetIsAccessStatusCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Definition peak_dynamic_loader.h:7175
static PEAK_C_API PEAK_DataStream_GetID(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:5628
static PEAK_C_API PEAK_SystemDescriptor_GetVersion(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:4146
static PEAK_C_API PEAK_IntegerNode_GetValidValues(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:7552
static PEAK_C_API PEAK_IntegerNode_GetMinimum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Definition peak_dynamic_loader.h:7500
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:4510
static PEAK_C_API PEAK_System_GetKey(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4289
static PEAK_C_API PEAK_EventController_Destruct(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8735
static PEAK_C_API PEAK_Port_GetNumURLs(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Definition peak_dynamic_loader.h:8410
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:8111
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:8878
static PEAK_C_API PEAK_PortURL_GetFileName(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:8475
static PEAK_C_API PEAK_Module_GetNodeMap(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:6772
static PEAK_C_API PEAK_Interface_UnregisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4900
static PEAK_C_API PEAK_Event_GetData(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Definition peak_dynamic_loader.h:8774
static PEAK_C_API PEAK_DeviceDescriptor_GetDisplayName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4991
static PEAK_C_API PEAK_FloatNode_GetUnit(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:7812
static PEAK_C_API PEAK_EventController_GetNumEventsInQueue(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Definition peak_dynamic_loader.h:8631
static PEAK_C_API PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:5173
static PEAK_C_API PEAK_EnumerationNode_ToNode(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8046
static PEAK_C_API PEAK_Module_GetNumNodeMaps(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Definition peak_dynamic_loader.h:6759
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:8748
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:8215
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:9112
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:8150
static PEAK_C_API PEAK_CommandNode_WaitUntilDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Definition peak_dynamic_loader.h:7708
static PEAK_C_API PEAK_Node_GetNumSelectedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Definition peak_dynamic_loader.h:7396
static PEAK_C_API PEAK_FirmwareUpdater_Destruct(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:8917
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:8904
static PEAK_C_API PEAK_System_GetID(PEAK_SYSTEM_HANDLE systemHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:4315
static PEAK_C_API PEAK_System_GetDisplayName(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4328
static PEAK_C_API PEAK_DeviceDescriptor_GetModelName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:5017
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionStyle(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Definition peak_dynamic_loader.h:8995
static PEAK_C_API PEAK_FloatNode_GetHasConstantIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Definition peak_dynamic_loader.h:7851
static PEAK_C_API PEAK_Node_GetToolTip(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Definition peak_dynamic_loader.h:7253
static PEAK_C_API PEAK_RemoteDevice_GetLocalDevice(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5511
static PEAK_C_API PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Definition peak_dynamic_loader.h:8865
static PEAK_C_API PEAK_Interface_GetNumDevices(PEAK_INTERFACE_HANDLE interfaceHandle, size_t *numDevices)
Definition peak_dynamic_loader.h:4783
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:9073
static PEAK_C_API PEAK_EventController_KillWait(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8709
static PEAK_C_API PEAK_Node_GetIsDeprecated(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Definition peak_dynamic_loader.h:7201
static PEAK_C_API PEAK_DataStream_Destruct(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:5953
static PEAK_C_API PEAK_Interface_UpdateDevices(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:4770
static PEAK_C_API PEAK_SystemDescriptor_GetCTIFileName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:4172
static PEAK_C_API PEAK_EventController_GetNumEventsFired(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Definition peak_dynamic_loader.h:8644
static PEAK_C_API PEAK_NodeMap_PollNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Definition peak_dynamic_loader.h:6837
static PEAK_C_API PEAK_Node_GetDisplayName(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:7110
static PEAK_C_API PEAK_NodeMap_StoreToFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:6928
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Definition peak_dynamic_loader.h:8085
static PEAK_C_API PEAK_ProducerLibrary_Destruct(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Definition peak_dynamic_loader.h:4055
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:7305
static PEAK_C_API PEAK_Library_GetVersionSubminor(uint32_t *libraryVersionSubminor)
Definition peak_dynamic_loader.h:3951
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetDescription(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:8956
static PEAK_C_API PEAK_DataStream_GetBufferAlignment(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *bufferAlignment)
Definition peak_dynamic_loader.h:5758
static PEAK_C_API PEAK_Buffer_GetIsAcquiring(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Definition peak_dynamic_loader.h:6330
static PEAK_C_API PEAK_Buffer_GetWidth(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Definition peak_dynamic_loader.h:6213
static PEAK_C_API PEAK_BufferPart_GetBasePtr(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Definition peak_dynamic_loader.h:6577
static PEAK_C_API PEAK_NodeMap_Unlock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:6967
static PEAK_C_API PEAK_Node_GetPollingTime(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Definition peak_dynamic_loader.h:7240
static PEAK_C_API PEAK_Buffer_GetYOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:6252
static PEAK_C_API PEAK_Buffer_GetDeliveredImageHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:6161
static PEAK_C_API PEAK_FloatNode_GetValidValues(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:7786
static PEAK_C_API PEAK_SystemDescriptor_ToModuleDescriptor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:4068
static PEAK_C_API PEAK_System_GetModelName(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:4354
static PEAK_C_API PEAK_InterfaceDescriptor_GetTLType(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4627
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:4094
static PEAK_C_API PEAK_RemoteDevice_ToModule(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5498
static PEAK_C_API PEAK_InterfaceDescriptor_GetDisplayName(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4614
static PEAK_C_API PEAK_System_GetTLType(PEAK_SYSTEM_HANDLE systemHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4380
static PEAK_C_API PEAK_DataStreamDescriptor_ToModuleDescriptor(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:5524
static PEAK_C_API PEAK_System_GetGenTLVersionMinor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:4432
static PEAK_C_API PEAK_NodeMap_UpdateChunkNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6889
static PEAK_C_API PEAK_Buffer_GetUserPtr(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Definition peak_dynamic_loader.h:6044
static PEAK_C_API PEAK_Interface_ToEventSupportingModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:4679
static PEAK_C_API PEAK_DeviceDescriptor_ToModuleDescriptor(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:4952
static PEAK_C_API PEAK_CategoryNode_ToNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8007
static PEAK_C_API PEAK_Port_GetIsWritable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Definition peak_dynamic_loader.h:8345
static PEAK_C_API PEAK_Device_GetRemoteDevice(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Definition peak_dynamic_loader.h:5446
static PEAK_C_API PEAK_CategoryNode_GetSubNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8033
static PEAK_C_API PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:5160
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:4302
static PEAK_C_API PEAK_System_ToEventSupportingModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:4276
static PEAK_C_API PEAK_CommandNode_Execute(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:7682
static PEAK_C_API PEAK_RegisterNode_GetLength(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Definition peak_dynamic_loader.h:7968
static PEAK_C_API PEAK_BufferPart_GetFormat(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Definition peak_dynamic_loader.h:6616
static PEAK_C_API PEAK_Node_ToBooleanNode(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Definition peak_dynamic_loader.h:6993
static PEAK_C_API PEAK_Device_GetSerialNumber(PEAK_DEVICE_HANDLE deviceHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:5394
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:9125
static PEAK_C_API PEAK_Buffer_GetIsQueued(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Definition peak_dynamic_loader.h:6317
static PEAK_C_API PEAK_NodeMap_GetNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:6863
static PEAK_C_API PEAK_BooleanNode_ToNode(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7617
static PEAK_C_API PEAK_IntegerNode_GetIncrement(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Definition peak_dynamic_loader.h:7526
static PEAK_C_API PEAK_FirmwareUpdater_Construct(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:8826
static PEAK_C_API PEAK_Node_ToIntegerNode(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Definition peak_dynamic_loader.h:6980
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:8618
static PEAK_C_API PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Definition peak_dynamic_loader.h:8839
static PEAK_C_API PEAK_Interface_ToModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:4666
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:8059
static PEAK_C_API PEAK_Node_GetParentNodeMap(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:7292
static PEAK_C_API PEAK_Library_IsInitialized(PEAK_BOOL8 *isInitialized)
Definition peak_dynamic_loader.h:3912
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:5472
static PEAK_C_API PEAK_SystemDescriptor_GetParentLibrary(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4237
static PEAK_C_API PEAK_Buffer_GetTimestamp_ticks(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Definition peak_dynamic_loader.h:6291
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:9151
static PEAK_C_API PEAK_InterfaceDescriptor_GetParentSystem(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4640
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:5121
static PEAK_C_API PEAK_IntegerNode_GetMaximum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Definition peak_dynamic_loader.h:7513
static PEAK_C_API PEAK_System_GetParentLibrary(PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4458
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:4978
static PEAK_C_API PEAK_Buffer_GetPixelEndianness(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Definition peak_dynamic_loader.h:6096
static PEAK_C_API PEAK_Port_GetName(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:8241
static PEAK_C_API PEAK_Port_GetVendorName(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:8254
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:4705
static PEAK_C_API PEAK_InterfaceDescriptor_OpenInterface(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:4653
static PEAK_C_API PEAK_Device_GetAccessStatus(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:5407
static PEAK_C_API PEAK_NodeMap_Lock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:6954
static PEAK_C_API PEAK_BufferChunk_GetID(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Definition peak_dynamic_loader.h:6486
static PEAK_C_API PEAK_DataStream_GetParentDevice(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5810
static PEAK_C_API PEAK_DataStream_GetNumBuffersAwaitDelivery(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAwaitDelivery)
Definition peak_dynamic_loader.h:5693
static PEAK_C_API PEAK_Node_GetNumInvalidatingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Definition peak_dynamic_loader.h:7357
static PEAK_C_API PEAK_NodeMap_GetHasEventSupportedData(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Definition peak_dynamic_loader.h:6902
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:4861
static PEAK_C_API PEAK_RegisterNode_Write(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition peak_dynamic_loader.h:7994
static PEAK_C_API PEAK_System_GetInterface(PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE *interfaceDescriptorHandle)
Definition peak_dynamic_loader.h:4497
static PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMajor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMajor)
Definition peak_dynamic_loader.h:4198
static PEAK_C_API PEAK_ModuleDescriptor_GetID(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:6746
static PEAK_C_API PEAK_Buffer_GetDeliveredChunkPayloadSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Definition peak_dynamic_loader.h:6174
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:5134
static PEAK_C_API PEAK_BufferPart_GetDeliveredImageHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:6707
static PEAK_C_API PEAK_Buffer_GetXOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:6239
static PEAK_C_API PEAK_Node_ToRegisterNode(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Definition peak_dynamic_loader.h:7045
static PEAK_C_API PEAK_Port_GetTLType(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:8293
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:5836
static PEAK_C_API PEAK_Node_GetSelectingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition peak_dynamic_loader.h:7448
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:7422
static PEAK_C_API PEAK_EventController_GetControlledEventType(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Definition peak_dynamic_loader.h:8683
static PEAK_C_API PEAK_DeviceDescriptor_GetVersion(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:5030
static PEAK_C_API PEAK_DataStream_ToEventSupportingModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:5589
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:8605
static PEAK_C_API PEAK_System_UnregisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4523
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:7591
static PEAK_C_API PEAK_EventController_GetEventMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Definition peak_dynamic_loader.h:8657
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:6798
static PEAK_C_API PEAK_Device_GetDisplayName(PEAK_DEVICE_HANDLE deviceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:5316
static PEAK_C_API PEAK_Node_GetAccessStatus(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:7149
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:4601
static PEAK_C_API PEAK_Node_GetIsCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Definition peak_dynamic_loader.h:7162
static PEAK_C_API PEAK_DataStream_KillWait(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:5888
static PEAK_C_API PEAK_Buffer_GetPixelFormat(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Definition peak_dynamic_loader.h:6070
static PEAK_C_API PEAK_NodeMap_LoadFromFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:6941
static PEAK_C_API PEAK_Buffer_UpdateChunks(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6408
static PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMinor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:4211
static PEAK_C_API PEAK_DeviceDescriptor_GetSerialNumber(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:5069
static PEAK_C_API PEAK_Buffer_GetSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Definition peak_dynamic_loader.h:6031
static PEAK_C_API PEAK_Buffer_GetHasImage(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Definition peak_dynamic_loader.h:6369
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:7344
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:9216
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Construct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:9060
static PEAK_C_API PEAK_Device_GetTLType(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5368
static PEAK_C_API PEAK_Node_GetDescription(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:7266
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetFileName(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:8943
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersion(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:8969
static PEAK_C_API PEAK_DeviceDescriptor_GetUserDefinedName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:5056
static PEAK_C_API PEAK_Buffer_GetNumParts(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Definition peak_dynamic_loader.h:6460
static PEAK_C_API PEAK_SystemDescriptor_GetVendorName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:4120
static PEAK_C_API PEAK_Buffer_GetFileName(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:6200
static PEAK_C_API PEAK_EnumerationNode_GetNumEntries(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Definition peak_dynamic_loader.h:8137
static PEAK_C_API PEAK_SystemDescriptor_OpenSystem(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4250
static PEAK_C_API PEAK_Device_GetParentInterface(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:5433
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:5823
static PEAK_C_API PEAK_Event_Destruct(PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:8813
static PEAK_C_API PEAK_System_GetVendorName(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:4341
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:4887
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:8436
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:8891
static PEAK_C_API PEAK_Buffer_GetImageOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Definition peak_dynamic_loader.h:6148
static PEAK_C_API PEAK_Port_GetIsReadable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Definition peak_dynamic_loader.h:8332
static PEAK_C_API PEAK_BufferPart_GetXOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:6668
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:5186
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:8852
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:8397
static PEAK_C_API PEAK_DataStream_GetNumBuffersDelivered(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersDelivered)
Definition peak_dynamic_loader.h:5706
static PEAK_C_API PEAK_BooleanNode_SetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Definition peak_dynamic_loader.h:7643
static PEAK_C_API PEAK_DataStream_GetDefinesPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *definesPayloadSize)
Definition peak_dynamic_loader.h:5784
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:6551
static PEAK_C_API PEAK_Buffer_GetYPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Definition peak_dynamic_loader.h:6278
static PEAK_C_API PEAK_DataStream_StartAcquisitionInfinite(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Definition peak_dynamic_loader.h:5914
static PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Definition peak_dynamic_loader.h:8579
static PEAK_C_API PEAK_Interface_GetDisplayName(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4731
static PEAK_C_API PEAK_Library_GetVersionMajor(uint32_t *libraryVersionMajor)
Definition peak_dynamic_loader.h:3925
static PEAK_C_API PEAK_DataStream_RevokeBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:5862
static PEAK_C_API PEAK_EnumerationEntryNode_GetSymbolicValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Definition peak_dynamic_loader.h:8189
static PEAK_C_API PEAK_DataStreamDescriptor_GetKey(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5537
static PEAK_C_API PEAK_Buffer_GetPart(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Definition peak_dynamic_loader.h:6473
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:4913
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:5615
static PEAK_C_API PEAK_System_GetGenTLVersionMajor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMajor)
Definition peak_dynamic_loader.h:4419
static PEAK_C_API PEAK_EnvironmentInspector_GetNumCTIPaths(size_t *numCtiPaths)
Definition peak_dynamic_loader.h:3990
static PEAK_C_API PEAK_StringNode_ToNode(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7890
static PEAK_C_API PEAK_EnumerationEntryNode_GetIsSelfClearing(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Definition peak_dynamic_loader.h:8176
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Definition peak_dynamic_loader.h:9021
static PEAK_C_API PEAK_NodeMap_InvalidateNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:6824
static PEAK_C_API PEAK_System_GetCharacterEncoding(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:4445
static PEAK_C_API PEAK_InterfaceDescriptor_GetKey(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4588
static PEAK_C_API PEAK_SystemDescriptor_GetCharacterEncoding(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:4224
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:8124
static PEAK_C_API PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnouncedMinRequired)
Definition peak_dynamic_loader.h:5654
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:4536
static PEAK_C_API PEAK_Node_GetType(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Definition peak_dynamic_loader.h:7279
static PEAK_C_API PEAK_BufferPart_Destruct(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Definition peak_dynamic_loader.h:6733
static PEAK_C_API PEAK_Node_ToEnumerationNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Definition peak_dynamic_loader.h:7071
static PEAK_C_API PEAK_IntegerNode_GetIncrementType(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:7539
static PEAK_C_API PEAK_DataStreamDescriptor_OpenDataStream(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Definition peak_dynamic_loader.h:5563
static PEAK_C_API PEAK_Buffer_GetPayloadType(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Definition peak_dynamic_loader.h:6057
static PEAK_C_API PEAK_Library_Close()
Definition peak_dynamic_loader.h:3899
static PEAK_C_API PEAK_DataStream_GetNumUnderruns(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Definition peak_dynamic_loader.h:5732
static PEAK_C_API PEAK_Node_GetInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition peak_dynamic_loader.h:7370
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:4809
static PEAK_C_API PEAK_Buffer_GetHasChunks(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Definition peak_dynamic_loader.h:6382
static PEAK_C_API PEAK_PortURL_GetFileVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Definition peak_dynamic_loader.h:8540
static PEAK_C_API PEAK_FloatNode_GetMinimum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Definition peak_dynamic_loader.h:7734
static PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Definition peak_dynamic_loader.h:8566
static PEAK_C_API PEAK_Buffer_GetHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Definition peak_dynamic_loader.h:6226
static PEAK_C_API PEAK_Buffer_GetBasePtr(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Definition peak_dynamic_loader.h:6018
static PEAK_C_API PEAK_Buffer_GetNumChunks(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Definition peak_dynamic_loader.h:6421
static PEAK_C_API PEAK_Node_GetNumInvalidatedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Definition peak_dynamic_loader.h:7318
static PEAK_C_API PEAK_DataStream_GetPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Definition peak_dynamic_loader.h:5771
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:9177
static PEAK_C_API PEAK_FloatNode_GetMaximum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Definition peak_dynamic_loader.h:7747
static PEAK_C_API PEAK_Node_GetName(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:7097
static PEAK_C_API PEAK_IntegerNode_ToNode(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7487
static PEAK_C_API PEAK_Port_GetIsImplemented(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Definition peak_dynamic_loader.h:8371
static PEAK_C_API PEAK_SystemDescriptor_GetModelName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:4133
static PEAK_C_API PEAK_Port_GetURL(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Definition peak_dynamic_loader.h:8423
static PEAK_C_API PEAK_Device_GetUserDefinedName(PEAK_DEVICE_HANDLE deviceHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:5381
static PEAK_C_API PEAK_Node_ToFloatNode(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Definition peak_dynamic_loader.h:7019
static PEAK_C_API PEAK_Interface_GetID(PEAK_INTERFACE_HANDLE interfaceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:4718
static PEAK_C_API PEAK_Node_GetSelectedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition peak_dynamic_loader.h:7409
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:225
PEAK_C_API(* dyn_PEAK_BooleanNode_SetValue)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Definition peak_dynamic_loader.h:326
PEAK_C_API(* dyn_PEAK_Buffer_GetExpectedDataSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Definition peak_dynamic_loader.h:208
PEAK_C_API(* dyn_PEAK_Port_GetID)(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:371
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:390
PEAK_C_API(* dyn_PEAK_Node_ToBooleanNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Definition peak_dynamic_loader.h:276
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:307
PEAK_C_API(* dyn_PEAK_Event_Destruct)(PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:416
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:419
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:278
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:249
PEAK_C_API(* dyn_PEAK_CategoryNode_ToNode)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:354
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:358
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:384
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:322
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:382
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:369
PEAK_C_API(* dyn_PEAK_IntegerNode_GetIncrementType)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:318
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:209
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:236
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSchemaVersionMinor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Definition peak_dynamic_loader.h:398
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:447
PEAK_C_API(* dyn_PEAK_Port_GetModelName)(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:374
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:259
PEAK_C_API(* dyn_PEAK_Buffer_GetUserPtr)(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Definition peak_dynamic_loader.h:203
PEAK_C_API(* dyn_PEAK_StringNode_ToNode)(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:345
PEAK_C_API(* dyn_PEAK_FloatNode_GetValidValues)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:337
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:330
PEAK_C_API(* dyn_PEAK_Node_GetName)(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:284
PEAK_C_API(* dyn_PEAK_Buffer_GetXOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:218
PEAK_C_API(* dyn_PEAK_BufferPart_GetBasePtr)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Definition peak_dynamic_loader.h:244
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:231
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelEndianness)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Definition peak_dynamic_loader.h:207
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:338
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:271
PEAK_C_API(* dyn_PEAK_FloatNode_ToNode)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:332
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:439
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Definition peak_dynamic_loader.h:429
PEAK_C_API(* dyn_PEAK_Buffer_GetTLType)(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:200
PEAK_C_API(* dyn_PEAK_Buffer_GetHasChunks)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Definition peak_dynamic_loader.h:229
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:262
PEAK_C_API(* dyn_PEAK_Node_GetNamespace)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Definition peak_dynamic_loader.h:286
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:195
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:387
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:407
PEAK_C_API(* dyn_PEAK_Node_ToCommandNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Definition peak_dynamic_loader.h:277
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:280
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:299
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:219
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:279
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:424
PEAK_C_API(* dyn_PEAK_NodeMap_GetNumNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Definition peak_dynamic_loader.h:265
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:230
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:192
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_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:327
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetFileName)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:426
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:348
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:347
PEAK_C_API(* dyn_PEAK_EnumerationNode_GetNumEntries)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Definition peak_dynamic_loader.h:364
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:333
PEAK_C_API(* dyn_PEAK_Buffer_GetChunkLayoutID)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Definition peak_dynamic_loader.h:214
PEAK_C_API(* dyn_PEAK_Buffer_GetInfo)(PEAK_BUFFER_HANDLE bufferHandle, int32_t infoCommand, int32_t *infoDataType, uint8_t *info, size_t *infoSize)
Definition peak_dynamic_loader.h:199
PEAK_C_API(* dyn_PEAK_BufferPart_GetFormatNamespace)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Definition peak_dynamic_loader.h:248
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:300
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_Node_GetVisibility)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Definition peak_dynamic_loader.h:287
PEAK_C_API(* dyn_PEAK_Node_GetInvalidatedNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition peak_dynamic_loader.h:302
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:221
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:297
PEAK_C_API(* dyn_PEAK_Node_GetIsStreamable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Definition peak_dynamic_loader.h:291
PEAK_C_API(* dyn_PEAK_Event_GetType)(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Definition peak_dynamic_loader.h:414
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredChunkPayloadSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Definition peak_dynamic_loader.h:213
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:306
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Definition peak_dynamic_loader.h:418
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionMinor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Definition peak_dynamic_loader.h:395
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:237
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:362
PEAK_C_API(* dyn_PEAK_Buffer_UpdateParts)(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:234
PEAK_C_API(* dyn_PEAK_NodeMap_InvalidateNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:263
PEAK_C_API(* dyn_PEAK_Node_GetIsCacheable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Definition peak_dynamic_loader.h:289
PEAK_C_API(* dyn_PEAK_IntegerNode_GetUnit)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:321
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_ToNode)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:366
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntryByValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:361
PEAK_C_API(* dyn_PEAK_NodeMap_Unlock)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:274
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:313
PEAK_C_API(* dyn_PEAK_Node_GetSelectingNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition peak_dynamic_loader.h:311
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:298
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:420
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:344
PEAK_C_API(* dyn_PEAK_Node_GetCachingMode)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Definition peak_dynamic_loader.h:294
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:432
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:242
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:292
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:437
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:331
PEAK_C_API(* dyn_PEAK_NodeMap_GetNode)(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:266
PEAK_C_API(* dyn_PEAK_Port_GetURL)(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Definition peak_dynamic_loader.h:386
PEAK_C_API(* dyn_PEAK_FloatNode_GetDisplayNotation)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Definition peak_dynamic_loader.h:340
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:355
PEAK_C_API(* dyn_PEAK_Port_GetIsAvailable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Definition peak_dynamic_loader.h:381
PEAK_C_API(* dyn_PEAK_RegisterNode_GetLength)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Definition peak_dynamic_loader.h:351
PEAK_C_API(* dyn_PEAK_Buffer_GetFrameID)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Definition peak_dynamic_loader.h:210
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:440
PEAK_C_API(* dyn_PEAK_Port_GetModuleName)(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Definition peak_dynamic_loader.h:377
PEAK_C_API(* dyn_PEAK_FloatNode_GetDisplayPrecision)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Definition peak_dynamic_loader.h:341
PEAK_C_API(* dyn_PEAK_NodeMap_PollNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Definition peak_dynamic_loader.h:264
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:217
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:428
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:370
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:250
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:273
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetSymbolicValue)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Definition peak_dynamic_loader.h:368
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:406
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:261
PEAK_C_API(* dyn_PEAK_Port_GetIsReadable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Definition peak_dynamic_loader.h:379
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetIsSelfClearing)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Definition peak_dynamic_loader.h:367
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:193
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:422
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionMajor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Definition peak_dynamic_loader.h:394
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:391
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:425
PEAK_C_API(* dyn_PEAK_Buffer_GetPayloadType)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Definition peak_dynamic_loader.h:204
PEAK_C_API(* dyn_PEAK_EnumerationNode_ToNode)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:357
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:316
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_Destruct)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:448
PEAK_C_API(* dyn_PEAK_EventController_GetEventDataMaxSize)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Definition peak_dynamic_loader.h:405
PEAK_C_API(* dyn_PEAK_IntegerNode_GetMinimum)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Definition peak_dynamic_loader.h:315
PEAK_C_API(* dyn_PEAK_BufferPart_GetYOffset)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:252
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:400
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:305
PEAK_C_API(* dyn_PEAK_Node_GetNumSelectingNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Definition peak_dynamic_loader.h:310
PEAK_C_API(* dyn_PEAK_Port_GetNumURLs)(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Definition peak_dynamic_loader.h:385
PEAK_C_API(* dyn_PEAK_Port_GetVendorName)(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:373
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:240
PEAK_C_API(* dyn_PEAK_RegisterNode_ToNode)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:349
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredImageHeight)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:212
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:430
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_FirmwareUpdater_Construct)(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:417
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:232
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetDescription)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:427
PEAK_C_API(* dyn_PEAK_BufferPart_GetSize)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Definition peak_dynamic_loader.h:245
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:423
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:1300
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelFormatNamespace)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Definition peak_dynamic_loader.h:206
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:431
PEAK_C_API(* dyn_PEAK_FloatNode_GetMaximum)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Definition peak_dynamic_loader.h:334
PEAK_C_API(* dyn_PEAK_BufferPart_GetXOffset)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:251
PEAK_C_API(* dyn_PEAK_PortURL_GetURL)(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Definition peak_dynamic_loader.h:388
PEAK_C_API(* dyn_PEAK_Buffer_GetFileName)(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:215
PEAK_C_API(* dyn_PEAK_Buffer_GetImageOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Definition peak_dynamic_loader.h:211
PEAK_C_API(* dyn_PEAK_NodeMap_GetHasEventSupportedData)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Definition peak_dynamic_loader.h:269
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntry)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:359
PEAK_C_API(* dyn_PEAK_Node_GetIsFeature)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Definition peak_dynamic_loader.h:293
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:312
PEAK_C_API(* dyn_PEAK_Node_GetSelectedNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition peak_dynamic_loader.h:308
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:399
PEAK_C_API(* dyn_PEAK_IntegerNode_SetValue)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:323
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:288
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetUserSetPersistence)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Definition peak_dynamic_loader.h:433
PEAK_C_API(* dyn_PEAK_Event_GetData)(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Definition peak_dynamic_loader.h:413
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:342
PEAK_C_API(* dyn_PEAK_Port_GetVersion)(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:375
PEAK_C_API(* dyn_PEAK_IntegerNode_GetRepresentation)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:320
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:270
PEAK_C_API(* dyn_PEAK_Module_GetNumNodeMaps)(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Definition peak_dynamic_loader.h:258
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:216
PEAK_C_API(* dyn_PEAK_EventController_GetEventMaxSize)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Definition peak_dynamic_loader.h:404
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:383
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:411
PEAK_C_API(* dyn_PEAK_Event_GetRawData)(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Definition peak_dynamic_loader.h:415
PEAK_C_API(* dyn_PEAK_ModuleDescriptor_GetID)(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:257
PEAK_C_API(* dyn_PEAK_RegisterNode_GetAddress)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Definition peak_dynamic_loader.h:350
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:233
PEAK_C_API(* dyn_PEAK_Port_GetDataEndianness)(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Definition peak_dynamic_loader.h:378
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_PortURL_GetFileSchemaVersionMajor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Definition peak_dynamic_loader.h:397
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:443
PEAK_C_API(* dyn_PEAK_BufferChunk_Destruct)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Definition peak_dynamic_loader.h:241
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:239
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:401
PEAK_C_API(* dyn_PEAK_BufferPart_GetSourceID)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Definition peak_dynamic_loader.h:243
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:444
PEAK_C_API(* dyn_PEAK_PortURL_GetScheme)(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Definition peak_dynamic_loader.h:389
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_Construct)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:435
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:235
PEAK_C_API(* dyn_PEAK_Node_ToCategoryNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Definition peak_dynamic_loader.h:281
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:356
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:402
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:304
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:325
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:442
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:446
PEAK_C_API(* dyn_PEAK_NodeMap_LoadFromFile)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:272
PEAK_C_API(* dyn_PEAK_Buffer_GetXPadding)(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:220
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:303
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:441
PEAK_C_API(* dyn_PEAK_Port_GetIsWritable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Definition peak_dynamic_loader.h:380
PEAK_C_API(* dyn_PEAK_BufferPart_GetParentBuffer)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:255
PEAK_C_API(* dyn_PEAK_BufferPart_Destruct)(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Definition peak_dynamic_loader.h:256
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:328
PEAK_C_API(* dyn_PEAK_DataStream_Destruct)(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:196
PEAK_C_API(* dyn_PEAK_EventController_Destruct)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:410
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:372
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:290
PEAK_C_API(* dyn_PEAK_NodeMap_UpdateChunkNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:268
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:267
PEAK_C_API(* dyn_PEAK_Node_GetToolTip)(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Definition peak_dynamic_loader.h:296
PEAK_C_API(* dyn_PEAK_StringNode_GetMaximumLength)(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Definition peak_dynamic_loader.h:346
PEAK_C_API(* dyn_PEAK_BufferPart_GetFormat)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Definition peak_dynamic_loader.h:247
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:309
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:329
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:227
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:408
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:205
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:343
PEAK_C_API(* dyn_PEAK_IntegerNode_ToNode)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:314
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:194
PEAK_C_API(* dyn_PEAK_FloatNode_GetIncrement)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Definition peak_dynamic_loader.h:335
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:376
PEAK_C_API(* dyn_PEAK_BufferPart_GetType)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Definition peak_dynamic_loader.h:246
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:436
PEAK_C_API(* dyn_PEAK_IntegerNode_GetIncrement)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Definition peak_dynamic_loader.h:317
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:363
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:319
PEAK_C_API(* dyn_PEAK_FloatNode_GetUnit)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:339
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:445
PEAK_C_API(* dyn_PEAK_Node_GetNumInvalidatedNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Definition peak_dynamic_loader.h:301
PEAK_C_API(* dyn_PEAK_Event_GetID)(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Definition peak_dynamic_loader.h:412
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:434
PEAK_C_API(* dyn_PEAK_Buffer_GetHasImage)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Definition peak_dynamic_loader.h:228
PEAK_C_API(* dyn_PEAK_Buffer_GetTimestamp_ns)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Definition peak_dynamic_loader.h:223
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:438
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSize)(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Definition peak_dynamic_loader.h:392
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:352
PEAK_C_API(* dyn_PEAK_Buffer_GetIsQueued)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Definition peak_dynamic_loader.h:224
PEAK_C_API(* dyn_PEAK_EventController_FlushEvents)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:409
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:222
PEAK_C_API(* dyn_PEAK_Buffer_ToModule)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:197
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:198
PEAK_C_API(* dyn_PEAK_BooleanNode_ToNode)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:324
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:282
PEAK_C_API(* dyn_PEAK_EventController_GetNumEventsFired)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Definition peak_dynamic_loader.h:403
PEAK_C_API(* dyn_PEAK_Node_ToEnumerationEntryNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:283
PEAK_C_API(* dyn_PEAK_Buffer_GetIsIncomplete)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Definition peak_dynamic_loader.h:226
PEAK_C_API(* dyn_PEAK_BufferPart_GetDeliveredImageHeight)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:254
PEAK_C_API(* dyn_PEAK_Node_ToIntegerNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Definition peak_dynamic_loader.h:275
PEAK_C_API(* dyn_PEAK_Node_GetPollingTime)(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Definition peak_dynamic_loader.h:295
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSHA1Hash)(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Definition peak_dynamic_loader.h:393
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_PortURL_GetFileVersionSubminor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Definition peak_dynamic_loader.h:396
PEAK_C_API(* dyn_PEAK_FloatNode_GetIncrementType)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:336
PEAK_C_API(* dyn_PEAK_BufferPart_GetXPadding)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:253
PEAK_C_API(* dyn_PEAK_Node_GetDisplayName)(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:285
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:421
PEAK_C_API(* dyn_PEAK_RegisterNode_Write)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition peak_dynamic_loader.h:353
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:260
PEAK_C_API(* dyn_PEAK_BufferChunk_GetBasePtr)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Definition peak_dynamic_loader.h:238
PEAK_C_API(* dyn_PEAK_Buffer_GetBasePtr)(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Definition peak_dynamic_loader.h:201
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Definition peak_dynamic_loader.h:360
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:365
PEAK_C_API(* dyn_PEAK_Buffer_GetSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Definition peak_dynamic_loader.h:202
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:384
void(PEAK_CALL_CONV * PEAK_DEVICE_DISCONNETED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE disconnectedDevice, void *context)
Definition peak_backend.h:540
PEAK_INTERFACE_LOST_CALLBACK * PEAK_INTERFACE_LOST_CALLBACK_HANDLE
Definition peak_backend.h:494
struct PEAK_PORT_URL * PEAK_PORT_URL_HANDLE
Definition peak_backend.h:456
struct PEAK_SYSTEM_DESCRIPTOR * PEAK_SYSTEM_DESCRIPTOR_HANDLE
Definition peak_backend.h:352
struct PEAK_MODULE_DESCRIPTOR * PEAK_MODULE_DESCRIPTOR_HANDLE
Definition peak_backend.h:400
struct PEAK_EVENT * PEAK_EVENT_HANDLE
Definition peak_backend.h:468
struct PEAK_MODULE * PEAK_MODULE_HANDLE
Definition peak_backend.h:404
PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE
Definition peak_backend.h:575
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:564
struct PEAK_INTERFACE_DESCRIPTOR * PEAK_INTERFACE_DESCRIPTOR_HANDLE
Definition peak_backend.h:360
struct PEAK_DATA_STREAM_DESCRIPTOR * PEAK_DATA_STREAM_DESCRIPTOR_HANDLE
Definition peak_backend.h:380
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK)(void *context)
Definition peak_backend.h:593
PEAK_NODE_CHANGED_CALLBACK * PEAK_NODE_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:561
struct PEAK_PORT * PEAK_PORT_HANDLE
Definition peak_backend.h:452
int32_t PEAK_EVENT_TYPE
Definition peak_backend.h:168
struct PEAK_ENUMERATION_NODE * PEAK_ENUMERATION_NODE_HANDLE
Definition peak_backend.h:444
struct PEAK_COMMAND_NODE * PEAK_COMMAND_NODE_HANDLE
Definition peak_backend.h:424
int32_t PEAK_NODE_INCREMENT_TYPE
Definition peak_backend.h:243
int32_t PEAK_BUFFER_PART_TYPE
Definition peak_backend.h:63
struct PEAK_STRING_NODE * PEAK_STRING_NODE_HANDLE
Definition peak_backend.h:432
struct PEAK_NODE * PEAK_NODE_HANDLE
Definition peak_backend.h:412
struct PEAK_BUFFER_CHUNK * PEAK_BUFFER_CHUNK_HANDLE
Definition peak_backend.h:392
struct PEAK_INTERFACE * PEAK_INTERFACE_HANDLE
Definition peak_backend.h:364
PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:568
PEAK_DEVICE_DISCONNETED_CALLBACK * PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE
Definition peak_backend.h:549
struct PEAK_PRODUCER_LIBRARY * PEAK_PRODUCER_LIBRARY_HANDLE
Definition peak_backend.h:348
struct PEAK_BUFFER * PEAK_BUFFER_HANDLE
Definition peak_backend.h:388
PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE
Definition peak_backend.h:595
int32_t PEAK_NODE_REPRESENTATION
Definition peak_backend.h:264
void(PEAK_CALL_CONV * PEAK_BUFFER_REVOCATION_CALLBACK)(void *buffer, void *userPtr, void *context)
Definition peak_backend.h:556
int32_t PEAK_NODE_ACCESS_STATUS
Definition peak_backend.h:208
struct PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER * PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE
Definition peak_backend.h:480
int32_t PEAK_NODE_TYPE
Definition peak_backend.h:279
struct PEAK_EVENT_SUPPORTING_MODULE * PEAK_EVENT_SUPPORTING_MODULE_HANDLE
Definition peak_backend.h:460
int32_t PEAK_FIRMWARE_UPDATE_PERSISTENCE
Definition peak_backend.h:176
PEAK_DEVICE_LOST_CALLBACK * PEAK_DEVICE_LOST_CALLBACK_HANDLE
Definition peak_backend.h:551
#define PEAK_C_API
Definition peak_backend.h:603
struct PEAK_EVENT_CONTROLLER * PEAK_EVENT_CONTROLLER_HANDLE
Definition peak_backend.h:464
struct PEAK_REMOTE_DEVICE * PEAK_REMOTE_DEVICE_HANDLE
Definition peak_backend.h:376
PEAK_DEVICE_RECONNECTED_CALLBACK * PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE
Definition peak_backend.h:547
PEAK_DEVICE_FOUND_CALLBACK * PEAK_DEVICE_FOUND_CALLBACK_HANDLE
Definition peak_backend.h:545
struct PEAK_BUFFER_PART * PEAK_BUFFER_PART_HANDLE
Definition peak_backend.h:396
struct PEAK_SYSTEM * PEAK_SYSTEM_HANDLE
Definition peak_backend.h:356
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, double progressPercentage, void *context)
Definition peak_backend.h:582
PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:586
void(PEAK_CALL_CONV * PEAK_NODE_CHANGED_CALLBACK)(PEAK_NODE_HANDLE changedNode, void *context)
Definition peak_backend.h:559
struct PEAK_FIRMWARE_UPDATE_INFORMATION * PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE
Definition peak_backend.h:476
struct PEAK_FLOAT_NODE * PEAK_FLOAT_NODE_HANDLE
Definition peak_backend.h:428
PEAK_DEVICE_LIST_CHANGED_CALLBACK * PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:553
int32_t PEAK_NODE_CACHE_USE_POLICY
Definition peak_backend.h:225
struct PEAK_FIRMWARE_UPDATER * PEAK_FIRMWARE_UPDATER_HANDLE
Definition peak_backend.h:472
int32_t PEAK_FIRMWARE_UPDATE_VERSION_STYLE
Definition peak_backend.h:197
int32_t PEAK_ACQUISITION_START_MODE
Definition peak_backend.h:35
int8_t PEAK_BOOL8
Definition peak_backend.h:26
PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK_HANDLE
Definition peak_backend.h:600
int32_t PEAK_ENDIANNESS
Definition peak_backend.h:155
struct PEAK_NODE_MAP * PEAK_NODE_MAP_HANDLE
Definition peak_backend.h:408
int32_t PEAK_RETURN_CODE
Definition peak_backend.h:338
int32_t PEAK_NODE_CACHING_MODE
Definition peak_backend.h:217
int32_t PEAK_PORT_URL_SCHEME
Definition peak_backend.h:312
struct PEAK_ENUMERATION_ENTRY_NODE * PEAK_ENUMERATION_ENTRY_NODE_HANDLE
Definition peak_backend.h:448
void(PEAK_CALL_CONV * PEAK_DEVICE_LIST_CHANGED_CALLBACK)(void *context)
Definition peak_backend.h:543
int32_t PEAK_ACQUISITION_STOP_MODE
Definition peak_backend.h:45
void(PEAK_CALL_CONV * PEAK_DEVICE_RECONNECTED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE reconnectedDevice, PEAK_DEVICE_RECONNECT_INFORMATION reconnectInformation, void *context)
Definition peak_backend.h:534
void(PEAK_CALL_CONV * PEAK_DEVICE_FOUND_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void *context)
Definition peak_backend.h:531
struct PEAK_CATEGORY_NODE * PEAK_CATEGORY_NODE_HANDLE
Definition peak_backend.h:440
struct PEAK_REGISTER_NODE * PEAK_REGISTER_NODE_HANDLE
Definition peak_backend.h:436
int32_t PEAK_PIXEL_FORMAT_NAMESPACE
Definition peak_backend.h:301
int32_t PEAK_DATA_STREAM_FLUSH_MODE
Definition peak_backend.h:103
void(PEAK_CALL_CONV * PEAK_INTERFACE_LOST_CALLBACK)(const char *lostInterfaceId, size_t lostInterfaceIdSize, void *context)
Definition peak_backend.h:487
PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE
Definition peak_backend.h:580
int32_t PEAK_DEVICE_INFORMATION_ROLE
Definition peak_backend.h:146
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, void *context)
Definition peak_backend.h:588
int32_t PEAK_DEVICE_ACCESS_TYPE
Definition peak_backend.h:128
int32_t PEAK_NODE_NAMESPACE
Definition peak_backend.h:251
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:571
struct PEAK_DEVICE_DESCRIPTOR * PEAK_DEVICE_DESCRIPTOR_HANDLE
Definition peak_backend.h:368
int32_t PEAK_CHARACTER_ENCODING
Definition peak_backend.h:90
int32_t PEAK_BUFFER_PAYLOAD_TYPE
Definition peak_backend.h:82
void(PEAK_CALL_CONV * PEAK_INTERFACE_FOUND_CALLBACK)(PEAK_INTERFACE_DESCRIPTOR_HANDLE foundInterface, void *context)
Definition peak_backend.h:484
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK)(const char *errorDescription, size_t errorDescriptionSize, void *context)
Definition peak_backend.h:597
int32_t PEAK_NODE_VISIBILITY
Definition peak_backend.h:289
void(PEAK_CALL_CONV * PEAK_DEVICE_LOST_CALLBACK)(const char *lostDeviceId, size_t lostDeviceIdSize, void *context)
Definition peak_backend.h:537
struct PEAK_BOOLEAN_NODE * PEAK_BOOLEAN_NODE_HANDLE
Definition peak_backend.h:420
struct PEAK_INTEGER_NODE * PEAK_INTEGER_NODE_HANDLE
Definition peak_backend.h:416
int32_t PEAK_NODE_DISPLAY_NOTATION
Definition peak_backend.h:234
PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_FINISHED_CALLBACK_HANDLE
Definition peak_backend.h:591
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:577
struct PEAK_DEVICE * PEAK_DEVICE_HANDLE
Definition peak_backend.h:372
PEAK_INTERFACE_FOUND_CALLBACK * PEAK_INTERFACE_FOUND_CALLBACK_HANDLE
Definition peak_backend.h:492
int32_t PEAK_DEVICE_ACCESS_STATUS
Definition peak_backend.h:117
