peak_interface.hpp

Go to the documentation of this file.

 
#pragma once
 
 
#include <peak/backend/peak_backend.h>
#include <peak/common/peak_common_structs.hpp>
#include <peak/common/peak_event_supporting_module.hpp>
#include <peak/device/peak_device_descriptor.hpp>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
#include <peak/generic/peak_t_callback_manager.hpp>
#include <peak/reconnect/reconnect_information.hpp>
 
#include <unordered_map>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
 
namespace peak
{
namespace core
{
 
class System;
 
struct DeviceFoundCallbackContainer;
 
class Interface
    : public EventSupportingModule
    , public std::enable_shared_from_this<Interface>
{
public:
    using DeviceFoundCallback = std::function<void(const std::shared_ptr<DeviceDescriptor>& foundDevice)>;
    using DeviceFoundCallbackHandle = DeviceFoundCallback*;
    using DeviceDisconnectedCallback = std::function<void(const std::shared_ptr<DeviceDescriptor>& disconnectedDevice)>;
    using DeviceDisconnectedCallbackHandle = DeviceDisconnectedCallback*;
    using DeviceReconnectedCallback = std::function<void(
        const std::shared_ptr<DeviceDescriptor>& reconnectedDevice, DeviceReconnectInformation reconnectInformation)>;
    using DeviceReconnectedCallbackHandle = DeviceReconnectedCallback*;
    using DeviceLostCallback = std::function<void(const std::string& lostDeviceId)>;
    using DeviceLostCallbackHandle = DeviceLostCallback*;
    using DeviceListChangedCallback = std::function<void()>;
    using DeviceListChangedCallbackHandle = DeviceListChangedCallback*;
 
    Interface() = delete;
    ~Interface() override;
    Interface(const Interface& other) = delete;
    Interface& operator=(const Interface& other) = delete;
    Interface(Interface&& other) = delete;
    Interface& operator=(Interface&& other) = delete;
 
    std::string Key() const;
 
    RawInformation Info(int32_t infoCommand) const;
    std::string ID() const;
    std::string DisplayName() const;
    std::string TLType() const;
 
    void UpdateDevices(Timeout timeout_ms);
 
    std::vector<std::shared_ptr<DeviceDescriptor>> Devices() const;
 
    std::shared_ptr<System> ParentSystem() const;
 
    DeviceFoundCallbackHandle RegisterDeviceFoundCallback(const DeviceFoundCallback& callback);
 
    void UnregisterDeviceFoundCallback(DeviceFoundCallbackHandle callbackHandle);
 
    DeviceLostCallbackHandle RegisterDeviceLostCallback(const DeviceLostCallback& callback);
 
    void UnregisterDeviceLostCallback(DeviceLostCallbackHandle callbackHandle);
 
    DeviceReconnectedCallbackHandle RegisterDeviceReconnectedCallback(const DeviceReconnectedCallback& callback);
 
    void UnregisterDeviceReconnectedCallback(DeviceReconnectedCallbackHandle callbackHandle);
 
    DeviceDisconnectedCallbackHandle RegisterDeviceDisconnectedCallback(const DeviceDisconnectedCallback& callback);
 
    void UnregisterDeviceDisconnectedCallback(DeviceDisconnectedCallbackHandle callbackHandle);
 
    DeviceListChangedCallbackHandle RegisterDeviceListChangedCallback(const DeviceListChangedCallback& callback);
 
    void UnregisterDeviceListChangedCallback(DeviceListChangedCallbackHandle callbackHandle);
 
private:
    struct DeviceFoundCallbackContainer
    {
        std::weak_ptr<Interface> _Interface;
        Interface::DeviceFoundCallback Callback;
    };
    struct DeviceDisconnectedCallbackContainer
    {
        std::weak_ptr<Interface> _Interface;
        Interface::DeviceDisconnectedCallback Callback;
    };
    struct DeviceReconnectedCallbackContainer
    {
        std::weak_ptr<Interface> _Interface;
        Interface::DeviceReconnectedCallback Callback;
    };
    static void PEAK_CALL_CONV DeviceFoundCallbackCWrapper(
        PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void* context);
    static void PEAK_CALL_CONV DeviceLostCallbackCWrapper(
        const char* lostDeviceId, size_t lostDeviceIdSize, void* context);
    static void PEAK_CALL_CONV DeviceDisconnectedCallbackCWrapper(
        PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void* context);
    static void PEAK_CALL_CONV DeviceReconnectedCallbackCWrapper(PEAK_DEVICE_DESCRIPTOR_HANDLE reconnectedDevice,
        PEAK_DEVICE_RECONNECT_INFORMATION reconnectInformation, void* context);
    static void PEAK_CALL_CONV DeviceListChangedCallbackCWrapper(void* context);
 
    std::shared_ptr<DeviceDescriptor> GetOrAddFoundDevice(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice);
 
    PEAK_MODULE_HANDLE ModuleHandle() const override;
    PEAK_EVENT_SUPPORTING_MODULE_HANDLE EventSupportingModuleHandle() const override;
 
    void InitializeUpdateMechanismIfNecessary();
 
    friend ClassCreator<Interface>;
    Interface(PEAK_INTERFACE_HANDLE interfaceHandle, const std::weak_ptr<System>& parentSystem);
    PEAK_INTERFACE_HANDLE m_backendHandle;
 
    std::weak_ptr<System> m_parentSystem;
 
    std::unique_ptr<TCallbackManager<PEAK_DEVICE_FOUND_CALLBACK_HANDLE, DeviceFoundCallbackContainer>>
        m_deviceFoundCallbackManager;
    std::unique_ptr<TCallbackManager<PEAK_DEVICE_LOST_CALLBACK_HANDLE, DeviceLostCallback>>
        m_deviceLostCallbackManager;
 
    std::unique_ptr<TCallbackManager<PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE, DeviceDisconnectedCallbackContainer>>
        m_deviceDisconnectedCallbackManager;
    std::unique_ptr<TCallbackManager<PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE, DeviceReconnectedCallbackContainer>>
        m_deviceReconnectedCallbackManager;
 
    std::unique_ptr<TCallbackManager<PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE, DeviceListChangedCallback>>
        m_deviceListChangedCallbackManager;
 
    std::vector<std::shared_ptr<DeviceDescriptor>> m_devices;
    std::unordered_map<std::string, std::shared_ptr<DeviceDescriptor>> m_devicesByKey;
    std::unordered_map<std::string, std::string> m_devicesKeyById;
    mutable std::mutex m_devicesMutex;
    std::once_flag m_updateMechanismInitializedFlag;
 
    std::string m_key;
};
 
} /* namespace core */
} /* namespace peak */
 
