peak_device_descriptor.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_module_descriptor.hpp>
#include <peak/device/peak_common_device_enums.hpp>
#include <peak/device/peak_device.hpp>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
#include <peak/generic/peak_t_callback_manager.hpp>

#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>


namespace peak
{
namespace core
{

enum class DeviceAccessType
{
    ReadOnly = 2,
    Control,
    Exclusive,

    Custom = 1000
};

enum class DeviceInformationRole
{
    ID = 0,
    VendorName,
    ModelName,
    TLType,
    DisplayName,
    AccessStatus,
    UserDefinedName,
    SerialNumber,
    Version,
    TimestampTickFrequency,

    Custom = 1000
};

class Interface;

class DeviceDescriptor : public ModuleDescriptor
{
public:
    using InformationChangedCallback = std::function<void(const std::vector<DeviceInformationRole>& changedRoles)>;
    using InformationChangedCallbackHandle = InformationChangedCallback*;
    using DeviceOpenedCallback = std::function<void(const std::shared_ptr<core::Device>& openedDevice)>;
    using DeviceOpenedCallbackHandle = DeviceOpenedCallback*;

    DeviceDescriptor() = delete;
    ~DeviceDescriptor() override;
    DeviceDescriptor(const DeviceDescriptor& other) = delete;
    DeviceDescriptor& operator=(const DeviceDescriptor& other) = delete;
    DeviceDescriptor(DeviceDescriptor&& other) = delete;
    DeviceDescriptor& operator=(DeviceDescriptor&& other) = delete;

    std::string Key() const;

    RawInformation Info(int32_t infoCommand) const;

    std::string DisplayName() const;

    std::string VendorName() const;

    std::string ModelName() const;

    std::string Version() const;

    std::string TLType() const;

    std::string UserDefinedName() const;

    std::string SerialNumber() const;

    DeviceAccessStatus AccessStatus() const;

    uint64_t TimestampTickFrequency() const;

    std::shared_ptr<Interface> ParentInterface() const;


    bool IsOpenable(DeviceAccessType accessType = DeviceAccessType::Exclusive) const;

    std::shared_ptr<Device> OpenDevice(DeviceAccessType accessType);

    std::shared_ptr<Device> OpenedDevice() const;

    DeviceOpenedCallbackHandle RegisterDeviceOpenedCallback(const DeviceOpenedCallback& callback);

    void UnregisterDeviceOpenedCallback(DeviceOpenedCallbackHandle callbackHandle);



    uint64_t MonitoringUpdateInterval() const;

    void SetMonitoringUpdateInterval(uint64_t monitoringUpdateInterval_ms);

    bool IsInformationRoleMonitored(DeviceInformationRole informationRole) const;

    void AddInformationRoleToMonitoring(DeviceInformationRole informationRole);

    void RemoveInformationRoleFromMonitoring(DeviceInformationRole informationRole);

    InformationChangedCallbackHandle RegisterInformationChangedCallback(const InformationChangedCallback& callback);

    void UnregisterInformationChangedCallback(InformationChangedCallbackHandle callbackHandle);


private:
    static void PEAK_CALL_CONV InformationChangedCallbackCWrapper(
        const PEAK_DEVICE_INFORMATION_ROLE* changedRoles, size_t changedRolesSize, void* context);

    friend ClassCreator<DeviceDescriptor>;
    DeviceDescriptor(
        PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, const std::weak_ptr<Interface>& parentInterface);
    PEAK_MODULE_DESCRIPTOR_HANDLE ModuleDescriptorHandle() const override;

    PEAK_DEVICE_DESCRIPTOR_HANDLE m_backendHandle;

    std::weak_ptr<Interface> m_parentInterface;
    std::weak_ptr<Device> m_openedDevice;

    std::unique_ptr<
        TCallbackManager<PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE, InformationChangedCallback>>
        m_informationChangedCallbackManager;

    TTriggerCallbackManager<DeviceOpenedCallbackHandle, DeviceOpenedCallback> m_deviceOpenedCallbackManager;

