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 */