peak_firmware_update_information.hpp

Go to the documentation of this file.

 
#pragma once
 
 
#include <peak/backend/peak_backend.h>
#include <peak/dll_interface/peak_dll_interface_util.hpp>
 
#include <string>
 
 
namespace peak
{
namespace core
{

enum class FirmwareUpdatePersistence
{
    None, 
    Full 
};

enum class FirmwareUpdateVersionStyle
{
    Dotted,
    Semantic
};

class FirmwareUpdateInformation
{
public:
    FirmwareUpdateInformation() = delete;
    ~FirmwareUpdateInformation() = default;
    FirmwareUpdateInformation(const FirmwareUpdateInformation& other) = delete;
    FirmwareUpdateInformation& operator=(const FirmwareUpdateInformation& other) = delete;
    FirmwareUpdateInformation(FirmwareUpdateInformation&& other) = delete;
    FirmwareUpdateInformation& operator=(FirmwareUpdateInformation&& other) = delete;

    bool IsValid() const;

    std::string FileName() const;

    std::string Description() const;

    std::string Version() const;

    std::string VersionExtractionPattern() const;

    FirmwareUpdateVersionStyle VersionStyle() const;

    std::string ReleaseNotes() const;

    std::string ReleaseNotesURL() const;

    FirmwareUpdatePersistence UserSetPersistence() const;

    FirmwareUpdatePersistence SequencerSetPersistence() const;
 
private:
    friend ClassCreator<FirmwareUpdateInformation>;
    explicit FirmwareUpdateInformation(PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle);
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE m_backendHandle;
 
    friend class FirmwareUpdater;
};
 
} /* namespace core */
} /* namespace peak */
 
/* Implementation */
namespace peak
{
namespace core
{
 
inline FirmwareUpdateInformation::FirmwareUpdateInformation(
    PEAK_FIRMWARE_UPDATE_INFORMATION_HANDLE firmwareUpdateInformationHandle)
    : m_backendHandle(firmwareUpdateInformationHandle)
{}
 
inline bool FirmwareUpdateInformation::IsValid() const
{
    return QueryNumericFromCInterfaceFunction<PEAK_BOOL8>([&](PEAK_BOOL8* isValid) {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetIsValid(m_backendHandle, isValid);
    }) > 0;
}
 
inline std::string FirmwareUpdateInformation::FileName() const
{
    return QueryStringFromCInterfaceFunction([&](char* fileName, size_t* fileNameSize) {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetFileName(
            m_backendHandle, fileName, fileNameSize);
    });
}
 
inline std::string FirmwareUpdateInformation::Description() const
{
    return QueryStringFromCInterfaceFunction([&](char* description, size_t* descriptionSize) {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetDescription(
            m_backendHandle, description, descriptionSize);
    });
}
 
inline std::string FirmwareUpdateInformation::Version() const
{
    return QueryStringFromCInterfaceFunction([&](char* version, size_t* versionSize) {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetVersion(m_backendHandle, version, versionSize);
    });
}
 
inline std::string FirmwareUpdateInformation::VersionExtractionPattern() const
{
    return QueryStringFromCInterfaceFunction([&](char* versionExtractionPattern, size_t* versionExtractionPatternSize) {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetVersionExtractionPattern(
            m_backendHandle, versionExtractionPattern, versionExtractionPatternSize);
    });
}
 
inline FirmwareUpdateVersionStyle FirmwareUpdateInformation::VersionStyle() const
{
    return static_cast<FirmwareUpdateVersionStyle>(
        QueryNumericFromCInterfaceFunction<PEAK_FIRMWARE_UPDATE_VERSION_STYLE>(
            [&](PEAK_FIRMWARE_UPDATE_VERSION_STYLE* versionStyle) {
                return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetVersionStyle(
                    m_backendHandle, versionStyle);
            }));
}
 
inline std::string FirmwareUpdateInformation::ReleaseNotes() const
{
    return QueryStringFromCInterfaceFunction([&](char* releaseNotes, size_t* releaseNotesSize) {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetReleaseNotes(
            m_backendHandle, releaseNotes, releaseNotesSize);
    });
}
 
inline std::string FirmwareUpdateInformation::ReleaseNotesURL() const
{
    return QueryStringFromCInterfaceFunction([&](char* releaseNotesUrl, size_t* releaseNotesUrlSize) {
        return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetReleaseNotesURL(
            m_backendHandle, releaseNotesUrl, releaseNotesUrlSize);
    });
}
 
inline FirmwareUpdatePersistence FirmwareUpdateInformation::UserSetPersistence() const
{
    return static_cast<FirmwareUpdatePersistence>(
        QueryNumericFromCInterfaceFunction<PEAK_FIRMWARE_UPDATE_PERSISTENCE>(
            [&](PEAK_FIRMWARE_UPDATE_PERSISTENCE* userSetPersistence) {
                return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetUserSetPersistence(
                    m_backendHandle, userSetPersistence);
            }));
}
 
inline FirmwareUpdatePersistence FirmwareUpdateInformation::SequencerSetPersistence() const
{
    return static_cast<FirmwareUpdatePersistence>(
        QueryNumericFromCInterfaceFunction<PEAK_FIRMWARE_UPDATE_PERSISTENCE>(
            [&](PEAK_FIRMWARE_UPDATE_PERSISTENCE* sequencerSetPersistence) {
                return PEAK_C_ABI_PREFIX PEAK_FirmwareUpdateInformation_GetSequencerSetPersistence(
                    m_backendHandle, sequencerSetPersistence);
            }));
}
 
inline std::string ToString(FirmwareUpdatePersistence entry)
{
    std::string entryString;
 
    if (entry == FirmwareUpdatePersistence::None)
    {
        entryString = "None";
    }
    else if (entry == FirmwareUpdatePersistence::Full)
    {
        entryString = "Full";
    }
 
    return entryString;
}
 
inline std::string ToString(FirmwareUpdateVersionStyle entry)
{
    std::string entryString;
 
    if (entry == FirmwareUpdateVersionStyle::Dotted)
    {
        entryString = "Dotted";
    }
    else if (entry == FirmwareUpdateVersionStyle::Semantic)
    {
        entryString = "Semantic";
    }
 
    return entryString;
}
 
} /* namespace core */
} /* namespace peak */