457 return dynamicLoader;
459 bool loadLib(
const char* file);
461 bool setPointers(
bool load);
881 void* m_handle =
nullptr;
1299 return dlsym(module, proc_name);
1301 return GetProcAddress(
static_cast<HMODULE
>(module), proc_name);
1305inline DynamicLoader::DynamicLoader()
1307#if defined _WIN32 || defined _WIN64
1309 if (_wgetenv_s(&sz, NULL, 0, L
"IDS_PEAK_GENERIC_SDK_PATH") == 0
1312 std::vector<wchar_t> env_ids_peak(sz);
1313 if (_wgetenv_s(&sz, env_ids_peak.data(), sz, L
"IDS_PEAK_GENERIC_SDK_PATH") == 0)
1315 if (_wgetenv_s(&sz, NULL, 0, L
"PATH") == 0
1318 std::vector<wchar_t> env_path(sz);
1319 if (_wgetenv_s(&sz, env_path.data(), sz, L
"PATH") == 0)
1321 std::wstring ids_peak_path(env_ids_peak.data());
1323 ids_peak_path.append(L
"\\api\\lib\\x86_64");
1325 ids_peak_path.append(L
"\\api\\lib\\x86_32");
1327 AddDllDirectory(ids_peak_path.c_str());
1333 loadLib(
"ids_peak.dll");
1335 loadLib(
"libids_peak.so");
1341 if(m_handle !=
nullptr)
1349 auto&& inst = instance();
1350 return inst.m_handle !=
nullptr;
1353inline void DynamicLoader::unload()
1357 if (m_handle !=
nullptr)
1362 FreeLibrary(
static_cast<HMODULE
>(m_handle));
1369inline bool DynamicLoader::loadLib(
const char* file)
1376 m_handle = dlopen(file, RTLD_NOW);
1378 m_handle = LoadLibraryExA(file,
nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
1380 if (m_handle !=
nullptr)
1385 }
catch (
const std::exception&) {
1392 throw std::runtime_error(std::string(
"Lib load failed: ") + file);
1397 throw std::runtime_error(
"Filename empty");
1403inline bool DynamicLoader::setPointers(
bool load)
1407 if(m_PEAK_Library_Initialize ==
nullptr && load)
1409 throw std::runtime_error(
"Failed to load PEAK_Library_Initialize");
1413 if(m_PEAK_Library_Close ==
nullptr && load)
1415 throw std::runtime_error(
"Failed to load PEAK_Library_Close");
1419 if(m_PEAK_Library_IsInitialized ==
nullptr && load)
1421 throw std::runtime_error(
"Failed to load PEAK_Library_IsInitialized");
1425 if(m_PEAK_Library_GetVersionMajor ==
nullptr && load)
1427 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionMajor");
1431 if(m_PEAK_Library_GetVersionMinor ==
nullptr && load)
1433 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionMinor");
1437 if(m_PEAK_Library_GetVersionSubminor ==
nullptr && load)
1439 throw std::runtime_error(
"Failed to load PEAK_Library_GetVersionSubminor");
1443 if(m_PEAK_Library_GetLastError ==
nullptr && load)
1445 throw std::runtime_error(
"Failed to load PEAK_Library_GetLastError");
1449 if(m_PEAK_EnvironmentInspector_UpdateCTIPaths ==
nullptr && load)
1451 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_UpdateCTIPaths");
1455 if(m_PEAK_EnvironmentInspector_GetNumCTIPaths ==
nullptr && load)
1457 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_GetNumCTIPaths");
1461 if(m_PEAK_EnvironmentInspector_GetCTIPath ==
nullptr && load)
1463 throw std::runtime_error(
"Failed to load PEAK_EnvironmentInspector_GetCTIPath");
1467 if(m_PEAK_ProducerLibrary_Construct ==
nullptr && load)
1469 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_Construct");
1473 if(m_PEAK_ProducerLibrary_GetKey ==
nullptr && load)
1475 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_GetKey");
1479 if(m_PEAK_ProducerLibrary_GetSystem ==
nullptr && load)
1481 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_GetSystem");
1485 if(m_PEAK_ProducerLibrary_Destruct ==
nullptr && load)
1487 throw std::runtime_error(
"Failed to load PEAK_ProducerLibrary_Destruct");
1491 if(m_PEAK_SystemDescriptor_ToModuleDescriptor ==
nullptr && load)
1493 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_ToModuleDescriptor");
1497 if(m_PEAK_SystemDescriptor_GetKey ==
nullptr && load)
1499 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetKey");
1503 if(m_PEAK_SystemDescriptor_GetInfo ==
nullptr && load)
1505 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetInfo");
1509 if(m_PEAK_SystemDescriptor_GetDisplayName ==
nullptr && load)
1511 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetDisplayName");
1515 if(m_PEAK_SystemDescriptor_GetVendorName ==
nullptr && load)
1517 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetVendorName");
1521 if(m_PEAK_SystemDescriptor_GetModelName ==
nullptr && load)
1523 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetModelName");
1527 if(m_PEAK_SystemDescriptor_GetVersion ==
nullptr && load)
1529 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetVersion");
1533 if(m_PEAK_SystemDescriptor_GetTLType ==
nullptr && load)
1535 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetTLType");
1539 if(m_PEAK_SystemDescriptor_GetCTIFileName ==
nullptr && load)
1541 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCTIFileName");
1545 if(m_PEAK_SystemDescriptor_GetCTIFullPath ==
nullptr && load)
1547 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCTIFullPath");
1551 if(m_PEAK_SystemDescriptor_GetGenTLVersionMajor ==
nullptr && load)
1553 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetGenTLVersionMajor");
1557 if(m_PEAK_SystemDescriptor_GetGenTLVersionMinor ==
nullptr && load)
1559 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetGenTLVersionMinor");
1563 if(m_PEAK_SystemDescriptor_GetCharacterEncoding ==
nullptr && load)
1565 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetCharacterEncoding");
1569 if(m_PEAK_SystemDescriptor_GetParentLibrary ==
nullptr && load)
1571 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_GetParentLibrary");
1575 if(m_PEAK_SystemDescriptor_OpenSystem ==
nullptr && load)
1577 throw std::runtime_error(
"Failed to load PEAK_SystemDescriptor_OpenSystem");
1581 if(m_PEAK_System_ToModule ==
nullptr && load)
1583 throw std::runtime_error(
"Failed to load PEAK_System_ToModule");
1587 if(m_PEAK_System_ToEventSupportingModule ==
nullptr && load)
1589 throw std::runtime_error(
"Failed to load PEAK_System_ToEventSupportingModule");
1593 if(m_PEAK_System_GetKey ==
nullptr && load)
1595 throw std::runtime_error(
"Failed to load PEAK_System_GetKey");
1599 if(m_PEAK_System_GetInfo ==
nullptr && load)
1601 throw std::runtime_error(
"Failed to load PEAK_System_GetInfo");
1605 if(m_PEAK_System_GetID ==
nullptr && load)
1607 throw std::runtime_error(
"Failed to load PEAK_System_GetID");
1611 if(m_PEAK_System_GetDisplayName ==
nullptr && load)
1613 throw std::runtime_error(
"Failed to load PEAK_System_GetDisplayName");
1617 if(m_PEAK_System_GetVendorName ==
nullptr && load)
1619 throw std::runtime_error(
"Failed to load PEAK_System_GetVendorName");
1623 if(m_PEAK_System_GetModelName ==
nullptr && load)
1625 throw std::runtime_error(
"Failed to load PEAK_System_GetModelName");
1629 if(m_PEAK_System_GetVersion ==
nullptr && load)
1631 throw std::runtime_error(
"Failed to load PEAK_System_GetVersion");
1635 if(m_PEAK_System_GetTLType ==
nullptr && load)
1637 throw std::runtime_error(
"Failed to load PEAK_System_GetTLType");
1641 if(m_PEAK_System_GetCTIFileName ==
nullptr && load)
1643 throw std::runtime_error(
"Failed to load PEAK_System_GetCTIFileName");
1647 if(m_PEAK_System_GetCTIFullPath ==
nullptr && load)
1649 throw std::runtime_error(
"Failed to load PEAK_System_GetCTIFullPath");
1653 if(m_PEAK_System_GetGenTLVersionMajor ==
nullptr && load)
1655 throw std::runtime_error(
"Failed to load PEAK_System_GetGenTLVersionMajor");
1659 if(m_PEAK_System_GetGenTLVersionMinor ==
nullptr && load)
1661 throw std::runtime_error(
"Failed to load PEAK_System_GetGenTLVersionMinor");
1665 if(m_PEAK_System_GetCharacterEncoding ==
nullptr && load)
1667 throw std::runtime_error(
"Failed to load PEAK_System_GetCharacterEncoding");
1671 if(m_PEAK_System_GetParentLibrary ==
nullptr && load)
1673 throw std::runtime_error(
"Failed to load PEAK_System_GetParentLibrary");
1677 if(m_PEAK_System_UpdateInterfaces ==
nullptr && load)
1679 throw std::runtime_error(
"Failed to load PEAK_System_UpdateInterfaces");
1683 if(m_PEAK_System_GetNumInterfaces ==
nullptr && load)
1685 throw std::runtime_error(
"Failed to load PEAK_System_GetNumInterfaces");
1689 if(m_PEAK_System_GetInterface ==
nullptr && load)
1691 throw std::runtime_error(
"Failed to load PEAK_System_GetInterface");
1695 if(m_PEAK_System_RegisterInterfaceFoundCallback ==
nullptr && load)
1697 throw std::runtime_error(
"Failed to load PEAK_System_RegisterInterfaceFoundCallback");
1701 if(m_PEAK_System_UnregisterInterfaceFoundCallback ==
nullptr && load)
1703 throw std::runtime_error(
"Failed to load PEAK_System_UnregisterInterfaceFoundCallback");
1707 if(m_PEAK_System_RegisterInterfaceLostCallback ==
nullptr && load)
1709 throw std::runtime_error(
"Failed to load PEAK_System_RegisterInterfaceLostCallback");
1713 if(m_PEAK_System_UnregisterInterfaceLostCallback ==
nullptr && load)
1715 throw std::runtime_error(
"Failed to load PEAK_System_UnregisterInterfaceLostCallback");
1719 if(m_PEAK_System_Destruct ==
nullptr && load)
1721 throw std::runtime_error(
"Failed to load PEAK_System_Destruct");
1725 if(m_PEAK_InterfaceDescriptor_ToModuleDescriptor ==
nullptr && load)
1727 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_ToModuleDescriptor");
1731 if(m_PEAK_InterfaceDescriptor_GetKey ==
nullptr && load)
1733 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetKey");
1737 if(m_PEAK_InterfaceDescriptor_GetInfo ==
nullptr && load)
1739 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetInfo");
1743 if(m_PEAK_InterfaceDescriptor_GetDisplayName ==
nullptr && load)
1745 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetDisplayName");
1749 if(m_PEAK_InterfaceDescriptor_GetTLType ==
nullptr && load)
1751 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetTLType");
1755 if(m_PEAK_InterfaceDescriptor_GetParentSystem ==
nullptr && load)
1757 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_GetParentSystem");
1761 if(m_PEAK_InterfaceDescriptor_OpenInterface ==
nullptr && load)
1763 throw std::runtime_error(
"Failed to load PEAK_InterfaceDescriptor_OpenInterface");
1767 if(m_PEAK_Interface_ToModule ==
nullptr && load)
1769 throw std::runtime_error(
"Failed to load PEAK_Interface_ToModule");
1773 if(m_PEAK_Interface_ToEventSupportingModule ==
nullptr && load)
1775 throw std::runtime_error(
"Failed to load PEAK_Interface_ToEventSupportingModule");
1779 if(m_PEAK_Interface_GetKey ==
nullptr && load)
1781 throw std::runtime_error(
"Failed to load PEAK_Interface_GetKey");
1785 if(m_PEAK_Interface_GetInfo ==
nullptr && load)
1787 throw std::runtime_error(
"Failed to load PEAK_Interface_GetInfo");
1791 if(m_PEAK_Interface_GetID ==
nullptr && load)
1793 throw std::runtime_error(
"Failed to load PEAK_Interface_GetID");
1797 if(m_PEAK_Interface_GetDisplayName ==
nullptr && load)
1799 throw std::runtime_error(
"Failed to load PEAK_Interface_GetDisplayName");
1803 if(m_PEAK_Interface_GetTLType ==
nullptr && load)
1805 throw std::runtime_error(
"Failed to load PEAK_Interface_GetTLType");
1809 if(m_PEAK_Interface_GetParentSystem ==
nullptr && load)
1811 throw std::runtime_error(
"Failed to load PEAK_Interface_GetParentSystem");
1815 if(m_PEAK_Interface_UpdateDevices ==
nullptr && load)
1817 throw std::runtime_error(
"Failed to load PEAK_Interface_UpdateDevices");
1821 if(m_PEAK_Interface_GetNumDevices ==
nullptr && load)
1823 throw std::runtime_error(
"Failed to load PEAK_Interface_GetNumDevices");
1827 if(m_PEAK_Interface_GetDevice ==
nullptr && load)
1829 throw std::runtime_error(
"Failed to load PEAK_Interface_GetDevice");
1833 if(m_PEAK_Interface_RegisterDeviceFoundCallback ==
nullptr && load)
1835 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceFoundCallback");
1839 if(m_PEAK_Interface_UnregisterDeviceFoundCallback ==
nullptr && load)
1841 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceFoundCallback");
1845 if(m_PEAK_Interface_RegisterDeviceReconnectedCallback ==
nullptr && load)
1847 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceReconnectedCallback");
1851 if(m_PEAK_Interface_UnregisterDeviceReconnectedCallback ==
nullptr && load)
1853 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceReconnectedCallback");
1857 if(m_PEAK_Interface_RegisterDeviceDisconnectedCallback ==
nullptr && load)
1859 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceDisconnectedCallback");
1863 if(m_PEAK_Interface_UnregisterDeviceDisconnectedCallback ==
nullptr && load)
1865 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceDisconnectedCallback");
1869 if(m_PEAK_Interface_RegisterDeviceLostCallback ==
nullptr && load)
1871 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceLostCallback");
1875 if(m_PEAK_Interface_UnregisterDeviceLostCallback ==
nullptr && load)
1877 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceLostCallback");
1881 if(m_PEAK_Interface_RegisterDeviceListChangedCallback ==
nullptr && load)
1883 throw std::runtime_error(
"Failed to load PEAK_Interface_RegisterDeviceListChangedCallback");
1887 if(m_PEAK_Interface_UnregisterDeviceListChangedCallback ==
nullptr && load)
1889 throw std::runtime_error(
"Failed to load PEAK_Interface_UnregisterDeviceListChangedCallback");
1893 if(m_PEAK_Interface_Destruct ==
nullptr && load)
1895 throw std::runtime_error(
"Failed to load PEAK_Interface_Destruct");
1899 if(m_PEAK_DeviceDescriptor_ToModuleDescriptor ==
nullptr && load)
1901 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_ToModuleDescriptor");
1905 if(m_PEAK_DeviceDescriptor_GetKey ==
nullptr && load)
1907 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetKey");
1911 if(m_PEAK_DeviceDescriptor_GetInfo ==
nullptr && load)
1913 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetInfo");
1917 if(m_PEAK_DeviceDescriptor_GetDisplayName ==
nullptr && load)
1919 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetDisplayName");
1923 if(m_PEAK_DeviceDescriptor_GetVendorName ==
nullptr && load)
1925 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetVendorName");
1929 if(m_PEAK_DeviceDescriptor_GetModelName ==
nullptr && load)
1931 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetModelName");
1935 if(m_PEAK_DeviceDescriptor_GetVersion ==
nullptr && load)
1937 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetVersion");
1941 if(m_PEAK_DeviceDescriptor_GetTLType ==
nullptr && load)
1943 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetTLType");
1947 if(m_PEAK_DeviceDescriptor_GetUserDefinedName ==
nullptr && load)
1949 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetUserDefinedName");
1953 if(m_PEAK_DeviceDescriptor_GetSerialNumber ==
nullptr && load)
1955 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetSerialNumber");
1959 if(m_PEAK_DeviceDescriptor_GetAccessStatus ==
nullptr && load)
1961 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetAccessStatus");
1965 if(m_PEAK_DeviceDescriptor_GetTimestampTickFrequency ==
nullptr && load)
1967 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetTimestampTickFrequency");
1971 if(m_PEAK_DeviceDescriptor_GetIsOpenableExclusive ==
nullptr && load)
1973 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetIsOpenableExclusive");
1977 if(m_PEAK_DeviceDescriptor_GetIsOpenable ==
nullptr && load)
1979 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetIsOpenable");
1983 if(m_PEAK_DeviceDescriptor_OpenDevice ==
nullptr && load)
1985 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_OpenDevice");
1989 if(m_PEAK_DeviceDescriptor_GetParentInterface ==
nullptr && load)
1991 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetParentInterface");
1995 if(m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval ==
nullptr && load)
1997 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_GetMonitoringUpdateInterval");
2001 if(m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval ==
nullptr && load)
2003 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_SetMonitoringUpdateInterval");
2007 if(m_PEAK_DeviceDescriptor_IsInformationRoleMonitored ==
nullptr && load)
2009 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_IsInformationRoleMonitored");
2013 if(m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring ==
nullptr && load)
2015 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_AddInformationRoleToMonitoring");
2019 if(m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring ==
nullptr && load)
2021 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring");
2025 if(m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback ==
nullptr && load)
2027 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_RegisterInformationChangedCallback");
2031 if(m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback ==
nullptr && load)
2033 throw std::runtime_error(
"Failed to load PEAK_DeviceDescriptor_UnregisterInformationChangedCallback");
2037 if(m_PEAK_Device_ToModule ==
nullptr && load)
2039 throw std::runtime_error(
"Failed to load PEAK_Device_ToModule");
2043 if(m_PEAK_Device_ToEventSupportingModule ==
nullptr && load)
2045 throw std::runtime_error(
"Failed to load PEAK_Device_ToEventSupportingModule");
2049 if(m_PEAK_Device_GetKey ==
nullptr && load)
2051 throw std::runtime_error(
"Failed to load PEAK_Device_GetKey");
2055 if(m_PEAK_Device_GetInfo ==
nullptr && load)
2057 throw std::runtime_error(
"Failed to load PEAK_Device_GetInfo");
2061 if(m_PEAK_Device_GetID ==
nullptr && load)
2063 throw std::runtime_error(
"Failed to load PEAK_Device_GetID");
2067 if(m_PEAK_Device_GetDisplayName ==
nullptr && load)
2069 throw std::runtime_error(
"Failed to load PEAK_Device_GetDisplayName");
2073 if(m_PEAK_Device_GetVendorName ==
nullptr && load)
2075 throw std::runtime_error(
"Failed to load PEAK_Device_GetVendorName");
2079 if(m_PEAK_Device_GetModelName ==
nullptr && load)
2081 throw std::runtime_error(
"Failed to load PEAK_Device_GetModelName");
2085 if(m_PEAK_Device_GetVersion ==
nullptr && load)
2087 throw std::runtime_error(
"Failed to load PEAK_Device_GetVersion");
2091 if(m_PEAK_Device_GetTLType ==
nullptr && load)
2093 throw std::runtime_error(
"Failed to load PEAK_Device_GetTLType");
2097 if(m_PEAK_Device_GetUserDefinedName ==
nullptr && load)
2099 throw std::runtime_error(
"Failed to load PEAK_Device_GetUserDefinedName");
2103 if(m_PEAK_Device_GetSerialNumber ==
nullptr && load)
2105 throw std::runtime_error(
"Failed to load PEAK_Device_GetSerialNumber");
2109 if(m_PEAK_Device_GetAccessStatus ==
nullptr && load)
2111 throw std::runtime_error(
"Failed to load PEAK_Device_GetAccessStatus");
2115 if(m_PEAK_Device_GetTimestampTickFrequency ==
nullptr && load)
2117 throw std::runtime_error(
"Failed to load PEAK_Device_GetTimestampTickFrequency");
2121 if(m_PEAK_Device_GetParentInterface ==
nullptr && load)
2123 throw std::runtime_error(
"Failed to load PEAK_Device_GetParentInterface");
2127 if(m_PEAK_Device_GetRemoteDevice ==
nullptr && load)
2129 throw std::runtime_error(
"Failed to load PEAK_Device_GetRemoteDevice");
2133 if(m_PEAK_Device_GetNumDataStreams ==
nullptr && load)
2135 throw std::runtime_error(
"Failed to load PEAK_Device_GetNumDataStreams");
2139 if(m_PEAK_Device_GetDataStream ==
nullptr && load)
2141 throw std::runtime_error(
"Failed to load PEAK_Device_GetDataStream");
2145 if(m_PEAK_Device_Destruct ==
nullptr && load)
2147 throw std::runtime_error(
"Failed to load PEAK_Device_Destruct");
2151 if(m_PEAK_RemoteDevice_ToModule ==
nullptr && load)
2153 throw std::runtime_error(
"Failed to load PEAK_RemoteDevice_ToModule");
2157 if(m_PEAK_RemoteDevice_GetLocalDevice ==
nullptr && load)
2159 throw std::runtime_error(
"Failed to load PEAK_RemoteDevice_GetLocalDevice");
2163 if(m_PEAK_DataStreamDescriptor_ToModuleDescriptor ==
nullptr && load)
2165 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_ToModuleDescriptor");
2169 if(m_PEAK_DataStreamDescriptor_GetKey ==
nullptr && load)
2171 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_GetKey");
2175 if(m_PEAK_DataStreamDescriptor_GetParentDevice ==
nullptr && load)
2177 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_GetParentDevice");
2181 if(m_PEAK_DataStreamDescriptor_OpenDataStream ==
nullptr && load)
2183 throw std::runtime_error(
"Failed to load PEAK_DataStreamDescriptor_OpenDataStream");
2187 if(m_PEAK_DataStream_ToModule ==
nullptr && load)
2189 throw std::runtime_error(
"Failed to load PEAK_DataStream_ToModule");
2193 if(m_PEAK_DataStream_ToEventSupportingModule ==
nullptr && load)
2195 throw std::runtime_error(
"Failed to load PEAK_DataStream_ToEventSupportingModule");
2199 if(m_PEAK_DataStream_GetKey ==
nullptr && load)
2201 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetKey");
2205 if(m_PEAK_DataStream_GetInfo ==
nullptr && load)
2207 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetInfo");
2211 if(m_PEAK_DataStream_GetID ==
nullptr && load)
2213 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetID");
2217 if(m_PEAK_DataStream_GetTLType ==
nullptr && load)
2219 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetTLType");
2223 if(m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired ==
nullptr && load)
2225 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAnnouncedMinRequired");
2229 if(m_PEAK_DataStream_GetNumBuffersAnnounced ==
nullptr && load)
2231 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAnnounced");
2235 if(m_PEAK_DataStream_GetNumBuffersQueued ==
nullptr && load)
2237 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersQueued");
2241 if(m_PEAK_DataStream_GetNumBuffersAwaitDelivery ==
nullptr && load)
2243 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersAwaitDelivery");
2247 if(m_PEAK_DataStream_GetNumBuffersDelivered ==
nullptr && load)
2249 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersDelivered");
2253 if(m_PEAK_DataStream_GetNumBuffersStarted ==
nullptr && load)
2255 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumBuffersStarted");
2259 if(m_PEAK_DataStream_GetNumUnderruns ==
nullptr && load)
2261 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumUnderruns");
2265 if(m_PEAK_DataStream_GetNumChunksPerBufferMax ==
nullptr && load)
2267 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetNumChunksPerBufferMax");
2271 if(m_PEAK_DataStream_GetBufferAlignment ==
nullptr && load)
2273 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetBufferAlignment");
2277 if(m_PEAK_DataStream_GetPayloadSize ==
nullptr && load)
2279 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetPayloadSize");
2283 if(m_PEAK_DataStream_GetDefinesPayloadSize ==
nullptr && load)
2285 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetDefinesPayloadSize");
2289 if(m_PEAK_DataStream_GetIsGrabbing ==
nullptr && load)
2291 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetIsGrabbing");
2295 if(m_PEAK_DataStream_GetParentDevice ==
nullptr && load)
2297 throw std::runtime_error(
"Failed to load PEAK_DataStream_GetParentDevice");
2301 if(m_PEAK_DataStream_AnnounceBuffer ==
nullptr && load)
2303 throw std::runtime_error(
"Failed to load PEAK_DataStream_AnnounceBuffer");
2307 if(m_PEAK_DataStream_AllocAndAnnounceBuffer ==
nullptr && load)
2309 throw std::runtime_error(
"Failed to load PEAK_DataStream_AllocAndAnnounceBuffer");
2313 if(m_PEAK_DataStream_QueueBuffer ==
nullptr && load)
2315 throw std::runtime_error(
"Failed to load PEAK_DataStream_QueueBuffer");
2319 if(m_PEAK_DataStream_RevokeBuffer ==
nullptr && load)
2321 throw std::runtime_error(
"Failed to load PEAK_DataStream_RevokeBuffer");
2325 if(m_PEAK_DataStream_WaitForFinishedBuffer ==
nullptr && load)
2327 throw std::runtime_error(
"Failed to load PEAK_DataStream_WaitForFinishedBuffer");
2331 if(m_PEAK_DataStream_KillWait ==
nullptr && load)
2333 throw std::runtime_error(
"Failed to load PEAK_DataStream_KillWait");
2337 if(m_PEAK_DataStream_Flush ==
nullptr && load)
2339 throw std::runtime_error(
"Failed to load PEAK_DataStream_Flush");
2343 if(m_PEAK_DataStream_StartAcquisitionInfinite ==
nullptr && load)
2345 throw std::runtime_error(
"Failed to load PEAK_DataStream_StartAcquisitionInfinite");
2349 if(m_PEAK_DataStream_StartAcquisition ==
nullptr && load)
2351 throw std::runtime_error(
"Failed to load PEAK_DataStream_StartAcquisition");
2355 if(m_PEAK_DataStream_StopAcquisition ==
nullptr && load)
2357 throw std::runtime_error(
"Failed to load PEAK_DataStream_StopAcquisition");
2361 if(m_PEAK_DataStream_Destruct ==
nullptr && load)
2363 throw std::runtime_error(
"Failed to load PEAK_DataStream_Destruct");
2367 if(m_PEAK_Buffer_ToModule ==
nullptr && load)
2369 throw std::runtime_error(
"Failed to load PEAK_Buffer_ToModule");
2373 if(m_PEAK_Buffer_ToEventSupportingModule ==
nullptr && load)
2375 throw std::runtime_error(
"Failed to load PEAK_Buffer_ToEventSupportingModule");
2379 if(m_PEAK_Buffer_GetInfo ==
nullptr && load)
2381 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetInfo");
2385 if(m_PEAK_Buffer_GetTLType ==
nullptr && load)
2387 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTLType");
2391 if(m_PEAK_Buffer_GetBasePtr ==
nullptr && load)
2393 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetBasePtr");
2397 if(m_PEAK_Buffer_GetSize ==
nullptr && load)
2399 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetSize");
2403 if(m_PEAK_Buffer_GetUserPtr ==
nullptr && load)
2405 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetUserPtr");
2409 if(m_PEAK_Buffer_GetPayloadType ==
nullptr && load)
2411 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPayloadType");
2415 if(m_PEAK_Buffer_GetPixelFormat ==
nullptr && load)
2417 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelFormat");
2421 if(m_PEAK_Buffer_GetPixelFormatNamespace ==
nullptr && load)
2423 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelFormatNamespace");
2427 if(m_PEAK_Buffer_GetPixelEndianness ==
nullptr && load)
2429 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPixelEndianness");
2433 if(m_PEAK_Buffer_GetExpectedDataSize ==
nullptr && load)
2435 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetExpectedDataSize");
2439 if(m_PEAK_Buffer_GetDeliveredDataSize ==
nullptr && load)
2441 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredDataSize");
2445 if(m_PEAK_Buffer_GetFrameID ==
nullptr && load)
2447 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetFrameID");
2451 if(m_PEAK_Buffer_GetImageOffset ==
nullptr && load)
2453 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetImageOffset");
2457 if(m_PEAK_Buffer_GetDeliveredImageHeight ==
nullptr && load)
2459 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredImageHeight");
2463 if(m_PEAK_Buffer_GetDeliveredChunkPayloadSize ==
nullptr && load)
2465 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetDeliveredChunkPayloadSize");
2469 if(m_PEAK_Buffer_GetChunkLayoutID ==
nullptr && load)
2471 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetChunkLayoutID");
2475 if(m_PEAK_Buffer_GetFileName ==
nullptr && load)
2477 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetFileName");
2481 if(m_PEAK_Buffer_GetWidth ==
nullptr && load)
2483 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetWidth");
2487 if(m_PEAK_Buffer_GetHeight ==
nullptr && load)
2489 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHeight");
2493 if(m_PEAK_Buffer_GetXOffset ==
nullptr && load)
2495 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetXOffset");
2499 if(m_PEAK_Buffer_GetYOffset ==
nullptr && load)
2501 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetYOffset");
2505 if(m_PEAK_Buffer_GetXPadding ==
nullptr && load)
2507 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetXPadding");
2511 if(m_PEAK_Buffer_GetYPadding ==
nullptr && load)
2513 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetYPadding");
2517 if(m_PEAK_Buffer_GetTimestamp_ticks ==
nullptr && load)
2519 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTimestamp_ticks");
2523 if(m_PEAK_Buffer_GetTimestamp_ns ==
nullptr && load)
2525 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetTimestamp_ns");
2529 if(m_PEAK_Buffer_GetIsQueued ==
nullptr && load)
2531 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsQueued");
2535 if(m_PEAK_Buffer_GetIsAcquiring ==
nullptr && load)
2537 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsAcquiring");
2541 if(m_PEAK_Buffer_GetIsIncomplete ==
nullptr && load)
2543 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetIsIncomplete");
2547 if(m_PEAK_Buffer_GetHasNewData ==
nullptr && load)
2549 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasNewData");
2553 if(m_PEAK_Buffer_GetHasImage ==
nullptr && load)
2555 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasImage");
2559 if(m_PEAK_Buffer_GetHasChunks ==
nullptr && load)
2561 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetHasChunks");
2565 if(m_PEAK_Buffer_UpdateChunks ==
nullptr && load)
2567 throw std::runtime_error(
"Failed to load PEAK_Buffer_UpdateChunks");
2571 if(m_PEAK_Buffer_GetNumChunks ==
nullptr && load)
2573 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetNumChunks");
2577 if(m_PEAK_Buffer_GetChunk ==
nullptr && load)
2579 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetChunk");
2583 if(m_PEAK_Buffer_UpdateParts ==
nullptr && load)
2585 throw std::runtime_error(
"Failed to load PEAK_Buffer_UpdateParts");
2589 if(m_PEAK_Buffer_GetNumParts ==
nullptr && load)
2591 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetNumParts");
2595 if(m_PEAK_Buffer_GetPart ==
nullptr && load)
2597 throw std::runtime_error(
"Failed to load PEAK_Buffer_GetPart");
2601 if(m_PEAK_BufferChunk_GetID ==
nullptr && load)
2603 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetID");
2607 if(m_PEAK_BufferChunk_GetBasePtr ==
nullptr && load)
2609 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetBasePtr");
2613 if(m_PEAK_BufferChunk_GetSize ==
nullptr && load)
2615 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetSize");
2619 if(m_PEAK_BufferChunk_GetParentBuffer ==
nullptr && load)
2621 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_GetParentBuffer");
2625 if(m_PEAK_BufferChunk_Destruct ==
nullptr && load)
2627 throw std::runtime_error(
"Failed to load PEAK_BufferChunk_Destruct");
2631 if(m_PEAK_BufferPart_GetInfo ==
nullptr && load)
2633 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetInfo");
2637 if(m_PEAK_BufferPart_GetSourceID ==
nullptr && load)
2639 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetSourceID");
2643 if(m_PEAK_BufferPart_GetBasePtr ==
nullptr && load)
2645 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetBasePtr");
2649 if(m_PEAK_BufferPart_GetSize ==
nullptr && load)
2651 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetSize");
2655 if(m_PEAK_BufferPart_GetType ==
nullptr && load)
2657 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetType");
2661 if(m_PEAK_BufferPart_GetFormat ==
nullptr && load)
2663 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetFormat");
2667 if(m_PEAK_BufferPart_GetFormatNamespace ==
nullptr && load)
2669 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetFormatNamespace");
2673 if(m_PEAK_BufferPart_GetWidth ==
nullptr && load)
2675 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetWidth");
2679 if(m_PEAK_BufferPart_GetHeight ==
nullptr && load)
2681 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetHeight");
2685 if(m_PEAK_BufferPart_GetXOffset ==
nullptr && load)
2687 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetXOffset");
2691 if(m_PEAK_BufferPart_GetYOffset ==
nullptr && load)
2693 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetYOffset");
2697 if(m_PEAK_BufferPart_GetXPadding ==
nullptr && load)
2699 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetXPadding");
2703 if(m_PEAK_BufferPart_GetDeliveredImageHeight ==
nullptr && load)
2705 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetDeliveredImageHeight");
2709 if(m_PEAK_BufferPart_GetParentBuffer ==
nullptr && load)
2711 throw std::runtime_error(
"Failed to load PEAK_BufferPart_GetParentBuffer");
2715 if(m_PEAK_BufferPart_Destruct ==
nullptr && load)
2717 throw std::runtime_error(
"Failed to load PEAK_BufferPart_Destruct");
2721 if(m_PEAK_ModuleDescriptor_GetID ==
nullptr && load)
2723 throw std::runtime_error(
"Failed to load PEAK_ModuleDescriptor_GetID");
2727 if(m_PEAK_Module_GetNumNodeMaps ==
nullptr && load)
2729 throw std::runtime_error(
"Failed to load PEAK_Module_GetNumNodeMaps");
2733 if(m_PEAK_Module_GetNodeMap ==
nullptr && load)
2735 throw std::runtime_error(
"Failed to load PEAK_Module_GetNodeMap");
2739 if(m_PEAK_Module_GetPort ==
nullptr && load)
2741 throw std::runtime_error(
"Failed to load PEAK_Module_GetPort");
2745 if(m_PEAK_NodeMap_GetHasNode ==
nullptr && load)
2747 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasNode");
2751 if(m_PEAK_NodeMap_FindNode ==
nullptr && load)
2753 throw std::runtime_error(
"Failed to load PEAK_NodeMap_FindNode");
2757 if(m_PEAK_NodeMap_InvalidateNodes ==
nullptr && load)
2759 throw std::runtime_error(
"Failed to load PEAK_NodeMap_InvalidateNodes");
2763 if(m_PEAK_NodeMap_PollNodes ==
nullptr && load)
2765 throw std::runtime_error(
"Failed to load PEAK_NodeMap_PollNodes");
2769 if(m_PEAK_NodeMap_GetNumNodes ==
nullptr && load)
2771 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetNumNodes");
2775 if(m_PEAK_NodeMap_GetNode ==
nullptr && load)
2777 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetNode");
2781 if(m_PEAK_NodeMap_GetHasBufferSupportedChunks ==
nullptr && load)
2783 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasBufferSupportedChunks");
2787 if(m_PEAK_NodeMap_UpdateChunkNodes ==
nullptr && load)
2789 throw std::runtime_error(
"Failed to load PEAK_NodeMap_UpdateChunkNodes");
2793 if(m_PEAK_NodeMap_GetHasEventSupportedData ==
nullptr && load)
2795 throw std::runtime_error(
"Failed to load PEAK_NodeMap_GetHasEventSupportedData");
2799 if(m_PEAK_NodeMap_UpdateEventNodes ==
nullptr && load)
2801 throw std::runtime_error(
"Failed to load PEAK_NodeMap_UpdateEventNodes");
2805 if(m_PEAK_NodeMap_StoreToFile ==
nullptr && load)
2807 throw std::runtime_error(
"Failed to load PEAK_NodeMap_StoreToFile");
2811 if(m_PEAK_NodeMap_LoadFromFile ==
nullptr && load)
2813 throw std::runtime_error(
"Failed to load PEAK_NodeMap_LoadFromFile");
2817 if(m_PEAK_NodeMap_Lock ==
nullptr && load)
2819 throw std::runtime_error(
"Failed to load PEAK_NodeMap_Lock");
2823 if(m_PEAK_NodeMap_Unlock ==
nullptr && load)
2825 throw std::runtime_error(
"Failed to load PEAK_NodeMap_Unlock");
2829 if(m_PEAK_Node_ToIntegerNode ==
nullptr && load)
2831 throw std::runtime_error(
"Failed to load PEAK_Node_ToIntegerNode");
2835 if(m_PEAK_Node_ToBooleanNode ==
nullptr && load)
2837 throw std::runtime_error(
"Failed to load PEAK_Node_ToBooleanNode");
2841 if(m_PEAK_Node_ToCommandNode ==
nullptr && load)
2843 throw std::runtime_error(
"Failed to load PEAK_Node_ToCommandNode");
2847 if(m_PEAK_Node_ToFloatNode ==
nullptr && load)
2849 throw std::runtime_error(
"Failed to load PEAK_Node_ToFloatNode");
2853 if(m_PEAK_Node_ToStringNode ==
nullptr && load)
2855 throw std::runtime_error(
"Failed to load PEAK_Node_ToStringNode");
2859 if(m_PEAK_Node_ToRegisterNode ==
nullptr && load)
2861 throw std::runtime_error(
"Failed to load PEAK_Node_ToRegisterNode");
2865 if(m_PEAK_Node_ToCategoryNode ==
nullptr && load)
2867 throw std::runtime_error(
"Failed to load PEAK_Node_ToCategoryNode");
2871 if(m_PEAK_Node_ToEnumerationNode ==
nullptr && load)
2873 throw std::runtime_error(
"Failed to load PEAK_Node_ToEnumerationNode");
2877 if(m_PEAK_Node_ToEnumerationEntryNode ==
nullptr && load)
2879 throw std::runtime_error(
"Failed to load PEAK_Node_ToEnumerationEntryNode");
2883 if(m_PEAK_Node_GetName ==
nullptr && load)
2885 throw std::runtime_error(
"Failed to load PEAK_Node_GetName");
2889 if(m_PEAK_Node_GetDisplayName ==
nullptr && load)
2891 throw std::runtime_error(
"Failed to load PEAK_Node_GetDisplayName");
2895 if(m_PEAK_Node_GetNamespace ==
nullptr && load)
2897 throw std::runtime_error(
"Failed to load PEAK_Node_GetNamespace");
2901 if(m_PEAK_Node_GetVisibility ==
nullptr && load)
2903 throw std::runtime_error(
"Failed to load PEAK_Node_GetVisibility");
2907 if(m_PEAK_Node_GetAccessStatus ==
nullptr && load)
2909 throw std::runtime_error(
"Failed to load PEAK_Node_GetAccessStatus");
2913 if(m_PEAK_Node_GetIsCacheable ==
nullptr && load)
2915 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsCacheable");
2919 if(m_PEAK_Node_GetIsAccessStatusCacheable ==
nullptr && load)
2921 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsAccessStatusCacheable");
2925 if(m_PEAK_Node_GetIsStreamable ==
nullptr && load)
2927 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsStreamable");
2931 if(m_PEAK_Node_GetIsDeprecated ==
nullptr && load)
2933 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsDeprecated");
2937 if(m_PEAK_Node_GetIsFeature ==
nullptr && load)
2939 throw std::runtime_error(
"Failed to load PEAK_Node_GetIsFeature");
2943 if(m_PEAK_Node_GetCachingMode ==
nullptr && load)
2945 throw std::runtime_error(
"Failed to load PEAK_Node_GetCachingMode");
2949 if(m_PEAK_Node_GetPollingTime ==
nullptr && load)
2951 throw std::runtime_error(
"Failed to load PEAK_Node_GetPollingTime");
2955 if(m_PEAK_Node_GetToolTip ==
nullptr && load)
2957 throw std::runtime_error(
"Failed to load PEAK_Node_GetToolTip");
2961 if(m_PEAK_Node_GetDescription ==
nullptr && load)
2963 throw std::runtime_error(
"Failed to load PEAK_Node_GetDescription");
2967 if(m_PEAK_Node_GetType ==
nullptr && load)
2969 throw std::runtime_error(
"Failed to load PEAK_Node_GetType");
2973 if(m_PEAK_Node_GetParentNodeMap ==
nullptr && load)
2975 throw std::runtime_error(
"Failed to load PEAK_Node_GetParentNodeMap");
2979 if(m_PEAK_Node_FindInvalidatedNode ==
nullptr && load)
2981 throw std::runtime_error(
"Failed to load PEAK_Node_FindInvalidatedNode");
2985 if(m_PEAK_Node_GetNumInvalidatedNodes ==
nullptr && load)
2987 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumInvalidatedNodes");
2991 if(m_PEAK_Node_GetInvalidatedNode ==
nullptr && load)
2993 throw std::runtime_error(
"Failed to load PEAK_Node_GetInvalidatedNode");
2997 if(m_PEAK_Node_FindInvalidatingNode ==
nullptr && load)
2999 throw std::runtime_error(
"Failed to load PEAK_Node_FindInvalidatingNode");
3003 if(m_PEAK_Node_GetNumInvalidatingNodes ==
nullptr && load)
3005 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumInvalidatingNodes");
3009 if(m_PEAK_Node_GetInvalidatingNode ==
nullptr && load)
3011 throw std::runtime_error(
"Failed to load PEAK_Node_GetInvalidatingNode");
3015 if(m_PEAK_Node_FindSelectedNode ==
nullptr && load)
3017 throw std::runtime_error(
"Failed to load PEAK_Node_FindSelectedNode");
3021 if(m_PEAK_Node_GetNumSelectedNodes ==
nullptr && load)
3023 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumSelectedNodes");
3027 if(m_PEAK_Node_GetSelectedNode ==
nullptr && load)
3029 throw std::runtime_error(
"Failed to load PEAK_Node_GetSelectedNode");
3033 if(m_PEAK_Node_FindSelectingNode ==
nullptr && load)
3035 throw std::runtime_error(
"Failed to load PEAK_Node_FindSelectingNode");
3039 if(m_PEAK_Node_GetNumSelectingNodes ==
nullptr && load)
3041 throw std::runtime_error(
"Failed to load PEAK_Node_GetNumSelectingNodes");
3045 if(m_PEAK_Node_GetSelectingNode ==
nullptr && load)
3047 throw std::runtime_error(
"Failed to load PEAK_Node_GetSelectingNode");
3051 if(m_PEAK_Node_RegisterChangedCallback ==
nullptr && load)
3053 throw std::runtime_error(
"Failed to load PEAK_Node_RegisterChangedCallback");
3057 if(m_PEAK_Node_UnregisterChangedCallback ==
nullptr && load)
3059 throw std::runtime_error(
"Failed to load PEAK_Node_UnregisterChangedCallback");
3063 if(m_PEAK_IntegerNode_ToNode ==
nullptr && load)
3065 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_ToNode");
3069 if(m_PEAK_IntegerNode_GetMinimum ==
nullptr && load)
3071 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetMinimum");
3075 if(m_PEAK_IntegerNode_GetMaximum ==
nullptr && load)
3077 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetMaximum");
3081 if(m_PEAK_IntegerNode_GetIncrement ==
nullptr && load)
3083 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetIncrement");
3087 if(m_PEAK_IntegerNode_GetIncrementType ==
nullptr && load)
3089 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetIncrementType");
3093 if(m_PEAK_IntegerNode_GetValidValues ==
nullptr && load)
3095 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetValidValues");
3099 if(m_PEAK_IntegerNode_GetRepresentation ==
nullptr && load)
3101 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetRepresentation");
3105 if(m_PEAK_IntegerNode_GetUnit ==
nullptr && load)
3107 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetUnit");
3111 if(m_PEAK_IntegerNode_GetValue ==
nullptr && load)
3113 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_GetValue");
3117 if(m_PEAK_IntegerNode_SetValue ==
nullptr && load)
3119 throw std::runtime_error(
"Failed to load PEAK_IntegerNode_SetValue");
3123 if(m_PEAK_BooleanNode_ToNode ==
nullptr && load)
3125 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_ToNode");
3129 if(m_PEAK_BooleanNode_GetValue ==
nullptr && load)
3131 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_GetValue");
3135 if(m_PEAK_BooleanNode_SetValue ==
nullptr && load)
3137 throw std::runtime_error(
"Failed to load PEAK_BooleanNode_SetValue");
3141 if(m_PEAK_CommandNode_ToNode ==
nullptr && load)
3143 throw std::runtime_error(
"Failed to load PEAK_CommandNode_ToNode");
3147 if(m_PEAK_CommandNode_GetIsDone ==
nullptr && load)
3149 throw std::runtime_error(
"Failed to load PEAK_CommandNode_GetIsDone");
3153 if(m_PEAK_CommandNode_Execute ==
nullptr && load)
3155 throw std::runtime_error(
"Failed to load PEAK_CommandNode_Execute");
3159 if(m_PEAK_CommandNode_WaitUntilDoneInfinite ==
nullptr && load)
3161 throw std::runtime_error(
"Failed to load PEAK_CommandNode_WaitUntilDoneInfinite");
3165 if(m_PEAK_CommandNode_WaitUntilDone ==
nullptr && load)
3167 throw std::runtime_error(
"Failed to load PEAK_CommandNode_WaitUntilDone");
3171 if(m_PEAK_FloatNode_ToNode ==
nullptr && load)
3173 throw std::runtime_error(
"Failed to load PEAK_FloatNode_ToNode");
3177 if(m_PEAK_FloatNode_GetMinimum ==
nullptr && load)
3179 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetMinimum");
3183 if(m_PEAK_FloatNode_GetMaximum ==
nullptr && load)
3185 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetMaximum");
3189 if(m_PEAK_FloatNode_GetIncrement ==
nullptr && load)
3191 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetIncrement");
3195 if(m_PEAK_FloatNode_GetIncrementType ==
nullptr && load)
3197 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetIncrementType");
3201 if(m_PEAK_FloatNode_GetValidValues ==
nullptr && load)
3203 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetValidValues");
3207 if(m_PEAK_FloatNode_GetRepresentation ==
nullptr && load)
3209 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetRepresentation");
3213 if(m_PEAK_FloatNode_GetUnit ==
nullptr && load)
3215 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetUnit");
3219 if(m_PEAK_FloatNode_GetDisplayNotation ==
nullptr && load)
3221 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetDisplayNotation");
3225 if(m_PEAK_FloatNode_GetDisplayPrecision ==
nullptr && load)
3227 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetDisplayPrecision");
3231 if(m_PEAK_FloatNode_GetHasConstantIncrement ==
nullptr && load)
3233 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetHasConstantIncrement");
3237 if(m_PEAK_FloatNode_GetValue ==
nullptr && load)
3239 throw std::runtime_error(
"Failed to load PEAK_FloatNode_GetValue");
3243 if(m_PEAK_FloatNode_SetValue ==
nullptr && load)
3245 throw std::runtime_error(
"Failed to load PEAK_FloatNode_SetValue");
3249 if(m_PEAK_StringNode_ToNode ==
nullptr && load)
3251 throw std::runtime_error(
"Failed to load PEAK_StringNode_ToNode");
3255 if(m_PEAK_StringNode_GetMaximumLength ==
nullptr && load)
3257 throw std::runtime_error(
"Failed to load PEAK_StringNode_GetMaximumLength");
3261 if(m_PEAK_StringNode_GetValue ==
nullptr && load)
3263 throw std::runtime_error(
"Failed to load PEAK_StringNode_GetValue");
3267 if(m_PEAK_StringNode_SetValue ==
nullptr && load)
3269 throw std::runtime_error(
"Failed to load PEAK_StringNode_SetValue");
3273 if(m_PEAK_RegisterNode_ToNode ==
nullptr && load)
3275 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_ToNode");
3279 if(m_PEAK_RegisterNode_GetAddress ==
nullptr && load)
3281 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_GetAddress");
3285 if(m_PEAK_RegisterNode_GetLength ==
nullptr && load)
3287 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_GetLength");
3291 if(m_PEAK_RegisterNode_Read ==
nullptr && load)
3293 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_Read");
3297 if(m_PEAK_RegisterNode_Write ==
nullptr && load)
3299 throw std::runtime_error(
"Failed to load PEAK_RegisterNode_Write");
3303 if(m_PEAK_CategoryNode_ToNode ==
nullptr && load)
3305 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_ToNode");
3309 if(m_PEAK_CategoryNode_GetNumSubNodes ==
nullptr && load)
3311 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_GetNumSubNodes");
3315 if(m_PEAK_CategoryNode_GetSubNode ==
nullptr && load)
3317 throw std::runtime_error(
"Failed to load PEAK_CategoryNode_GetSubNode");
3321 if(m_PEAK_EnumerationNode_ToNode ==
nullptr && load)
3323 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_ToNode");
3327 if(m_PEAK_EnumerationNode_GetCurrentEntry ==
nullptr && load)
3329 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetCurrentEntry");
3333 if(m_PEAK_EnumerationNode_SetCurrentEntry ==
nullptr && load)
3335 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntry");
3339 if(m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue ==
nullptr && load)
3341 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue");
3345 if(m_PEAK_EnumerationNode_SetCurrentEntryByValue ==
nullptr && load)
3347 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_SetCurrentEntryByValue");
3351 if(m_PEAK_EnumerationNode_FindEntryBySymbolicValue ==
nullptr && load)
3353 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_FindEntryBySymbolicValue");
3357 if(m_PEAK_EnumerationNode_FindEntryByValue ==
nullptr && load)
3359 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_FindEntryByValue");
3363 if(m_PEAK_EnumerationNode_GetNumEntries ==
nullptr && load)
3365 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetNumEntries");
3369 if(m_PEAK_EnumerationNode_GetEntry ==
nullptr && load)
3371 throw std::runtime_error(
"Failed to load PEAK_EnumerationNode_GetEntry");
3375 if(m_PEAK_EnumerationEntryNode_ToNode ==
nullptr && load)
3377 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_ToNode");
3381 if(m_PEAK_EnumerationEntryNode_GetIsSelfClearing ==
nullptr && load)
3383 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetIsSelfClearing");
3387 if(m_PEAK_EnumerationEntryNode_GetSymbolicValue ==
nullptr && load)
3389 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetSymbolicValue");
3393 if(m_PEAK_EnumerationEntryNode_GetValue ==
nullptr && load)
3395 throw std::runtime_error(
"Failed to load PEAK_EnumerationEntryNode_GetValue");
3399 if(m_PEAK_Port_GetInfo ==
nullptr && load)
3401 throw std::runtime_error(
"Failed to load PEAK_Port_GetInfo");
3405 if(m_PEAK_Port_GetID ==
nullptr && load)
3407 throw std::runtime_error(
"Failed to load PEAK_Port_GetID");
3411 if(m_PEAK_Port_GetName ==
nullptr && load)
3413 throw std::runtime_error(
"Failed to load PEAK_Port_GetName");
3417 if(m_PEAK_Port_GetVendorName ==
nullptr && load)
3419 throw std::runtime_error(
"Failed to load PEAK_Port_GetVendorName");
3423 if(m_PEAK_Port_GetModelName ==
nullptr && load)
3425 throw std::runtime_error(
"Failed to load PEAK_Port_GetModelName");
3429 if(m_PEAK_Port_GetVersion ==
nullptr && load)
3431 throw std::runtime_error(
"Failed to load PEAK_Port_GetVersion");
3435 if(m_PEAK_Port_GetTLType ==
nullptr && load)
3437 throw std::runtime_error(
"Failed to load PEAK_Port_GetTLType");
3441 if(m_PEAK_Port_GetModuleName ==
nullptr && load)
3443 throw std::runtime_error(
"Failed to load PEAK_Port_GetModuleName");
3447 if(m_PEAK_Port_GetDataEndianness ==
nullptr && load)
3449 throw std::runtime_error(
"Failed to load PEAK_Port_GetDataEndianness");
3453 if(m_PEAK_Port_GetIsReadable ==
nullptr && load)
3455 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsReadable");
3459 if(m_PEAK_Port_GetIsWritable ==
nullptr && load)
3461 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsWritable");
3465 if(m_PEAK_Port_GetIsAvailable ==
nullptr && load)
3467 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsAvailable");
3471 if(m_PEAK_Port_GetIsImplemented ==
nullptr && load)
3473 throw std::runtime_error(
"Failed to load PEAK_Port_GetIsImplemented");
3477 if(m_PEAK_Port_Read ==
nullptr && load)
3479 throw std::runtime_error(
"Failed to load PEAK_Port_Read");
3483 if(m_PEAK_Port_Write ==
nullptr && load)
3485 throw std::runtime_error(
"Failed to load PEAK_Port_Write");
3489 if(m_PEAK_Port_GetNumURLs ==
nullptr && load)
3491 throw std::runtime_error(
"Failed to load PEAK_Port_GetNumURLs");
3495 if(m_PEAK_Port_GetURL ==
nullptr && load)
3497 throw std::runtime_error(
"Failed to load PEAK_Port_GetURL");
3501 if(m_PEAK_PortURL_GetInfo ==
nullptr && load)
3503 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetInfo");
3507 if(m_PEAK_PortURL_GetURL ==
nullptr && load)
3509 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetURL");
3513 if(m_PEAK_PortURL_GetScheme ==
nullptr && load)
3515 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetScheme");
3519 if(m_PEAK_PortURL_GetFileName ==
nullptr && load)
3521 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileName");
3525 if(m_PEAK_PortURL_GetFileRegisterAddress ==
nullptr && load)
3527 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileRegisterAddress");
3531 if(m_PEAK_PortURL_GetFileSize ==
nullptr && load)
3533 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSize");
3537 if(m_PEAK_PortURL_GetFileSHA1Hash ==
nullptr && load)
3539 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSHA1Hash");
3543 if(m_PEAK_PortURL_GetFileVersionMajor ==
nullptr && load)
3545 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionMajor");
3549 if(m_PEAK_PortURL_GetFileVersionMinor ==
nullptr && load)
3551 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionMinor");
3555 if(m_PEAK_PortURL_GetFileVersionSubminor ==
nullptr && load)
3557 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileVersionSubminor");
3561 if(m_PEAK_PortURL_GetFileSchemaVersionMajor ==
nullptr && load)
3563 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSchemaVersionMajor");
3567 if(m_PEAK_PortURL_GetFileSchemaVersionMinor ==
nullptr && load)
3569 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetFileSchemaVersionMinor");
3573 if(m_PEAK_PortURL_GetParentPort ==
nullptr && load)
3575 throw std::runtime_error(
"Failed to load PEAK_PortURL_GetParentPort");
3579 if(m_PEAK_EventSupportingModule_EnableEvents ==
nullptr && load)
3581 throw std::runtime_error(
"Failed to load PEAK_EventSupportingModule_EnableEvents");
3585 if(m_PEAK_EventController_GetInfo ==
nullptr && load)
3587 throw std::runtime_error(
"Failed to load PEAK_EventController_GetInfo");
3591 if(m_PEAK_EventController_GetNumEventsInQueue ==
nullptr && load)
3593 throw std::runtime_error(
"Failed to load PEAK_EventController_GetNumEventsInQueue");
3597 if(m_PEAK_EventController_GetNumEventsFired ==
nullptr && load)
3599 throw std::runtime_error(
"Failed to load PEAK_EventController_GetNumEventsFired");
3603 if(m_PEAK_EventController_GetEventMaxSize ==
nullptr && load)
3605 throw std::runtime_error(
"Failed to load PEAK_EventController_GetEventMaxSize");
3609 if(m_PEAK_EventController_GetEventDataMaxSize ==
nullptr && load)
3611 throw std::runtime_error(
"Failed to load PEAK_EventController_GetEventDataMaxSize");
3615 if(m_PEAK_EventController_GetControlledEventType ==
nullptr && load)
3617 throw std::runtime_error(
"Failed to load PEAK_EventController_GetControlledEventType");
3621 if(m_PEAK_EventController_WaitForEvent ==
nullptr && load)
3623 throw std::runtime_error(
"Failed to load PEAK_EventController_WaitForEvent");
3627 if(m_PEAK_EventController_KillWait ==
nullptr && load)
3629 throw std::runtime_error(
"Failed to load PEAK_EventController_KillWait");
3633 if(m_PEAK_EventController_FlushEvents ==
nullptr && load)
3635 throw std::runtime_error(
"Failed to load PEAK_EventController_FlushEvents");
3639 if(m_PEAK_EventController_Destruct ==
nullptr && load)
3641 throw std::runtime_error(
"Failed to load PEAK_EventController_Destruct");
3645 if(m_PEAK_Event_GetInfo ==
nullptr && load)
3647 throw std::runtime_error(
"Failed to load PEAK_Event_GetInfo");
3651 if(m_PEAK_Event_GetID ==
nullptr && load)
3653 throw std::runtime_error(
"Failed to load PEAK_Event_GetID");
3657 if(m_PEAK_Event_GetData ==
nullptr && load)
3659 throw std::runtime_error(
"Failed to load PEAK_Event_GetData");
3663 if(m_PEAK_Event_GetType ==
nullptr && load)
3665 throw std::runtime_error(
"Failed to load PEAK_Event_GetType");
3669 if(m_PEAK_Event_GetRawData ==
nullptr && load)
3671 throw std::runtime_error(
"Failed to load PEAK_Event_GetRawData");
3675 if(m_PEAK_Event_Destruct ==
nullptr && load)
3677 throw std::runtime_error(
"Failed to load PEAK_Event_Destruct");
3681 if(m_PEAK_FirmwareUpdater_Construct ==
nullptr && load)
3683 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_Construct");
3687 if(m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation ==
nullptr && load)
3689 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation");
3693 if(m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation ==
nullptr && load)
3695 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation");
3699 if(m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation ==
nullptr && load)
3701 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation");
3705 if(m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation ==
nullptr && load)
3707 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_GetFirmwareUpdateInformation");
3711 if(m_PEAK_FirmwareUpdater_UpdateDevice ==
nullptr && load)
3713 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_UpdateDevice");
3717 if(m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout ==
nullptr && load)
3719 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout");
3723 if(m_PEAK_FirmwareUpdater_Destruct ==
nullptr && load)
3725 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdater_Destruct");
3729 if(m_PEAK_FirmwareUpdateInformation_GetIsValid ==
nullptr && load)
3731 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetIsValid");
3735 if(m_PEAK_FirmwareUpdateInformation_GetFileName ==
nullptr && load)
3737 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetFileName");
3741 if(m_PEAK_FirmwareUpdateInformation_GetDescription ==
nullptr && load)
3743 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetDescription");
3747 if(m_PEAK_FirmwareUpdateInformation_GetVersion ==
nullptr && load)
3749 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersion");
3753 if(m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern ==
nullptr && load)
3755 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern");
3759 if(m_PEAK_FirmwareUpdateInformation_GetVersionStyle ==
nullptr && load)
3761 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetVersionStyle");
3765 if(m_PEAK_FirmwareUpdateInformation_GetReleaseNotes ==
nullptr && load)
3767 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetReleaseNotes");
3771 if(m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL ==
nullptr && load)
3773 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetReleaseNotesURL");
3777 if(m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence ==
nullptr && load)
3779 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetUserSetPersistence");
3783 if(m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence ==
nullptr && load)
3785 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence");
3789 if(m_PEAK_FirmwareUpdateProgressObserver_Construct ==
nullptr && load)
3791 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_Construct");
3795 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback ==
nullptr && load)
3797 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback");
3801 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback ==
nullptr && load)
3803 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback");
3807 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback ==
nullptr && load)
3809 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback");
3813 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback ==
nullptr && load)
3815 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback");
3819 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback ==
nullptr && load)
3821 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback");
3825 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback ==
nullptr && load)
3827 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback");
3831 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback ==
nullptr && load)
3833 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback");
3837 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback ==
nullptr && load)
3839 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback");
3843 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback ==
nullptr && load)
3845 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback");
3849 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback ==
nullptr && load)
3851 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback");
3855 if(m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback ==
nullptr && load)
3857 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback");
3861 if(m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback ==
nullptr && load)
3863 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback");
3867 if(m_PEAK_FirmwareUpdateProgressObserver_Destruct ==
nullptr && load)
3869 throw std::runtime_error(
"Failed to load PEAK_FirmwareUpdateProgressObserver_Destruct");
3878 auto& inst = instance();
3879 if(inst.m_PEAK_Library_Initialize)
3881 return inst.m_PEAK_Library_Initialize();
3885 throw std::runtime_error(
"Library not loaded!");
3891 auto& inst = instance();
3892 if(inst.m_PEAK_Library_Close)
3894 return inst.m_PEAK_Library_Close();
3898 throw std::runtime_error(
"Library not loaded!");
3904 auto& inst = instance();
3905 if(inst.m_PEAK_Library_IsInitialized)
3907 return inst.m_PEAK_Library_IsInitialized(isInitialized);
3911 throw std::runtime_error(
"Library not loaded!");
3917 auto& inst = instance();
3918 if(inst.m_PEAK_Library_GetVersionMajor)
3920 return inst.m_PEAK_Library_GetVersionMajor(libraryVersionMajor);
3924 throw std::runtime_error(
"Library not loaded!");
3930 auto& inst = instance();
3931 if(inst.m_PEAK_Library_GetVersionMinor)
3933 return inst.m_PEAK_Library_GetVersionMinor(libraryVersionMinor);
3937 throw std::runtime_error(
"Library not loaded!");
3943 auto& inst = instance();
3944 if(inst.m_PEAK_Library_GetVersionSubminor)
3946 return inst.m_PEAK_Library_GetVersionSubminor(libraryVersionSubminor);
3950 throw std::runtime_error(
"Library not loaded!");
3956 auto& inst = instance();
3957 if(inst.m_PEAK_Library_GetLastError)
3959 return inst.m_PEAK_Library_GetLastError(lastErrorCode, lastErrorDescription, lastErrorDescriptionSize);
3963 throw std::runtime_error(
"Library not loaded!");
3969 auto& inst = instance();
3970 if(inst.m_PEAK_EnvironmentInspector_UpdateCTIPaths)
3972 return inst.m_PEAK_EnvironmentInspector_UpdateCTIPaths();
3976 throw std::runtime_error(
"Library not loaded!");
3982 auto& inst = instance();
3983 if(inst.m_PEAK_EnvironmentInspector_GetNumCTIPaths)
3985 return inst.m_PEAK_EnvironmentInspector_GetNumCTIPaths(numCtiPaths);
3989 throw std::runtime_error(
"Library not loaded!");
3995 auto& inst = instance();
3996 if(inst.m_PEAK_EnvironmentInspector_GetCTIPath)
3998 return inst.m_PEAK_EnvironmentInspector_GetCTIPath(index, ctiPath, ctiPathSize);
4002 throw std::runtime_error(
"Library not loaded!");
4008 auto& inst = instance();
4009 if(inst.m_PEAK_ProducerLibrary_Construct)
4011 return inst.m_PEAK_ProducerLibrary_Construct(ctiPath, ctiPathSize, producerLibraryHandle);
4015 throw std::runtime_error(
"Library not loaded!");
4021 auto& inst = instance();
4022 if(inst.m_PEAK_ProducerLibrary_GetKey)
4024 return inst.m_PEAK_ProducerLibrary_GetKey(producerLibraryHandle, key, keySize);
4028 throw std::runtime_error(
"Library not loaded!");
4034 auto& inst = instance();
4035 if(inst.m_PEAK_ProducerLibrary_GetSystem)
4037 return inst.m_PEAK_ProducerLibrary_GetSystem(producerLibraryHandle, systemDescriptorHandle);
4041 throw std::runtime_error(
"Library not loaded!");
4047 auto& inst = instance();
4048 if(inst.m_PEAK_ProducerLibrary_Destruct)
4050 return inst.m_PEAK_ProducerLibrary_Destruct(producerLibraryHandle);
4054 throw std::runtime_error(
"Library not loaded!");
4060 auto& inst = instance();
4061 if(inst.m_PEAK_SystemDescriptor_ToModuleDescriptor)
4063 return inst.m_PEAK_SystemDescriptor_ToModuleDescriptor(systemDescriptorHandle, moduleDescriptorHandle);
4067 throw std::runtime_error(
"Library not loaded!");
4073 auto& inst = instance();
4074 if(inst.m_PEAK_SystemDescriptor_GetKey)
4076 return inst.m_PEAK_SystemDescriptor_GetKey(systemDescriptorHandle, key, keySize);
4080 throw std::runtime_error(
"Library not loaded!");
4086 auto& inst = instance();
4087 if(inst.m_PEAK_SystemDescriptor_GetInfo)
4089 return inst.m_PEAK_SystemDescriptor_GetInfo(systemDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4093 throw std::runtime_error(
"Library not loaded!");
4099 auto& inst = instance();
4100 if(inst.m_PEAK_SystemDescriptor_GetDisplayName)
4102 return inst.m_PEAK_SystemDescriptor_GetDisplayName(systemDescriptorHandle, displayName, displayNameSize);
4106 throw std::runtime_error(
"Library not loaded!");
4112 auto& inst = instance();
4113 if(inst.m_PEAK_SystemDescriptor_GetVendorName)
4115 return inst.m_PEAK_SystemDescriptor_GetVendorName(systemDescriptorHandle, vendorName, vendorNameSize);
4119 throw std::runtime_error(
"Library not loaded!");
4125 auto& inst = instance();
4126 if(inst.m_PEAK_SystemDescriptor_GetModelName)
4128 return inst.m_PEAK_SystemDescriptor_GetModelName(systemDescriptorHandle, modelName, modelNameSize);
4132 throw std::runtime_error(
"Library not loaded!");
4138 auto& inst = instance();
4139 if(inst.m_PEAK_SystemDescriptor_GetVersion)
4141 return inst.m_PEAK_SystemDescriptor_GetVersion(systemDescriptorHandle, version, versionSize);
4145 throw std::runtime_error(
"Library not loaded!");
4151 auto& inst = instance();
4152 if(inst.m_PEAK_SystemDescriptor_GetTLType)
4154 return inst.m_PEAK_SystemDescriptor_GetTLType(systemDescriptorHandle, tlType, tlTypeSize);
4158 throw std::runtime_error(
"Library not loaded!");
4164 auto& inst = instance();
4165 if(inst.m_PEAK_SystemDescriptor_GetCTIFileName)
4167 return inst.m_PEAK_SystemDescriptor_GetCTIFileName(systemDescriptorHandle, ctiFileName, ctiFileNameSize);
4171 throw std::runtime_error(
"Library not loaded!");
4177 auto& inst = instance();
4178 if(inst.m_PEAK_SystemDescriptor_GetCTIFullPath)
4180 return inst.m_PEAK_SystemDescriptor_GetCTIFullPath(systemDescriptorHandle, ctiFullPath, ctiFullPathSize);
4184 throw std::runtime_error(
"Library not loaded!");
4190 auto& inst = instance();
4191 if(inst.m_PEAK_SystemDescriptor_GetGenTLVersionMajor)
4193 return inst.m_PEAK_SystemDescriptor_GetGenTLVersionMajor(systemDescriptorHandle, gentlVersionMajor);
4197 throw std::runtime_error(
"Library not loaded!");
4203 auto& inst = instance();
4204 if(inst.m_PEAK_SystemDescriptor_GetGenTLVersionMinor)
4206 return inst.m_PEAK_SystemDescriptor_GetGenTLVersionMinor(systemDescriptorHandle, gentlVersionMinor);
4210 throw std::runtime_error(
"Library not loaded!");
4216 auto& inst = instance();
4217 if(inst.m_PEAK_SystemDescriptor_GetCharacterEncoding)
4219 return inst.m_PEAK_SystemDescriptor_GetCharacterEncoding(systemDescriptorHandle, characterEncoding);
4223 throw std::runtime_error(
"Library not loaded!");
4229 auto& inst = instance();
4230 if(inst.m_PEAK_SystemDescriptor_GetParentLibrary)
4232 return inst.m_PEAK_SystemDescriptor_GetParentLibrary(systemDescriptorHandle, producerLibraryHandle);
4236 throw std::runtime_error(
"Library not loaded!");
4242 auto& inst = instance();
4243 if(inst.m_PEAK_SystemDescriptor_OpenSystem)
4245 return inst.m_PEAK_SystemDescriptor_OpenSystem(systemDescriptorHandle, systemHandle);
4249 throw std::runtime_error(
"Library not loaded!");
4255 auto& inst = instance();
4256 if(inst.m_PEAK_System_ToModule)
4258 return inst.m_PEAK_System_ToModule(systemHandle, moduleHandle);
4262 throw std::runtime_error(
"Library not loaded!");
4268 auto& inst = instance();
4269 if(inst.m_PEAK_System_ToEventSupportingModule)
4271 return inst.m_PEAK_System_ToEventSupportingModule(systemHandle, eventSupportingModuleHandle);
4275 throw std::runtime_error(
"Library not loaded!");
4281 auto& inst = instance();
4282 if(inst.m_PEAK_System_GetKey)
4284 return inst.m_PEAK_System_GetKey(systemHandle, key, keySize);
4288 throw std::runtime_error(
"Library not loaded!");
4294 auto& inst = instance();
4295 if(inst.m_PEAK_System_GetInfo)
4297 return inst.m_PEAK_System_GetInfo(systemHandle, infoCommand, infoDataType, info, infoSize);
4301 throw std::runtime_error(
"Library not loaded!");
4307 auto& inst = instance();
4308 if(inst.m_PEAK_System_GetID)
4310 return inst.m_PEAK_System_GetID(systemHandle,
id, idSize);
4314 throw std::runtime_error(
"Library not loaded!");
4320 auto& inst = instance();
4321 if(inst.m_PEAK_System_GetDisplayName)
4323 return inst.m_PEAK_System_GetDisplayName(systemHandle, displayName, displayNameSize);
4327 throw std::runtime_error(
"Library not loaded!");
4333 auto& inst = instance();
4334 if(inst.m_PEAK_System_GetVendorName)
4336 return inst.m_PEAK_System_GetVendorName(systemHandle, vendorName, vendorNameSize);
4340 throw std::runtime_error(
"Library not loaded!");
4346 auto& inst = instance();
4347 if(inst.m_PEAK_System_GetModelName)
4349 return inst.m_PEAK_System_GetModelName(systemHandle, modelName, modelNameSize);
4353 throw std::runtime_error(
"Library not loaded!");
4359 auto& inst = instance();
4360 if(inst.m_PEAK_System_GetVersion)
4362 return inst.m_PEAK_System_GetVersion(systemHandle, version, versionSize);
4366 throw std::runtime_error(
"Library not loaded!");
4372 auto& inst = instance();
4373 if(inst.m_PEAK_System_GetTLType)
4375 return inst.m_PEAK_System_GetTLType(systemHandle, tlType, tlTypeSize);
4379 throw std::runtime_error(
"Library not loaded!");
4385 auto& inst = instance();
4386 if(inst.m_PEAK_System_GetCTIFileName)
4388 return inst.m_PEAK_System_GetCTIFileName(systemHandle, ctiFileName, ctiFileNameSize);
4392 throw std::runtime_error(
"Library not loaded!");
4398 auto& inst = instance();
4399 if(inst.m_PEAK_System_GetCTIFullPath)
4401 return inst.m_PEAK_System_GetCTIFullPath(systemHandle, ctiFullPath, ctiFullPathSize);
4405 throw std::runtime_error(
"Library not loaded!");
4411 auto& inst = instance();
4412 if(inst.m_PEAK_System_GetGenTLVersionMajor)
4414 return inst.m_PEAK_System_GetGenTLVersionMajor(systemHandle, gentlVersionMajor);
4418 throw std::runtime_error(
"Library not loaded!");
4424 auto& inst = instance();
4425 if(inst.m_PEAK_System_GetGenTLVersionMinor)
4427 return inst.m_PEAK_System_GetGenTLVersionMinor(systemHandle, gentlVersionMinor);
4431 throw std::runtime_error(
"Library not loaded!");
4437 auto& inst = instance();
4438 if(inst.m_PEAK_System_GetCharacterEncoding)
4440 return inst.m_PEAK_System_GetCharacterEncoding(systemHandle, characterEncoding);
4444 throw std::runtime_error(
"Library not loaded!");
4450 auto& inst = instance();
4451 if(inst.m_PEAK_System_GetParentLibrary)
4453 return inst.m_PEAK_System_GetParentLibrary(systemHandle, producerLibraryHandle);
4457 throw std::runtime_error(
"Library not loaded!");
4463 auto& inst = instance();
4464 if(inst.m_PEAK_System_UpdateInterfaces)
4466 return inst.m_PEAK_System_UpdateInterfaces(systemHandle, timeout_ms);
4470 throw std::runtime_error(
"Library not loaded!");
4476 auto& inst = instance();
4477 if(inst.m_PEAK_System_GetNumInterfaces)
4479 return inst.m_PEAK_System_GetNumInterfaces(systemHandle, numInterfaces);
4483 throw std::runtime_error(
"Library not loaded!");
4489 auto& inst = instance();
4490 if(inst.m_PEAK_System_GetInterface)
4492 return inst.m_PEAK_System_GetInterface(systemHandle, index, interfaceDescriptorHandle);
4496 throw std::runtime_error(
"Library not loaded!");
4502 auto& inst = instance();
4503 if(inst.m_PEAK_System_RegisterInterfaceFoundCallback)
4505 return inst.m_PEAK_System_RegisterInterfaceFoundCallback(systemHandle, callback, callbackContext, callbackHandle);
4509 throw std::runtime_error(
"Library not loaded!");
4515 auto& inst = instance();
4516 if(inst.m_PEAK_System_UnregisterInterfaceFoundCallback)
4518 return inst.m_PEAK_System_UnregisterInterfaceFoundCallback(systemHandle, callbackHandle);
4522 throw std::runtime_error(
"Library not loaded!");
4528 auto& inst = instance();
4529 if(inst.m_PEAK_System_RegisterInterfaceLostCallback)
4531 return inst.m_PEAK_System_RegisterInterfaceLostCallback(systemHandle, callback, callbackContext, callbackHandle);
4535 throw std::runtime_error(
"Library not loaded!");
4541 auto& inst = instance();
4542 if(inst.m_PEAK_System_UnregisterInterfaceLostCallback)
4544 return inst.m_PEAK_System_UnregisterInterfaceLostCallback(systemHandle, callbackHandle);
4548 throw std::runtime_error(
"Library not loaded!");
4554 auto& inst = instance();
4555 if(inst.m_PEAK_System_Destruct)
4557 return inst.m_PEAK_System_Destruct(systemHandle);
4561 throw std::runtime_error(
"Library not loaded!");
4567 auto& inst = instance();
4568 if(inst.m_PEAK_InterfaceDescriptor_ToModuleDescriptor)
4570 return inst.m_PEAK_InterfaceDescriptor_ToModuleDescriptor(interfaceDescriptorHandle, moduleDescriptorHandle);
4574 throw std::runtime_error(
"Library not loaded!");
4580 auto& inst = instance();
4581 if(inst.m_PEAK_InterfaceDescriptor_GetKey)
4583 return inst.m_PEAK_InterfaceDescriptor_GetKey(interfaceDescriptorHandle, key, keySize);
4587 throw std::runtime_error(
"Library not loaded!");
4593 auto& inst = instance();
4594 if(inst.m_PEAK_InterfaceDescriptor_GetInfo)
4596 return inst.m_PEAK_InterfaceDescriptor_GetInfo(interfaceDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4600 throw std::runtime_error(
"Library not loaded!");
4606 auto& inst = instance();
4607 if(inst.m_PEAK_InterfaceDescriptor_GetDisplayName)
4609 return inst.m_PEAK_InterfaceDescriptor_GetDisplayName(interfaceDescriptorHandle, displayName, displayNameSize);
4613 throw std::runtime_error(
"Library not loaded!");
4619 auto& inst = instance();
4620 if(inst.m_PEAK_InterfaceDescriptor_GetTLType)
4622 return inst.m_PEAK_InterfaceDescriptor_GetTLType(interfaceDescriptorHandle, tlType, tlTypeSize);
4626 throw std::runtime_error(
"Library not loaded!");
4632 auto& inst = instance();
4633 if(inst.m_PEAK_InterfaceDescriptor_GetParentSystem)
4635 return inst.m_PEAK_InterfaceDescriptor_GetParentSystem(interfaceDescriptorHandle, systemHandle);
4639 throw std::runtime_error(
"Library not loaded!");
4645 auto& inst = instance();
4646 if(inst.m_PEAK_InterfaceDescriptor_OpenInterface)
4648 return inst.m_PEAK_InterfaceDescriptor_OpenInterface(interfaceDescriptorHandle, interfaceHandle);
4652 throw std::runtime_error(
"Library not loaded!");
4658 auto& inst = instance();
4659 if(inst.m_PEAK_Interface_ToModule)
4661 return inst.m_PEAK_Interface_ToModule(interfaceHandle, moduleHandle);
4665 throw std::runtime_error(
"Library not loaded!");
4671 auto& inst = instance();
4672 if(inst.m_PEAK_Interface_ToEventSupportingModule)
4674 return inst.m_PEAK_Interface_ToEventSupportingModule(interfaceHandle, eventSupportingModuleHandle);
4678 throw std::runtime_error(
"Library not loaded!");
4684 auto& inst = instance();
4685 if(inst.m_PEAK_Interface_GetKey)
4687 return inst.m_PEAK_Interface_GetKey(interfaceHandle, key, keySize);
4691 throw std::runtime_error(
"Library not loaded!");
4697 auto& inst = instance();
4698 if(inst.m_PEAK_Interface_GetInfo)
4700 return inst.m_PEAK_Interface_GetInfo(interfaceHandle, infoCommand, infoDataType, info, infoSize);
4704 throw std::runtime_error(
"Library not loaded!");
4710 auto& inst = instance();
4711 if(inst.m_PEAK_Interface_GetID)
4713 return inst.m_PEAK_Interface_GetID(interfaceHandle,
id, idSize);
4717 throw std::runtime_error(
"Library not loaded!");
4723 auto& inst = instance();
4724 if(inst.m_PEAK_Interface_GetDisplayName)
4726 return inst.m_PEAK_Interface_GetDisplayName(interfaceHandle, displayName, displayNameSize);
4730 throw std::runtime_error(
"Library not loaded!");
4736 auto& inst = instance();
4737 if(inst.m_PEAK_Interface_GetTLType)
4739 return inst.m_PEAK_Interface_GetTLType(interfaceHandle, tlType, tlTypeSize);
4743 throw std::runtime_error(
"Library not loaded!");
4749 auto& inst = instance();
4750 if(inst.m_PEAK_Interface_GetParentSystem)
4752 return inst.m_PEAK_Interface_GetParentSystem(interfaceHandle, systemHandle);
4756 throw std::runtime_error(
"Library not loaded!");
4762 auto& inst = instance();
4763 if(inst.m_PEAK_Interface_UpdateDevices)
4765 return inst.m_PEAK_Interface_UpdateDevices(interfaceHandle, timeout_ms);
4769 throw std::runtime_error(
"Library not loaded!");
4775 auto& inst = instance();
4776 if(inst.m_PEAK_Interface_GetNumDevices)
4778 return inst.m_PEAK_Interface_GetNumDevices(interfaceHandle, numDevices);
4782 throw std::runtime_error(
"Library not loaded!");
4788 auto& inst = instance();
4789 if(inst.m_PEAK_Interface_GetDevice)
4791 return inst.m_PEAK_Interface_GetDevice(interfaceHandle, index, deviceDescriptorHandle);
4795 throw std::runtime_error(
"Library not loaded!");
4801 auto& inst = instance();
4802 if(inst.m_PEAK_Interface_RegisterDeviceFoundCallback)
4804 return inst.m_PEAK_Interface_RegisterDeviceFoundCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4808 throw std::runtime_error(
"Library not loaded!");
4814 auto& inst = instance();
4815 if(inst.m_PEAK_Interface_UnregisterDeviceFoundCallback)
4817 return inst.m_PEAK_Interface_UnregisterDeviceFoundCallback(interfaceHandle, callbackHandle);
4821 throw std::runtime_error(
"Library not loaded!");
4827 auto& inst = instance();
4828 if(inst.m_PEAK_Interface_RegisterDeviceReconnectedCallback)
4830 return inst.m_PEAK_Interface_RegisterDeviceReconnectedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4834 throw std::runtime_error(
"Library not loaded!");
4840 auto& inst = instance();
4841 if(inst.m_PEAK_Interface_UnregisterDeviceReconnectedCallback)
4843 return inst.m_PEAK_Interface_UnregisterDeviceReconnectedCallback(interfaceHandle, callbackHandle);
4847 throw std::runtime_error(
"Library not loaded!");
4853 auto& inst = instance();
4854 if(inst.m_PEAK_Interface_RegisterDeviceDisconnectedCallback)
4856 return inst.m_PEAK_Interface_RegisterDeviceDisconnectedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4860 throw std::runtime_error(
"Library not loaded!");
4866 auto& inst = instance();
4867 if(inst.m_PEAK_Interface_UnregisterDeviceDisconnectedCallback)
4869 return inst.m_PEAK_Interface_UnregisterDeviceDisconnectedCallback(interfaceHandle, callbackHandle);
4873 throw std::runtime_error(
"Library not loaded!");
4879 auto& inst = instance();
4880 if(inst.m_PEAK_Interface_RegisterDeviceLostCallback)
4882 return inst.m_PEAK_Interface_RegisterDeviceLostCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4886 throw std::runtime_error(
"Library not loaded!");
4892 auto& inst = instance();
4893 if(inst.m_PEAK_Interface_UnregisterDeviceLostCallback)
4895 return inst.m_PEAK_Interface_UnregisterDeviceLostCallback(interfaceHandle, callbackHandle);
4899 throw std::runtime_error(
"Library not loaded!");
4905 auto& inst = instance();
4906 if(inst.m_PEAK_Interface_RegisterDeviceListChangedCallback)
4908 return inst.m_PEAK_Interface_RegisterDeviceListChangedCallback(interfaceHandle, callback, callbackContext, callbackHandle);
4912 throw std::runtime_error(
"Library not loaded!");
4918 auto& inst = instance();
4919 if(inst.m_PEAK_Interface_UnregisterDeviceListChangedCallback)
4921 return inst.m_PEAK_Interface_UnregisterDeviceListChangedCallback(interfaceHandle, callbackHandle);
4925 throw std::runtime_error(
"Library not loaded!");
4931 auto& inst = instance();
4932 if(inst.m_PEAK_Interface_Destruct)
4934 return inst.m_PEAK_Interface_Destruct(interfaceHandle);
4938 throw std::runtime_error(
"Library not loaded!");
4944 auto& inst = instance();
4945 if(inst.m_PEAK_DeviceDescriptor_ToModuleDescriptor)
4947 return inst.m_PEAK_DeviceDescriptor_ToModuleDescriptor(deviceDescriptorHandle, moduleDescriptorHandle);
4951 throw std::runtime_error(
"Library not loaded!");
4957 auto& inst = instance();
4958 if(inst.m_PEAK_DeviceDescriptor_GetKey)
4960 return inst.m_PEAK_DeviceDescriptor_GetKey(deviceDescriptorHandle, key, keySize);
4964 throw std::runtime_error(
"Library not loaded!");
4970 auto& inst = instance();
4971 if(inst.m_PEAK_DeviceDescriptor_GetInfo)
4973 return inst.m_PEAK_DeviceDescriptor_GetInfo(deviceDescriptorHandle, infoCommand, infoDataType, info, infoSize);
4977 throw std::runtime_error(
"Library not loaded!");
4983 auto& inst = instance();
4984 if(inst.m_PEAK_DeviceDescriptor_GetDisplayName)
4986 return inst.m_PEAK_DeviceDescriptor_GetDisplayName(deviceDescriptorHandle, displayName, displayNameSize);
4990 throw std::runtime_error(
"Library not loaded!");
4996 auto& inst = instance();
4997 if(inst.m_PEAK_DeviceDescriptor_GetVendorName)
4999 return inst.m_PEAK_DeviceDescriptor_GetVendorName(deviceDescriptorHandle, vendorName, vendorNameSize);
5003 throw std::runtime_error(
"Library not loaded!");
5009 auto& inst = instance();
5010 if(inst.m_PEAK_DeviceDescriptor_GetModelName)
5012 return inst.m_PEAK_DeviceDescriptor_GetModelName(deviceDescriptorHandle, modelName, modelNameSize);
5016 throw std::runtime_error(
"Library not loaded!");
5022 auto& inst = instance();
5023 if(inst.m_PEAK_DeviceDescriptor_GetVersion)
5025 return inst.m_PEAK_DeviceDescriptor_GetVersion(deviceDescriptorHandle, version, versionSize);
5029 throw std::runtime_error(
"Library not loaded!");
5035 auto& inst = instance();
5036 if(inst.m_PEAK_DeviceDescriptor_GetTLType)
5038 return inst.m_PEAK_DeviceDescriptor_GetTLType(deviceDescriptorHandle, tlType, tlTypeSize);
5042 throw std::runtime_error(
"Library not loaded!");
5048 auto& inst = instance();
5049 if(inst.m_PEAK_DeviceDescriptor_GetUserDefinedName)
5051 return inst.m_PEAK_DeviceDescriptor_GetUserDefinedName(deviceDescriptorHandle, userDefinedName, userDefinedNameSize);
5055 throw std::runtime_error(
"Library not loaded!");
5061 auto& inst = instance();
5062 if(inst.m_PEAK_DeviceDescriptor_GetSerialNumber)
5064 return inst.m_PEAK_DeviceDescriptor_GetSerialNumber(deviceDescriptorHandle, serialNumber, serialNumberSize);
5068 throw std::runtime_error(
"Library not loaded!");
5074 auto& inst = instance();
5075 if(inst.m_PEAK_DeviceDescriptor_GetAccessStatus)
5077 return inst.m_PEAK_DeviceDescriptor_GetAccessStatus(deviceDescriptorHandle, accessStatus);
5081 throw std::runtime_error(
"Library not loaded!");
5087 auto& inst = instance();
5088 if(inst.m_PEAK_DeviceDescriptor_GetTimestampTickFrequency)
5090 return inst.m_PEAK_DeviceDescriptor_GetTimestampTickFrequency(deviceDescriptorHandle, timestampTickFrequency);
5094 throw std::runtime_error(
"Library not loaded!");
5100 auto& inst = instance();
5101 if(inst.m_PEAK_DeviceDescriptor_GetIsOpenableExclusive)
5103 return inst.m_PEAK_DeviceDescriptor_GetIsOpenableExclusive(deviceDescriptorHandle, isOpenable);
5107 throw std::runtime_error(
"Library not loaded!");
5113 auto& inst = instance();
5114 if(inst.m_PEAK_DeviceDescriptor_GetIsOpenable)
5116 return inst.m_PEAK_DeviceDescriptor_GetIsOpenable(deviceDescriptorHandle, accessType, isOpenable);
5120 throw std::runtime_error(
"Library not loaded!");
5126 auto& inst = instance();
5127 if(inst.m_PEAK_DeviceDescriptor_OpenDevice)
5129 return inst.m_PEAK_DeviceDescriptor_OpenDevice(deviceDescriptorHandle, accessType, deviceHandle);
5133 throw std::runtime_error(
"Library not loaded!");
5139 auto& inst = instance();
5140 if(inst.m_PEAK_DeviceDescriptor_GetParentInterface)
5142 return inst.m_PEAK_DeviceDescriptor_GetParentInterface(deviceDescriptorHandle, interfaceHandle);
5146 throw std::runtime_error(
"Library not loaded!");
5152 auto& inst = instance();
5153 if(inst.m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval)
5155 return inst.m_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(deviceDescriptorHandle, monitoringUpdateInterval_ms);
5159 throw std::runtime_error(
"Library not loaded!");
5165 auto& inst = instance();
5166 if(inst.m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval)
5168 return inst.m_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(deviceDescriptorHandle, monitoringUpdateInterval_ms);
5172 throw std::runtime_error(
"Library not loaded!");
5178 auto& inst = instance();
5179 if(inst.m_PEAK_DeviceDescriptor_IsInformationRoleMonitored)
5181 return inst.m_PEAK_DeviceDescriptor_IsInformationRoleMonitored(deviceDescriptorHandle, informationRole, isInformationRoleMonitored);
5185 throw std::runtime_error(
"Library not loaded!");
5191 auto& inst = instance();
5192 if(inst.m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring)
5194 return inst.m_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(deviceDescriptorHandle, informationRole);
5198 throw std::runtime_error(
"Library not loaded!");
5204 auto& inst = instance();
5205 if(inst.m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring)
5207 return inst.m_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(deviceDescriptorHandle, informationRole);
5211 throw std::runtime_error(
"Library not loaded!");
5217 auto& inst = instance();
5218 if(inst.m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback)
5220 return inst.m_PEAK_DeviceDescriptor_RegisterInformationChangedCallback(deviceDescriptorHandle, callback, callbackContext, callbackHandle);
5224 throw std::runtime_error(
"Library not loaded!");
5230 auto& inst = instance();
5231 if(inst.m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback)
5233 return inst.m_PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(deviceDescriptorHandle, callbackHandle);
5237 throw std::runtime_error(
"Library not loaded!");
5243 auto& inst = instance();
5244 if(inst.m_PEAK_Device_ToModule)
5246 return inst.m_PEAK_Device_ToModule(deviceHandle, moduleHandle);
5250 throw std::runtime_error(
"Library not loaded!");
5256 auto& inst = instance();
5257 if(inst.m_PEAK_Device_ToEventSupportingModule)
5259 return inst.m_PEAK_Device_ToEventSupportingModule(deviceHandle, eventSupportingModuleHandle);
5263 throw std::runtime_error(
"Library not loaded!");
5269 auto& inst = instance();
5270 if(inst.m_PEAK_Device_GetKey)
5272 return inst.m_PEAK_Device_GetKey(deviceHandle, key, keySize);
5276 throw std::runtime_error(
"Library not loaded!");
5282 auto& inst = instance();
5283 if(inst.m_PEAK_Device_GetInfo)
5285 return inst.m_PEAK_Device_GetInfo(deviceHandle, infoCommand, infoDataType, info, infoSize);
5289 throw std::runtime_error(
"Library not loaded!");
5295 auto& inst = instance();
5296 if(inst.m_PEAK_Device_GetID)
5298 return inst.m_PEAK_Device_GetID(deviceHandle,
id, idSize);
5302 throw std::runtime_error(
"Library not loaded!");
5308 auto& inst = instance();
5309 if(inst.m_PEAK_Device_GetDisplayName)
5311 return inst.m_PEAK_Device_GetDisplayName(deviceHandle, displayName, displayNameSize);
5315 throw std::runtime_error(
"Library not loaded!");
5321 auto& inst = instance();
5322 if(inst.m_PEAK_Device_GetVendorName)
5324 return inst.m_PEAK_Device_GetVendorName(deviceHandle, vendorName, vendorNameSize);
5328 throw std::runtime_error(
"Library not loaded!");
5334 auto& inst = instance();
5335 if(inst.m_PEAK_Device_GetModelName)
5337 return inst.m_PEAK_Device_GetModelName(deviceHandle, modelName, modelNameSize);
5341 throw std::runtime_error(
"Library not loaded!");
5347 auto& inst = instance();
5348 if(inst.m_PEAK_Device_GetVersion)
5350 return inst.m_PEAK_Device_GetVersion(deviceHandle, version, versionSize);
5354 throw std::runtime_error(
"Library not loaded!");
5360 auto& inst = instance();
5361 if(inst.m_PEAK_Device_GetTLType)
5363 return inst.m_PEAK_Device_GetTLType(deviceHandle, tlType, tlTypeSize);
5367 throw std::runtime_error(
"Library not loaded!");
5373 auto& inst = instance();
5374 if(inst.m_PEAK_Device_GetUserDefinedName)
5376 return inst.m_PEAK_Device_GetUserDefinedName(deviceHandle, userDefinedName, userDefinedNameSize);
5380 throw std::runtime_error(
"Library not loaded!");
5386 auto& inst = instance();
5387 if(inst.m_PEAK_Device_GetSerialNumber)
5389 return inst.m_PEAK_Device_GetSerialNumber(deviceHandle, serialNumber, serialNumberSize);
5393 throw std::runtime_error(
"Library not loaded!");
5399 auto& inst = instance();
5400 if(inst.m_PEAK_Device_GetAccessStatus)
5402 return inst.m_PEAK_Device_GetAccessStatus(deviceHandle, accessStatus);
5406 throw std::runtime_error(
"Library not loaded!");
5412 auto& inst = instance();
5413 if(inst.m_PEAK_Device_GetTimestampTickFrequency)
5415 return inst.m_PEAK_Device_GetTimestampTickFrequency(deviceHandle, timestampTickFrequency);
5419 throw std::runtime_error(
"Library not loaded!");
5425 auto& inst = instance();
5426 if(inst.m_PEAK_Device_GetParentInterface)
5428 return inst.m_PEAK_Device_GetParentInterface(deviceHandle, interfaceHandle);
5432 throw std::runtime_error(
"Library not loaded!");
5438 auto& inst = instance();
5439 if(inst.m_PEAK_Device_GetRemoteDevice)
5441 return inst.m_PEAK_Device_GetRemoteDevice(deviceHandle, remoteDeviceHandle);
5445 throw std::runtime_error(
"Library not loaded!");
5451 auto& inst = instance();
5452 if(inst.m_PEAK_Device_GetNumDataStreams)
5454 return inst.m_PEAK_Device_GetNumDataStreams(deviceHandle, numDataStreams);
5458 throw std::runtime_error(
"Library not loaded!");
5464 auto& inst = instance();
5465 if(inst.m_PEAK_Device_GetDataStream)
5467 return inst.m_PEAK_Device_GetDataStream(deviceHandle, index, dataStreamDescriptorHandle);
5471 throw std::runtime_error(
"Library not loaded!");
5477 auto& inst = instance();
5478 if(inst.m_PEAK_Device_Destruct)
5480 return inst.m_PEAK_Device_Destruct(deviceHandle);
5484 throw std::runtime_error(
"Library not loaded!");
5490 auto& inst = instance();
5491 if(inst.m_PEAK_RemoteDevice_ToModule)
5493 return inst.m_PEAK_RemoteDevice_ToModule(remoteDeviceHandle, moduleHandle);
5497 throw std::runtime_error(
"Library not loaded!");
5503 auto& inst = instance();
5504 if(inst.m_PEAK_RemoteDevice_GetLocalDevice)
5506 return inst.m_PEAK_RemoteDevice_GetLocalDevice(remoteDeviceHandle, deviceHandle);
5510 throw std::runtime_error(
"Library not loaded!");
5516 auto& inst = instance();
5517 if(inst.m_PEAK_DataStreamDescriptor_ToModuleDescriptor)
5519 return inst.m_PEAK_DataStreamDescriptor_ToModuleDescriptor(dataStreamDescriptorHandle, moduleDescriptorHandle);
5523 throw std::runtime_error(
"Library not loaded!");
5529 auto& inst = instance();
5530 if(inst.m_PEAK_DataStreamDescriptor_GetKey)
5532 return inst.m_PEAK_DataStreamDescriptor_GetKey(dataStreamDescriptorHandle, key, keySize);
5536 throw std::runtime_error(
"Library not loaded!");
5542 auto& inst = instance();
5543 if(inst.m_PEAK_DataStreamDescriptor_GetParentDevice)
5545 return inst.m_PEAK_DataStreamDescriptor_GetParentDevice(dataStreamDescriptorHandle, deviceHandle);
5549 throw std::runtime_error(
"Library not loaded!");
5555 auto& inst = instance();
5556 if(inst.m_PEAK_DataStreamDescriptor_OpenDataStream)
5558 return inst.m_PEAK_DataStreamDescriptor_OpenDataStream(dataStreamDescriptorHandle, dataStreamHandle);
5562 throw std::runtime_error(
"Library not loaded!");
5568 auto& inst = instance();
5569 if(inst.m_PEAK_DataStream_ToModule)
5571 return inst.m_PEAK_DataStream_ToModule(dataStreamHandle, moduleHandle);
5575 throw std::runtime_error(
"Library not loaded!");
5581 auto& inst = instance();
5582 if(inst.m_PEAK_DataStream_ToEventSupportingModule)
5584 return inst.m_PEAK_DataStream_ToEventSupportingModule(dataStreamHandle, eventSupportingModuleHandle);
5588 throw std::runtime_error(
"Library not loaded!");
5594 auto& inst = instance();
5595 if(inst.m_PEAK_DataStream_GetKey)
5597 return inst.m_PEAK_DataStream_GetKey(dataStreamHandle, key, keySize);
5601 throw std::runtime_error(
"Library not loaded!");
5607 auto& inst = instance();
5608 if(inst.m_PEAK_DataStream_GetInfo)
5610 return inst.m_PEAK_DataStream_GetInfo(dataStreamHandle, infoCommand, infoDataType, info, infoSize);
5614 throw std::runtime_error(
"Library not loaded!");
5620 auto& inst = instance();
5621 if(inst.m_PEAK_DataStream_GetID)
5623 return inst.m_PEAK_DataStream_GetID(dataStreamHandle,
id, idSize);
5627 throw std::runtime_error(
"Library not loaded!");
5633 auto& inst = instance();
5634 if(inst.m_PEAK_DataStream_GetTLType)
5636 return inst.m_PEAK_DataStream_GetTLType(dataStreamHandle, tlType, tlTypeSize);
5640 throw std::runtime_error(
"Library not loaded!");
5646 auto& inst = instance();
5647 if(inst.m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired)
5649 return inst.m_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(dataStreamHandle, numBuffersAnnouncedMinRequired);
5653 throw std::runtime_error(
"Library not loaded!");
5659 auto& inst = instance();
5660 if(inst.m_PEAK_DataStream_GetNumBuffersAnnounced)
5662 return inst.m_PEAK_DataStream_GetNumBuffersAnnounced(dataStreamHandle, numBuffersAnnounced);
5666 throw std::runtime_error(
"Library not loaded!");
5672 auto& inst = instance();
5673 if(inst.m_PEAK_DataStream_GetNumBuffersQueued)
5675 return inst.m_PEAK_DataStream_GetNumBuffersQueued(dataStreamHandle, numBuffersQueued);
5679 throw std::runtime_error(
"Library not loaded!");
5685 auto& inst = instance();
5686 if(inst.m_PEAK_DataStream_GetNumBuffersAwaitDelivery)
5688 return inst.m_PEAK_DataStream_GetNumBuffersAwaitDelivery(dataStreamHandle, numBuffersAwaitDelivery);
5692 throw std::runtime_error(
"Library not loaded!");
5698 auto& inst = instance();
5699 if(inst.m_PEAK_DataStream_GetNumBuffersDelivered)
5701 return inst.m_PEAK_DataStream_GetNumBuffersDelivered(dataStreamHandle, numBuffersDelivered);
5705 throw std::runtime_error(
"Library not loaded!");
5711 auto& inst = instance();
5712 if(inst.m_PEAK_DataStream_GetNumBuffersStarted)
5714 return inst.m_PEAK_DataStream_GetNumBuffersStarted(dataStreamHandle, numBuffersStarted);
5718 throw std::runtime_error(
"Library not loaded!");
5724 auto& inst = instance();
5725 if(inst.m_PEAK_DataStream_GetNumUnderruns)
5727 return inst.m_PEAK_DataStream_GetNumUnderruns(dataStreamHandle, numUnderruns);
5731 throw std::runtime_error(
"Library not loaded!");
5737 auto& inst = instance();
5738 if(inst.m_PEAK_DataStream_GetNumChunksPerBufferMax)
5740 return inst.m_PEAK_DataStream_GetNumChunksPerBufferMax(dataStreamHandle, numChunksPerBufferMax);
5744 throw std::runtime_error(
"Library not loaded!");
5750 auto& inst = instance();
5751 if(inst.m_PEAK_DataStream_GetBufferAlignment)
5753 return inst.m_PEAK_DataStream_GetBufferAlignment(dataStreamHandle, bufferAlignment);
5757 throw std::runtime_error(
"Library not loaded!");
5763 auto& inst = instance();
5764 if(inst.m_PEAK_DataStream_GetPayloadSize)
5766 return inst.m_PEAK_DataStream_GetPayloadSize(dataStreamHandle, payloadSize);
5770 throw std::runtime_error(
"Library not loaded!");
5776 auto& inst = instance();
5777 if(inst.m_PEAK_DataStream_GetDefinesPayloadSize)
5779 return inst.m_PEAK_DataStream_GetDefinesPayloadSize(dataStreamHandle, definesPayloadSize);
5783 throw std::runtime_error(
"Library not loaded!");
5789 auto& inst = instance();
5790 if(inst.m_PEAK_DataStream_GetIsGrabbing)
5792 return inst.m_PEAK_DataStream_GetIsGrabbing(dataStreamHandle, isGrabbing);
5796 throw std::runtime_error(
"Library not loaded!");
5802 auto& inst = instance();
5803 if(inst.m_PEAK_DataStream_GetParentDevice)
5805 return inst.m_PEAK_DataStream_GetParentDevice(dataStreamHandle, deviceHandle);
5809 throw std::runtime_error(
"Library not loaded!");
5815 auto& inst = instance();
5816 if(inst.m_PEAK_DataStream_AnnounceBuffer)
5818 return inst.m_PEAK_DataStream_AnnounceBuffer(dataStreamHandle, buffer, bufferSize, userPtr, revocationCallback, callbackContext, bufferHandle);
5822 throw std::runtime_error(
"Library not loaded!");
5828 auto& inst = instance();
5829 if(inst.m_PEAK_DataStream_AllocAndAnnounceBuffer)
5831 return inst.m_PEAK_DataStream_AllocAndAnnounceBuffer(dataStreamHandle, bufferSize, userPtr, bufferHandle);
5835 throw std::runtime_error(
"Library not loaded!");
5841 auto& inst = instance();
5842 if(inst.m_PEAK_DataStream_QueueBuffer)
5844 return inst.m_PEAK_DataStream_QueueBuffer(dataStreamHandle, bufferHandle);
5848 throw std::runtime_error(
"Library not loaded!");
5854 auto& inst = instance();
5855 if(inst.m_PEAK_DataStream_RevokeBuffer)
5857 return inst.m_PEAK_DataStream_RevokeBuffer(dataStreamHandle, bufferHandle);
5861 throw std::runtime_error(
"Library not loaded!");
5867 auto& inst = instance();
5868 if(inst.m_PEAK_DataStream_WaitForFinishedBuffer)
5870 return inst.m_PEAK_DataStream_WaitForFinishedBuffer(dataStreamHandle, timeout_ms, bufferHandle);
5874 throw std::runtime_error(
"Library not loaded!");
5880 auto& inst = instance();
5881 if(inst.m_PEAK_DataStream_KillWait)
5883 return inst.m_PEAK_DataStream_KillWait(dataStreamHandle);
5887 throw std::runtime_error(
"Library not loaded!");
5893 auto& inst = instance();
5894 if(inst.m_PEAK_DataStream_Flush)
5896 return inst.m_PEAK_DataStream_Flush(dataStreamHandle, flushMode);
5900 throw std::runtime_error(
"Library not loaded!");
5906 auto& inst = instance();
5907 if(inst.m_PEAK_DataStream_StartAcquisitionInfinite)
5909 return inst.m_PEAK_DataStream_StartAcquisitionInfinite(dataStreamHandle, startMode);
5913 throw std::runtime_error(
"Library not loaded!");
5919 auto& inst = instance();
5920 if(inst.m_PEAK_DataStream_StartAcquisition)
5922 return inst.m_PEAK_DataStream_StartAcquisition(dataStreamHandle, startMode, numToAcquire);
5926 throw std::runtime_error(
"Library not loaded!");
5932 auto& inst = instance();
5933 if(inst.m_PEAK_DataStream_StopAcquisition)
5935 return inst.m_PEAK_DataStream_StopAcquisition(dataStreamHandle, stopMode);
5939 throw std::runtime_error(
"Library not loaded!");
5945 auto& inst = instance();
5946 if(inst.m_PEAK_DataStream_Destruct)
5948 return inst.m_PEAK_DataStream_Destruct(dataStreamHandle);
5952 throw std::runtime_error(
"Library not loaded!");
5958 auto& inst = instance();
5959 if(inst.m_PEAK_Buffer_ToModule)
5961 return inst.m_PEAK_Buffer_ToModule(bufferHandle, moduleHandle);
5965 throw std::runtime_error(
"Library not loaded!");
5971 auto& inst = instance();
5972 if(inst.m_PEAK_Buffer_ToEventSupportingModule)
5974 return inst.m_PEAK_Buffer_ToEventSupportingModule(bufferHandle, eventSupportingModuleHandle);
5978 throw std::runtime_error(
"Library not loaded!");
5984 auto& inst = instance();
5985 if(inst.m_PEAK_Buffer_GetInfo)
5987 return inst.m_PEAK_Buffer_GetInfo(bufferHandle, infoCommand, infoDataType, info, infoSize);
5991 throw std::runtime_error(
"Library not loaded!");
5997 auto& inst = instance();
5998 if(inst.m_PEAK_Buffer_GetTLType)
6000 return inst.m_PEAK_Buffer_GetTLType(bufferHandle, tlType, tlTypeSize);
6004 throw std::runtime_error(
"Library not loaded!");
6010 auto& inst = instance();
6011 if(inst.m_PEAK_Buffer_GetBasePtr)
6013 return inst.m_PEAK_Buffer_GetBasePtr(bufferHandle, basePtr);
6017 throw std::runtime_error(
"Library not loaded!");
6023 auto& inst = instance();
6024 if(inst.m_PEAK_Buffer_GetSize)
6026 return inst.m_PEAK_Buffer_GetSize(bufferHandle, size);
6030 throw std::runtime_error(
"Library not loaded!");
6036 auto& inst = instance();
6037 if(inst.m_PEAK_Buffer_GetUserPtr)
6039 return inst.m_PEAK_Buffer_GetUserPtr(bufferHandle, userPtr);
6043 throw std::runtime_error(
"Library not loaded!");
6049 auto& inst = instance();
6050 if(inst.m_PEAK_Buffer_GetPayloadType)
6052 return inst.m_PEAK_Buffer_GetPayloadType(bufferHandle, payloadType);
6056 throw std::runtime_error(
"Library not loaded!");
6062 auto& inst = instance();
6063 if(inst.m_PEAK_Buffer_GetPixelFormat)
6065 return inst.m_PEAK_Buffer_GetPixelFormat(bufferHandle, pixelFormat);
6069 throw std::runtime_error(
"Library not loaded!");
6075 auto& inst = instance();
6076 if(inst.m_PEAK_Buffer_GetPixelFormatNamespace)
6078 return inst.m_PEAK_Buffer_GetPixelFormatNamespace(bufferHandle, pixelFormatNamespace);
6082 throw std::runtime_error(
"Library not loaded!");
6088 auto& inst = instance();
6089 if(inst.m_PEAK_Buffer_GetPixelEndianness)
6091 return inst.m_PEAK_Buffer_GetPixelEndianness(bufferHandle, pixelEndianness);
6095 throw std::runtime_error(
"Library not loaded!");
6101 auto& inst = instance();
6102 if(inst.m_PEAK_Buffer_GetExpectedDataSize)
6104 return inst.m_PEAK_Buffer_GetExpectedDataSize(bufferHandle, expectedDataSize);
6108 throw std::runtime_error(
"Library not loaded!");
6114 auto& inst = instance();
6115 if(inst.m_PEAK_Buffer_GetDeliveredDataSize)
6117 return inst.m_PEAK_Buffer_GetDeliveredDataSize(bufferHandle, deliveredDataSize);
6121 throw std::runtime_error(
"Library not loaded!");
6127 auto& inst = instance();
6128 if(inst.m_PEAK_Buffer_GetFrameID)
6130 return inst.m_PEAK_Buffer_GetFrameID(bufferHandle, frameId);
6134 throw std::runtime_error(
"Library not loaded!");
6140 auto& inst = instance();
6141 if(inst.m_PEAK_Buffer_GetImageOffset)
6143 return inst.m_PEAK_Buffer_GetImageOffset(bufferHandle, imageOffset);
6147 throw std::runtime_error(
"Library not loaded!");
6153 auto& inst = instance();
6154 if(inst.m_PEAK_Buffer_GetDeliveredImageHeight)
6156 return inst.m_PEAK_Buffer_GetDeliveredImageHeight(bufferHandle, deliveredImageHeight);
6160 throw std::runtime_error(
"Library not loaded!");
6166 auto& inst = instance();
6167 if(inst.m_PEAK_Buffer_GetDeliveredChunkPayloadSize)
6169 return inst.m_PEAK_Buffer_GetDeliveredChunkPayloadSize(bufferHandle, deliveredChunkPayloadSize);
6173 throw std::runtime_error(
"Library not loaded!");
6179 auto& inst = instance();
6180 if(inst.m_PEAK_Buffer_GetChunkLayoutID)
6182 return inst.m_PEAK_Buffer_GetChunkLayoutID(bufferHandle, chunkLayoutId);
6186 throw std::runtime_error(
"Library not loaded!");
6192 auto& inst = instance();
6193 if(inst.m_PEAK_Buffer_GetFileName)
6195 return inst.m_PEAK_Buffer_GetFileName(bufferHandle, fileName, fileNameSize);
6199 throw std::runtime_error(
"Library not loaded!");
6205 auto& inst = instance();
6206 if(inst.m_PEAK_Buffer_GetWidth)
6208 return inst.m_PEAK_Buffer_GetWidth(bufferHandle, width);
6212 throw std::runtime_error(
"Library not loaded!");
6218 auto& inst = instance();
6219 if(inst.m_PEAK_Buffer_GetHeight)
6221 return inst.m_PEAK_Buffer_GetHeight(bufferHandle, height);
6225 throw std::runtime_error(
"Library not loaded!");
6231 auto& inst = instance();
6232 if(inst.m_PEAK_Buffer_GetXOffset)
6234 return inst.m_PEAK_Buffer_GetXOffset(bufferHandle, xOffset);
6238 throw std::runtime_error(
"Library not loaded!");
6244 auto& inst = instance();
6245 if(inst.m_PEAK_Buffer_GetYOffset)
6247 return inst.m_PEAK_Buffer_GetYOffset(bufferHandle, yOffset);
6251 throw std::runtime_error(
"Library not loaded!");
6257 auto& inst = instance();
6258 if(inst.m_PEAK_Buffer_GetXPadding)
6260 return inst.m_PEAK_Buffer_GetXPadding(bufferHandle, xPadding);
6264 throw std::runtime_error(
"Library not loaded!");
6270 auto& inst = instance();
6271 if(inst.m_PEAK_Buffer_GetYPadding)
6273 return inst.m_PEAK_Buffer_GetYPadding(bufferHandle, yPadding);
6277 throw std::runtime_error(
"Library not loaded!");
6283 auto& inst = instance();
6284 if(inst.m_PEAK_Buffer_GetTimestamp_ticks)
6286 return inst.m_PEAK_Buffer_GetTimestamp_ticks(bufferHandle, timestamp_ticks);
6290 throw std::runtime_error(
"Library not loaded!");
6296 auto& inst = instance();
6297 if(inst.m_PEAK_Buffer_GetTimestamp_ns)
6299 return inst.m_PEAK_Buffer_GetTimestamp_ns(bufferHandle, timestamp_ns);
6303 throw std::runtime_error(
"Library not loaded!");
6309 auto& inst = instance();
6310 if(inst.m_PEAK_Buffer_GetIsQueued)
6312 return inst.m_PEAK_Buffer_GetIsQueued(bufferHandle, isQueued);
6316 throw std::runtime_error(
"Library not loaded!");
6322 auto& inst = instance();
6323 if(inst.m_PEAK_Buffer_GetIsAcquiring)
6325 return inst.m_PEAK_Buffer_GetIsAcquiring(bufferHandle, isAcquiring);
6329 throw std::runtime_error(
"Library not loaded!");
6335 auto& inst = instance();
6336 if(inst.m_PEAK_Buffer_GetIsIncomplete)
6338 return inst.m_PEAK_Buffer_GetIsIncomplete(bufferHandle, isIncomplete);
6342 throw std::runtime_error(
"Library not loaded!");
6348 auto& inst = instance();
6349 if(inst.m_PEAK_Buffer_GetHasNewData)
6351 return inst.m_PEAK_Buffer_GetHasNewData(bufferHandle, hasNewData);
6355 throw std::runtime_error(
"Library not loaded!");
6361 auto& inst = instance();
6362 if(inst.m_PEAK_Buffer_GetHasImage)
6364 return inst.m_PEAK_Buffer_GetHasImage(bufferHandle, hasImage);
6368 throw std::runtime_error(
"Library not loaded!");
6374 auto& inst = instance();
6375 if(inst.m_PEAK_Buffer_GetHasChunks)
6377 return inst.m_PEAK_Buffer_GetHasChunks(bufferHandle, hasChunks);
6381 throw std::runtime_error(
"Library not loaded!");
6387 auto& inst = instance();
6388 if(inst.m_PEAK_Buffer_UpdateChunks)
6390 return inst.m_PEAK_Buffer_UpdateChunks(bufferHandle);
6394 throw std::runtime_error(
"Library not loaded!");
6400 auto& inst = instance();
6401 if(inst.m_PEAK_Buffer_GetNumChunks)
6403 return inst.m_PEAK_Buffer_GetNumChunks(bufferHandle, numChunks);
6407 throw std::runtime_error(
"Library not loaded!");
6413 auto& inst = instance();
6414 if(inst.m_PEAK_Buffer_GetChunk)
6416 return inst.m_PEAK_Buffer_GetChunk(bufferHandle, index, bufferChunkHandle);
6420 throw std::runtime_error(
"Library not loaded!");
6426 auto& inst = instance();
6427 if(inst.m_PEAK_Buffer_UpdateParts)
6429 return inst.m_PEAK_Buffer_UpdateParts(bufferHandle);
6433 throw std::runtime_error(
"Library not loaded!");
6439 auto& inst = instance();
6440 if(inst.m_PEAK_Buffer_GetNumParts)
6442 return inst.m_PEAK_Buffer_GetNumParts(bufferHandle, numParts);
6446 throw std::runtime_error(
"Library not loaded!");
6452 auto& inst = instance();
6453 if(inst.m_PEAK_Buffer_GetPart)
6455 return inst.m_PEAK_Buffer_GetPart(bufferHandle, index, bufferPartHandle);
6459 throw std::runtime_error(
"Library not loaded!");
6465 auto& inst = instance();
6466 if(inst.m_PEAK_BufferChunk_GetID)
6468 return inst.m_PEAK_BufferChunk_GetID(bufferChunkHandle,
id);
6472 throw std::runtime_error(
"Library not loaded!");
6478 auto& inst = instance();
6479 if(inst.m_PEAK_BufferChunk_GetBasePtr)
6481 return inst.m_PEAK_BufferChunk_GetBasePtr(bufferChunkHandle, basePtr);
6485 throw std::runtime_error(
"Library not loaded!");
6491 auto& inst = instance();
6492 if(inst.m_PEAK_BufferChunk_GetSize)
6494 return inst.m_PEAK_BufferChunk_GetSize(bufferChunkHandle, size);
6498 throw std::runtime_error(
"Library not loaded!");
6504 auto& inst = instance();
6505 if(inst.m_PEAK_BufferChunk_GetParentBuffer)
6507 return inst.m_PEAK_BufferChunk_GetParentBuffer(bufferChunkHandle, bufferHandle);
6511 throw std::runtime_error(
"Library not loaded!");
6517 auto& inst = instance();
6518 if(inst.m_PEAK_BufferChunk_Destruct)
6520 return inst.m_PEAK_BufferChunk_Destruct(bufferChunkHandle);
6524 throw std::runtime_error(
"Library not loaded!");
6530 auto& inst = instance();
6531 if(inst.m_PEAK_BufferPart_GetInfo)
6533 return inst.m_PEAK_BufferPart_GetInfo(bufferPartHandle, infoCommand, infoDataType, info, infoSize);
6537 throw std::runtime_error(
"Library not loaded!");
6543 auto& inst = instance();
6544 if(inst.m_PEAK_BufferPart_GetSourceID)
6546 return inst.m_PEAK_BufferPart_GetSourceID(bufferPartHandle, sourceId);
6550 throw std::runtime_error(
"Library not loaded!");
6556 auto& inst = instance();
6557 if(inst.m_PEAK_BufferPart_GetBasePtr)
6559 return inst.m_PEAK_BufferPart_GetBasePtr(bufferPartHandle, basePtr);
6563 throw std::runtime_error(
"Library not loaded!");
6569 auto& inst = instance();
6570 if(inst.m_PEAK_BufferPart_GetSize)
6572 return inst.m_PEAK_BufferPart_GetSize(bufferPartHandle, size);
6576 throw std::runtime_error(
"Library not loaded!");
6582 auto& inst = instance();
6583 if(inst.m_PEAK_BufferPart_GetType)
6585 return inst.m_PEAK_BufferPart_GetType(bufferPartHandle, type);
6589 throw std::runtime_error(
"Library not loaded!");
6595 auto& inst = instance();
6596 if(inst.m_PEAK_BufferPart_GetFormat)
6598 return inst.m_PEAK_BufferPart_GetFormat(bufferPartHandle, format);
6602 throw std::runtime_error(
"Library not loaded!");
6608 auto& inst = instance();
6609 if(inst.m_PEAK_BufferPart_GetFormatNamespace)
6611 return inst.m_PEAK_BufferPart_GetFormatNamespace(bufferPartHandle, formatNamespace);
6615 throw std::runtime_error(
"Library not loaded!");
6621 auto& inst = instance();
6622 if(inst.m_PEAK_BufferPart_GetWidth)
6624 return inst.m_PEAK_BufferPart_GetWidth(bufferPartHandle, width);
6628 throw std::runtime_error(
"Library not loaded!");
6634 auto& inst = instance();
6635 if(inst.m_PEAK_BufferPart_GetHeight)
6637 return inst.m_PEAK_BufferPart_GetHeight(bufferPartHandle, height);
6641 throw std::runtime_error(
"Library not loaded!");
6647 auto& inst = instance();
6648 if(inst.m_PEAK_BufferPart_GetXOffset)
6650 return inst.m_PEAK_BufferPart_GetXOffset(bufferPartHandle, xOffset);
6654 throw std::runtime_error(
"Library not loaded!");
6660 auto& inst = instance();
6661 if(inst.m_PEAK_BufferPart_GetYOffset)
6663 return inst.m_PEAK_BufferPart_GetYOffset(bufferPartHandle, yOffset);
6667 throw std::runtime_error(
"Library not loaded!");
6673 auto& inst = instance();
6674 if(inst.m_PEAK_BufferPart_GetXPadding)
6676 return inst.m_PEAK_BufferPart_GetXPadding(bufferPartHandle, xPadding);
6680 throw std::runtime_error(
"Library not loaded!");
6686 auto& inst = instance();
6687 if(inst.m_PEAK_BufferPart_GetDeliveredImageHeight)
6689 return inst.m_PEAK_BufferPart_GetDeliveredImageHeight(bufferPartHandle, deliveredImageHeight);
6693 throw std::runtime_error(
"Library not loaded!");
6699 auto& inst = instance();
6700 if(inst.m_PEAK_BufferPart_GetParentBuffer)
6702 return inst.m_PEAK_BufferPart_GetParentBuffer(bufferPartHandle, bufferHandle);
6706 throw std::runtime_error(
"Library not loaded!");
6712 auto& inst = instance();
6713 if(inst.m_PEAK_BufferPart_Destruct)
6715 return inst.m_PEAK_BufferPart_Destruct(bufferPartHandle);
6719 throw std::runtime_error(
"Library not loaded!");
6725 auto& inst = instance();
6726 if(inst.m_PEAK_ModuleDescriptor_GetID)
6728 return inst.m_PEAK_ModuleDescriptor_GetID(moduleDescriptorHandle,
id, idSize);
6732 throw std::runtime_error(
"Library not loaded!");
6738 auto& inst = instance();
6739 if(inst.m_PEAK_Module_GetNumNodeMaps)
6741 return inst.m_PEAK_Module_GetNumNodeMaps(moduleHandle, numNodeMaps);
6745 throw std::runtime_error(
"Library not loaded!");
6751 auto& inst = instance();
6752 if(inst.m_PEAK_Module_GetNodeMap)
6754 return inst.m_PEAK_Module_GetNodeMap(moduleHandle, index, nodeMapHandle);
6758 throw std::runtime_error(
"Library not loaded!");
6764 auto& inst = instance();
6765 if(inst.m_PEAK_Module_GetPort)
6767 return inst.m_PEAK_Module_GetPort(moduleHandle, portHandle);
6771 throw std::runtime_error(
"Library not loaded!");
6777 auto& inst = instance();
6778 if(inst.m_PEAK_NodeMap_GetHasNode)
6780 return inst.m_PEAK_NodeMap_GetHasNode(nodeMapHandle, nodeName, nodeNameSize, hasNode);
6784 throw std::runtime_error(
"Library not loaded!");
6790 auto& inst = instance();
6791 if(inst.m_PEAK_NodeMap_FindNode)
6793 return inst.m_PEAK_NodeMap_FindNode(nodeMapHandle, nodeName, nodeNameSize, nodeHandle);
6797 throw std::runtime_error(
"Library not loaded!");
6803 auto& inst = instance();
6804 if(inst.m_PEAK_NodeMap_InvalidateNodes)
6806 return inst.m_PEAK_NodeMap_InvalidateNodes(nodeMapHandle);
6810 throw std::runtime_error(
"Library not loaded!");
6816 auto& inst = instance();
6817 if(inst.m_PEAK_NodeMap_PollNodes)
6819 return inst.m_PEAK_NodeMap_PollNodes(nodeMapHandle, elapsedTime_ms);
6823 throw std::runtime_error(
"Library not loaded!");
6829 auto& inst = instance();
6830 if(inst.m_PEAK_NodeMap_GetNumNodes)
6832 return inst.m_PEAK_NodeMap_GetNumNodes(nodeMapHandle, numNodes);
6836 throw std::runtime_error(
"Library not loaded!");
6842 auto& inst = instance();
6843 if(inst.m_PEAK_NodeMap_GetNode)
6845 return inst.m_PEAK_NodeMap_GetNode(nodeMapHandle, index, nodeHandle);
6849 throw std::runtime_error(
"Library not loaded!");
6855 auto& inst = instance();
6856 if(inst.m_PEAK_NodeMap_GetHasBufferSupportedChunks)
6858 return inst.m_PEAK_NodeMap_GetHasBufferSupportedChunks(nodeMapHandle, bufferHandle, hasSupportedChunks);
6862 throw std::runtime_error(
"Library not loaded!");
6868 auto& inst = instance();
6869 if(inst.m_PEAK_NodeMap_UpdateChunkNodes)
6871 return inst.m_PEAK_NodeMap_UpdateChunkNodes(nodeMapHandle, bufferHandle);
6875 throw std::runtime_error(
"Library not loaded!");
6881 auto& inst = instance();
6882 if(inst.m_PEAK_NodeMap_GetHasEventSupportedData)
6884 return inst.m_PEAK_NodeMap_GetHasEventSupportedData(nodeMapHandle, eventHandle, hasSupportedData);
6888 throw std::runtime_error(
"Library not loaded!");
6894 auto& inst = instance();
6895 if(inst.m_PEAK_NodeMap_UpdateEventNodes)
6897 return inst.m_PEAK_NodeMap_UpdateEventNodes(nodeMapHandle, eventHandle);
6901 throw std::runtime_error(
"Library not loaded!");
6907 auto& inst = instance();
6908 if(inst.m_PEAK_NodeMap_StoreToFile)
6910 return inst.m_PEAK_NodeMap_StoreToFile(nodeMapHandle, filePath, filePathSize);
6914 throw std::runtime_error(
"Library not loaded!");
6920 auto& inst = instance();
6921 if(inst.m_PEAK_NodeMap_LoadFromFile)
6923 return inst.m_PEAK_NodeMap_LoadFromFile(nodeMapHandle, filePath, filePathSize);
6927 throw std::runtime_error(
"Library not loaded!");
6933 auto& inst = instance();
6934 if(inst.m_PEAK_NodeMap_Lock)
6936 return inst.m_PEAK_NodeMap_Lock(nodeMapHandle);
6940 throw std::runtime_error(
"Library not loaded!");
6946 auto& inst = instance();
6947 if(inst.m_PEAK_NodeMap_Unlock)
6949 return inst.m_PEAK_NodeMap_Unlock(nodeMapHandle);
6953 throw std::runtime_error(
"Library not loaded!");
6959 auto& inst = instance();
6960 if(inst.m_PEAK_Node_ToIntegerNode)
6962 return inst.m_PEAK_Node_ToIntegerNode(nodeHandle, integerNodeHandle);
6966 throw std::runtime_error(
"Library not loaded!");
6972 auto& inst = instance();
6973 if(inst.m_PEAK_Node_ToBooleanNode)
6975 return inst.m_PEAK_Node_ToBooleanNode(nodeHandle, booleanNodeHandle);
6979 throw std::runtime_error(
"Library not loaded!");
6985 auto& inst = instance();
6986 if(inst.m_PEAK_Node_ToCommandNode)
6988 return inst.m_PEAK_Node_ToCommandNode(nodeHandle, commandNodeHandle);
6992 throw std::runtime_error(
"Library not loaded!");
6998 auto& inst = instance();
6999 if(inst.m_PEAK_Node_ToFloatNode)
7001 return inst.m_PEAK_Node_ToFloatNode(nodeHandle, floatNodeHandle);
7005 throw std::runtime_error(
"Library not loaded!");
7011 auto& inst = instance();
7012 if(inst.m_PEAK_Node_ToStringNode)
7014 return inst.m_PEAK_Node_ToStringNode(nodeHandle, stringNodeHandle);
7018 throw std::runtime_error(
"Library not loaded!");
7024 auto& inst = instance();
7025 if(inst.m_PEAK_Node_ToRegisterNode)
7027 return inst.m_PEAK_Node_ToRegisterNode(nodeHandle, registerNodeHandle);
7031 throw std::runtime_error(
"Library not loaded!");
7037 auto& inst = instance();
7038 if(inst.m_PEAK_Node_ToCategoryNode)
7040 return inst.m_PEAK_Node_ToCategoryNode(nodeHandle, categoryNodeHandle);
7044 throw std::runtime_error(
"Library not loaded!");
7050 auto& inst = instance();
7051 if(inst.m_PEAK_Node_ToEnumerationNode)
7053 return inst.m_PEAK_Node_ToEnumerationNode(nodeHandle, enumerationNodeHandle);
7057 throw std::runtime_error(
"Library not loaded!");
7063 auto& inst = instance();
7064 if(inst.m_PEAK_Node_ToEnumerationEntryNode)
7066 return inst.m_PEAK_Node_ToEnumerationEntryNode(nodeHandle, enumerationEntryNodeHandle);
7070 throw std::runtime_error(
"Library not loaded!");
7076 auto& inst = instance();
7077 if(inst.m_PEAK_Node_GetName)
7079 return inst.m_PEAK_Node_GetName(nodeHandle, name, nameSize);
7083 throw std::runtime_error(
"Library not loaded!");
7089 auto& inst = instance();
7090 if(inst.m_PEAK_Node_GetDisplayName)
7092 return inst.m_PEAK_Node_GetDisplayName(nodeHandle, displayName, displayNameSize);
7096 throw std::runtime_error(
"Library not loaded!");
7102 auto& inst = instance();
7103 if(inst.m_PEAK_Node_GetNamespace)
7105 return inst.m_PEAK_Node_GetNamespace(nodeHandle, _namespace);
7109 throw std::runtime_error(
"Library not loaded!");
7115 auto& inst = instance();
7116 if(inst.m_PEAK_Node_GetVisibility)
7118 return inst.m_PEAK_Node_GetVisibility(nodeHandle, visibility);
7122 throw std::runtime_error(
"Library not loaded!");
7128 auto& inst = instance();
7129 if(inst.m_PEAK_Node_GetAccessStatus)
7131 return inst.m_PEAK_Node_GetAccessStatus(nodeHandle, accessStatus);
7135 throw std::runtime_error(
"Library not loaded!");
7141 auto& inst = instance();
7142 if(inst.m_PEAK_Node_GetIsCacheable)
7144 return inst.m_PEAK_Node_GetIsCacheable(nodeHandle, isCacheable);
7148 throw std::runtime_error(
"Library not loaded!");
7154 auto& inst = instance();
7155 if(inst.m_PEAK_Node_GetIsAccessStatusCacheable)
7157 return inst.m_PEAK_Node_GetIsAccessStatusCacheable(nodeHandle, isAccessStatusCacheable);
7161 throw std::runtime_error(
"Library not loaded!");
7167 auto& inst = instance();
7168 if(inst.m_PEAK_Node_GetIsStreamable)
7170 return inst.m_PEAK_Node_GetIsStreamable(nodeHandle, isStreamable);
7174 throw std::runtime_error(
"Library not loaded!");
7180 auto& inst = instance();
7181 if(inst.m_PEAK_Node_GetIsDeprecated)
7183 return inst.m_PEAK_Node_GetIsDeprecated(nodeHandle, isDeprecated);
7187 throw std::runtime_error(
"Library not loaded!");
7193 auto& inst = instance();
7194 if(inst.m_PEAK_Node_GetIsFeature)
7196 return inst.m_PEAK_Node_GetIsFeature(nodeHandle, isFeature);
7200 throw std::runtime_error(
"Library not loaded!");
7206 auto& inst = instance();
7207 if(inst.m_PEAK_Node_GetCachingMode)
7209 return inst.m_PEAK_Node_GetCachingMode(nodeHandle, cachingMode);
7213 throw std::runtime_error(
"Library not loaded!");
7219 auto& inst = instance();
7220 if(inst.m_PEAK_Node_GetPollingTime)
7222 return inst.m_PEAK_Node_GetPollingTime(nodeHandle, pollingTime_ms);
7226 throw std::runtime_error(
"Library not loaded!");
7232 auto& inst = instance();
7233 if(inst.m_PEAK_Node_GetToolTip)
7235 return inst.m_PEAK_Node_GetToolTip(nodeHandle, toolTip, toolTipSize);
7239 throw std::runtime_error(
"Library not loaded!");
7245 auto& inst = instance();
7246 if(inst.m_PEAK_Node_GetDescription)
7248 return inst.m_PEAK_Node_GetDescription(nodeHandle, description, descriptionSize);
7252 throw std::runtime_error(
"Library not loaded!");
7258 auto& inst = instance();
7259 if(inst.m_PEAK_Node_GetType)
7261 return inst.m_PEAK_Node_GetType(nodeHandle, type);
7265 throw std::runtime_error(
"Library not loaded!");
7271 auto& inst = instance();
7272 if(inst.m_PEAK_Node_GetParentNodeMap)
7274 return inst.m_PEAK_Node_GetParentNodeMap(nodeHandle, nodeMapHandle);
7278 throw std::runtime_error(
"Library not loaded!");
7284 auto& inst = instance();
7285 if(inst.m_PEAK_Node_FindInvalidatedNode)
7287 return inst.m_PEAK_Node_FindInvalidatedNode(nodeHandle, name, nameSize, invalidatedNodeHandle);
7291 throw std::runtime_error(
"Library not loaded!");
7297 auto& inst = instance();
7298 if(inst.m_PEAK_Node_GetNumInvalidatedNodes)
7300 return inst.m_PEAK_Node_GetNumInvalidatedNodes(nodeHandle, numInvalidatedNodes);
7304 throw std::runtime_error(
"Library not loaded!");
7310 auto& inst = instance();
7311 if(inst.m_PEAK_Node_GetInvalidatedNode)
7313 return inst.m_PEAK_Node_GetInvalidatedNode(nodeHandle, index, invalidatedNodeHandle);
7317 throw std::runtime_error(
"Library not loaded!");
7323 auto& inst = instance();
7324 if(inst.m_PEAK_Node_FindInvalidatingNode)
7326 return inst.m_PEAK_Node_FindInvalidatingNode(nodeHandle, name, nameSize, invalidatingNodeHandle);
7330 throw std::runtime_error(
"Library not loaded!");
7336 auto& inst = instance();
7337 if(inst.m_PEAK_Node_GetNumInvalidatingNodes)
7339 return inst.m_PEAK_Node_GetNumInvalidatingNodes(nodeHandle, numInvalidatingNodes);
7343 throw std::runtime_error(
"Library not loaded!");
7349 auto& inst = instance();
7350 if(inst.m_PEAK_Node_GetInvalidatingNode)
7352 return inst.m_PEAK_Node_GetInvalidatingNode(nodeHandle, index, invalidatingNodeHandle);
7356 throw std::runtime_error(
"Library not loaded!");
7362 auto& inst = instance();
7363 if(inst.m_PEAK_Node_FindSelectedNode)
7365 return inst.m_PEAK_Node_FindSelectedNode(nodeHandle, name, nameSize, selectedNodeHandle);
7369 throw std::runtime_error(
"Library not loaded!");
7375 auto& inst = instance();
7376 if(inst.m_PEAK_Node_GetNumSelectedNodes)
7378 return inst.m_PEAK_Node_GetNumSelectedNodes(nodeHandle, numSelectedNodes);
7382 throw std::runtime_error(
"Library not loaded!");
7388 auto& inst = instance();
7389 if(inst.m_PEAK_Node_GetSelectedNode)
7391 return inst.m_PEAK_Node_GetSelectedNode(nodeHandle, index, selectedNodeHandle);
7395 throw std::runtime_error(
"Library not loaded!");
7401 auto& inst = instance();
7402 if(inst.m_PEAK_Node_FindSelectingNode)
7404 return inst.m_PEAK_Node_FindSelectingNode(nodeHandle, name, nameSize, selectingNodeHandle);
7408 throw std::runtime_error(
"Library not loaded!");
7414 auto& inst = instance();
7415 if(inst.m_PEAK_Node_GetNumSelectingNodes)
7417 return inst.m_PEAK_Node_GetNumSelectingNodes(nodeHandle, numSelectingNodes);
7421 throw std::runtime_error(
"Library not loaded!");
7427 auto& inst = instance();
7428 if(inst.m_PEAK_Node_GetSelectingNode)
7430 return inst.m_PEAK_Node_GetSelectingNode(nodeHandle, index, selectingNodeHandle);
7434 throw std::runtime_error(
"Library not loaded!");
7440 auto& inst = instance();
7441 if(inst.m_PEAK_Node_RegisterChangedCallback)
7443 return inst.m_PEAK_Node_RegisterChangedCallback(nodeHandle, callback, callbackContext, callbackHandle);
7447 throw std::runtime_error(
"Library not loaded!");
7453 auto& inst = instance();
7454 if(inst.m_PEAK_Node_UnregisterChangedCallback)
7456 return inst.m_PEAK_Node_UnregisterChangedCallback(nodeHandle, callbackHandle);
7460 throw std::runtime_error(
"Library not loaded!");
7466 auto& inst = instance();
7467 if(inst.m_PEAK_IntegerNode_ToNode)
7469 return inst.m_PEAK_IntegerNode_ToNode(integerNodeHandle, nodeHandle);
7473 throw std::runtime_error(
"Library not loaded!");
7479 auto& inst = instance();
7480 if(inst.m_PEAK_IntegerNode_GetMinimum)
7482 return inst.m_PEAK_IntegerNode_GetMinimum(integerNodeHandle, minimum);
7486 throw std::runtime_error(
"Library not loaded!");
7492 auto& inst = instance();
7493 if(inst.m_PEAK_IntegerNode_GetMaximum)
7495 return inst.m_PEAK_IntegerNode_GetMaximum(integerNodeHandle, maximum);
7499 throw std::runtime_error(
"Library not loaded!");
7505 auto& inst = instance();
7506 if(inst.m_PEAK_IntegerNode_GetIncrement)
7508 return inst.m_PEAK_IntegerNode_GetIncrement(integerNodeHandle, increment);
7512 throw std::runtime_error(
"Library not loaded!");
7518 auto& inst = instance();
7519 if(inst.m_PEAK_IntegerNode_GetIncrementType)
7521 return inst.m_PEAK_IntegerNode_GetIncrementType(integerNodeHandle, incrementType);
7525 throw std::runtime_error(
"Library not loaded!");
7531 auto& inst = instance();
7532 if(inst.m_PEAK_IntegerNode_GetValidValues)
7534 return inst.m_PEAK_IntegerNode_GetValidValues(integerNodeHandle, validValues, validValuesSize);
7538 throw std::runtime_error(
"Library not loaded!");
7544 auto& inst = instance();
7545 if(inst.m_PEAK_IntegerNode_GetRepresentation)
7547 return inst.m_PEAK_IntegerNode_GetRepresentation(integerNodeHandle, representation);
7551 throw std::runtime_error(
"Library not loaded!");
7557 auto& inst = instance();
7558 if(inst.m_PEAK_IntegerNode_GetUnit)
7560 return inst.m_PEAK_IntegerNode_GetUnit(integerNodeHandle, unit, unitSize);
7564 throw std::runtime_error(
"Library not loaded!");
7570 auto& inst = instance();
7571 if(inst.m_PEAK_IntegerNode_GetValue)
7573 return inst.m_PEAK_IntegerNode_GetValue(integerNodeHandle, cacheUsePolicy, value);
7577 throw std::runtime_error(
"Library not loaded!");
7583 auto& inst = instance();
7584 if(inst.m_PEAK_IntegerNode_SetValue)
7586 return inst.m_PEAK_IntegerNode_SetValue(integerNodeHandle, value);
7590 throw std::runtime_error(
"Library not loaded!");
7596 auto& inst = instance();
7597 if(inst.m_PEAK_BooleanNode_ToNode)
7599 return inst.m_PEAK_BooleanNode_ToNode(booleanNodeHandle, nodeHandle);
7603 throw std::runtime_error(
"Library not loaded!");
7609 auto& inst = instance();
7610 if(inst.m_PEAK_BooleanNode_GetValue)
7612 return inst.m_PEAK_BooleanNode_GetValue(booleanNodeHandle, cacheUsePolicy, value);
7616 throw std::runtime_error(
"Library not loaded!");
7622 auto& inst = instance();
7623 if(inst.m_PEAK_BooleanNode_SetValue)
7625 return inst.m_PEAK_BooleanNode_SetValue(booleanNodeHandle, value);
7629 throw std::runtime_error(
"Library not loaded!");
7635 auto& inst = instance();
7636 if(inst.m_PEAK_CommandNode_ToNode)
7638 return inst.m_PEAK_CommandNode_ToNode(commandNodeHandle, nodeHandle);
7642 throw std::runtime_error(
"Library not loaded!");
7648 auto& inst = instance();
7649 if(inst.m_PEAK_CommandNode_GetIsDone)
7651 return inst.m_PEAK_CommandNode_GetIsDone(commandNodeHandle, isDone);
7655 throw std::runtime_error(
"Library not loaded!");
7661 auto& inst = instance();
7662 if(inst.m_PEAK_CommandNode_Execute)
7664 return inst.m_PEAK_CommandNode_Execute(commandNodeHandle);
7668 throw std::runtime_error(
"Library not loaded!");
7674 auto& inst = instance();
7675 if(inst.m_PEAK_CommandNode_WaitUntilDoneInfinite)
7677 return inst.m_PEAK_CommandNode_WaitUntilDoneInfinite(commandNodeHandle);
7681 throw std::runtime_error(
"Library not loaded!");
7687 auto& inst = instance();
7688 if(inst.m_PEAK_CommandNode_WaitUntilDone)
7690 return inst.m_PEAK_CommandNode_WaitUntilDone(commandNodeHandle, waitTimeout_ms);
7694 throw std::runtime_error(
"Library not loaded!");
7700 auto& inst = instance();
7701 if(inst.m_PEAK_FloatNode_ToNode)
7703 return inst.m_PEAK_FloatNode_ToNode(floatNodeHandle, nodeHandle);
7707 throw std::runtime_error(
"Library not loaded!");
7713 auto& inst = instance();
7714 if(inst.m_PEAK_FloatNode_GetMinimum)
7716 return inst.m_PEAK_FloatNode_GetMinimum(floatNodeHandle, minimum);
7720 throw std::runtime_error(
"Library not loaded!");
7726 auto& inst = instance();
7727 if(inst.m_PEAK_FloatNode_GetMaximum)
7729 return inst.m_PEAK_FloatNode_GetMaximum(floatNodeHandle, maximum);
7733 throw std::runtime_error(
"Library not loaded!");
7739 auto& inst = instance();
7740 if(inst.m_PEAK_FloatNode_GetIncrement)
7742 return inst.m_PEAK_FloatNode_GetIncrement(floatNodeHandle, increment);
7746 throw std::runtime_error(
"Library not loaded!");
7752 auto& inst = instance();
7753 if(inst.m_PEAK_FloatNode_GetIncrementType)
7755 return inst.m_PEAK_FloatNode_GetIncrementType(floatNodeHandle, incrementType);
7759 throw std::runtime_error(
"Library not loaded!");
7765 auto& inst = instance();
7766 if(inst.m_PEAK_FloatNode_GetValidValues)
7768 return inst.m_PEAK_FloatNode_GetValidValues(floatNodeHandle, validValues, validValuesSize);
7772 throw std::runtime_error(
"Library not loaded!");
7778 auto& inst = instance();
7779 if(inst.m_PEAK_FloatNode_GetRepresentation)
7781 return inst.m_PEAK_FloatNode_GetRepresentation(floatNodeHandle, representation);
7785 throw std::runtime_error(
"Library not loaded!");
7791 auto& inst = instance();
7792 if(inst.m_PEAK_FloatNode_GetUnit)
7794 return inst.m_PEAK_FloatNode_GetUnit(floatNodeHandle, unit, unitSize);
7798 throw std::runtime_error(
"Library not loaded!");
7804 auto& inst = instance();
7805 if(inst.m_PEAK_FloatNode_GetDisplayNotation)
7807 return inst.m_PEAK_FloatNode_GetDisplayNotation(floatNodeHandle, displayNotation);
7811 throw std::runtime_error(
"Library not loaded!");
7817 auto& inst = instance();
7818 if(inst.m_PEAK_FloatNode_GetDisplayPrecision)
7820 return inst.m_PEAK_FloatNode_GetDisplayPrecision(floatNodeHandle, displayPrecision);
7824 throw std::runtime_error(
"Library not loaded!");
7830 auto& inst = instance();
7831 if(inst.m_PEAK_FloatNode_GetHasConstantIncrement)
7833 return inst.m_PEAK_FloatNode_GetHasConstantIncrement(floatNodeHandle, hasConstantIncrement);
7837 throw std::runtime_error(
"Library not loaded!");
7843 auto& inst = instance();
7844 if(inst.m_PEAK_FloatNode_GetValue)
7846 return inst.m_PEAK_FloatNode_GetValue(floatNodeHandle, cacheUsePolicy, value);
7850 throw std::runtime_error(
"Library not loaded!");
7856 auto& inst = instance();
7857 if(inst.m_PEAK_FloatNode_SetValue)
7859 return inst.m_PEAK_FloatNode_SetValue(floatNodeHandle, value);
7863 throw std::runtime_error(
"Library not loaded!");
7869 auto& inst = instance();
7870 if(inst.m_PEAK_StringNode_ToNode)
7872 return inst.m_PEAK_StringNode_ToNode(stringNodeHandle, nodeHandle);
7876 throw std::runtime_error(
"Library not loaded!");
7882 auto& inst = instance();
7883 if(inst.m_PEAK_StringNode_GetMaximumLength)
7885 return inst.m_PEAK_StringNode_GetMaximumLength(stringNodeHandle, maximumLength);
7889 throw std::runtime_error(
"Library not loaded!");
7895 auto& inst = instance();
7896 if(inst.m_PEAK_StringNode_GetValue)
7898 return inst.m_PEAK_StringNode_GetValue(stringNodeHandle, cacheUsePolicy, value, valueSize);
7902 throw std::runtime_error(
"Library not loaded!");
7908 auto& inst = instance();
7909 if(inst.m_PEAK_StringNode_SetValue)
7911 return inst.m_PEAK_StringNode_SetValue(stringNodeHandle, value, valueSize);
7915 throw std::runtime_error(
"Library not loaded!");
7921 auto& inst = instance();
7922 if(inst.m_PEAK_RegisterNode_ToNode)
7924 return inst.m_PEAK_RegisterNode_ToNode(registerNodeHandle, nodeHandle);
7928 throw std::runtime_error(
"Library not loaded!");
7934 auto& inst = instance();
7935 if(inst.m_PEAK_RegisterNode_GetAddress)
7937 return inst.m_PEAK_RegisterNode_GetAddress(registerNodeHandle, address);
7941 throw std::runtime_error(
"Library not loaded!");
7947 auto& inst = instance();
7948 if(inst.m_PEAK_RegisterNode_GetLength)
7950 return inst.m_PEAK_RegisterNode_GetLength(registerNodeHandle, length);
7954 throw std::runtime_error(
"Library not loaded!");
7960 auto& inst = instance();
7961 if(inst.m_PEAK_RegisterNode_Read)
7963 return inst.m_PEAK_RegisterNode_Read(registerNodeHandle, cacheUsePolicy, bytesToRead, bytesToReadSize);
7967 throw std::runtime_error(
"Library not loaded!");
7973 auto& inst = instance();
7974 if(inst.m_PEAK_RegisterNode_Write)
7976 return inst.m_PEAK_RegisterNode_Write(registerNodeHandle, bytesToWrite, bytesToWriteSize);
7980 throw std::runtime_error(
"Library not loaded!");
7986 auto& inst = instance();
7987 if(inst.m_PEAK_CategoryNode_ToNode)
7989 return inst.m_PEAK_CategoryNode_ToNode(categoryNodeHandle, nodeHandle);
7993 throw std::runtime_error(
"Library not loaded!");
7999 auto& inst = instance();
8000 if(inst.m_PEAK_CategoryNode_GetNumSubNodes)
8002 return inst.m_PEAK_CategoryNode_GetNumSubNodes(categoryNodeHandle, numSubNodes);
8006 throw std::runtime_error(
"Library not loaded!");
8012 auto& inst = instance();
8013 if(inst.m_PEAK_CategoryNode_GetSubNode)
8015 return inst.m_PEAK_CategoryNode_GetSubNode(categoryNodeHandle, index, nodeHandle);
8019 throw std::runtime_error(
"Library not loaded!");
8025 auto& inst = instance();
8026 if(inst.m_PEAK_EnumerationNode_ToNode)
8028 return inst.m_PEAK_EnumerationNode_ToNode(enumerationNodeHandle, nodeHandle);
8032 throw std::runtime_error(
"Library not loaded!");
8038 auto& inst = instance();
8039 if(inst.m_PEAK_EnumerationNode_GetCurrentEntry)
8041 return inst.m_PEAK_EnumerationNode_GetCurrentEntry(enumerationNodeHandle, cacheUsePolicy, enumerationEntryNodeHandle);
8045 throw std::runtime_error(
"Library not loaded!");
8051 auto& inst = instance();
8052 if(inst.m_PEAK_EnumerationNode_SetCurrentEntry)
8054 return inst.m_PEAK_EnumerationNode_SetCurrentEntry(enumerationNodeHandle, enumerationEntryNodeHandle);
8058 throw std::runtime_error(
"Library not loaded!");
8064 auto& inst = instance();
8065 if(inst.m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue)
8067 return inst.m_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize);
8071 throw std::runtime_error(
"Library not loaded!");
8077 auto& inst = instance();
8078 if(inst.m_PEAK_EnumerationNode_SetCurrentEntryByValue)
8080 return inst.m_PEAK_EnumerationNode_SetCurrentEntryByValue(enumerationNodeHandle, value);
8084 throw std::runtime_error(
"Library not loaded!");
8090 auto& inst = instance();
8091 if(inst.m_PEAK_EnumerationNode_FindEntryBySymbolicValue)
8093 return inst.m_PEAK_EnumerationNode_FindEntryBySymbolicValue(enumerationNodeHandle, symbolicValue, symbolicValueSize, enumerationEntryNodeHandle);
8097 throw std::runtime_error(
"Library not loaded!");
8103 auto& inst = instance();
8104 if(inst.m_PEAK_EnumerationNode_FindEntryByValue)
8106 return inst.m_PEAK_EnumerationNode_FindEntryByValue(enumerationNodeHandle, value, enumerationEntryNodeHandle);
8110 throw std::runtime_error(
"Library not loaded!");
8116 auto& inst = instance();
8117 if(inst.m_PEAK_EnumerationNode_GetNumEntries)
8119 return inst.m_PEAK_EnumerationNode_GetNumEntries(enumerationNodeHandle, numEntries);
8123 throw std::runtime_error(
"Library not loaded!");
8129 auto& inst = instance();
8130 if(inst.m_PEAK_EnumerationNode_GetEntry)
8132 return inst.m_PEAK_EnumerationNode_GetEntry(enumerationNodeHandle, index, enumerationEntryNodeHandle);
8136 throw std::runtime_error(
"Library not loaded!");
8142 auto& inst = instance();
8143 if(inst.m_PEAK_EnumerationEntryNode_ToNode)
8145 return inst.m_PEAK_EnumerationEntryNode_ToNode(enumerationEntryNodeHandle, nodeHandle);
8149 throw std::runtime_error(
"Library not loaded!");
8155 auto& inst = instance();
8156 if(inst.m_PEAK_EnumerationEntryNode_GetIsSelfClearing)
8158 return inst.m_PEAK_EnumerationEntryNode_GetIsSelfClearing(enumerationEntryNodeHandle, isSelfClearing);
8162 throw std::runtime_error(
"Library not loaded!");
8168 auto& inst = instance();
8169 if(inst.m_PEAK_EnumerationEntryNode_GetSymbolicValue)
8171 return inst.m_PEAK_EnumerationEntryNode_GetSymbolicValue(enumerationEntryNodeHandle, symbolicValue, symbolicValueSize);
8175 throw std::runtime_error(
"Library not loaded!");
8181 auto& inst = instance();
8182 if(inst.m_PEAK_EnumerationEntryNode_GetValue)
8184 return inst.m_PEAK_EnumerationEntryNode_GetValue(enumerationEntryNodeHandle, value);
8188 throw std::runtime_error(
"Library not loaded!");
8194 auto& inst = instance();
8195 if(inst.m_PEAK_Port_GetInfo)
8197 return inst.m_PEAK_Port_GetInfo(portHandle, infoCommand, infoDataType, info, infoSize);
8201 throw std::runtime_error(
"Library not loaded!");
8207 auto& inst = instance();
8208 if(inst.m_PEAK_Port_GetID)
8210 return inst.m_PEAK_Port_GetID(portHandle,
id, idSize);
8214 throw std::runtime_error(
"Library not loaded!");
8220 auto& inst = instance();
8221 if(inst.m_PEAK_Port_GetName)
8223 return inst.m_PEAK_Port_GetName(portHandle, name, nameSize);
8227 throw std::runtime_error(
"Library not loaded!");
8233 auto& inst = instance();
8234 if(inst.m_PEAK_Port_GetVendorName)
8236 return inst.m_PEAK_Port_GetVendorName(portHandle, vendorName, vendorNameSize);
8240 throw std::runtime_error(
"Library not loaded!");
8246 auto& inst = instance();
8247 if(inst.m_PEAK_Port_GetModelName)
8249 return inst.m_PEAK_Port_GetModelName(portHandle, modelName, modelNameSize);
8253 throw std::runtime_error(
"Library not loaded!");
8259 auto& inst = instance();
8260 if(inst.m_PEAK_Port_GetVersion)
8262 return inst.m_PEAK_Port_GetVersion(portHandle, version, versionSize);
8266 throw std::runtime_error(
"Library not loaded!");
8272 auto& inst = instance();
8273 if(inst.m_PEAK_Port_GetTLType)
8275 return inst.m_PEAK_Port_GetTLType(portHandle, tlType, tlTypeSize);
8279 throw std::runtime_error(
"Library not loaded!");
8285 auto& inst = instance();
8286 if(inst.m_PEAK_Port_GetModuleName)
8288 return inst.m_PEAK_Port_GetModuleName(portHandle, moduleName, moduleNameSize);
8292 throw std::runtime_error(
"Library not loaded!");
8298 auto& inst = instance();
8299 if(inst.m_PEAK_Port_GetDataEndianness)
8301 return inst.m_PEAK_Port_GetDataEndianness(portHandle, dataEndianness);
8305 throw std::runtime_error(
"Library not loaded!");
8311 auto& inst = instance();
8312 if(inst.m_PEAK_Port_GetIsReadable)
8314 return inst.m_PEAK_Port_GetIsReadable(portHandle, isReadable);
8318 throw std::runtime_error(
"Library not loaded!");
8324 auto& inst = instance();
8325 if(inst.m_PEAK_Port_GetIsWritable)
8327 return inst.m_PEAK_Port_GetIsWritable(portHandle, isWritable);
8331 throw std::runtime_error(
"Library not loaded!");
8337 auto& inst = instance();
8338 if(inst.m_PEAK_Port_GetIsAvailable)
8340 return inst.m_PEAK_Port_GetIsAvailable(portHandle, isAvailable);
8344 throw std::runtime_error(
"Library not loaded!");
8350 auto& inst = instance();
8351 if(inst.m_PEAK_Port_GetIsImplemented)
8353 return inst.m_PEAK_Port_GetIsImplemented(portHandle, isImplemented);
8357 throw std::runtime_error(
"Library not loaded!");
8363 auto& inst = instance();
8364 if(inst.m_PEAK_Port_Read)
8366 return inst.m_PEAK_Port_Read(portHandle, address, bytesToRead, bytesToReadSize);
8370 throw std::runtime_error(
"Library not loaded!");
8376 auto& inst = instance();
8377 if(inst.m_PEAK_Port_Write)
8379 return inst.m_PEAK_Port_Write(portHandle, address, bytesToWrite, bytesToWriteSize);
8383 throw std::runtime_error(
"Library not loaded!");
8389 auto& inst = instance();
8390 if(inst.m_PEAK_Port_GetNumURLs)
8392 return inst.m_PEAK_Port_GetNumURLs(portHandle, numUrls);
8396 throw std::runtime_error(
"Library not loaded!");
8402 auto& inst = instance();
8403 if(inst.m_PEAK_Port_GetURL)
8405 return inst.m_PEAK_Port_GetURL(portHandle, index, portUrlHandle);
8409 throw std::runtime_error(
"Library not loaded!");
8415 auto& inst = instance();
8416 if(inst.m_PEAK_PortURL_GetInfo)
8418 return inst.m_PEAK_PortURL_GetInfo(portUrlHandle, infoCommand, infoDataType, info, infoSize);
8422 throw std::runtime_error(
"Library not loaded!");
8428 auto& inst = instance();
8429 if(inst.m_PEAK_PortURL_GetURL)
8431 return inst.m_PEAK_PortURL_GetURL(portUrlHandle, url, urlSize);
8435 throw std::runtime_error(
"Library not loaded!");
8441 auto& inst = instance();
8442 if(inst.m_PEAK_PortURL_GetScheme)
8444 return inst.m_PEAK_PortURL_GetScheme(portUrlHandle, scheme);
8448 throw std::runtime_error(
"Library not loaded!");
8454 auto& inst = instance();
8455 if(inst.m_PEAK_PortURL_GetFileName)
8457 return inst.m_PEAK_PortURL_GetFileName(portUrlHandle, fileName, fileNameSize);
8461 throw std::runtime_error(
"Library not loaded!");
8467 auto& inst = instance();
8468 if(inst.m_PEAK_PortURL_GetFileRegisterAddress)
8470 return inst.m_PEAK_PortURL_GetFileRegisterAddress(portUrlHandle, fileRegisterAddress);
8474 throw std::runtime_error(
"Library not loaded!");
8480 auto& inst = instance();
8481 if(inst.m_PEAK_PortURL_GetFileSize)
8483 return inst.m_PEAK_PortURL_GetFileSize(portUrlHandle, fileSize);
8487 throw std::runtime_error(
"Library not loaded!");
8493 auto& inst = instance();
8494 if(inst.m_PEAK_PortURL_GetFileSHA1Hash)
8496 return inst.m_PEAK_PortURL_GetFileSHA1Hash(portUrlHandle, fileSha1Hash, fileSha1HashSize);
8500 throw std::runtime_error(
"Library not loaded!");
8506 auto& inst = instance();
8507 if(inst.m_PEAK_PortURL_GetFileVersionMajor)
8509 return inst.m_PEAK_PortURL_GetFileVersionMajor(portUrlHandle, fileVersionMajor);
8513 throw std::runtime_error(
"Library not loaded!");
8519 auto& inst = instance();
8520 if(inst.m_PEAK_PortURL_GetFileVersionMinor)
8522 return inst.m_PEAK_PortURL_GetFileVersionMinor(portUrlHandle, fileVersionMinor);
8526 throw std::runtime_error(
"Library not loaded!");
8532 auto& inst = instance();
8533 if(inst.m_PEAK_PortURL_GetFileVersionSubminor)
8535 return inst.m_PEAK_PortURL_GetFileVersionSubminor(portUrlHandle, fileVersionSubminor);
8539 throw std::runtime_error(
"Library not loaded!");
8545 auto& inst = instance();
8546 if(inst.m_PEAK_PortURL_GetFileSchemaVersionMajor)
8548 return inst.m_PEAK_PortURL_GetFileSchemaVersionMajor(portUrlHandle, fileSchemaVersionMajor);
8552 throw std::runtime_error(
"Library not loaded!");
8558 auto& inst = instance();
8559 if(inst.m_PEAK_PortURL_GetFileSchemaVersionMinor)
8561 return inst.m_PEAK_PortURL_GetFileSchemaVersionMinor(portUrlHandle, fileSchemaVersionMinor);
8565 throw std::runtime_error(
"Library not loaded!");
8571 auto& inst = instance();
8572 if(inst.m_PEAK_PortURL_GetParentPort)
8574 return inst.m_PEAK_PortURL_GetParentPort(portUrlHandle, portHandle);
8578 throw std::runtime_error(
"Library not loaded!");
8584 auto& inst = instance();
8585 if(inst.m_PEAK_EventSupportingModule_EnableEvents)
8587 return inst.m_PEAK_EventSupportingModule_EnableEvents(eventSupportingModuleHandle, eventType, eventControllerHandle);
8591 throw std::runtime_error(
"Library not loaded!");
8597 auto& inst = instance();
8598 if(inst.m_PEAK_EventController_GetInfo)
8600 return inst.m_PEAK_EventController_GetInfo(eventControllerHandle, infoCommand, infoDataType, info, infoSize);
8604 throw std::runtime_error(
"Library not loaded!");
8610 auto& inst = instance();
8611 if(inst.m_PEAK_EventController_GetNumEventsInQueue)
8613 return inst.m_PEAK_EventController_GetNumEventsInQueue(eventControllerHandle, numEventsInQueue);
8617 throw std::runtime_error(
"Library not loaded!");
8623 auto& inst = instance();
8624 if(inst.m_PEAK_EventController_GetNumEventsFired)
8626 return inst.m_PEAK_EventController_GetNumEventsFired(eventControllerHandle, numEventsFired);
8630 throw std::runtime_error(
"Library not loaded!");
8636 auto& inst = instance();
8637 if(inst.m_PEAK_EventController_GetEventMaxSize)
8639 return inst.m_PEAK_EventController_GetEventMaxSize(eventControllerHandle, eventMaxSize);
8643 throw std::runtime_error(
"Library not loaded!");
8649 auto& inst = instance();
8650 if(inst.m_PEAK_EventController_GetEventDataMaxSize)
8652 return inst.m_PEAK_EventController_GetEventDataMaxSize(eventControllerHandle, eventDataMaxSize);
8656 throw std::runtime_error(
"Library not loaded!");
8662 auto& inst = instance();
8663 if(inst.m_PEAK_EventController_GetControlledEventType)
8665 return inst.m_PEAK_EventController_GetControlledEventType(eventControllerHandle, controlledEventType);
8669 throw std::runtime_error(
"Library not loaded!");
8675 auto& inst = instance();
8676 if(inst.m_PEAK_EventController_WaitForEvent)
8678 return inst.m_PEAK_EventController_WaitForEvent(eventControllerHandle, timeout_ms, eventHandle);
8682 throw std::runtime_error(
"Library not loaded!");
8688 auto& inst = instance();
8689 if(inst.m_PEAK_EventController_KillWait)
8691 return inst.m_PEAK_EventController_KillWait(eventControllerHandle);
8695 throw std::runtime_error(
"Library not loaded!");
8701 auto& inst = instance();
8702 if(inst.m_PEAK_EventController_FlushEvents)
8704 return inst.m_PEAK_EventController_FlushEvents(eventControllerHandle);
8708 throw std::runtime_error(
"Library not loaded!");
8714 auto& inst = instance();
8715 if(inst.m_PEAK_EventController_Destruct)
8717 return inst.m_PEAK_EventController_Destruct(eventControllerHandle);
8721 throw std::runtime_error(
"Library not loaded!");
8727 auto& inst = instance();
8728 if(inst.m_PEAK_Event_GetInfo)
8730 return inst.m_PEAK_Event_GetInfo(eventHandle, infoCommand, infoDataType, info, infoSize);
8734 throw std::runtime_error(
"Library not loaded!");
8740 auto& inst = instance();
8741 if(inst.m_PEAK_Event_GetID)
8743 return inst.m_PEAK_Event_GetID(eventHandle,
id);
8747 throw std::runtime_error(
"Library not loaded!");
8753 auto& inst = instance();
8754 if(inst.m_PEAK_Event_GetData)
8756 return inst.m_PEAK_Event_GetData(eventHandle, data, dataSize);
8760 throw std::runtime_error(
"Library not loaded!");
8766 auto& inst = instance();
8767 if(inst.m_PEAK_Event_GetType)
8769 return inst.m_PEAK_Event_GetType(eventHandle, type);
8773 throw std::runtime_error(
"Library not loaded!");
8779 auto& inst = instance();
8780 if(inst.m_PEAK_Event_GetRawData)
8782 return inst.m_PEAK_Event_GetRawData(eventHandle, rawData, rawDataSize);
8786 throw std::runtime_error(
"Library not loaded!");
8792 auto& inst = instance();
8793 if(inst.m_PEAK_Event_Destruct)
8795 return inst.m_PEAK_Event_Destruct(eventHandle);
8799 throw std::runtime_error(
"Library not loaded!");
8805 auto& inst = instance();
8806 if(inst.m_PEAK_FirmwareUpdater_Construct)
8808 return inst.m_PEAK_FirmwareUpdater_Construct(firmwareUpdaterHandle);
8812 throw std::runtime_error(
"Library not loaded!");
8818 auto& inst = instance();
8819 if(inst.m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation)
8821 return inst.m_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(firmwareUpdaterHandle, gufPath, gufPathSize);
8825 throw std::runtime_error(
"Library not loaded!");
8831 auto& inst = instance();
8832 if(inst.m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation)
8834 return inst.m_PEAK_FirmwareUpdater_CollectFirmwareUpdateInformation(firmwareUpdaterHandle, gufPath, gufPathSize, deviceDescriptorHandle);
8838 throw std::runtime_error(
"Library not loaded!");
8844 auto& inst = instance();
8845 if(inst.m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation)
8847 return inst.m_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(firmwareUpdaterHandle, numFirmwareUpdateInformation);
8851 throw std::runtime_error(
"Library not loaded!");
8857 auto& inst = instance();
8858 if(inst.m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation)
8860 return inst.m_PEAK_FirmwareUpdater_GetFirmwareUpdateInformation(firmwareUpdaterHandle, index, firmwareUpdateInformationHandle);
8864 throw std::runtime_error(
"Library not loaded!");
8870 auto& inst = instance();
8871 if(inst.m_PEAK_FirmwareUpdater_UpdateDevice)
8873 return inst.m_PEAK_FirmwareUpdater_UpdateDevice(firmwareUpdaterHandle, deviceDescriptorHandle, firmwareUpdateInformationHandle, firmwareUpdateProgressObserverHandle);
8877 throw std::runtime_error(
"Library not loaded!");
8883 auto& inst = instance();
8884 if(inst.m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout)
8886 return inst.m_PEAK_FirmwareUpdater_UpdateDeviceWithResetTimeout(firmwareUpdaterHandle, deviceDescriptorHandle, firmwareUpdateInformationHandle, firmwareUpdateProgressObserverHandle, deviceResetDiscoveryTimeout_ms);
8890 throw std::runtime_error(
"Library not loaded!");
8896 auto& inst = instance();
8897 if(inst.m_PEAK_FirmwareUpdater_Destruct)
8899 return inst.m_PEAK_FirmwareUpdater_Destruct(firmwareUpdaterHandle);
8903 throw std::runtime_error(
"Library not loaded!");
8909 auto& inst = instance();
8910 if(inst.m_PEAK_FirmwareUpdateInformation_GetIsValid)
8912 return inst.m_PEAK_FirmwareUpdateInformation_GetIsValid(firmwareUpdateInformationHandle, isValid);
8916 throw std::runtime_error(
"Library not loaded!");
8922 auto& inst = instance();
8923 if(inst.m_PEAK_FirmwareUpdateInformation_GetFileName)
8925 return inst.m_PEAK_FirmwareUpdateInformation_GetFileName(firmwareUpdateInformationHandle, fileName, fileNameSize);
8929 throw std::runtime_error(
"Library not loaded!");
8935 auto& inst = instance();
8936 if(inst.m_PEAK_FirmwareUpdateInformation_GetDescription)
8938 return inst.m_PEAK_FirmwareUpdateInformation_GetDescription(firmwareUpdateInformationHandle, description, descriptionSize);
8942 throw std::runtime_error(
"Library not loaded!");
8948 auto& inst = instance();
8949 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersion)
8951 return inst.m_PEAK_FirmwareUpdateInformation_GetVersion(firmwareUpdateInformationHandle, version, versionSize);
8955 throw std::runtime_error(
"Library not loaded!");
8961 auto& inst = instance();
8962 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern)
8964 return inst.m_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(firmwareUpdateInformationHandle, versionExtractionPattern, versionExtractionPatternSize);
8968 throw std::runtime_error(
"Library not loaded!");
8974 auto& inst = instance();
8975 if(inst.m_PEAK_FirmwareUpdateInformation_GetVersionStyle)
8977 return inst.m_PEAK_FirmwareUpdateInformation_GetVersionStyle(firmwareUpdateInformationHandle, versionStyle);
8981 throw std::runtime_error(
"Library not loaded!");
8987 auto& inst = instance();
8988 if(inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotes)
8990 return inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotes(firmwareUpdateInformationHandle, releaseNotes, releaseNotesSize);
8994 throw std::runtime_error(
"Library not loaded!");
9000 auto& inst = instance();
9001 if(inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL)
9003 return inst.m_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(firmwareUpdateInformationHandle, releaseNotesUrl, releaseNotesUrlSize);
9007 throw std::runtime_error(
"Library not loaded!");
9013 auto& inst = instance();
9014 if(inst.m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence)
9016 return inst.m_PEAK_FirmwareUpdateInformation_GetUserSetPersistence(firmwareUpdateInformationHandle, userSetPersistence);
9020 throw std::runtime_error(
"Library not loaded!");
9026 auto& inst = instance();
9027 if(inst.m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence)
9029 return inst.m_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(firmwareUpdateInformationHandle, sequencerSetPersistence);
9033 throw std::runtime_error(
"Library not loaded!");
9039 auto& inst = instance();
9040 if(inst.m_PEAK_FirmwareUpdateProgressObserver_Construct)
9042 return inst.m_PEAK_FirmwareUpdateProgressObserver_Construct(firmwareUpdateProgressObserverHandle);
9046 throw std::runtime_error(
"Library not loaded!");
9052 auto& inst = instance();
9053 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback)
9055 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStartedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9059 throw std::runtime_error(
"Library not loaded!");
9065 auto& inst = instance();
9066 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback)
9068 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStartedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9072 throw std::runtime_error(
"Library not loaded!");
9078 auto& inst = instance();
9079 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback)
9081 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepStartedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9085 throw std::runtime_error(
"Library not loaded!");
9091 auto& inst = instance();
9092 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback)
9094 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepStartedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9098 throw std::runtime_error(
"Library not loaded!");
9104 auto& inst = instance();
9105 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback)
9107 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepProgressChangedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9111 throw std::runtime_error(
"Library not loaded!");
9117 auto& inst = instance();
9118 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback)
9120 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepProgressChangedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9124 throw std::runtime_error(
"Library not loaded!");
9130 auto& inst = instance();
9131 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback)
9133 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateStepFinishedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9137 throw std::runtime_error(
"Library not loaded!");
9143 auto& inst = instance();
9144 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback)
9146 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateStepFinishedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9150 throw std::runtime_error(
"Library not loaded!");
9156 auto& inst = instance();
9157 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback)
9159 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFinishedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9163 throw std::runtime_error(
"Library not loaded!");
9169 auto& inst = instance();
9170 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback)
9172 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFinishedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9176 throw std::runtime_error(
"Library not loaded!");
9182 auto& inst = instance();
9183 if(inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback)
9185 return inst.m_PEAK_FirmwareUpdateProgressObserver_RegisterUpdateFailedCallback(firmwareUpdateProgressObserverHandle, callback, callbackContext, callbackHandle);
9189 throw std::runtime_error(
"Library not loaded!");
9195 auto& inst = instance();
9196 if(inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback)
9198 return inst.m_PEAK_FirmwareUpdateProgressObserver_UnregisterUpdateFailedCallback(firmwareUpdateProgressObserverHandle, callbackHandle);
9202 throw std::runtime_error(
"Library not loaded!");
9208 auto& inst = instance();
9209 if(inst.m_PEAK_FirmwareUpdateProgressObserver_Destruct)
9211 return inst.m_PEAK_FirmwareUpdateProgressObserver_Destruct(firmwareUpdateProgressObserverHandle);
9215 throw std::runtime_error(
"Library not loaded!");
Definition peak_dynamic_loader.h:450
static PEAK_C_API PEAK_Interface_Destruct(PEAK_INTERFACE_HANDLE interfaceHandle)
Definition peak_dynamic_loader.h:4929
static PEAK_C_API PEAK_BufferPart_GetWidth(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Definition peak_dynamic_loader.h:6619
static PEAK_C_API PEAK_DataStream_GetNumBuffersStarted(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Definition peak_dynamic_loader.h:5709
static PEAK_C_API PEAK_Interface_UnregisterDeviceListChangedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4916
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:7958
static PEAK_C_API PEAK_PortURL_GetFileSHA1Hash(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Definition peak_dynamic_loader.h:8491
static PEAK_C_API PEAK_Buffer_GetTLType(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5995
static PEAK_C_API PEAK_DataStream_GetKey(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5592
static PEAK_C_API PEAK_DataStream_StopAcquisition(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Definition peak_dynamic_loader.h:5930
static PEAK_C_API PEAK_Buffer_ToModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5956
static PEAK_C_API PEAK_Node_GetInvalidatedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition peak_dynamic_loader.h:7308
static PEAK_C_API PEAK_SystemDescriptor_GetKey(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4071
static PEAK_C_API PEAK_Library_Initialize()
Definition peak_dynamic_loader.h:3876
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:7438
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:8673
static PEAK_C_API PEAK_DeviceDescriptor_GetKey(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4955
static PEAK_C_API PEAK_BufferChunk_GetBasePtr(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Definition peak_dynamic_loader.h:6476
static PEAK_C_API PEAK_Library_GetLastError(PEAK_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Definition peak_dynamic_loader.h:3954
static PEAK_C_API PEAK_BufferPart_GetSourceID(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Definition peak_dynamic_loader.h:6541
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:7841
static PEAK_C_API PEAK_EventController_FlushEvents(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8699
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:5865
static PEAK_C_API PEAK_Interface_UnregisterDeviceReconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4838
static PEAK_C_API PEAK_Node_ToEnumerationEntryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:7061
static PEAK_C_API PEAK_Buffer_GetPixelFormatNamespace(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Definition peak_dynamic_loader.h:6073
static PEAK_C_API PEAK_System_UpdateInterfaces(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:4461
static PEAK_C_API PEAK_BufferPart_GetFormatNamespace(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Definition peak_dynamic_loader.h:6606
static PEAK_C_API PEAK_System_GetNumInterfaces(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Definition peak_dynamic_loader.h:4474
static PEAK_C_API PEAK_System_GetVersion(PEAK_SYSTEM_HANDLE systemHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:4357
static bool isLoaded()
Definition peak_dynamic_loader.h:1347
static PEAK_C_API PEAK_System_GetCTIFullPath(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:4396
static PEAK_C_API PEAK_Library_GetVersionMinor(uint32_t *libraryVersionMinor)
Definition peak_dynamic_loader.h:3928
static PEAK_C_API PEAK_Node_UnregisterChangedCallback(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:7451
static PEAK_C_API PEAK_BufferChunk_GetParentBuffer(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:6502
static PEAK_C_API PEAK_DeviceDescriptor_GetVendorName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:4994
static PEAK_C_API PEAK_Node_GetCachingMode(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Definition peak_dynamic_loader.h:7204
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:7360
static PEAK_C_API PEAK_BufferPart_GetYOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:6658
static PEAK_C_API PEAK_FloatNode_GetIncrementType(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:7750
static PEAK_C_API PEAK_FloatNode_GetDisplayNotation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Definition peak_dynamic_loader.h:7802
static PEAK_C_API PEAK_Node_ToStringNode(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Definition peak_dynamic_loader.h:7009
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Destruct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:9206
static PEAK_C_API PEAK_NodeMap_GetHasBufferSupportedChunks(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Definition peak_dynamic_loader.h:6853
static PEAK_C_API PEAK_CategoryNode_GetNumSubNodes(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Definition peak_dynamic_loader.h:7997
static PEAK_C_API PEAK_Node_GetIsFeature(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Definition peak_dynamic_loader.h:7191
static PEAK_C_API PEAK_Interface_UnregisterDeviceFoundCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4812
static PEAK_C_API PEAK_Buffer_GetIsIncomplete(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Definition peak_dynamic_loader.h:6333
static PEAK_C_API PEAK_Device_ToEventSupportingModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:5254
static PEAK_C_API PEAK_EnumerationEntryNode_ToNode(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8140
static PEAK_C_API PEAK_StringNode_SetValue(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Definition peak_dynamic_loader.h:7906
static PEAK_C_API PEAK_PortURL_GetParentPort(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:8569
static PEAK_C_API PEAK_DataStream_GetIsGrabbing(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Definition peak_dynamic_loader.h:5787
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntry(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:8049
static PEAK_C_API PEAK_Device_GetVersion(PEAK_DEVICE_HANDLE deviceHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:5345
static PEAK_C_API PEAK_Device_Destruct(PEAK_DEVICE_HANDLE deviceHandle)
Definition peak_dynamic_loader.h:5475
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryByValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:8075
static PEAK_C_API PEAK_Node_GetIsStreamable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Definition peak_dynamic_loader.h:7165
static PEAK_C_API PEAK_CommandNode_WaitUntilDoneInfinite(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:7672
static PEAK_C_API PEAK_DataStream_QueueBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:5839
static PEAK_C_API PEAK_Device_GetTimestampTickFrequency(PEAK_DEVICE_HANDLE deviceHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:5410
static PEAK_C_API PEAK_Buffer_GetExpectedDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Definition peak_dynamic_loader.h:6099
static PEAK_C_API PEAK_Buffer_GetFrameID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Definition peak_dynamic_loader.h:6125
static PEAK_C_API PEAK_DeviceDescriptor_GetTimestampTickFrequency(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:5085
static PEAK_C_API PEAK_Node_ToCategoryNode(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Definition peak_dynamic_loader.h:7035
static PEAK_C_API PEAK_EnumerationEntryNode_GetValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Definition peak_dynamic_loader.h:8179
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:5215
static PEAK_C_API PEAK_Node_ToCommandNode(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Definition peak_dynamic_loader.h:6983
static PEAK_C_API PEAK_Module_GetPort(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:6762
static PEAK_C_API PEAK_NodeMap_GetNumNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Definition peak_dynamic_loader.h:6827
static PEAK_C_API PEAK_Interface_UnregisterDeviceDisconnectedCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4864
static PEAK_C_API PEAK_PortURL_GetScheme(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Definition peak_dynamic_loader.h:8439
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:7607
static PEAK_C_API PEAK_Port_GetDataEndianness(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Definition peak_dynamic_loader.h:8296
static PEAK_C_API PEAK_BufferChunk_GetSize(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Definition peak_dynamic_loader.h:6489
static PEAK_C_API PEAK_Port_GetIsAvailable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Definition peak_dynamic_loader.h:8335
static PEAK_C_API PEAK_BufferPart_GetHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Definition peak_dynamic_loader.h:6632
static PEAK_C_API PEAK_IntegerNode_SetValue(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:7581
static PEAK_C_API PEAK_StringNode_GetMaximumLength(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Definition peak_dynamic_loader.h:7880
static PEAK_C_API PEAK_Buffer_GetXPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:6255
static PEAK_C_API PEAK_Device_GetModelName(PEAK_DEVICE_HANDLE deviceHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:5332
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetIsValid(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Definition peak_dynamic_loader.h:8907
static PEAK_C_API PEAK_CommandNode_GetIsDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Definition peak_dynamic_loader.h:7646
static PEAK_C_API PEAK_Device_GetKey(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5267
static PEAK_C_API PEAK_Port_GetID(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:8205
~DynamicLoader()
Definition peak_dynamic_loader.h:1339
static PEAK_C_API PEAK_DeviceDescriptor_GetAccessStatus(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:5072
static PEAK_C_API PEAK_SystemDescriptor_GetDisplayName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4097
static PEAK_C_API PEAK_SystemDescriptor_GetTLType(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4149
static PEAK_C_API PEAK_PortURL_GetURL(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Definition peak_dynamic_loader.h:8426
static PEAK_C_API PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition peak_dynamic_loader.h:5189
static PEAK_C_API PEAK_Device_GetID(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:5293
static PEAK_C_API PEAK_Buffer_GetHasNewData(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Definition peak_dynamic_loader.h:6346
static PEAK_C_API PEAK_RegisterNode_GetAddress(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Definition peak_dynamic_loader.h:7932
static PEAK_C_API PEAK_System_Destruct(PEAK_SYSTEM_HANDLE systemHandle)
Definition peak_dynamic_loader.h:4552
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:9115
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:9180
static PEAK_C_API PEAK_PortURL_GetFileVersionSubminor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Definition peak_dynamic_loader.h:8530
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:5280
static PEAK_C_API PEAK_Buffer_GetChunkLayoutID(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Definition peak_dynamic_loader.h:6177
static PEAK_C_API PEAK_SystemDescriptor_GetCTIFullPath(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:4175
static PEAK_C_API PEAK_IntegerNode_GetRepresentation(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:7542
static PEAK_C_API PEAK_RegisterNode_ToNode(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7919
static PEAK_C_API PEAK_System_UnregisterInterfaceLostCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4539
static PEAK_C_API PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition peak_dynamic_loader.h:5202
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:4825
static PEAK_C_API PEAK_FloatNode_SetValue(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Definition peak_dynamic_loader.h:7854
static PEAK_C_API PEAK_FloatNode_GetDisplayPrecision(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Definition peak_dynamic_loader.h:7815
static PEAK_C_API PEAK_Buffer_GetDeliveredDataSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Definition peak_dynamic_loader.h:6112
static PEAK_C_API PEAK_System_GetCTIFileName(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:4383
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetUserSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Definition peak_dynamic_loader.h:9011
static PEAK_C_API PEAK_ProducerLibrary_GetSystem(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Definition peak_dynamic_loader.h:4032
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Definition peak_dynamic_loader.h:8959
static PEAK_C_API PEAK_Event_GetRawData(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Definition peak_dynamic_loader.h:8777
static PEAK_C_API PEAK_DataStream_ToModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5566
static PEAK_C_API PEAK_Port_GetModuleName(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Definition peak_dynamic_loader.h:8283
static PEAK_C_API PEAK_DeviceDescriptor_GetParentInterface(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:5137
static PEAK_C_API PEAK_DataStream_GetNumChunksPerBufferMax(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numChunksPerBufferMax)
Definition peak_dynamic_loader.h:5735
static PEAK_C_API PEAK_BufferPart_GetParentBuffer(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:6697
static PEAK_C_API PEAK_Interface_GetTLType(PEAK_INTERFACE_HANDLE interfaceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4734
static PEAK_C_API PEAK_Device_GetVendorName(PEAK_DEVICE_HANDLE deviceHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:5319
static PEAK_C_API PEAK_PortURL_GetFileRegisterAddress(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Definition peak_dynamic_loader.h:8465
static PEAK_C_API PEAK_Buffer_GetTimestamp_ns(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Definition peak_dynamic_loader.h:6294
static PEAK_C_API PEAK_Port_GetModelName(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:8244
static PEAK_C_API PEAK_FloatNode_GetRepresentation(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:7776
static PEAK_C_API PEAK_EnvironmentInspector_UpdateCTIPaths()
Definition peak_dynamic_loader.h:3967
static PEAK_C_API PEAK_PortURL_GetFileVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Definition peak_dynamic_loader.h:8504
static PEAK_C_API PEAK_Interface_GetParentSystem(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4747
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:6788
static PEAK_C_API PEAK_System_ToModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:4253
static PEAK_C_API PEAK_ProducerLibrary_Construct(const char *ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4006
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotes(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Definition peak_dynamic_loader.h:8985
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:5228
static PEAK_C_API PEAK_BufferChunk_Destruct(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Definition peak_dynamic_loader.h:6515
static PEAK_C_API PEAK_NodeMap_UpdateEventNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:6892
static PEAK_C_API PEAK_DataStream_GetTLType(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5631
static PEAK_C_API PEAK_Port_GetVersion(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:8257
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:9141
static PEAK_C_API PEAK_Event_GetType(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Definition peak_dynamic_loader.h:8764
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:5982
static PEAK_C_API PEAK_FloatNode_ToNode(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7698
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:9167
static PEAK_C_API PEAK_Event_GetID(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Definition peak_dynamic_loader.h:8738
static PEAK_C_API PEAK_DataStream_GetNumBuffersQueued(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersQueued)
Definition peak_dynamic_loader.h:5670
static PEAK_C_API PEAK_EventController_GetEventDataMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Definition peak_dynamic_loader.h:8647
static PEAK_C_API PEAK_ProducerLibrary_GetKey(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4019
static PEAK_C_API PEAK_IntegerNode_GetUnit(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:7555
static PEAK_C_API PEAK_BufferPart_GetSize(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Definition peak_dynamic_loader.h:6567
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:7893
static PEAK_C_API PEAK_DataStream_GetNumBuffersAnnounced(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnounced)
Definition peak_dynamic_loader.h:5657
static PEAK_C_API PEAK_Buffer_GetChunk(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Definition peak_dynamic_loader.h:6411
static PEAK_C_API PEAK_DeviceDescriptor_GetIsOpenableExclusive(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Definition peak_dynamic_loader.h:5098
static PEAK_C_API PEAK_CommandNode_ToNode(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7633
static PEAK_C_API PEAK_PortURL_GetFileSize(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Definition peak_dynamic_loader.h:8478
static PEAK_C_API PEAK_DataStream_Flush(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Definition peak_dynamic_loader.h:5891
static PEAK_C_API PEAK_EnvironmentInspector_GetCTIPath(size_t index, char *ctiPath, size_t *ctiPathSize)
Definition peak_dynamic_loader.h:3993
static PEAK_C_API PEAK_Interface_GetKey(PEAK_INTERFACE_HANDLE interfaceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4682
static PEAK_C_API PEAK_Buffer_ToEventSupportingModule(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:5969
static PEAK_C_API PEAK_Device_GetNumDataStreams(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Definition peak_dynamic_loader.h:5449
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:9076
static PEAK_C_API PEAK_Device_ToModule(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5241
static PEAK_C_API PEAK_DataStreamDescriptor_GetParentDevice(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5540
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:8361
static PEAK_C_API PEAK_InterfaceDescriptor_ToModuleDescriptor(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:4565
static PEAK_C_API PEAK_FloatNode_GetIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Definition peak_dynamic_loader.h:7737
static PEAK_C_API PEAK_Interface_GetDevice(PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE *deviceDescriptorHandle)
Definition peak_dynamic_loader.h:4786
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:9063
static PEAK_C_API PEAK_Node_GetNumSelectingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Definition peak_dynamic_loader.h:7412
static PEAK_C_API PEAK_Buffer_UpdateParts(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6424
static PEAK_C_API PEAK_BufferPart_GetXPadding(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:6671
static PEAK_C_API PEAK_BufferPart_GetType(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Definition peak_dynamic_loader.h:6580
static PEAK_C_API PEAK_Node_GetNamespace(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Definition peak_dynamic_loader.h:7100
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:5917
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Definition peak_dynamic_loader.h:9024
static PEAK_C_API PEAK_DeviceDescriptor_GetTLType(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5033
static PEAK_C_API PEAK_Node_GetVisibility(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Definition peak_dynamic_loader.h:7113
static PEAK_C_API PEAK_Node_GetIsAccessStatusCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Definition peak_dynamic_loader.h:7152
static PEAK_C_API PEAK_DataStream_GetID(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:5618
static PEAK_C_API PEAK_SystemDescriptor_GetVersion(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:4136
static PEAK_C_API PEAK_IntegerNode_GetValidValues(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:7529
static PEAK_C_API PEAK_IntegerNode_GetMinimum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Definition peak_dynamic_loader.h:7477
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:4500
static PEAK_C_API PEAK_System_GetKey(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4279
static PEAK_C_API PEAK_EventController_Destruct(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8712
static PEAK_C_API PEAK_Port_GetNumURLs(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Definition peak_dynamic_loader.h:8387
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:8088
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:8855
static PEAK_C_API PEAK_PortURL_GetFileName(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:8452
static PEAK_C_API PEAK_Module_GetNodeMap(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:6749
static PEAK_C_API PEAK_Interface_UnregisterDeviceLostCallback(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4890
static PEAK_C_API PEAK_Event_GetData(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Definition peak_dynamic_loader.h:8751
static PEAK_C_API PEAK_DeviceDescriptor_GetDisplayName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4981
static PEAK_C_API PEAK_FloatNode_GetUnit(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:7789
static PEAK_C_API PEAK_EventController_GetNumEventsInQueue(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Definition peak_dynamic_loader.h:8608
static PEAK_C_API PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:5163
static PEAK_C_API PEAK_EnumerationNode_ToNode(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8023
static PEAK_C_API PEAK_Module_GetNumNodeMaps(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Definition peak_dynamic_loader.h:6736
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:8725
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:8192
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:9089
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:8127
static PEAK_C_API PEAK_CommandNode_WaitUntilDone(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Definition peak_dynamic_loader.h:7685
static PEAK_C_API PEAK_Node_GetNumSelectedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Definition peak_dynamic_loader.h:7373
static PEAK_C_API PEAK_FirmwareUpdater_Destruct(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:8894
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:8881
static PEAK_C_API PEAK_System_GetID(PEAK_SYSTEM_HANDLE systemHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:4305
static PEAK_C_API PEAK_System_GetDisplayName(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4318
static PEAK_C_API PEAK_DeviceDescriptor_GetModelName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:5007
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersionStyle(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Definition peak_dynamic_loader.h:8972
static PEAK_C_API PEAK_FloatNode_GetHasConstantIncrement(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Definition peak_dynamic_loader.h:7828
static PEAK_C_API PEAK_Node_GetToolTip(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Definition peak_dynamic_loader.h:7230
static PEAK_C_API PEAK_RemoteDevice_GetLocalDevice(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5501
static PEAK_C_API PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Definition peak_dynamic_loader.h:8842
static PEAK_C_API PEAK_Interface_GetNumDevices(PEAK_INTERFACE_HANDLE interfaceHandle, size_t *numDevices)
Definition peak_dynamic_loader.h:4773
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:9050
static PEAK_C_API PEAK_EventController_KillWait(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:8686
static PEAK_C_API PEAK_Node_GetIsDeprecated(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Definition peak_dynamic_loader.h:7178
static PEAK_C_API PEAK_DataStream_Destruct(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:5943
static PEAK_C_API PEAK_Interface_UpdateDevices(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:4760
static PEAK_C_API PEAK_SystemDescriptor_GetCTIFileName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:4162
static PEAK_C_API PEAK_EventController_GetNumEventsFired(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Definition peak_dynamic_loader.h:8621
static PEAK_C_API PEAK_NodeMap_PollNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Definition peak_dynamic_loader.h:6814
static PEAK_C_API PEAK_Node_GetDisplayName(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:7087
static PEAK_C_API PEAK_NodeMap_StoreToFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:6905
static PEAK_C_API PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Definition peak_dynamic_loader.h:8062
static PEAK_C_API PEAK_ProducerLibrary_Destruct(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Definition peak_dynamic_loader.h:4045
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:7282
static PEAK_C_API PEAK_Library_GetVersionSubminor(uint32_t *libraryVersionSubminor)
Definition peak_dynamic_loader.h:3941
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetDescription(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:8933
static PEAK_C_API PEAK_DataStream_GetBufferAlignment(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *bufferAlignment)
Definition peak_dynamic_loader.h:5748
static PEAK_C_API PEAK_Buffer_GetIsAcquiring(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Definition peak_dynamic_loader.h:6320
static PEAK_C_API PEAK_Buffer_GetWidth(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Definition peak_dynamic_loader.h:6203
static PEAK_C_API PEAK_BufferPart_GetBasePtr(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Definition peak_dynamic_loader.h:6554
static PEAK_C_API PEAK_NodeMap_Unlock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:6944
static PEAK_C_API PEAK_Node_GetPollingTime(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Definition peak_dynamic_loader.h:7217
static PEAK_C_API PEAK_Buffer_GetYOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:6242
static PEAK_C_API PEAK_Buffer_GetDeliveredImageHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:6151
static PEAK_C_API PEAK_FloatNode_GetValidValues(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:7763
static PEAK_C_API PEAK_SystemDescriptor_ToModuleDescriptor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:4058
static PEAK_C_API PEAK_System_GetModelName(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:4344
static PEAK_C_API PEAK_InterfaceDescriptor_GetTLType(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4617
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:4084
static PEAK_C_API PEAK_RemoteDevice_ToModule(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:5488
static PEAK_C_API PEAK_InterfaceDescriptor_GetDisplayName(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4604
static PEAK_C_API PEAK_System_GetTLType(PEAK_SYSTEM_HANDLE systemHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:4370
static PEAK_C_API PEAK_DataStreamDescriptor_ToModuleDescriptor(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:5514
static PEAK_C_API PEAK_System_GetGenTLVersionMinor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:4422
static PEAK_C_API PEAK_NodeMap_UpdateChunkNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6866
static PEAK_C_API PEAK_Buffer_GetUserPtr(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Definition peak_dynamic_loader.h:6034
static PEAK_C_API PEAK_Interface_ToEventSupportingModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:4669
static PEAK_C_API PEAK_DeviceDescriptor_ToModuleDescriptor(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:4942
static PEAK_C_API PEAK_CategoryNode_ToNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7984
static PEAK_C_API PEAK_Port_GetIsWritable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Definition peak_dynamic_loader.h:8322
static PEAK_C_API PEAK_Device_GetRemoteDevice(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Definition peak_dynamic_loader.h:5436
static PEAK_C_API PEAK_CategoryNode_GetSubNode(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:8010
static PEAK_C_API PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:5150
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:4292
static PEAK_C_API PEAK_System_ToEventSupportingModule(PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:4266
static PEAK_C_API PEAK_CommandNode_Execute(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:7659
static PEAK_C_API PEAK_RegisterNode_GetLength(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Definition peak_dynamic_loader.h:7945
static PEAK_C_API PEAK_BufferPart_GetFormat(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Definition peak_dynamic_loader.h:6593
static PEAK_C_API PEAK_Node_ToBooleanNode(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Definition peak_dynamic_loader.h:6970
static PEAK_C_API PEAK_Device_GetSerialNumber(PEAK_DEVICE_HANDLE deviceHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:5384
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:9102
static PEAK_C_API PEAK_Buffer_GetIsQueued(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Definition peak_dynamic_loader.h:6307
static PEAK_C_API PEAK_NodeMap_GetNode(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:6840
static PEAK_C_API PEAK_BooleanNode_ToNode(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7594
static PEAK_C_API PEAK_IntegerNode_GetIncrement(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Definition peak_dynamic_loader.h:7503
static PEAK_C_API PEAK_FirmwareUpdater_Construct(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:8803
static PEAK_C_API PEAK_Node_ToIntegerNode(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Definition peak_dynamic_loader.h:6957
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:8595
static PEAK_C_API PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Definition peak_dynamic_loader.h:8816
static PEAK_C_API PEAK_Interface_ToModule(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:4656
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:8036
static PEAK_C_API PEAK_Node_GetParentNodeMap(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:7269
static PEAK_C_API PEAK_Library_IsInitialized(PEAK_BOOL8 *isInitialized)
Definition peak_dynamic_loader.h:3902
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:5462
static PEAK_C_API PEAK_SystemDescriptor_GetParentLibrary(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4227
static PEAK_C_API PEAK_Buffer_GetTimestamp_ticks(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Definition peak_dynamic_loader.h:6281
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:9128
static PEAK_C_API PEAK_InterfaceDescriptor_GetParentSystem(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4630
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:5111
static PEAK_C_API PEAK_IntegerNode_GetMaximum(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Definition peak_dynamic_loader.h:7490
static PEAK_C_API PEAK_System_GetParentLibrary(PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:4448
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:4968
static PEAK_C_API PEAK_Buffer_GetPixelEndianness(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Definition peak_dynamic_loader.h:6086
static PEAK_C_API PEAK_Port_GetName(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:8218
static PEAK_C_API PEAK_Port_GetVendorName(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:8231
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:4695
static PEAK_C_API PEAK_InterfaceDescriptor_OpenInterface(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:4643
static PEAK_C_API PEAK_Device_GetAccessStatus(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:5397
static PEAK_C_API PEAK_NodeMap_Lock(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:6931
static PEAK_C_API PEAK_BufferChunk_GetID(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Definition peak_dynamic_loader.h:6463
static PEAK_C_API PEAK_DataStream_GetParentDevice(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:5800
static PEAK_C_API PEAK_DataStream_GetNumBuffersAwaitDelivery(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAwaitDelivery)
Definition peak_dynamic_loader.h:5683
static PEAK_C_API PEAK_Node_GetNumInvalidatingNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Definition peak_dynamic_loader.h:7334
static PEAK_C_API PEAK_NodeMap_GetHasEventSupportedData(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Definition peak_dynamic_loader.h:6879
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:4851
static PEAK_C_API PEAK_RegisterNode_Write(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition peak_dynamic_loader.h:7971
static PEAK_C_API PEAK_System_GetInterface(PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE *interfaceDescriptorHandle)
Definition peak_dynamic_loader.h:4487
static PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMajor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMajor)
Definition peak_dynamic_loader.h:4188
static PEAK_C_API PEAK_ModuleDescriptor_GetID(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:6723
static PEAK_C_API PEAK_Buffer_GetDeliveredChunkPayloadSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Definition peak_dynamic_loader.h:6164
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:5124
static PEAK_C_API PEAK_BufferPart_GetDeliveredImageHeight(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:6684
static PEAK_C_API PEAK_Buffer_GetXOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:6229
static PEAK_C_API PEAK_Node_ToRegisterNode(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Definition peak_dynamic_loader.h:7022
static PEAK_C_API PEAK_Port_GetTLType(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:8270
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:5826
static PEAK_C_API PEAK_Node_GetSelectingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition peak_dynamic_loader.h:7425
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:7399
static PEAK_C_API PEAK_EventController_GetControlledEventType(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Definition peak_dynamic_loader.h:8660
static PEAK_C_API PEAK_DeviceDescriptor_GetVersion(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:5020
static PEAK_C_API PEAK_DataStream_ToEventSupportingModule(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:5579
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:8582
static PEAK_C_API PEAK_System_UnregisterInterfaceFoundCallback(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:4513
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:7568
static PEAK_C_API PEAK_EventController_GetEventMaxSize(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Definition peak_dynamic_loader.h:8634
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:6775
static PEAK_C_API PEAK_Device_GetDisplayName(PEAK_DEVICE_HANDLE deviceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:5306
static PEAK_C_API PEAK_Node_GetAccessStatus(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:7126
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:4591
static PEAK_C_API PEAK_Node_GetIsCacheable(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Definition peak_dynamic_loader.h:7139
static PEAK_C_API PEAK_DataStream_KillWait(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:5878
static PEAK_C_API PEAK_Buffer_GetPixelFormat(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Definition peak_dynamic_loader.h:6060
static PEAK_C_API PEAK_NodeMap_LoadFromFile(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:6918
static PEAK_C_API PEAK_Buffer_UpdateChunks(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:6385
static PEAK_C_API PEAK_SystemDescriptor_GetGenTLVersionMinor(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:4201
static PEAK_C_API PEAK_DeviceDescriptor_GetSerialNumber(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:5059
static PEAK_C_API PEAK_Buffer_GetSize(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Definition peak_dynamic_loader.h:6021
static PEAK_C_API PEAK_Buffer_GetHasImage(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Definition peak_dynamic_loader.h:6359
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:7321
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:9193
static PEAK_C_API PEAK_FirmwareUpdateProgressObserver_Construct(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:9037
static PEAK_C_API PEAK_Device_GetTLType(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:5358
static PEAK_C_API PEAK_Node_GetDescription(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:7243
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetFileName(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:8920
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetVersion(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:8946
static PEAK_C_API PEAK_DeviceDescriptor_GetUserDefinedName(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:5046
static PEAK_C_API PEAK_Buffer_GetNumParts(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Definition peak_dynamic_loader.h:6437
static PEAK_C_API PEAK_SystemDescriptor_GetVendorName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:4110
static PEAK_C_API PEAK_Buffer_GetFileName(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:6190
static PEAK_C_API PEAK_EnumerationNode_GetNumEntries(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Definition peak_dynamic_loader.h:8114
static PEAK_C_API PEAK_SystemDescriptor_OpenSystem(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:4240
static PEAK_C_API PEAK_Device_GetParentInterface(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:5423
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:5813
static PEAK_C_API PEAK_Event_Destruct(PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:8790
static PEAK_C_API PEAK_System_GetVendorName(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:4331
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:4877
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:8413
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:8868
static PEAK_C_API PEAK_Buffer_GetImageOffset(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Definition peak_dynamic_loader.h:6138
static PEAK_C_API PEAK_Port_GetIsReadable(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Definition peak_dynamic_loader.h:8309
static PEAK_C_API PEAK_BufferPart_GetXOffset(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:6645
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:5176
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:8829
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:8374
static PEAK_C_API PEAK_DataStream_GetNumBuffersDelivered(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersDelivered)
Definition peak_dynamic_loader.h:5696
static PEAK_C_API PEAK_BooleanNode_SetValue(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Definition peak_dynamic_loader.h:7620
static PEAK_C_API PEAK_DataStream_GetDefinesPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *definesPayloadSize)
Definition peak_dynamic_loader.h:5774
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:6528
static PEAK_C_API PEAK_Buffer_GetYPadding(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Definition peak_dynamic_loader.h:6268
static PEAK_C_API PEAK_DataStream_StartAcquisitionInfinite(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Definition peak_dynamic_loader.h:5904
static PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Definition peak_dynamic_loader.h:8556
static PEAK_C_API PEAK_Interface_GetDisplayName(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:4721
static PEAK_C_API PEAK_Library_GetVersionMajor(uint32_t *libraryVersionMajor)
Definition peak_dynamic_loader.h:3915
static PEAK_C_API PEAK_DataStream_RevokeBuffer(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:5852
static PEAK_C_API PEAK_EnumerationEntryNode_GetSymbolicValue(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Definition peak_dynamic_loader.h:8166
static PEAK_C_API PEAK_DataStreamDescriptor_GetKey(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:5527
static PEAK_C_API PEAK_Buffer_GetPart(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Definition peak_dynamic_loader.h:6450
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:4903
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:5605
static PEAK_C_API PEAK_System_GetGenTLVersionMajor(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMajor)
Definition peak_dynamic_loader.h:4409
static PEAK_C_API PEAK_EnvironmentInspector_GetNumCTIPaths(size_t *numCtiPaths)
Definition peak_dynamic_loader.h:3980
static PEAK_C_API PEAK_StringNode_ToNode(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7867
static PEAK_C_API PEAK_EnumerationEntryNode_GetIsSelfClearing(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Definition peak_dynamic_loader.h:8153
static PEAK_C_API PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Definition peak_dynamic_loader.h:8998
static PEAK_C_API PEAK_NodeMap_InvalidateNodes(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:6801
static PEAK_C_API PEAK_System_GetCharacterEncoding(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:4435
static PEAK_C_API PEAK_InterfaceDescriptor_GetKey(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:4578
static PEAK_C_API PEAK_SystemDescriptor_GetCharacterEncoding(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:4214
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:8101
static PEAK_C_API PEAK_DataStream_GetNumBuffersAnnouncedMinRequired(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnouncedMinRequired)
Definition peak_dynamic_loader.h:5644
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:4526
static PEAK_C_API PEAK_Node_GetType(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Definition peak_dynamic_loader.h:7256
static PEAK_C_API PEAK_BufferPart_Destruct(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Definition peak_dynamic_loader.h:6710
static PEAK_C_API PEAK_Node_ToEnumerationNode(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Definition peak_dynamic_loader.h:7048
static PEAK_C_API PEAK_IntegerNode_GetIncrementType(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:7516
static PEAK_C_API PEAK_DataStreamDescriptor_OpenDataStream(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Definition peak_dynamic_loader.h:5553
static PEAK_C_API PEAK_Buffer_GetPayloadType(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Definition peak_dynamic_loader.h:6047
static PEAK_C_API PEAK_Library_Close()
Definition peak_dynamic_loader.h:3889
static PEAK_C_API PEAK_DataStream_GetNumUnderruns(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Definition peak_dynamic_loader.h:5722
static PEAK_C_API PEAK_Node_GetInvalidatingNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition peak_dynamic_loader.h:7347
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:4799
static PEAK_C_API PEAK_Buffer_GetHasChunks(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Definition peak_dynamic_loader.h:6372
static PEAK_C_API PEAK_PortURL_GetFileVersionMinor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Definition peak_dynamic_loader.h:8517
static PEAK_C_API PEAK_FloatNode_GetMinimum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Definition peak_dynamic_loader.h:7711
static PEAK_C_API PEAK_PortURL_GetFileSchemaVersionMajor(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Definition peak_dynamic_loader.h:8543
static PEAK_C_API PEAK_Buffer_GetHeight(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Definition peak_dynamic_loader.h:6216
static PEAK_C_API PEAK_Buffer_GetBasePtr(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Definition peak_dynamic_loader.h:6008
static PEAK_C_API PEAK_Buffer_GetNumChunks(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Definition peak_dynamic_loader.h:6398
static PEAK_C_API PEAK_Node_GetNumInvalidatedNodes(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Definition peak_dynamic_loader.h:7295
static PEAK_C_API PEAK_DataStream_GetPayloadSize(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Definition peak_dynamic_loader.h:5761
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:9154
static PEAK_C_API PEAK_FloatNode_GetMaximum(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Definition peak_dynamic_loader.h:7724
static PEAK_C_API PEAK_Node_GetName(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:7074
static PEAK_C_API PEAK_IntegerNode_ToNode(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:7464
static PEAK_C_API PEAK_Port_GetIsImplemented(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Definition peak_dynamic_loader.h:8348
static PEAK_C_API PEAK_SystemDescriptor_GetModelName(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:4123
static PEAK_C_API PEAK_Port_GetURL(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Definition peak_dynamic_loader.h:8400
static PEAK_C_API PEAK_Device_GetUserDefinedName(PEAK_DEVICE_HANDLE deviceHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:5371
static PEAK_C_API PEAK_Node_ToFloatNode(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Definition peak_dynamic_loader.h:6996
static PEAK_C_API PEAK_Interface_GetID(PEAK_INTERFACE_HANDLE interfaceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:4708
static PEAK_C_API PEAK_Node_GetSelectedNode(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition peak_dynamic_loader.h:7386
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_GetNumCTIPaths)(size_t *numCtiPaths)
Definition peak_dynamic_loader.h:44
PEAK_C_API(* dyn_PEAK_Buffer_GetIsAcquiring)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isAcquiring)
Definition peak_dynamic_loader.h:224
PEAK_C_API(* dyn_PEAK_BooleanNode_SetValue)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_BOOL8 value)
Definition peak_dynamic_loader.h:324
PEAK_C_API(* dyn_PEAK_Buffer_GetExpectedDataSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *expectedDataSize)
Definition peak_dynamic_loader.h:207
PEAK_C_API(* dyn_PEAK_Port_GetID)(PEAK_PORT_HANDLE portHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:369
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:169
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:68
PEAK_C_API(* dyn_PEAK_PortURL_GetFileName)(PEAK_PORT_URL_HANDLE portUrlHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:388
PEAK_C_API(* dyn_PEAK_Node_ToBooleanNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOLEAN_NODE_HANDLE *booleanNodeHandle)
Definition peak_dynamic_loader.h:274
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:84
PEAK_C_API(* dyn_PEAK_Node_GetNumSelectedNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectedNodes)
Definition peak_dynamic_loader.h:305
PEAK_C_API(* dyn_PEAK_Event_Destruct)(PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:414
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:417
PEAK_C_API(* dyn_PEAK_DataStream_GetNumChunksPerBufferMax)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numChunksPerBufferMax)
Definition peak_dynamic_loader.h:179
PEAK_C_API(* dyn_PEAK_Node_ToFloatNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_FLOAT_NODE_HANDLE *floatNodeHandle)
Definition peak_dynamic_loader.h:276
PEAK_C_API(* dyn_PEAK_Device_GetModelName)(PEAK_DEVICE_HANDLE deviceHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:148
PEAK_C_API(* dyn_PEAK_BufferPart_GetWidth)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *width)
Definition peak_dynamic_loader.h:247
PEAK_C_API(* dyn_PEAK_CategoryNode_ToNode)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:352
PEAK_C_API(* dyn_PEAK_DataStream_ToEventSupportingModule)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:167
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:356
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:382
PEAK_C_API(* dyn_PEAK_Interface_GetKey)(PEAK_INTERFACE_HANDLE interfaceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:98
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:320
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetModelName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:55
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:86
PEAK_C_API(* dyn_PEAK_Port_GetIsImplemented)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isImplemented)
Definition peak_dynamic_loader.h:380
PEAK_C_API(* dyn_PEAK_Interface_ToModule)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:96
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetValue)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, int64_t *value)
Definition peak_dynamic_loader.h:367
PEAK_C_API(* dyn_PEAK_IntegerNode_GetIncrementType)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:316
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersAnnouncedMinRequired)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnouncedMinRequired)
Definition peak_dynamic_loader.h:172
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetDisplayName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:121
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredDataSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredDataSize)
Definition peak_dynamic_loader.h:208
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:99
PEAK_C_API(* dyn_PEAK_Interface_GetNumDevices)(PEAK_INTERFACE_HANDLE interfaceHandle, size_t *numDevices)
Definition peak_dynamic_loader.h:105
PEAK_C_API(* dyn_PEAK_Buffer_GetPart)(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_PART_HANDLE *bufferPartHandle)
Definition peak_dynamic_loader.h:234
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSchemaVersionMinor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMinor)
Definition peak_dynamic_loader.h:396
PEAK_C_API(* dyn_PEAK_System_Destruct)(PEAK_SYSTEM_HANDLE systemHandle)
Definition peak_dynamic_loader.h:88
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:445
PEAK_C_API(* dyn_PEAK_Port_GetModelName)(PEAK_PORT_HANDLE portHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:372
PEAK_C_API(* dyn_PEAK_System_UpdateInterfaces)(PEAK_SYSTEM_HANDLE systemHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:81
PEAK_C_API(* dyn_PEAK_System_GetID)(PEAK_SYSTEM_HANDLE systemHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:69
PEAK_C_API(* dyn_PEAK_RemoteDevice_GetLocalDevice)(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:161
PEAK_C_API(* dyn_PEAK_Library_Close)()
Definition peak_dynamic_loader.h:37
PEAK_C_API(* dyn_PEAK_Module_GetNodeMap)(PEAK_MODULE_HANDLE moduleHandle, size_t index, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:257
PEAK_C_API(* dyn_PEAK_Buffer_GetUserPtr)(PEAK_BUFFER_HANDLE bufferHandle, void **userPtr)
Definition peak_dynamic_loader.h:202
PEAK_C_API(* dyn_PEAK_StringNode_ToNode)(PEAK_STRING_NODE_HANDLE stringNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:343
PEAK_C_API(* dyn_PEAK_FloatNode_GetValidValues)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:335
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_UpdateCTIPaths)()
Definition peak_dynamic_loader.h:43
PEAK_C_API(* dyn_PEAK_CommandNode_WaitUntilDoneInfinite)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:328
PEAK_C_API(* dyn_PEAK_Node_GetName)(PEAK_NODE_HANDLE nodeHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:282
PEAK_C_API(* dyn_PEAK_Buffer_GetXOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:217
PEAK_C_API(* dyn_PEAK_BufferPart_GetBasePtr)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, void **basePtr)
Definition peak_dynamic_loader.h:242
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetTLType)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:125
PEAK_C_API(* dyn_PEAK_Buffer_UpdateChunks)(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:229
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelEndianness)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_ENDIANNESS *pixelEndianness)
Definition peak_dynamic_loader.h:206
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_AddInformationRoleToMonitoring)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition peak_dynamic_loader.h:137
PEAK_C_API(* dyn_PEAK_FloatNode_GetRepresentation)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:336
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_ToModuleDescriptor)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:89
PEAK_C_API(* dyn_PEAK_NodeMap_StoreToFile)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:269
PEAK_C_API(* dyn_PEAK_FloatNode_ToNode)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:330
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:437
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *versionExtractionPattern, size_t *versionExtractionPatternSize)
Definition peak_dynamic_loader.h:427
PEAK_C_API(* dyn_PEAK_Buffer_GetTLType)(PEAK_BUFFER_HANDLE bufferHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:199
PEAK_C_API(* dyn_PEAK_Buffer_GetHasChunks)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasChunks)
Definition peak_dynamic_loader.h:228
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:260
PEAK_C_API(* dyn_PEAK_Node_GetNamespace)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_NAMESPACE *_namespace)
Definition peak_dynamic_loader.h:284
PEAK_C_API(* dyn_PEAK_Device_GetDisplayName)(PEAK_DEVICE_HANDLE deviceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:146
PEAK_C_API(* dyn_PEAK_DataStream_StopAcquisition)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_STOP_MODE stopMode)
Definition peak_dynamic_loader.h:194
PEAK_C_API(* dyn_PEAK_EnvironmentInspector_GetCTIPath)(size_t index, char *ctiPath, size_t *ctiPathSize)
Definition peak_dynamic_loader.h:45
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:107
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:385
PEAK_C_API(* dyn_PEAK_DataStream_GetBufferAlignment)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *bufferAlignment)
Definition peak_dynamic_loader.h:180
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:405
PEAK_C_API(* dyn_PEAK_Node_ToCommandNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_COMMAND_NODE_HANDLE *commandNodeHandle)
Definition peak_dynamic_loader.h:275
PEAK_C_API(* dyn_PEAK_Device_GetRemoteDevice)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_REMOTE_DEVICE_HANDLE *remoteDeviceHandle)
Definition peak_dynamic_loader.h:156
PEAK_C_API(* dyn_PEAK_SystemDescriptor_ToModuleDescriptor)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:50
PEAK_C_API(* dyn_PEAK_Node_ToRegisterNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_REGISTER_NODE_HANDLE *registerNodeHandle)
Definition peak_dynamic_loader.h:278
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetGenTLVersionMinor)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:61
PEAK_C_API(* dyn_PEAK_Node_GetParentNodeMap)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_MAP_HANDLE *nodeMapHandle)
Definition peak_dynamic_loader.h:297
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetCharacterEncoding)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:62
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetTLType)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:93
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetUserDefinedName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:126
PEAK_C_API(* dyn_PEAK_Buffer_GetYOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:218
PEAK_C_API(* dyn_PEAK_ProducerLibrary_GetKey)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:47
PEAK_C_API(* dyn_PEAK_Node_ToStringNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_STRING_NODE_HANDLE *stringNodeHandle)
Definition peak_dynamic_loader.h:277
PEAK_C_API(* dyn_PEAK_DataStream_GetNumUnderruns)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numUnderruns)
Definition peak_dynamic_loader.h:178
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_Destruct)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:422
PEAK_C_API(* dyn_PEAK_NodeMap_GetNumNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t *numNodes)
Definition peak_dynamic_loader.h:263
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_GetKey)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:163
PEAK_C_API(* dyn_PEAK_Device_GetParentInterface)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:155
PEAK_C_API(* dyn_PEAK_Interface_Destruct)(PEAK_INTERFACE_HANDLE interfaceHandle)
Definition peak_dynamic_loader.h:117
PEAK_C_API(* dyn_PEAK_DataStream_Flush)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DATA_STREAM_FLUSH_MODE flushMode)
Definition peak_dynamic_loader.h:191
PEAK_C_API(* dyn_PEAK_System_UnregisterInterfaceFoundCallback)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:85
PEAK_C_API(* dyn_PEAK_System_GetInterface)(PEAK_SYSTEM_HANDLE systemHandle, size_t index, PEAK_INTERFACE_DESCRIPTOR_HANDLE *interfaceDescriptorHandle)
Definition peak_dynamic_loader.h:83
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:139
PEAK_C_API(* dyn_PEAK_Device_GetTLType)(PEAK_DEVICE_HANDLE deviceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:150
PEAK_C_API(* dyn_PEAK_CommandNode_ToNode)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:325
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetFileName)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:424
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:189
PEAK_C_API(* dyn_PEAK_StringNode_SetValue)(PEAK_STRING_NODE_HANDLE stringNodeHandle, const char *value, size_t valueSize)
Definition peak_dynamic_loader.h:346
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:345
PEAK_C_API(* dyn_PEAK_EnumerationNode_GetNumEntries)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, size_t *numEntries)
Definition peak_dynamic_loader.h:362
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:185
PEAK_C_API(* dyn_PEAK_FloatNode_GetMinimum)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *minimum)
Definition peak_dynamic_loader.h:331
PEAK_C_API(* dyn_PEAK_Buffer_GetChunkLayoutID)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *chunkLayoutId)
Definition peak_dynamic_loader.h:213
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:198
PEAK_C_API(* dyn_PEAK_BufferPart_GetFormatNamespace)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *formatNamespace)
Definition peak_dynamic_loader.h:246
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:298
PEAK_C_API(* dyn_PEAK_Device_GetAccessStatus)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:153
PEAK_C_API(* dyn_PEAK_Node_GetVisibility)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_VISIBILITY *visibility)
Definition peak_dynamic_loader.h:285
PEAK_C_API(* dyn_PEAK_Node_GetInvalidatedNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatedNodeHandle)
Definition peak_dynamic_loader.h:300
PEAK_C_API(* dyn_PEAK_Device_GetTimestampTickFrequency)(PEAK_DEVICE_HANDLE deviceHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:154
PEAK_C_API(* dyn_PEAK_Buffer_GetYPadding)(PEAK_BUFFER_HANDLE bufferHandle, size_t *yPadding)
Definition peak_dynamic_loader.h:220
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetGenTLVersionMajor)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, uint32_t *gentlVersionMajor)
Definition peak_dynamic_loader.h:60
PEAK_C_API(* dyn_PEAK_Node_GetDescription)(PEAK_NODE_HANDLE nodeHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:295
PEAK_C_API(* dyn_PEAK_Node_GetIsStreamable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isStreamable)
Definition peak_dynamic_loader.h:289
PEAK_C_API(* dyn_PEAK_Event_GetType)(PEAK_EVENT_HANDLE eventHandle, PEAK_EVENT_TYPE *type)
Definition peak_dynamic_loader.h:412
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredChunkPayloadSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredChunkPayloadSize)
Definition peak_dynamic_loader.h:212
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:304
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_CollectAllFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, const char *gufPath, size_t gufPathSize)
Definition peak_dynamic_loader.h:416
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionMinor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMinor)
Definition peak_dynamic_loader.h:393
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersStarted)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersStarted)
Definition peak_dynamic_loader.h:177
PEAK_C_API(* dyn_PEAK_BufferChunk_GetID)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, uint64_t *id)
Definition peak_dynamic_loader.h:235
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:360
PEAK_C_API(* dyn_PEAK_Buffer_UpdateParts)(PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:232
PEAK_C_API(* dyn_PEAK_NodeMap_InvalidateNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:261
PEAK_C_API(* dyn_PEAK_Node_GetIsCacheable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isCacheable)
Definition peak_dynamic_loader.h:287
PEAK_C_API(* dyn_PEAK_IntegerNode_GetUnit)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:319
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_ToNode)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:364
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntryByValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:359
PEAK_C_API(* dyn_PEAK_NodeMap_Unlock)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:272
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:120
PEAK_C_API(* dyn_PEAK_DataStream_KillWait)(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:190
PEAK_C_API(* dyn_PEAK_Node_UnregisterChangedCallback)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:311
PEAK_C_API(* dyn_PEAK_Node_GetSelectingNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectingNodeHandle)
Definition peak_dynamic_loader.h:309
PEAK_C_API(* dyn_PEAK_Library_GetVersionMinor)(uint32_t *libraryVersionMinor)
Definition peak_dynamic_loader.h:40
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetKey)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:90
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:111
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:91
PEAK_C_API(* dyn_PEAK_Node_GetType)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_TYPE *type)
Definition peak_dynamic_loader.h:296
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:132
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_GetNumFirmwareUpdateInformation)(PEAK_FIRMWARE_UPDATER_HANDLE firmwareUpdaterHandle, size_t *numFirmwareUpdateInformation)
Definition peak_dynamic_loader.h:418
PEAK_C_API(* dyn_PEAK_Device_GetUserDefinedName)(PEAK_DEVICE_HANDLE deviceHandle, char *userDefinedName, size_t *userDefinedNameSize)
Definition peak_dynamic_loader.h:151
PEAK_C_API(* dyn_PEAK_FloatNode_SetValue)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double value)
Definition peak_dynamic_loader.h:342
PEAK_C_API(* dyn_PEAK_Node_GetCachingMode)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_CACHING_MODE *cachingMode)
Definition peak_dynamic_loader.h:292
PEAK_C_API(* dyn_PEAK_Interface_GetDisplayName)(PEAK_INTERFACE_HANDLE interfaceHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:101
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetReleaseNotesURL)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotesUrl, size_t *releaseNotesUrlSize)
Definition peak_dynamic_loader.h:430
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:240
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersQueued)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersQueued)
Definition peak_dynamic_loader.h:174
PEAK_C_API(* dyn_PEAK_Node_GetIsDeprecated)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isDeprecated)
Definition peak_dynamic_loader.h:290
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:435
PEAK_C_API(* dyn_PEAK_Interface_UpdateDevices)(PEAK_INTERFACE_HANDLE interfaceHandle, uint64_t timeout_ms)
Definition peak_dynamic_loader.h:104
PEAK_C_API(* dyn_PEAK_CommandNode_WaitUntilDone)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, uint64_t waitTimeout_ms)
Definition peak_dynamic_loader.h:329
PEAK_C_API(* dyn_PEAK_NodeMap_GetNode)(PEAK_NODE_MAP_HANDLE nodeMapHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:264
PEAK_C_API(* dyn_PEAK_Port_GetURL)(PEAK_PORT_HANDLE portHandle, size_t index, PEAK_PORT_URL_HANDLE *portUrlHandle)
Definition peak_dynamic_loader.h:384
PEAK_C_API(* dyn_PEAK_FloatNode_GetDisplayNotation)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_DISPLAY_NOTATION *displayNotation)
Definition peak_dynamic_loader.h:338
PEAK_C_API(* dyn_PEAK_System_GetKey)(PEAK_SYSTEM_HANDLE systemHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:67
PEAK_C_API(* dyn_PEAK_CategoryNode_GetNumSubNodes)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t *numSubNodes)
Definition peak_dynamic_loader.h:353
PEAK_C_API(* dyn_PEAK_Port_GetIsAvailable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isAvailable)
Definition peak_dynamic_loader.h:379
PEAK_C_API(* dyn_PEAK_RegisterNode_GetLength)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, size_t *length)
Definition peak_dynamic_loader.h:349
PEAK_C_API(* dyn_PEAK_Buffer_GetFrameID)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *frameId)
Definition peak_dynamic_loader.h:209
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:438
PEAK_C_API(* dyn_PEAK_Port_GetModuleName)(PEAK_PORT_HANDLE portHandle, char *moduleName, size_t *moduleNameSize)
Definition peak_dynamic_loader.h:375
PEAK_C_API(* dyn_PEAK_FloatNode_GetDisplayPrecision)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, int64_t *displayPrecision)
Definition peak_dynamic_loader.h:339
PEAK_C_API(* dyn_PEAK_NodeMap_PollNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, int64_t elapsedTime_ms)
Definition peak_dynamic_loader.h:262
PEAK_C_API(* dyn_PEAK_Device_GetVendorName)(PEAK_DEVICE_HANDLE deviceHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:147
PEAK_C_API(* dyn_PEAK_Buffer_GetHeight)(PEAK_BUFFER_HANDLE bufferHandle, size_t *height)
Definition peak_dynamic_loader.h:216
PEAK_C_API(* dyn_PEAK_Device_Destruct)(PEAK_DEVICE_HANDLE deviceHandle)
Definition peak_dynamic_loader.h:159
PEAK_C_API(* dyn_PEAK_DataStream_GetPayloadSize)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *payloadSize)
Definition peak_dynamic_loader.h:181
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetCTIFileName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:58
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersion)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:426
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:109
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetMonitoringUpdateInterval)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:134
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetVersion)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:124
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:368
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetModelName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:123
PEAK_C_API(* dyn_PEAK_BufferPart_GetHeight)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *height)
Definition peak_dynamic_loader.h:248
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetTLType)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:57
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:144
PEAK_C_API(* dyn_PEAK_NodeMap_Lock)(PEAK_NODE_MAP_HANDLE nodeMapHandle)
Definition peak_dynamic_loader.h:271
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetSymbolicValue)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, char *symbolicValue, size_t *symbolicValueSize)
Definition peak_dynamic_loader.h:366
PEAK_C_API(* dyn_PEAK_System_GetDisplayName)(PEAK_SYSTEM_HANDLE systemHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:70
PEAK_C_API(* dyn_PEAK_EventController_GetControlledEventType)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, PEAK_EVENT_TYPE *controlledEventType)
Definition peak_dynamic_loader.h:404
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_INFORMATION_ROLE informationRole)
Definition peak_dynamic_loader.h:138
PEAK_C_API(* dyn_PEAK_DataStream_GetID)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:170
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:259
PEAK_C_API(* dyn_PEAK_Port_GetIsReadable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isReadable)
Definition peak_dynamic_loader.h:377
PEAK_C_API(* dyn_PEAK_EnumerationEntryNode_GetIsSelfClearing)(PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle, PEAK_BOOL8 *isSelfClearing)
Definition peak_dynamic_loader.h:365
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetVendorName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:54
PEAK_C_API(* dyn_PEAK_System_GetCharacterEncoding)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_CHARACTER_ENCODING *characterEncoding)
Definition peak_dynamic_loader.h:79
PEAK_C_API(* dyn_PEAK_DataStream_StartAcquisitionInfinite)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_ACQUISITION_START_MODE startMode)
Definition peak_dynamic_loader.h:192
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:420
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionMajor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionMajor)
Definition peak_dynamic_loader.h:392
PEAK_C_API(* dyn_PEAK_DataStream_GetParentDevice)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:184
PEAK_C_API(* dyn_PEAK_PortURL_GetFileRegisterAddress)(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileRegisterAddress)
Definition peak_dynamic_loader.h:389
PEAK_C_API(* dyn_PEAK_System_ToModule)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:65
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetIsValid)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_BOOL8 *isValid)
Definition peak_dynamic_loader.h:423
PEAK_C_API(* dyn_PEAK_Buffer_GetPayloadType)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BUFFER_PAYLOAD_TYPE *payloadType)
Definition peak_dynamic_loader.h:203
PEAK_C_API(* dyn_PEAK_EnumerationNode_ToNode)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:355
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:113
PEAK_C_API(* dyn_PEAK_IntegerNode_GetMaximum)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *maximum)
Definition peak_dynamic_loader.h:314
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_Destruct)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:446
PEAK_C_API(* dyn_PEAK_EventController_GetEventDataMaxSize)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventDataMaxSize)
Definition peak_dynamic_loader.h:403
PEAK_C_API(* dyn_PEAK_IntegerNode_GetMinimum)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *minimum)
Definition peak_dynamic_loader.h:313
PEAK_C_API(* dyn_PEAK_BufferPart_GetYOffset)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *yOffset)
Definition peak_dynamic_loader.h:250
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_GetParentDevice)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DEVICE_HANDLE *deviceHandle)
Definition peak_dynamic_loader.h:164
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceFoundCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:108
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:398
PEAK_C_API(* dyn_PEAK_Interface_GetDevice)(PEAK_INTERFACE_HANDLE interfaceHandle, size_t index, PEAK_DEVICE_DESCRIPTOR_HANDLE *deviceDescriptorHandle)
Definition peak_dynamic_loader.h:106
PEAK_C_API(* dyn_PEAK_Node_GetInvalidatingNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *invalidatingNodeHandle)
Definition peak_dynamic_loader.h:303
PEAK_C_API(* dyn_PEAK_Node_GetNumSelectingNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numSelectingNodes)
Definition peak_dynamic_loader.h:308
PEAK_C_API(* dyn_PEAK_Port_GetNumURLs)(PEAK_PORT_HANDLE portHandle, size_t *numUrls)
Definition peak_dynamic_loader.h:383
PEAK_C_API(* dyn_PEAK_Port_GetVendorName)(PEAK_PORT_HANDLE portHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:371
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:115
PEAK_C_API(* dyn_PEAK_BufferChunk_GetParentBuffer)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:238
PEAK_C_API(* dyn_PEAK_RegisterNode_ToNode)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:347
PEAK_C_API(* dyn_PEAK_Buffer_GetDeliveredImageHeight)(PEAK_BUFFER_HANDLE bufferHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:211
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:52
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetVersionStyle)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_VERSION_STYLE *versionStyle)
Definition peak_dynamic_loader.h:428
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:131
PEAK_C_API(* dyn_PEAK_FirmwareUpdater_Construct)(PEAK_FIRMWARE_UPDATER_HANDLE *firmwareUpdaterHandle)
Definition peak_dynamic_loader.h:415
PEAK_C_API(* dyn_PEAK_RemoteDevice_ToModule)(PEAK_REMOTE_DEVICE_HANDLE remoteDeviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:160
PEAK_C_API(* dyn_PEAK_Buffer_GetNumChunks)(PEAK_BUFFER_HANDLE bufferHandle, size_t *numChunks)
Definition peak_dynamic_loader.h:230
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetDescription)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *description, size_t *descriptionSize)
Definition peak_dynamic_loader.h:425
PEAK_C_API(* dyn_PEAK_BufferPart_GetSize)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *size)
Definition peak_dynamic_loader.h:243
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:421
PEAK_C_API(* dyn_PEAK_ProducerLibrary_Destruct)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle)
Definition peak_dynamic_loader.h:49
void * import_function(void *module, const char *proc_name)
Definition peak_dynamic_loader.h:1296
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelFormatNamespace)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_PIXEL_FORMAT_NAMESPACE *pixelFormatNamespace)
Definition peak_dynamic_loader.h:205
PEAK_C_API(* dyn_PEAK_System_GetCTIFileName)(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFileName, size_t *ctiFileNameSize)
Definition peak_dynamic_loader.h:75
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetParentLibrary)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:63
PEAK_C_API(* dyn_PEAK_DataStream_GetTLType)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:171
PEAK_C_API(* dyn_PEAK_Device_GetID)(PEAK_DEVICE_HANDLE deviceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:145
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetReleaseNotes)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, char *releaseNotes, size_t *releaseNotesSize)
Definition peak_dynamic_loader.h:429
PEAK_C_API(* dyn_PEAK_FloatNode_GetMaximum)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *maximum)
Definition peak_dynamic_loader.h:332
PEAK_C_API(* dyn_PEAK_BufferPart_GetXOffset)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xOffset)
Definition peak_dynamic_loader.h:249
PEAK_C_API(* dyn_PEAK_PortURL_GetURL)(PEAK_PORT_URL_HANDLE portUrlHandle, char *url, size_t *urlSize)
Definition peak_dynamic_loader.h:386
PEAK_C_API(* dyn_PEAK_Buffer_GetFileName)(PEAK_BUFFER_HANDLE bufferHandle, char *fileName, size_t *fileNameSize)
Definition peak_dynamic_loader.h:214
PEAK_C_API(* dyn_PEAK_Buffer_GetImageOffset)(PEAK_BUFFER_HANDLE bufferHandle, size_t *imageOffset)
Definition peak_dynamic_loader.h:210
PEAK_C_API(* dyn_PEAK_NodeMap_GetHasEventSupportedData)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle, PEAK_BOOL8 *hasSupportedData)
Definition peak_dynamic_loader.h:267
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntry)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:357
PEAK_C_API(* dyn_PEAK_Node_GetIsFeature)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isFeature)
Definition peak_dynamic_loader.h:291
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:310
PEAK_C_API(* dyn_PEAK_Node_GetSelectedNode)(PEAK_NODE_HANDLE nodeHandle, size_t index, PEAK_NODE_HANDLE *selectedNodeHandle)
Definition peak_dynamic_loader.h:306
PEAK_C_API(* dyn_PEAK_DataStream_GetIsGrabbing)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *isGrabbing)
Definition peak_dynamic_loader.h:183
PEAK_C_API(* dyn_PEAK_PortURL_GetParentPort)(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:397
PEAK_C_API(* dyn_PEAK_IntegerNode_SetValue)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t value)
Definition peak_dynamic_loader.h:321
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersDelivered)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, uint64_t *numBuffersDelivered)
Definition peak_dynamic_loader.h:176
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetVendorName)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:122
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_ToModuleDescriptor)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:118
PEAK_C_API(* dyn_PEAK_Node_GetAccessStatus)(PEAK_NODE_HANDLE nodeHandle, PEAK_NODE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:286
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetUserSetPersistence)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *userSetPersistence)
Definition peak_dynamic_loader.h:431
PEAK_C_API(* dyn_PEAK_Event_GetData)(PEAK_EVENT_HANDLE eventHandle, uint8_t *data, size_t *dataSize)
Definition peak_dynamic_loader.h:411
PEAK_C_API(* dyn_PEAK_System_GetGenTLVersionMajor)(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMajor)
Definition peak_dynamic_loader.h:77
PEAK_C_API(* dyn_PEAK_FloatNode_GetHasConstantIncrement)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_BOOL8 *hasConstantIncrement)
Definition peak_dynamic_loader.h:340
PEAK_C_API(* dyn_PEAK_Port_GetVersion)(PEAK_PORT_HANDLE portHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:373
PEAK_C_API(* dyn_PEAK_IntegerNode_GetRepresentation)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_REPRESENTATION *representation)
Definition peak_dynamic_loader.h:318
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:158
PEAK_C_API(* dyn_PEAK_NodeMap_UpdateEventNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_EVENT_HANDLE eventHandle)
Definition peak_dynamic_loader.h:268
PEAK_C_API(* dyn_PEAK_Module_GetNumNodeMaps)(PEAK_MODULE_HANDLE moduleHandle, size_t *numNodeMaps)
Definition peak_dynamic_loader.h:256
PEAK_C_API(* dyn_PEAK_Interface_ToEventSupportingModule)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:97
PEAK_C_API(* dyn_PEAK_Buffer_GetWidth)(PEAK_BUFFER_HANDLE bufferHandle, size_t *width)
Definition peak_dynamic_loader.h:215
PEAK_C_API(* dyn_PEAK_EventController_GetEventMaxSize)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *eventMaxSize)
Definition peak_dynamic_loader.h:402
PEAK_C_API(* dyn_PEAK_ProducerLibrary_GetSystem)(PEAK_PRODUCER_LIBRARY_HANDLE producerLibraryHandle, PEAK_SYSTEM_DESCRIPTOR_HANDLE *systemDescriptorHandle)
Definition peak_dynamic_loader.h:48
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:381
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:409
PEAK_C_API(* dyn_PEAK_Event_GetRawData)(PEAK_EVENT_HANDLE eventHandle, uint8_t *rawData, size_t *rawDataSize)
Definition peak_dynamic_loader.h:413
PEAK_C_API(* dyn_PEAK_ModuleDescriptor_GetID)(PEAK_MODULE_DESCRIPTOR_HANDLE moduleDescriptorHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:255
PEAK_C_API(* dyn_PEAK_RegisterNode_GetAddress)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, uint64_t *address)
Definition peak_dynamic_loader.h:348
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_OpenInterface)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:95
PEAK_C_API(* dyn_PEAK_Library_GetLastError)(PEAK_RETURN_CODE *lastErrorCode, char *lastErrorDescription, size_t *lastErrorDescriptionSize)
Definition peak_dynamic_loader.h:42
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:186
PEAK_C_API(* dyn_PEAK_DataStream_RevokeBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:188
PEAK_C_API(* dyn_PEAK_Buffer_GetChunk)(PEAK_BUFFER_HANDLE bufferHandle, size_t index, PEAK_BUFFER_CHUNK_HANDLE *bufferChunkHandle)
Definition peak_dynamic_loader.h:231
PEAK_C_API(* dyn_PEAK_Port_GetDataEndianness)(PEAK_PORT_HANDLE portHandle, PEAK_ENDIANNESS *dataEndianness)
Definition peak_dynamic_loader.h:376
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersAnnounced)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAnnounced)
Definition peak_dynamic_loader.h:173
PEAK_C_API(* dyn_PEAK_SystemDescriptor_OpenSystem)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:64
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSchemaVersionMajor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileSchemaVersionMajor)
Definition peak_dynamic_loader.h:395
PEAK_C_API(* dyn_PEAK_Library_Initialize)()
Definition peak_dynamic_loader.h:36
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceReconnectedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:110
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:140
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:441
PEAK_C_API(* dyn_PEAK_BufferChunk_Destruct)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle)
Definition peak_dynamic_loader.h:239
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetParentInterface)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_INTERFACE_HANDLE *interfaceHandle)
Definition peak_dynamic_loader.h:133
PEAK_C_API(* dyn_PEAK_BufferChunk_GetSize)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, size_t *size)
Definition peak_dynamic_loader.h:237
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:399
PEAK_C_API(* dyn_PEAK_BufferPart_GetSourceID)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *sourceId)
Definition peak_dynamic_loader.h:241
PEAK_C_API(* dyn_PEAK_DataStream_GetKey)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:168
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:442
PEAK_C_API(* dyn_PEAK_PortURL_GetScheme)(PEAK_PORT_URL_HANDLE portUrlHandle, PEAK_PORT_URL_SCHEME *scheme)
Definition peak_dynamic_loader.h:387
PEAK_C_API(* dyn_PEAK_FirmwareUpdateProgressObserver_Construct)(PEAK_FIRMWARE_UPDATE_PROGRESS_OBSERVER_HANDLE *firmwareUpdateProgressObserverHandle)
Definition peak_dynamic_loader.h:433
PEAK_C_API(* dyn_PEAK_Library_GetVersionSubminor)(uint32_t *libraryVersionSubminor)
Definition peak_dynamic_loader.h:41
PEAK_C_API(* dyn_PEAK_Buffer_GetNumParts)(PEAK_BUFFER_HANDLE bufferHandle, size_t *numParts)
Definition peak_dynamic_loader.h:233
PEAK_C_API(* dyn_PEAK_Node_ToCategoryNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_CATEGORY_NODE_HANDLE *categoryNodeHandle)
Definition peak_dynamic_loader.h:279
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceListChangedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:116
PEAK_C_API(* dyn_PEAK_CategoryNode_GetSubNode)(PEAK_CATEGORY_NODE_HANDLE categoryNodeHandle, size_t index, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:354
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetAccessStatus)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_DEVICE_ACCESS_STATUS *accessStatus)
Definition peak_dynamic_loader.h:128
PEAK_C_API(* dyn_PEAK_Device_ToModule)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:141
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetIsOpenableExclusive)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, PEAK_BOOL8 *isOpenable)
Definition peak_dynamic_loader.h:130
PEAK_C_API(* dyn_PEAK_EventController_GetNumEventsInQueue)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, size_t *numEventsInQueue)
Definition peak_dynamic_loader.h:400
PEAK_C_API(* dyn_PEAK_ProducerLibrary_Construct)(const char *ctiPath, size_t ctiPathSize, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:46
PEAK_C_API(* dyn_PEAK_Node_GetNumInvalidatingNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatingNodes)
Definition peak_dynamic_loader.h:302
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:323
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:440
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:444
PEAK_C_API(* dyn_PEAK_NodeMap_LoadFromFile)(PEAK_NODE_MAP_HANDLE nodeMapHandle, const char *filePath, size_t filePathSize)
Definition peak_dynamic_loader.h:270
PEAK_C_API(* dyn_PEAK_Buffer_GetXPadding)(PEAK_BUFFER_HANDLE bufferHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:219
PEAK_C_API(* dyn_PEAK_System_GetGenTLVersionMinor)(PEAK_SYSTEM_HANDLE systemHandle, uint32_t *gentlVersionMinor)
Definition peak_dynamic_loader.h:78
PEAK_C_API(* dyn_PEAK_System_GetCTIFullPath)(PEAK_SYSTEM_HANDLE systemHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:76
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetKey)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:51
PEAK_C_API(* dyn_PEAK_Device_ToEventSupportingModule)(PEAK_DEVICE_HANDLE deviceHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:142
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:301
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:439
PEAK_C_API(* dyn_PEAK_Port_GetIsWritable)(PEAK_PORT_HANDLE portHandle, PEAK_BOOL8 *isWritable)
Definition peak_dynamic_loader.h:378
PEAK_C_API(* dyn_PEAK_BufferPart_GetParentBuffer)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_HANDLE *bufferHandle)
Definition peak_dynamic_loader.h:253
PEAK_C_API(* dyn_PEAK_BufferPart_Destruct)(PEAK_BUFFER_PART_HANDLE bufferPartHandle)
Definition peak_dynamic_loader.h:254
PEAK_C_API(* dyn_PEAK_System_GetParentLibrary)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_PRODUCER_LIBRARY_HANDLE *producerLibraryHandle)
Definition peak_dynamic_loader.h:80
PEAK_C_API(* dyn_PEAK_CommandNode_GetIsDone)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle, PEAK_BOOL8 *isDone)
Definition peak_dynamic_loader.h:326
PEAK_C_API(* dyn_PEAK_DataStream_Destruct)(PEAK_DATA_STREAM_HANDLE dataStreamHandle)
Definition peak_dynamic_loader.h:195
PEAK_C_API(* dyn_PEAK_EventController_Destruct)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:408
PEAK_C_API(* dyn_PEAK_System_ToEventSupportingModule)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:66
PEAK_C_API(* dyn_PEAK_Port_GetName)(PEAK_PORT_HANDLE portHandle, char *name, size_t *nameSize)
Definition peak_dynamic_loader.h:370
PEAK_C_API(* dyn_PEAK_Device_GetKey)(PEAK_DEVICE_HANDLE deviceHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:143
PEAK_C_API(* dyn_PEAK_Node_GetIsAccessStatusCacheable)(PEAK_NODE_HANDLE nodeHandle, PEAK_BOOL8 *isAccessStatusCacheable)
Definition peak_dynamic_loader.h:288
PEAK_C_API(* dyn_PEAK_NodeMap_UpdateChunkNodes)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:266
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetKey)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *key, size_t *keySize)
Definition peak_dynamic_loader.h:119
PEAK_C_API(* dyn_PEAK_Library_IsInitialized)(PEAK_BOOL8 *isInitialized)
Definition peak_dynamic_loader.h:38
PEAK_C_API(* dyn_PEAK_Library_GetVersionMajor)(uint32_t *libraryVersionMajor)
Definition peak_dynamic_loader.h:39
PEAK_C_API(* dyn_PEAK_NodeMap_GetHasBufferSupportedChunks)(PEAK_NODE_MAP_HANDLE nodeMapHandle, PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasSupportedChunks)
Definition peak_dynamic_loader.h:265
PEAK_C_API(* dyn_PEAK_Node_GetToolTip)(PEAK_NODE_HANDLE nodeHandle, char *toolTip, size_t *toolTipSize)
Definition peak_dynamic_loader.h:294
PEAK_C_API(* dyn_PEAK_StringNode_GetMaximumLength)(PEAK_STRING_NODE_HANDLE stringNodeHandle, int64_t *maximumLength)
Definition peak_dynamic_loader.h:344
PEAK_C_API(* dyn_PEAK_BufferPart_GetFormat)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, uint64_t *format)
Definition peak_dynamic_loader.h:245
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:307
PEAK_C_API(* dyn_PEAK_System_UnregisterInterfaceLostCallback)(PEAK_SYSTEM_HANDLE systemHandle, PEAK_INTERFACE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:87
PEAK_C_API(* dyn_PEAK_CommandNode_Execute)(PEAK_COMMAND_NODE_HANDLE commandNodeHandle)
Definition peak_dynamic_loader.h:327
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceDisconnectedCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:112
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetDisplayName)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:53
PEAK_C_API(* dyn_PEAK_System_GetNumInterfaces)(PEAK_SYSTEM_HANDLE systemHandle, size_t *numInterfaces)
Definition peak_dynamic_loader.h:82
PEAK_C_API(* dyn_PEAK_Buffer_GetHasNewData)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasNewData)
Definition peak_dynamic_loader.h:226
PEAK_C_API(* dyn_PEAK_Interface_GetTLType)(PEAK_INTERFACE_HANDLE interfaceHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:102
PEAK_C_API(* dyn_PEAK_EventController_KillWait)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:406
PEAK_C_API(* dyn_PEAK_Interface_UnregisterDeviceLostCallback)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle)
Definition peak_dynamic_loader.h:114
PEAK_C_API(* dyn_PEAK_DataStream_QueueBuffer)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BUFFER_HANDLE bufferHandle)
Definition peak_dynamic_loader.h:187
PEAK_C_API(* dyn_PEAK_Buffer_GetPixelFormat)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *pixelFormat)
Definition peak_dynamic_loader.h:204
PEAK_C_API(* dyn_PEAK_Device_GetNumDataStreams)(PEAK_DEVICE_HANDLE deviceHandle, size_t *numDataStreams)
Definition peak_dynamic_loader.h:157
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:136
PEAK_C_API(* dyn_PEAK_FloatNode_GetValue)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_CACHE_USE_POLICY cacheUsePolicy, double *value)
Definition peak_dynamic_loader.h:341
PEAK_C_API(* dyn_PEAK_IntegerNode_ToNode)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:312
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_ToModuleDescriptor)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_MODULE_DESCRIPTOR_HANDLE *moduleDescriptorHandle)
Definition peak_dynamic_loader.h:162
PEAK_C_API(* dyn_PEAK_Device_GetSerialNumber)(PEAK_DEVICE_HANDLE deviceHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:152
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:193
PEAK_C_API(* dyn_PEAK_FloatNode_GetIncrement)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, double *increment)
Definition peak_dynamic_loader.h:333
PEAK_C_API(* dyn_PEAK_System_GetVendorName)(PEAK_SYSTEM_HANDLE systemHandle, char *vendorName, size_t *vendorNameSize)
Definition peak_dynamic_loader.h:71
PEAK_C_API(* dyn_PEAK_Port_GetTLType)(PEAK_PORT_HANDLE portHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:374
PEAK_C_API(* dyn_PEAK_BufferPart_GetType)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, PEAK_BUFFER_PART_TYPE *type)
Definition peak_dynamic_loader.h:244
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetVersion)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:56
PEAK_C_API(* dyn_PEAK_DataStreamDescriptor_OpenDataStream)(PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, PEAK_DATA_STREAM_HANDLE *dataStreamHandle)
Definition peak_dynamic_loader.h:165
PEAK_C_API(* dyn_PEAK_Interface_GetParentSystem)(PEAK_INTERFACE_HANDLE interfaceHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:103
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:434
PEAK_C_API(* dyn_PEAK_IntegerNode_GetIncrement)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *increment)
Definition peak_dynamic_loader.h:315
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:361
PEAK_C_API(* dyn_PEAK_Interface_GetID)(PEAK_INTERFACE_HANDLE interfaceHandle, char *id, size_t *idSize)
Definition peak_dynamic_loader.h:100
PEAK_C_API(* dyn_PEAK_IntegerNode_GetValidValues)(PEAK_INTEGER_NODE_HANDLE integerNodeHandle, int64_t *validValues, size_t *validValuesSize)
Definition peak_dynamic_loader.h:317
PEAK_C_API(* dyn_PEAK_FloatNode_GetUnit)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, char *unit, size_t *unitSize)
Definition peak_dynamic_loader.h:337
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:443
PEAK_C_API(* dyn_PEAK_Node_GetNumInvalidatedNodes)(PEAK_NODE_HANDLE nodeHandle, size_t *numInvalidatedNodes)
Definition peak_dynamic_loader.h:299
PEAK_C_API(* dyn_PEAK_Event_GetID)(PEAK_EVENT_HANDLE eventHandle, uint64_t *id)
Definition peak_dynamic_loader.h:410
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetSerialNumber)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, char *serialNumber, size_t *serialNumberSize)
Definition peak_dynamic_loader.h:127
PEAK_C_API(* dyn_PEAK_DataStream_GetDefinesPayloadSize)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_BOOL8 *definesPayloadSize)
Definition peak_dynamic_loader.h:182
PEAK_C_API(* dyn_PEAK_SystemDescriptor_GetCTIFullPath)(PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, char *ctiFullPath, size_t *ctiFullPathSize)
Definition peak_dynamic_loader.h:59
PEAK_C_API(* dyn_PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence)(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle, PEAK_FIRMWARE_UPDATE_PERSISTENCE *sequencerSetPersistence)
Definition peak_dynamic_loader.h:432
PEAK_C_API(* dyn_PEAK_Buffer_GetHasImage)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *hasImage)
Definition peak_dynamic_loader.h:227
PEAK_C_API(* dyn_PEAK_Buffer_GetTimestamp_ns)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ns)
Definition peak_dynamic_loader.h:222
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetParentSystem)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, PEAK_SYSTEM_HANDLE *systemHandle)
Definition peak_dynamic_loader.h:94
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:436
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSize)(PEAK_PORT_URL_HANDLE portUrlHandle, uint64_t *fileSize)
Definition peak_dynamic_loader.h:390
PEAK_C_API(* dyn_PEAK_System_GetTLType)(PEAK_SYSTEM_HANDLE systemHandle, char *tlType, size_t *tlTypeSize)
Definition peak_dynamic_loader.h:74
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:350
PEAK_C_API(* dyn_PEAK_Buffer_GetIsQueued)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isQueued)
Definition peak_dynamic_loader.h:223
PEAK_C_API(* dyn_PEAK_EventController_FlushEvents)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle)
Definition peak_dynamic_loader.h:407
PEAK_C_API(* dyn_PEAK_Device_GetVersion)(PEAK_DEVICE_HANDLE deviceHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:149
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_GetTimestampTickFrequency)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t *timestampTickFrequency)
Definition peak_dynamic_loader.h:129
PEAK_C_API(* dyn_PEAK_Buffer_GetTimestamp_ticks)(PEAK_BUFFER_HANDLE bufferHandle, uint64_t *timestamp_ticks)
Definition peak_dynamic_loader.h:221
PEAK_C_API(* dyn_PEAK_Buffer_ToModule)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:196
PEAK_C_API(* dyn_PEAK_DeviceDescriptor_SetMonitoringUpdateInterval)(PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, uint64_t monitoringUpdateInterval_ms)
Definition peak_dynamic_loader.h:135
PEAK_C_API(* dyn_PEAK_Buffer_ToEventSupportingModule)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_EVENT_SUPPORTING_MODULE_HANDLE *eventSupportingModuleHandle)
Definition peak_dynamic_loader.h:197
PEAK_C_API(* dyn_PEAK_BooleanNode_ToNode)(PEAK_BOOLEAN_NODE_HANDLE booleanNodeHandle, PEAK_NODE_HANDLE *nodeHandle)
Definition peak_dynamic_loader.h:322
PEAK_C_API(* dyn_PEAK_InterfaceDescriptor_GetDisplayName)(PEAK_INTERFACE_DESCRIPTOR_HANDLE interfaceDescriptorHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:92
PEAK_C_API(* dyn_PEAK_Node_ToEnumerationNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_NODE_HANDLE *enumerationNodeHandle)
Definition peak_dynamic_loader.h:280
PEAK_C_API(* dyn_PEAK_EventController_GetNumEventsFired)(PEAK_EVENT_CONTROLLER_HANDLE eventControllerHandle, uint64_t *numEventsFired)
Definition peak_dynamic_loader.h:401
PEAK_C_API(* dyn_PEAK_Node_ToEnumerationEntryNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_ENUMERATION_ENTRY_NODE_HANDLE *enumerationEntryNodeHandle)
Definition peak_dynamic_loader.h:281
PEAK_C_API(* dyn_PEAK_Buffer_GetIsIncomplete)(PEAK_BUFFER_HANDLE bufferHandle, PEAK_BOOL8 *isIncomplete)
Definition peak_dynamic_loader.h:225
PEAK_C_API(* dyn_PEAK_BufferPart_GetDeliveredImageHeight)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *deliveredImageHeight)
Definition peak_dynamic_loader.h:252
PEAK_C_API(* dyn_PEAK_Node_ToIntegerNode)(PEAK_NODE_HANDLE nodeHandle, PEAK_INTEGER_NODE_HANDLE *integerNodeHandle)
Definition peak_dynamic_loader.h:273
PEAK_C_API(* dyn_PEAK_Node_GetPollingTime)(PEAK_NODE_HANDLE nodeHandle, int64_t *pollingTime_ms)
Definition peak_dynamic_loader.h:293
PEAK_C_API(* dyn_PEAK_PortURL_GetFileSHA1Hash)(PEAK_PORT_URL_HANDLE portUrlHandle, uint8_t *fileSha1Hash, size_t *fileSha1HashSize)
Definition peak_dynamic_loader.h:391
PEAK_C_API(* dyn_PEAK_DataStream_GetNumBuffersAwaitDelivery)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, size_t *numBuffersAwaitDelivery)
Definition peak_dynamic_loader.h:175
PEAK_C_API(* dyn_PEAK_PortURL_GetFileVersionSubminor)(PEAK_PORT_URL_HANDLE portUrlHandle, int32_t *fileVersionSubminor)
Definition peak_dynamic_loader.h:394
PEAK_C_API(* dyn_PEAK_FloatNode_GetIncrementType)(PEAK_FLOAT_NODE_HANDLE floatNodeHandle, PEAK_NODE_INCREMENT_TYPE *incrementType)
Definition peak_dynamic_loader.h:334
PEAK_C_API(* dyn_PEAK_BufferPart_GetXPadding)(PEAK_BUFFER_PART_HANDLE bufferPartHandle, size_t *xPadding)
Definition peak_dynamic_loader.h:251
PEAK_C_API(* dyn_PEAK_Node_GetDisplayName)(PEAK_NODE_HANDLE nodeHandle, char *displayName, size_t *displayNameSize)
Definition peak_dynamic_loader.h:283
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:419
PEAK_C_API(* dyn_PEAK_RegisterNode_Write)(PEAK_REGISTER_NODE_HANDLE registerNodeHandle, const uint8_t *bytesToWrite, size_t bytesToWriteSize)
Definition peak_dynamic_loader.h:351
PEAK_C_API(* dyn_PEAK_DataStream_ToModule)(PEAK_DATA_STREAM_HANDLE dataStreamHandle, PEAK_MODULE_HANDLE *moduleHandle)
Definition peak_dynamic_loader.h:166
PEAK_C_API(* dyn_PEAK_Module_GetPort)(PEAK_MODULE_HANDLE moduleHandle, PEAK_PORT_HANDLE *portHandle)
Definition peak_dynamic_loader.h:258
PEAK_C_API(* dyn_PEAK_BufferChunk_GetBasePtr)(PEAK_BUFFER_CHUNK_HANDLE bufferChunkHandle, void **basePtr)
Definition peak_dynamic_loader.h:236
PEAK_C_API(* dyn_PEAK_Buffer_GetBasePtr)(PEAK_BUFFER_HANDLE bufferHandle, void **basePtr)
Definition peak_dynamic_loader.h:200
PEAK_C_API(* dyn_PEAK_EnumerationNode_SetCurrentEntryBySymbolicValue)(PEAK_ENUMERATION_NODE_HANDLE enumerationNodeHandle, const char *symbolicValue, size_t symbolicValueSize)
Definition peak_dynamic_loader.h:358
PEAK_C_API(* dyn_PEAK_System_GetVersion)(PEAK_SYSTEM_HANDLE systemHandle, char *version, size_t *versionSize)
Definition peak_dynamic_loader.h:73
PEAK_C_API(* dyn_PEAK_System_GetModelName)(PEAK_SYSTEM_HANDLE systemHandle, char *modelName, size_t *modelNameSize)
Definition peak_dynamic_loader.h:72
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:363
PEAK_C_API(* dyn_PEAK_Buffer_GetSize)(PEAK_BUFFER_HANDLE bufferHandle, size_t *size)
Definition peak_dynamic_loader.h:201
The "peak" namespace directly contains convenience functionality like the DeviceManager as well as th...
Definition peak_dynamic_loader.h:32
struct PEAK_DATA_STREAM * PEAK_DATA_STREAM_HANDLE
Definition peak_backend.h:383
void(PEAK_CALL_CONV * PEAK_DEVICE_DISCONNETED_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE disconnectedDevice, void *context)
Definition peak_backend.h:539
PEAK_INTERFACE_LOST_CALLBACK * PEAK_INTERFACE_LOST_CALLBACK_HANDLE
Definition peak_backend.h:493
struct PEAK_PORT_URL * PEAK_PORT_URL_HANDLE
Definition peak_backend.h:455
struct PEAK_SYSTEM_DESCRIPTOR * PEAK_SYSTEM_DESCRIPTOR_HANDLE
Definition peak_backend.h:351
struct PEAK_MODULE_DESCRIPTOR * PEAK_MODULE_DESCRIPTOR_HANDLE
Definition peak_backend.h:399
struct PEAK_EVENT * PEAK_EVENT_HANDLE
Definition peak_backend.h:467
struct PEAK_MODULE * PEAK_MODULE_HANDLE
Definition peak_backend.h:403
PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STARTED_CALLBACK_HANDLE
Definition peak_backend.h:574
void(PEAK_CALL_CONV * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK)(const PEAK_DEVICE_INFORMATION_ROLE *changedRoles, size_t changedRolesSize, void *context)
Definition peak_backend.h:563
struct PEAK_INTERFACE_DESCRIPTOR * PEAK_INTERFACE_DESCRIPTOR_HANDLE
Definition peak_backend.h:359
struct PEAK_DATA_STREAM_DESCRIPTOR * PEAK_DATA_STREAM_DESCRIPTOR_HANDLE
Definition peak_backend.h:379
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK)(void *context)
Definition peak_backend.h:592
PEAK_NODE_CHANGED_CALLBACK * PEAK_NODE_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:560
struct PEAK_PORT * PEAK_PORT_HANDLE
Definition peak_backend.h:451
int32_t PEAK_EVENT_TYPE
Definition peak_backend.h:168
struct PEAK_ENUMERATION_NODE * PEAK_ENUMERATION_NODE_HANDLE
Definition peak_backend.h:443
struct PEAK_COMMAND_NODE * PEAK_COMMAND_NODE_HANDLE
Definition peak_backend.h:423
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:431
struct PEAK_NODE * PEAK_NODE_HANDLE
Definition peak_backend.h:411
struct PEAK_BUFFER_CHUNK * PEAK_BUFFER_CHUNK_HANDLE
Definition peak_backend.h:391
struct PEAK_INTERFACE * PEAK_INTERFACE_HANDLE
Definition peak_backend.h:363
PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK * PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:567
PEAK_DEVICE_DISCONNETED_CALLBACK * PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE
Definition peak_backend.h:548
struct PEAK_PRODUCER_LIBRARY * PEAK_PRODUCER_LIBRARY_HANDLE
Definition peak_backend.h:347
struct PEAK_BUFFER * PEAK_BUFFER_HANDLE
Definition peak_backend.h:387
PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK * PEAK_FIRMWARE_UPDATE_FINISHED_CALLBACK_HANDLE
Definition peak_backend.h:594
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:555
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:479
int32_t PEAK_NODE_TYPE
Definition peak_backend.h:279
struct PEAK_EVENT_SUPPORTING_MODULE * PEAK_EVENT_SUPPORTING_MODULE_HANDLE
Definition peak_backend.h:459
int32_t PEAK_FIRMWARE_UPDATE_PERSISTENCE
Definition peak_backend.h:176
PEAK_DEVICE_LOST_CALLBACK * PEAK_DEVICE_LOST_CALLBACK_HANDLE
Definition peak_backend.h:550
#define PEAK_C_API
Definition peak_backend.h:602
struct PEAK_EVENT_CONTROLLER * PEAK_EVENT_CONTROLLER_HANDLE
Definition peak_backend.h:463
struct PEAK_REMOTE_DEVICE * PEAK_REMOTE_DEVICE_HANDLE
Definition peak_backend.h:375
PEAK_DEVICE_RECONNECTED_CALLBACK * PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE
Definition peak_backend.h:546
PEAK_DEVICE_FOUND_CALLBACK * PEAK_DEVICE_FOUND_CALLBACK_HANDLE
Definition peak_backend.h:544
struct PEAK_BUFFER_PART * PEAK_BUFFER_PART_HANDLE
Definition peak_backend.h:395
struct PEAK_SYSTEM * PEAK_SYSTEM_HANDLE
Definition peak_backend.h:355
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, double progressPercentage, void *context)
Definition peak_backend.h:581
PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_PROGRESS_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:585
void(PEAK_CALL_CONV * PEAK_NODE_CHANGED_CALLBACK)(PEAK_NODE_HANDLE changedNode, void *context)
Definition peak_backend.h:558
struct PEAK_FIRMWARE_UPDATE_INFORMATION * PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE
Definition peak_backend.h:475
struct PEAK_FLOAT_NODE * PEAK_FLOAT_NODE_HANDLE
Definition peak_backend.h:427
PEAK_DEVICE_LIST_CHANGED_CALLBACK * PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE
Definition peak_backend.h:552
int32_t PEAK_NODE_CACHE_USE_POLICY
Definition peak_backend.h:225
struct PEAK_FIRMWARE_UPDATER * PEAK_FIRMWARE_UPDATER_HANDLE
Definition peak_backend.h:471
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:599
int32_t PEAK_ENDIANNESS
Definition peak_backend.h:155
struct PEAK_NODE_MAP * PEAK_NODE_MAP_HANDLE
Definition peak_backend.h:407
int32_t PEAK_RETURN_CODE
Definition peak_backend.h:337
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:447
void(PEAK_CALL_CONV * PEAK_DEVICE_LIST_CHANGED_CALLBACK)(void *context)
Definition peak_backend.h:542
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:533
void(PEAK_CALL_CONV * PEAK_DEVICE_FOUND_CALLBACK)(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void *context)
Definition peak_backend.h:530
struct PEAK_CATEGORY_NODE * PEAK_CATEGORY_NODE_HANDLE
Definition peak_backend.h:439
struct PEAK_REGISTER_NODE * PEAK_REGISTER_NODE_HANDLE
Definition peak_backend.h:435
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:486
PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK_HANDLE
Definition peak_backend.h:579
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:587
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:570
struct PEAK_DEVICE_DESCRIPTOR * PEAK_DEVICE_DESCRIPTOR_HANDLE
Definition peak_backend.h:367
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:483
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_FAILED_CALLBACK)(const char *errorDescription, size_t errorDescriptionSize, void *context)
Definition peak_backend.h:596
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:536
struct PEAK_BOOLEAN_NODE * PEAK_BOOLEAN_NODE_HANDLE
Definition peak_backend.h:419
struct PEAK_INTEGER_NODE * PEAK_INTEGER_NODE_HANDLE
Definition peak_backend.h:415
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:590
void(PEAK_CALL_CONV * PEAK_FIRMWARE_UPDATE_STEP_STARTED_CALLBACK)(PEAK_FIRMWARE_UPDATE_STEP updateStep, uint32_t estimatedDuration_ms, const char *description, size_t descriptionSize, void *context)
Definition peak_backend.h:576
struct PEAK_DEVICE * PEAK_DEVICE_HANDLE
Definition peak_backend.h:371
PEAK_INTERFACE_FOUND_CALLBACK * PEAK_INTERFACE_FOUND_CALLBACK_HANDLE
Definition peak_backend.h:491
int32_t PEAK_DEVICE_ACCESS_STATUS
Definition peak_backend.h:117