    std::string m_key;

    friend class FirmwareUpdater;
};

} /* namespace core */
} /* namespace peak */

/* Implementation */
namespace peak
{
namespace core
{

inline std::string ToString(DeviceAccessType entry)
{
    std::string entryString;

    if (entry == DeviceAccessType::ReadOnly)
    {
        entryString = "ReadOnly";
    }
    else if (entry == DeviceAccessType::Control)
    {
        entryString = "Control";
    }
    else if (entry == DeviceAccessType::Exclusive)
    {
        entryString = "Exclusive";
    }
    else if (entry >= DeviceAccessType::Custom)
    {
        entryString = "Custom";
    }

    return entryString;
}

inline std::string ToString(DeviceInformationRole entry)
{
    std::string entryString;

    if (entry == DeviceInformationRole::ID)
    {
        entryString = "ID";
    }
    else if (entry == DeviceInformationRole::VendorName)
    {
        entryString = "VendorName";
    }
    else if (entry == DeviceInformationRole::ModelName)
    {
        entryString = "ModelName";
    }
    else if (entry == DeviceInformationRole::TLType)
    {
        entryString = "TLType";
    }
    else if (entry == DeviceInformationRole::DisplayName)
    {
        entryString = "DisplayName";
    }
    else if (entry == DeviceInformationRole::AccessStatus)
    {
        entryString = "AccessStatus";
    }
    else if (entry == DeviceInformationRole::UserDefinedName)
    {
        entryString = "UserDefinedName";
    }
    else if (entry == DeviceInformationRole::SerialNumber)
    {
        entryString = "SerialNumber";
    }
    else if (entry == DeviceInformationRole::Version)
    {
        entryString = "Version";
    }
    else if (entry == DeviceInformationRole::TimestampTickFrequency)
    {
        entryString = "TimestampTickFrequency";
    }
    else if (entry >= DeviceInformationRole::Custom)
    {
        entryString = "Custom";
    }

    return entryString;
}

inline DeviceDescriptor::DeviceDescriptor(
    PEAK_DEVICE_DESCRIPTOR_HANDLE deviceDescriptorHandle, const std::weak_ptr<Interface>& parentInterface)
    : m_backendHandle(deviceDescriptorHandle)
    , m_parentInterface(parentInterface)
    , m_informationChangedCallbackManager()
    , m_key(QueryStringFromCInterfaceFunction([&](char* key, size_t* keySize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetKey(deviceDescriptorHandle, key, keySize);
    }))
{
    m_informationChangedCallbackManager = std::make_unique<
        TCallbackManager<PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE, InformationChangedCallback>>(
        [&](void* callbackContext) {
            return QueryNumericFromCInterfaceFunction<PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE>(
                [&](PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE*
                        deviceDescriptorChangedCallbackHandle) {
                    return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_RegisterInformationChangedCallback(
                        m_backendHandle, InformationChangedCallbackCWrapper, callbackContext,
                        deviceDescriptorChangedCallbackHandle);
                });
        },
        [&](PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE callbackHandle) {
            CallAndCheckCInterfaceFunction([&] {
                return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_UnregisterInformationChangedCallback(
                    m_backendHandle, callbackHandle);
            });
        });
}

inline DeviceDescriptor::~DeviceDescriptor()
{
    try
    {
        m_informationChangedCallbackManager->UnregisterAllCallbacks();
    }
    catch (const Exception&)
    {}
}

inline std::string DeviceDescriptor::Key() const
{
    return m_key;
}

inline RawInformation DeviceDescriptor::Info(int32_t infoCommand) const
{
    return QueryRawInformationFromCInterfaceFunction([&](int32_t* dataType, uint8_t* buffer, size_t* bufferSize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetInfo(
            m_backendHandle, infoCommand, dataType, buffer, bufferSize);
    });
}

inline std::string DeviceDescriptor::DisplayName() const
{
    return QueryStringFromCInterfaceFunctionWithBufferSize([&](char* displayName, size_t* displayNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetDisplayName(
            m_backendHandle, displayName, displayNameSize);
    });
}

inline std::string DeviceDescriptor::VendorName() const
{
    return QueryStringFromCInterfaceFunctionWithBufferSize([&](char* vendorName, size_t* vendorNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetVendorName(m_backendHandle, vendorName, vendorNameSize);
    });
}

inline std::string DeviceDescriptor::ModelName() const
{
    return QueryStringFromCInterfaceFunctionWithBufferSize([&](char* modelName, size_t* modelNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetModelName(m_backendHandle, modelName, modelNameSize);
    });
}

inline std::string DeviceDescriptor::Version() const
{
    return QueryStringFromCInterfaceFunctionWithBufferSize([&](char* version, size_t* versionSize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetVersion(m_backendHandle, version, versionSize);
    });
}

inline std::string DeviceDescriptor::TLType() const
{
    return QueryStringFromCInterfaceFunctionWithBufferSize([&](char* tlType, size_t* tlTypeSize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetTLType(m_backendHandle, tlType, tlTypeSize);
    });
}

inline std::string DeviceDescriptor::UserDefinedName() const
{
    return QueryStringFromCInterfaceFunctionWithBufferSize([&](char* userDefinedName, size_t* userDefinedNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetUserDefinedName(
            m_backendHandle, userDefinedName, userDefinedNameSize);
    });
}

inline std::string DeviceDescriptor::SerialNumber() const
{
    return QueryStringFromCInterfaceFunctionWithBufferSize([&](char* serialNumber, size_t* serialNumberSize) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetSerialNumber(
            m_backendHandle, serialNumber, serialNumberSize);
    });
}

inline DeviceAccessStatus DeviceDescriptor::AccessStatus() const
{
    return static_cast<DeviceAccessStatus>(QueryNumericFromCInterfaceFunction<PEAK_DEVICE_ACCESS_STATUS>(
        [&](PEAK_DEVICE_ACCESS_STATUS* accessStatus) {
            return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetAccessStatus(m_backendHandle, accessStatus);
        }));
}

inline uint64_t DeviceDescriptor::TimestampTickFrequency() const
{
    return QueryNumericFromCInterfaceFunction<uint64_t>([&](uint64_t* timestampTickFrequency) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetTimestampTickFrequency(
            m_backendHandle, timestampTickFrequency);
    });
}

