peak_device.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/data_stream/peak_data_stream_descriptor.hpp>
#include <peak/device/peak_common_device_enums.hpp>
#include <peak/device/peak_remote_device.hpp>
#include <peak/dll_interface/peak_dll_interface_util.hpp>

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


namespace peak
{
namespace core
{

class Interface;

class Device
    : public EventSupportingModule
    , public std::enable_shared_from_this<Device>
{
public:
    Device() = delete;
    ~Device() override;
    Device(const Device& other) = delete;
    Device& operator=(const Device& other) = delete;
    Device(Device&& other) = delete;
    Device& operator=(Device&& other) = delete;

    std::string Key() const;

    RawInformation Info(int32_t infoCommand) const;

    std::string ID() 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<class RemoteDevice> RemoteDevice() const;

    std::vector<std::shared_ptr<DataStreamDescriptor>> DataStreams() const;

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

    PEAK_DEVICE_HANDLE Handle() const
    {
        return m_backendHandle;
    }

private:
    PEAK_MODULE_HANDLE ModuleHandle() const override;
    PEAK_EVENT_SUPPORTING_MODULE_HANDLE EventSupportingModuleHandle() const override;

    friend ClassCreator<Device>;
    Device(PEAK_DEVICE_HANDLE deviceHandle, const std::weak_ptr<Interface>& parentInterface);
    PEAK_DEVICE_HANDLE m_backendHandle;

    std::weak_ptr<Interface> m_parentInterface;

    void Initialize() const override;
    mutable std::vector<std::shared_ptr<DataStreamDescriptor>> m_dataStreams;
    mutable std::shared_ptr<class RemoteDevice> m_remoteDevice;

    std::string m_key;
};

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

/* Implementation */
namespace peak
{
namespace core
{

inline Device::Device(PEAK_DEVICE_HANDLE deviceHandle, const std::weak_ptr<Interface>& parentInterface)
    : m_backendHandle(deviceHandle)
    , m_parentInterface(parentInterface)
    , m_key(QueryStringFromCInterfaceFunction([&](char* key, size_t* keySize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetKey(deviceHandle, key, keySize);
    }))
{}

inline Device::~Device()
{
    (void)PEAK_C_ABI_PREFIX PEAK_Device_Destruct(m_backendHandle);
}

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

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

inline std::string Device::ID() const
{
    return QueryStringFromCInterfaceFunction([&](char* id, size_t* idSize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetID(m_backendHandle, id, idSize);
    });
}

inline std::string Device::DisplayName() const
{
    return QueryStringFromCInterfaceFunction([&](char* displayName, size_t* displayNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetDisplayName(m_backendHandle, displayName, displayNameSize);
    });
}

inline std::string Device::VendorName() const
{
    return QueryStringFromCInterfaceFunction([&](char* vendorName, size_t* vendorNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetVendorName(m_backendHandle, vendorName, vendorNameSize);
    });
}

inline std::string Device::ModelName() const
{
    return QueryStringFromCInterfaceFunction([&](char* modelName, size_t* modelNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetModelName(m_backendHandle, modelName, modelNameSize);
    });
}

inline std::string Device::Version() const
{
    return QueryStringFromCInterfaceFunction([&](char* version, size_t* versionSize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetVersion(m_backendHandle, version, versionSize);
    });
}

inline std::string Device::TLType() const
{
    return QueryStringFromCInterfaceFunction([&](char* tlType, size_t* tlTypeSize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetTLType(m_backendHandle, tlType, tlTypeSize);
    });
}

inline std::string Device::UserDefinedName() const
{
    return QueryStringFromCInterfaceFunction([&](char* userDefinedName, size_t* userDefinedNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetUserDefinedName(
            m_backendHandle, userDefinedName, userDefinedNameSize);
    });
}

inline std::string Device::SerialNumber() const
{
    return QueryStringFromCInterfaceFunction([&](char* serialNumber, size_t* serialNumberSize) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetSerialNumber(m_backendHandle, serialNumber, serialNumberSize);
    });
}

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

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

inline std::shared_ptr<class RemoteDevice> Device::RemoteDevice() const
{
    InitializeIfNecessary();

    return m_remoteDevice;
}

inline std::vector<std::shared_ptr<DataStreamDescriptor>> Device::DataStreams() const
{
    InitializeIfNecessary();

    return m_dataStreams;
}

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

inline PEAK_MODULE_HANDLE Device::ModuleHandle() const
{
    auto moduleHandle = QueryNumericFromCInterfaceFunction<PEAK_MODULE_HANDLE>(
        [&](PEAK_MODULE_HANDLE* _moduleHandle) {
            return PEAK_C_ABI_PREFIX PEAK_Device_ToModule(m_backendHandle, _moduleHandle);
        });

    return moduleHandle;
}

inline PEAK_EVENT_SUPPORTING_MODULE_HANDLE Device::EventSupportingModuleHandle() const
{
    auto eventSupportingModuleHandle = QueryNumericFromCInterfaceFunction<PEAK_EVENT_SUPPORTING_MODULE_HANDLE>(
        [&](PEAK_EVENT_SUPPORTING_MODULE_HANDLE* _eventSupportingModuleHandle) {
            return PEAK_C_ABI_PREFIX PEAK_Device_ToEventSupportingModule(
                m_backendHandle, _eventSupportingModuleHandle);
        });

    return eventSupportingModuleHandle;
}

inline void Device::Initialize() const
{
    EventSupportingModule::Initialize(); // init data of parent classes (i.e. Module) as well

    // init data streams
    auto numDataStreams = QueryNumericFromCInterfaceFunction<size_t>([&](size_t* _numDataStreams) {
        return PEAK_C_ABI_PREFIX PEAK_Device_GetNumDataStreams(m_backendHandle, _numDataStreams);
    });

    std::vector<std::shared_ptr<DataStreamDescriptor>> dataStreams;
    for (size_t x = 0; x < numDataStreams; ++x)
    {
        auto dataStreamDescriptorHandle = QueryNumericFromCInterfaceFunction<PEAK_DATA_STREAM_DESCRIPTOR_HANDLE>(
            [&](PEAK_DATA_STREAM_DESCRIPTOR_HANDLE* _dataStreamDescriptorHandle) {
                return PEAK_C_ABI_PREFIX PEAK_Device_GetDataStream(
                    m_backendHandle, x, _dataStreamDescriptorHandle);
            });

        dataStreams.emplace_back(std::make_shared<ClassCreator<DataStreamDescriptor>>(
            dataStreamDescriptorHandle, std::const_pointer_cast<Device>(shared_from_this())));
    }

    m_dataStreams = dataStreams;

    // init remote device
    auto remoteDeviceHandle = QueryNumericFromCInterfaceFunction<PEAK_REMOTE_DEVICE_HANDLE>(
        [&](PEAK_REMOTE_DEVICE_HANDLE* _remoteDeviceHandle) {
            return PEAK_C_ABI_PREFIX PEAK_Device_GetRemoteDevice(m_backendHandle, _remoteDeviceHandle);
        });

    m_remoteDevice = std::make_shared<ClassCreator<peak::core::RemoteDevice>>(
        remoteDeviceHandle, std::const_pointer_cast<Device>(shared_from_this()));
}

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