peak_data_stream_descriptor.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common_c/detail/peak_common_defines.h>
 
#include <peak/backend/peak_backend.h>
#include <peak/common/peak_module_descriptor.hpp>
#include <peak/data_stream/peak_data_stream.hpp>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
 
#include <memory>
#include <string>
 
 
namespace peak
{
namespace core
{
 
class Device;

class DataStreamDescriptor : public ModuleDescriptor
{
public:
    DataStreamDescriptor() = delete;
    ~DataStreamDescriptor() override = default;
    DataStreamDescriptor(const DataStreamDescriptor& other) = delete;
    DataStreamDescriptor& operator=(const DataStreamDescriptor& other) = delete;
    DataStreamDescriptor(DataStreamDescriptor&& other) = delete;
    DataStreamDescriptor& operator=(DataStreamDescriptor&& other) = delete;

    PEAK_COMMON_NO_DISCARD std::string Key() const;

    PEAK_COMMON_NO_DISCARD std::shared_ptr<Device> ParentDevice() const;

    PEAK_COMMON_NO_DISCARD std::shared_ptr<DataStream> OpenDataStream();

    PEAK_COMMON_NO_DISCARD std::shared_ptr<DataStream> OpenedDataStream() const;

    PEAK_COMMON_NO_DISCARD std::shared_ptr<DataStream> EnsureOpenedDataStream();

    PEAK_COMMON_NO_DISCARD bool IsOpened() const;
 
private:
    PEAK_MODULE_DESCRIPTOR_HANDLE ModuleDescriptorHandle() const override;
 
    friend ClassCreator<DataStreamDescriptor>;
    DataStreamDescriptor(
        PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, const std::weak_ptr<Device>& parentDevice);
    PEAK_DATA_STREAM_DESCRIPTOR_HANDLE m_backendHandle;
 
    std::weak_ptr<Device> m_parentDevice;
    std::weak_ptr<DataStream> m_openedDataStream;
 
    std::string m_key;
};
 
} /* namespace core */
} /* namespace peak */
 
/* Implementation */
namespace peak
{
namespace core
{
 
inline DataStreamDescriptor::DataStreamDescriptor(
    PEAK_DATA_STREAM_DESCRIPTOR_HANDLE dataStreamDescriptorHandle, const std::weak_ptr<Device>& parentDevice)
    : m_backendHandle(dataStreamDescriptorHandle)
    , m_parentDevice(parentDevice)
    , m_key(QueryStringFromCInterfaceFunction([&](char* key, size_t* keySize) {
        return PEAK_C_ABI_PREFIX PEAK_DataStreamDescriptor_GetKey(dataStreamDescriptorHandle, key, keySize);
    }))
{}
 
inline std::string DataStreamDescriptor::Key() const
{
    return m_key;
}
 
inline std::shared_ptr<Device> DataStreamDescriptor::ParentDevice() const
{
    return LockOrThrow(m_parentDevice);
}
 
inline std::shared_ptr<DataStream> DataStreamDescriptor::OpenDataStream()
{
    auto dataStreamHandle = QueryNumericFromCInterfaceFunction<PEAK_DATA_STREAM_HANDLE>(
        [&](PEAK_DATA_STREAM_HANDLE* _dataStreamHandle) {
            return PEAK_C_ABI_PREFIX PEAK_DataStreamDescriptor_OpenDataStream(m_backendHandle, _dataStreamHandle);
        });
 
    auto dataStream = std::make_shared<ClassCreator<DataStream>>(dataStreamHandle, m_parentDevice);
    m_openedDataStream = dataStream;
    return dataStream;
}
 
inline std::shared_ptr<DataStream> DataStreamDescriptor::OpenedDataStream() const
{
    return LockOrThrowOpenedModule(m_openedDataStream);
}
 
inline std::shared_ptr<DataStream> DataStreamDescriptor::EnsureOpenedDataStream()
{
    return IsOpened() ? OpenedDataStream() : OpenDataStream();
}
 
inline bool DataStreamDescriptor::IsOpened() const
{
    return !m_openedDataStream.expired();
}
 
inline PEAK_MODULE_DESCRIPTOR_HANDLE DataStreamDescriptor::ModuleDescriptorHandle() const
{
    auto moduleDescriptorHandle = QueryNumericFromCInterfaceFunction<PEAK_MODULE_DESCRIPTOR_HANDLE>(
        [&](PEAK_MODULE_DESCRIPTOR_HANDLE* _moduleDescriptorHandle) {
            return PEAK_C_ABI_PREFIX PEAK_DataStreamDescriptor_ToModuleDescriptor(
                m_backendHandle, _moduleDescriptorHandle);
        });
 
    return moduleDescriptorHandle;
}
 
} /* namespace core */
} /* namespace peak */