inline std::shared_ptr<Interface> DeviceDescriptor::ParentInterface() const
{
    return LockOrThrow(m_parentInterface);
}

inline bool DeviceDescriptor::IsOpenable(DeviceAccessType accessType) const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* isAccessTypeAvailable) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetIsOpenable(
            m_backendHandle, static_cast<PEAK_DEVICE_ACCESS_TYPE>(accessType), isAccessTypeAvailable);
    }) > 0;
}

inline std::shared_ptr<Device> DeviceDescriptor::OpenDevice(DeviceAccessType accessType)
{
    auto deviceHandle = QueryNumericFromCInterfaceFunction<PEAK_DEVICE_HANDLE>(
        [&](PEAK_DEVICE_HANDLE* _deviceHandle) {
            return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_OpenDevice(
                m_backendHandle, static_cast<PEAK_DEVICE_ACCESS_TYPE>(accessType), _deviceHandle);
        });

    auto device = std::make_shared<ClassCreator<Device>>(deviceHandle, m_parentInterface);
    m_openedDevice = device;
    m_deviceOpenedCallbackManager.TriggerCallbacks(device);

    return device;
}

inline std::shared_ptr<Device> DeviceDescriptor::OpenedDevice() const
{
    return LockOrThrowOpenedModule(m_openedDevice);
}

inline DeviceDescriptor::DeviceOpenedCallbackHandle DeviceDescriptor::RegisterDeviceOpenedCallback(
    const DeviceOpenedCallback& callback)
{
    return m_deviceOpenedCallbackManager.RegisterCallback(callback);
}

