peak_common_version.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/detail/peak_common_backend_accessor.hpp>
#include <peak_common_c/detail/peak_common_defines.h>
#include <peak_common_c/types/peak_common_simple_types.h>
#include <cstdint>
#include <sstream>
#include <string>
#include <tuple>
 
namespace peak
{
namespace common
{

class Version
{
 
public:
    PEAK_COMMON_DEPRECATED_MSG("Deprecated due to SemVer 2.0 migration. Use Version(major, minor, patch) instead.")
        Version(uint32_t major, uint32_t minor, uint32_t subminor, uint32_t patch);

    Version(uint32_t major, uint32_t minor, uint32_t patch);

    PEAK_COMMON_NO_DISCARD uint32_t GetMajor() const;

    PEAK_COMMON_NO_DISCARD uint32_t GetMinor() const;

    PEAK_COMMON_DEPRECATED_MSG(
        "Deprecated due to SemVer 2.0 migration. Always 0; use GetPatch() instead.") PEAK_COMMON_NO_DISCARD uint32_t
        GetSubminor() const;

    PEAK_COMMON_NO_DISCARD uint32_t GetPatch() const;

    PEAK_COMMON_NO_DISCARD bool operator==(const Version& other) const
    {
        return std::tie(other.m_major, other.m_minor, other.m_patch) == std::tie(this->m_major, this->m_minor, this->m_patch);
    }

    PEAK_COMMON_NO_DISCARD bool operator!=(const Version& other) const
    {
        return !(*this == other);
    }

    PEAK_COMMON_NO_DISCARD bool operator<(const Version& other) const
    {
        return std::tie(this->m_major, this->m_minor, this->m_patch) < std::tie(other.m_major, other.m_minor, other.m_patch);
    }

    PEAK_COMMON_NO_DISCARD bool operator>(const Version& other) const
    {
        return other < *this;
    }

    friend std::ostream& operator<<(std::ostream& os, Version version)
    {
        return os << version.m_major << '.' << version.m_minor << '.' << version.m_patch;
    }

    PEAK_COMMON_NO_DISCARD std::string ToString() const
    {
        std::ostringstream ss;
        ss << *this;
        return ss.str();
    }
 
private:
    friend detail::BackendAccessor<Version>;
 
    explicit Version(const detail::c_type_of_t<Version>& version)
        : Version(version.major, version.minor, version.patch)
    {}
 
    explicit operator detail::c_type_of_t<Version>() const
    {
        auto cVersion = detail::c_type_of_t<Version>();
        cVersion.major = GetMajor();
        cVersion.minor = GetMinor();
        cVersion.patch = GetPatch();
        return cVersion;
    }
 
    std::uint32_t m_major{};
    std::uint32_t m_minor{};
    std::uint32_t m_subminor{};
    std::uint32_t m_patch{};
};
 
inline Version::Version(uint32_t major, uint32_t minor, uint32_t patch)
    : m_major{ major }
    , m_minor{ minor }
    , m_patch{ patch }
{}
 
inline Version::Version(uint32_t major, uint32_t minor, uint32_t subminor, uint32_t patch)
    : m_major{ major }
    , m_minor{ minor }
    , m_subminor{ subminor }
    , m_patch{ patch }
{}
 
inline uint32_t Version::GetMajor() const
{
    return m_major;
}
 
inline uint32_t Version::GetMinor() const
{
    return m_minor;
}
 
inline uint32_t Version::GetSubminor() const
{
    return m_subminor;
}
 
inline uint32_t Version::GetPatch() const
{
    return m_patch;
}
 
} // namespace common 
} // namespace peak