/* Implementation */
namespace peak
{
namespace core
{
 
inline Interface::Interface(PEAK_INTERFACE_HANDLE interfaceHandle, const std::weak_ptr<System>& parentSystem)
    : m_backendHandle(interfaceHandle)
    , m_parentSystem(parentSystem)
    , m_key(QueryStringFromCInterfaceFunction([&](char* key, size_t* keySize) {
        return PEAK_C_ABI_PREFIX PEAK_Interface_GetKey(interfaceHandle, key, keySize);
    }))
{
    m_deviceFoundCallbackManager =
        std::make_unique<TCallbackManager<PEAK_DEVICE_FOUND_CALLBACK_HANDLE, DeviceFoundCallbackContainer>>(
            [&](void* callbackContext) {
                return QueryNumericFromCInterfaceFunction<PEAK_DEVICE_FOUND_CALLBACK_HANDLE>(
                    [&](PEAK_DEVICE_FOUND_CALLBACK_HANDLE* deviceFoundCallbackHandle) {
                        return PEAK_C_ABI_PREFIX PEAK_Interface_RegisterDeviceFoundCallback(
                            m_backendHandle, DeviceFoundCallbackCWrapper, callbackContext, deviceFoundCallbackHandle);
                    });
            },
            [&](PEAK_DEVICE_FOUND_CALLBACK_HANDLE callbackHandle) {
                CallAndCheckCInterfaceFunction([&] {
                    return PEAK_C_ABI_PREFIX PEAK_Interface_UnregisterDeviceFoundCallback(
                        m_backendHandle, callbackHandle);
                });
            });
 
    m_deviceLostCallbackManager =
        std::make_unique<TCallbackManager<PEAK_DEVICE_LOST_CALLBACK_HANDLE, DeviceLostCallback>>(
            [&](void* callbackContext) {
                return QueryNumericFromCInterfaceFunction<PEAK_DEVICE_LOST_CALLBACK_HANDLE>(
                    [&](PEAK_DEVICE_LOST_CALLBACK_HANDLE* deviceLostCallbackHandle) {
                        return PEAK_C_ABI_PREFIX PEAK_Interface_RegisterDeviceLostCallback(
                            m_backendHandle, DeviceLostCallbackCWrapper, callbackContext, deviceLostCallbackHandle);
                    });
            },
            [&](PEAK_DEVICE_LOST_CALLBACK_HANDLE callbackHandle) {
                CallAndCheckCInterfaceFunction([&] {
                    return PEAK_C_ABI_PREFIX PEAK_Interface_UnregisterDeviceLostCallback(
                        m_backendHandle, callbackHandle);
                });
            });
 
    m_deviceDisconnectedCallbackManager = std::make_unique<
        TCallbackManager<PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE, DeviceDisconnectedCallbackContainer>>(
        [&](void* callbackContext) {
            return QueryNumericFromCInterfaceFunction<PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE>(
                [&](PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE* deviceDisconnectedCallbackHandle) {
                    return PEAK_C_ABI_PREFIX PEAK_Interface_RegisterDeviceDisconnectedCallback(m_backendHandle,
                        DeviceDisconnectedCallbackCWrapper, callbackContext, deviceDisconnectedCallbackHandle);
                });
        },
        [&](PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE callbackHandle) {
            CallAndCheckCInterfaceFunction([&] {
                return PEAK_C_ABI_PREFIX PEAK_Interface_UnregisterDeviceDisconnectedCallback(
                    m_backendHandle, callbackHandle);
            });
        });
 
    m_deviceReconnectedCallbackManager = std::make_unique<
        TCallbackManager<PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE, DeviceReconnectedCallbackContainer>>(
        [&](void* callbackContext) {
            return QueryNumericFromCInterfaceFunction<PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE>(
                [&](PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE* deviceReconnectedCallbackHandle) {
                    return PEAK_C_ABI_PREFIX PEAK_Interface_RegisterDeviceReconnectedCallback(m_backendHandle,
                        DeviceReconnectedCallbackCWrapper, callbackContext, deviceReconnectedCallbackHandle);
                });
        },
        [&](PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE callbackHandle) {
            CallAndCheckCInterfaceFunction([&] {
                return PEAK_C_ABI_PREFIX PEAK_Interface_UnregisterDeviceReconnectedCallback(
                    m_backendHandle, callbackHandle);
            });
        });
 
    m_deviceListChangedCallbackManager =
        std::make_unique<TCallbackManager<PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE, DeviceListChangedCallback>>(
            [&](void* callbackContext) {
                return QueryNumericFromCInterfaceFunction<PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE>(
                    [&](PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE* deviceListChangedCallbackHandle) {
                        return PEAK_C_ABI_PREFIX PEAK_Interface_RegisterDeviceListChangedCallback(m_backendHandle,
                            DeviceListChangedCallbackCWrapper, callbackContext, deviceListChangedCallbackHandle);
                    });
            },
            [&](PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE callbackHandle) {
                CallAndCheckCInterfaceFunction([&] {
                    return PEAK_C_ABI_PREFIX PEAK_Interface_UnregisterDeviceListChangedCallback(
                        m_backendHandle, callbackHandle);
                });
            });
}
 
inline Interface::~Interface()
{
    try
    {
        m_deviceFoundCallbackManager->UnregisterAllCallbacks();
        m_deviceLostCallbackManager->UnregisterAllCallbacks();
 
        m_deviceDisconnectedCallbackManager->UnregisterAllCallbacks();
        m_deviceReconnectedCallbackManager->UnregisterAllCallbacks();
 
        m_deviceListChangedCallbackManager->UnregisterAllCallbacks();
    }
    catch (const Exception&)
    {}
 
    (void)PEAK_C_ABI_PREFIX PEAK_Interface_Destruct(m_backendHandle);
}
 
inline std::string Interface::Key() const
{
    return m_key;
}
 
inline RawInformation Interface::Info(int32_t infoCommand) const
{
    return QueryRawInformationFromCInterfaceFunction([&](int32_t* dataType, uint8_t* buffer, size_t* bufferSize) {
        return PEAK_C_ABI_PREFIX PEAK_Interface_GetInfo(
            m_backendHandle, infoCommand, dataType, buffer, bufferSize);
    });
}
 
inline std::string Interface::ID() const
{
    return QueryStringFromCInterfaceFunction([&](char* id, size_t* idSize) {
        return PEAK_C_ABI_PREFIX PEAK_Interface_GetID(m_backendHandle, id, idSize);
    });
}
 
inline std::string Interface::DisplayName() const
{
    return QueryStringFromCInterfaceFunction([&](char* displayName, size_t* displayNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_Interface_GetDisplayName(m_backendHandle, displayName, displayNameSize);
    });
}
 
inline std::string Interface::TLType() const
{
    return QueryStringFromCInterfaceFunction([&](char* tlType, size_t* tlTypeSize) {
        return PEAK_C_ABI_PREFIX PEAK_Interface_GetTLType(m_backendHandle, tlType, tlTypeSize);
    });
}
 
inline void Interface::UpdateDevices(Timeout timeout_ms)
{
    InitializeUpdateMechanismIfNecessary();
 
    CallAndCheckCInterfaceFunction(
        [&] { return PEAK_C_ABI_PREFIX PEAK_Interface_UpdateDevices(m_backendHandle, timeout_ms); });
}
 
inline std::vector<std::shared_ptr<DeviceDescriptor>> Interface::Devices() const
{
    std::lock_guard<std::mutex> lock(m_devicesMutex);
    return m_devices;
}
 
inline std::shared_ptr<System> Interface::ParentSystem() const
{
    return LockOrThrow(m_parentSystem);
}
 
inline Interface::DeviceFoundCallbackHandle Interface::RegisterDeviceFoundCallback(
    const Interface::DeviceFoundCallback& callback)
{
    return reinterpret_cast<DeviceFoundCallbackHandle>(
        m_deviceFoundCallbackManager->RegisterCallback(DeviceFoundCallbackContainer{ shared_from_this(), callback }));
}
 
inline void Interface::UnregisterDeviceFoundCallback(Interface::DeviceFoundCallbackHandle callbackHandle)
{
    m_deviceFoundCallbackManager->UnregisterCallback(
        reinterpret_cast<PEAK_DEVICE_FOUND_CALLBACK_HANDLE>(callbackHandle));
}
 
inline Interface::DeviceReconnectedCallbackHandle Interface::RegisterDeviceReconnectedCallback(
    const DeviceReconnectedCallback& callback)
{
    return reinterpret_cast<DeviceReconnectedCallbackHandle>(m_deviceReconnectedCallbackManager->RegisterCallback(
        DeviceReconnectedCallbackContainer{ shared_from_this(), callback }));
}
 
inline void Interface::UnregisterDeviceReconnectedCallback(DeviceReconnectedCallbackHandle callbackHandle)
{
    m_deviceReconnectedCallbackManager->UnregisterCallback(
        reinterpret_cast<PEAK_DEVICE_RECONNECTED_CALLBACK_HANDLE>(callbackHandle));
}
 
inline Interface::DeviceDisconnectedCallbackHandle Interface::RegisterDeviceDisconnectedCallback(
    const DeviceDisconnectedCallback& callback)
{
    return reinterpret_cast<DeviceDisconnectedCallbackHandle>(m_deviceDisconnectedCallbackManager->RegisterCallback(
        DeviceDisconnectedCallbackContainer{ shared_from_this(), callback }));
}
 
inline void Interface::UnregisterDeviceDisconnectedCallback(DeviceDisconnectedCallbackHandle callbackHandle)
{
    m_deviceDisconnectedCallbackManager->UnregisterCallback(
        reinterpret_cast<PEAK_DEVICE_DISCONNECTED_CALLBACK_HANDLE>(callbackHandle));
}
 
inline Interface::DeviceLostCallbackHandle Interface::RegisterDeviceLostCallback(
    const Interface::DeviceLostCallback& callback)
{
    return reinterpret_cast<DeviceLostCallbackHandle>(m_deviceLostCallbackManager->RegisterCallback(callback));
}
 
inline void Interface::UnregisterDeviceLostCallback(Interface::DeviceLostCallbackHandle callbackHandle)
{
    m_deviceLostCallbackManager->UnregisterCallback(
        reinterpret_cast<PEAK_DEVICE_LOST_CALLBACK_HANDLE>(callbackHandle));
}
 
inline Interface::DeviceListChangedCallbackHandle Interface::RegisterDeviceListChangedCallback(
    const Interface::DeviceListChangedCallback& callback)
{
    return reinterpret_cast<DeviceListChangedCallbackHandle>(m_deviceListChangedCallbackManager->RegisterCallback(callback));
}
 
inline void Interface::UnregisterDeviceListChangedCallback(Interface::DeviceListChangedCallbackHandle callbackHandle)
{
    m_deviceListChangedCallbackManager->UnregisterCallback(
        reinterpret_cast<PEAK_DEVICE_LIST_CHANGED_CALLBACK_HANDLE>(callbackHandle));
}
 
inline void PEAK_CALL_CONV Interface::DeviceFoundCallbackCWrapper(
    PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void* context)
{
    auto callbackContainer = static_cast<DeviceFoundCallbackContainer*>(context);
 
    auto interfaceDescriptor = callbackContainer->_Interface.lock()->GetOrAddFoundDevice(foundDevice);
 
    callbackContainer->Callback(interfaceDescriptor);
}
 
inline void PEAK_CALL_CONV Interface::DeviceLostCallbackCWrapper(
    const char* lostDeviceId, size_t lostDeviceIdSize, void* context)
{
    auto callback = static_cast<Interface::DeviceLostCallback*>(context);
 
    callback->operator()(std::string(lostDeviceId, lostDeviceIdSize - 1));
}
 
inline void PEAK_CALL_CONV Interface::DeviceDisconnectedCallbackCWrapper(
    PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice, void* context)
{
    auto callbackContainer = static_cast<DeviceDisconnectedCallbackContainer*>(context);
 
    auto deviceDescriptor = callbackContainer->_Interface.lock()->GetOrAddFoundDevice(foundDevice);
 
    callbackContainer->Callback(deviceDescriptor);
}
 
inline void PEAK_CALL_CONV Interface::DeviceReconnectedCallbackCWrapper(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice,
    PEAK_DEVICE_RECONNECT_INFORMATION reconnectInformation, void* context)
{
    auto callbackContainer = static_cast<DeviceReconnectedCallbackContainer*>(context);
 
    auto deviceDescriptor = callbackContainer->_Interface.lock()->GetOrAddFoundDevice(foundDevice);
 
    callbackContainer->Callback(deviceDescriptor, DeviceReconnectInformation(std::move(reconnectInformation)));
}
 
inline void PEAK_CALL_CONV Interface::DeviceListChangedCallbackCWrapper(void* context)
{
    auto callback = static_cast<Interface::DeviceListChangedCallback*>(context);
    callback->operator()();
}
 
inline std::shared_ptr<DeviceDescriptor> Interface::GetOrAddFoundDevice(PEAK_DEVICE_DESCRIPTOR_HANDLE foundDevice)
{
    std::lock_guard<std::mutex> lock(m_devicesMutex);
 
    const auto deviceKey = QueryStringFromCInterfaceFunction([&](char* key, size_t* keySize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetKey(foundDevice, key, keySize);
    });
    auto keyDevicePairIterator = m_devicesByKey.find(deviceKey);
    if (keyDevicePairIterator == m_devicesByKey.end())
    {
        auto deviceDescriptor = std::static_pointer_cast<DeviceDescriptor>(
            std::make_shared<ClassCreator<DeviceDescriptor>>(
                foundDevice, std::weak_ptr<Interface>{ shared_from_this() }));
        m_devices.emplace_back(deviceDescriptor);
        m_devicesByKey.emplace(deviceKey, deviceDescriptor);
        m_devicesKeyById.emplace(deviceDescriptor->ID(), deviceKey);
 
        return deviceDescriptor;
    }
 
    return keyDevicePairIterator->second;
}
 
inline PEAK_MODULE_HANDLE Interface::ModuleHandle() const
{
    auto moduleHandle = QueryNumericFromCInterfaceFunction<PEAK_MODULE_HANDLE>(
        [&](PEAK_MODULE_HANDLE* _moduleHandle) {
            return PEAK_C_ABI_PREFIX PEAK_Interface_ToModule(m_backendHandle, _moduleHandle);
        });
 
    return moduleHandle;
}
 
inline PEAK_EVENT_SUPPORTING_MODULE_HANDLE Interface::EventSupportingModuleHandle() const
{
    auto eventSupportingModuleHandle = QueryNumericFromCInterfaceFunction<PEAK_EVENT_SUPPORTING_MODULE_HANDLE>(
        [&](PEAK_EVENT_SUPPORTING_MODULE_HANDLE* _eventSupportingModuleHandle) {
            return PEAK_C_ABI_PREFIX PEAK_Interface_ToEventSupportingModule(
                m_backendHandle, _eventSupportingModuleHandle);
        });
 
    return eventSupportingModuleHandle;
}
 
inline void Interface::InitializeUpdateMechanismIfNecessary()
{
    std::call_once(m_updateMechanismInitializedFlag, [&] {
        (void)RegisterDeviceFoundCallback([](const std::shared_ptr<DeviceDescriptor>&) {
            // Registering an empty callback is enough since DeviceFoundCallbackCWrapper() handles everything else.
        });
 
        (void)RegisterDeviceLostCallback([&](const std::string& lostDeviceId) {
            {
                std::lock_guard<std::mutex> lock(m_devicesMutex);
                const auto lostDeviceKey = m_devicesKeyById.at(lostDeviceId);
                m_devices.erase(std::remove_if(std::begin(m_devices), std::end(m_devices),
                                    [lostDeviceKey](const std::shared_ptr<DeviceDescriptor>& device) {
                                        return device->Key() == lostDeviceKey;
                                    }),
                    std::end(m_devices));
                m_devicesByKey.erase(lostDeviceKey);
                m_devicesKeyById.erase(lostDeviceId);
            }
        });
    });
}
 
} /* namespace core */
} /* namespace peak */