inline void DeviceDescriptor::UnregisterDeviceOpenedCallback(DeviceOpenedCallbackHandle callback)
{
    return m_deviceOpenedCallbackManager.UnregisterCallback(callback);
}

inline uint64_t DeviceDescriptor::MonitoringUpdateInterval() const
{
    return QueryNumericFromCInterfaceFunction<uint64_t>([&](uint64_t* monitoringUpdateInterval_ms) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_GetMonitoringUpdateInterval(
            m_backendHandle, monitoringUpdateInterval_ms);
    });
}

inline void DeviceDescriptor::SetMonitoringUpdateInterval(uint64_t monitoringUpdateInterval_ms)
{
    return CallAndCheckCInterfaceFunction([&] {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_SetMonitoringUpdateInterval(
            m_backendHandle, monitoringUpdateInterval_ms);
    });
}

inline bool DeviceDescriptor::IsInformationRoleMonitored(DeviceInformationRole informationRole) const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* isInformationRoleMonitored) {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_IsInformationRoleMonitored(
            m_backendHandle, static_cast<PEAK_DEVICE_INFORMATION_ROLE>(informationRole), isInformationRoleMonitored);
    }) > 0;
}

inline void DeviceDescriptor::AddInformationRoleToMonitoring(DeviceInformationRole informationRole)
{
    return CallAndCheckCInterfaceFunction([&] {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_AddInformationRoleToMonitoring(
            m_backendHandle, static_cast<PEAK_DEVICE_INFORMATION_ROLE>(informationRole));
    });
}

inline void DeviceDescriptor::RemoveInformationRoleFromMonitoring(DeviceInformationRole informationRole)
{
    return CallAndCheckCInterfaceFunction([&] {
        return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_RemoveInformationRoleFromMonitoring(
            m_backendHandle, static_cast<PEAK_DEVICE_INFORMATION_ROLE>(informationRole));
    });
}

inline DeviceDescriptor::InformationChangedCallbackHandle DeviceDescriptor::RegisterInformationChangedCallback(
    const DeviceDescriptor::InformationChangedCallback& callback)
{
    return reinterpret_cast<InformationChangedCallbackHandle>(
        m_informationChangedCallbackManager->RegisterCallback(callback));
}

inline void DeviceDescriptor::UnregisterInformationChangedCallback(InformationChangedCallbackHandle callbackHandle)
{
    m_informationChangedCallbackManager->UnregisterCallback(
        reinterpret_cast<PEAK_DEVICE_DESCRIPTOR_INFORMATION_CHANGED_CALLBACK_HANDLE>(callbackHandle));
}

inline void PEAK_CALL_CONV DeviceDescriptor::InformationChangedCallbackCWrapper(
    const PEAK_DEVICE_INFORMATION_ROLE* changedRoles, size_t changedRolesSize, void* context)
{
    auto callback = static_cast<DeviceDescriptor::InformationChangedCallback*>(context);
    std::vector<DeviceInformationRole> changedRolesVec;
    changedRolesVec.reserve(changedRolesSize);
    for (size_t i = 0; i < changedRolesSize; ++i)
    {
        changedRolesVec.emplace_back(static_cast<DeviceInformationRole>(*(changedRoles + i)));
    }
    callback->operator()(changedRolesVec);
}

inline PEAK_MODULE_DESCRIPTOR_HANDLE DeviceDescriptor::ModuleDescriptorHandle() const
{
    auto moduleDescriptorHandle = QueryNumericFromCInterfaceFunction<PEAK_MODULE_DESCRIPTOR_HANDLE>(
        [&](PEAK_MODULE_DESCRIPTOR_HANDLE* _moduleDescriptorHandle) {
            return PEAK_C_ABI_PREFIX PEAK_DeviceDescriptor_ToModuleDescriptor(
                m_backendHandle, _moduleDescriptorHandle);
        });

    return moduleDescriptorHandle;
}

} /* namespace core */
} /* namespace peak */