peak_system_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/dll_interface/peak_dll_interface_util.hpp>
#include <peak/system/peak_common_system_enums.hpp>
#include <peak/system/peak_system.hpp>

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


namespace peak
{
namespace core
{

class ProducerLibrary;

class SystemDescriptor : public ModuleDescriptor
{
public:
    SystemDescriptor() = delete;
    ~SystemDescriptor() override = default;
    SystemDescriptor(const SystemDescriptor& other) = delete;
    SystemDescriptor& operator=(const SystemDescriptor& other) = delete;
    SystemDescriptor(SystemDescriptor&& other) = delete;
    SystemDescriptor& operator=(SystemDescriptor&& 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 CTIFileName() const;

    std::string CTIFullPath() const;

    uint32_t GenTLVersionMajor() const;

    uint32_t GenTLVersionMinor() const;

    peak::core::CharacterEncoding CharacterEncoding() const;

    std::shared_ptr<ProducerLibrary> ParentLibrary() const;

    std::shared_ptr<System> OpenSystem();

    std::shared_ptr<System> OpenedSystem() const;

    bool IsOpened() const;

private:
    PEAK_MODULE_DESCRIPTOR_HANDLE ModuleDescriptorHandle() const override;

    friend ClassCreator<SystemDescriptor>;
    SystemDescriptor(
        PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, const std::weak_ptr<ProducerLibrary>& parentLibrary);
    PEAK_SYSTEM_DESCRIPTOR_HANDLE m_backendHandle;

    std::weak_ptr<ProducerLibrary> m_parentLibrary;
    std::weak_ptr<System> m_openedSystem;

    std::string m_key;
};

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

/* Implementation */
namespace peak
{
namespace core
{

inline SystemDescriptor::SystemDescriptor(
    PEAK_SYSTEM_DESCRIPTOR_HANDLE systemDescriptorHandle, const std::weak_ptr<ProducerLibrary>& parentLibrary)
    : m_backendHandle(systemDescriptorHandle)
    , m_parentLibrary(parentLibrary)
    , m_key(QueryStringFromCInterfaceFunction([&](char* key, size_t* keySize) {
        return PEAK_C_ABI_PREFIX PEAK_SystemDescriptor_GetKey(systemDescriptorHandle, key, keySize);
    }))
{}

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

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

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

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

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

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

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

inline std::string SystemDescriptor::CTIFileName() const
{
    return QueryStringFromCInterfaceFunction([&](char* ctiFileName, size_t* ctiFileNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_SystemDescriptor_GetCTIFileName(
            m_backendHandle, ctiFileName, ctiFileNameSize);
    });
}

inline std::string SystemDescriptor::CTIFullPath() const
{
    return QueryStringFromCInterfaceFunction([&](char* ctiFullPath, size_t* ctiFullPathSize) {
        return PEAK_C_ABI_PREFIX PEAK_SystemDescriptor_GetCTIFullPath(
            m_backendHandle, ctiFullPath, ctiFullPathSize);
    });
}

inline uint32_t SystemDescriptor::GenTLVersionMajor() const
{
    return QueryNumericFromCInterfaceFunction<uint32_t>([&](uint32_t* gentlVersionMajor) {
        return PEAK_C_ABI_PREFIX PEAK_SystemDescriptor_GetGenTLVersionMajor(m_backendHandle, gentlVersionMajor);
    });
}

inline uint32_t SystemDescriptor::GenTLVersionMinor() const
{
    return QueryNumericFromCInterfaceFunction<uint32_t>([&](uint32_t* gentlVersionMinor) {
        return PEAK_C_ABI_PREFIX PEAK_SystemDescriptor_GetGenTLVersionMinor(m_backendHandle, gentlVersionMinor);
    });
}

inline peak::core::CharacterEncoding SystemDescriptor::CharacterEncoding() const
{
    return static_cast<peak::core::CharacterEncoding>(
        QueryNumericFromCInterfaceFunction<PEAK_CHARACTER_ENCODING>(
            [&](PEAK_CHARACTER_ENCODING* characterEncoding) {
                return PEAK_C_ABI_PREFIX PEAK_SystemDescriptor_GetCharacterEncoding(
                    m_backendHandle, characterEncoding);
            }));
}

inline std::shared_ptr<ProducerLibrary> SystemDescriptor::ParentLibrary() const
{
    return LockOrThrow(m_parentLibrary);
}

inline std::shared_ptr<System> SystemDescriptor::OpenSystem()
{
    auto systemHandle = QueryNumericFromCInterfaceFunction<PEAK_SYSTEM_HANDLE>(
        [&](PEAK_SYSTEM_HANDLE* _systemHandle) {
            return PEAK_C_ABI_PREFIX PEAK_SystemDescriptor_OpenSystem(m_backendHandle, _systemHandle);
        });

    auto system = std::make_shared<ClassCreator<System>>(systemHandle, m_parentLibrary);
    m_openedSystem = system;
    return system;
}

inline std::shared_ptr<System> SystemDescriptor::OpenedSystem() const
{
    return LockOrThrowOpenedModule(m_openedSystem);
}

inline bool SystemDescriptor::IsOpened() const
{
    return !m_openedSystem.expired();
}

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

    return moduleDescriptorHandle;
}



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