peak_version.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/dll_interface/peak_dll_interface_util.hpp>
 
#include <cstdint>
#include <sstream>
#include <string>
 
 
namespace peak
{
namespace core
{

class Version final
{
public:
    Version() = delete;
    Version(uint32_t major, uint32_t minor, uint32_t patch);
    ~Version() = default;
    Version(const Version& other) = default;
    Version& operator=(const Version& other) = default;
    Version(Version&& other) = default;
    Version& operator=(Version&& other) = default;

    PEAK_COMMON_NO_DISCARD std::string ToString() const;

    PEAK_COMMON_NO_DISCARD uint32_t Major() const;

    PEAK_COMMON_NO_DISCARD uint32_t Minor() const;

    PEAK_COMMON_DEPRECATED_MSG("Deprecated due to SemVer 2.0 migration. Use Patch() instead.")
    PEAK_COMMON_NO_DISCARD uint32_t Subminor() const;

    PEAK_COMMON_NO_DISCARD uint32_t Patch() const;
 
private:
    uint32_t m_major;
    uint32_t m_minor;
    uint32_t m_patch;
};
 
bool operator<(const Version& lhs, const Version& rhs);
bool operator>(const Version& lhs, const Version& rhs);
bool operator==(const Version& lhs, const Version& rhs);
bool operator!=(const Version& lhs, const Version& rhs);
 
} /* namespace core */
} /* namespace peak */
 
/* Implementation */
namespace peak
{
namespace core
{
 
inline Version::Version(uint32_t major, uint32_t minor, uint32_t patch)
    : m_major(major)
    , m_minor(minor)
    , m_patch(patch)
{}
 
inline std::string Version::ToString() const
{
    std::stringstream strStream;
 
    strStream << Major() << '.' << Minor() << '.' << Patch();
 
    return strStream.str();
}
 
inline uint32_t Version::Major() const
{
    return m_major;
}
 
inline uint32_t Version::Minor() const
{
    return m_minor;
}
 
inline uint32_t Version::Subminor() const
{
    return 0;
}
 
inline uint32_t Version::Patch() const
{
    return m_patch;
}
 
 
inline bool operator<(const Version& lhs, const Version& rhs)
{
    if (lhs.Major() < rhs.Major())
    {
        return true;
    }
    else if (lhs.Minor() < rhs.Minor())
    {
        return true;
    }
    else if (lhs.Patch() < rhs.Patch())
    {
        return true;
    }
 
    return false;
}
 
inline bool operator>(const Version& lhs, const Version& rhs)
{
    return rhs < lhs;
}
 
inline bool operator==(const Version& lhs, const Version& rhs)
{
    return !(lhs < rhs) && !(lhs > rhs);
}
 
inline bool operator!=(const Version& lhs, const Version& rhs)
{
    return !(lhs == rhs);
}
 
} /* namespace core */
} /* namespace peak */