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:
    Version(uint32_t major, uint32_t minor, uint32_t subminor, uint32_t patch);
 
    PEAK_COMMON_NO_DISCARD uint32_t GetMajor() const;
 
    PEAK_COMMON_NO_DISCARD uint32_t GetMinor() const;
 
    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_subminor, other.m_patch)
            == std::tie(this->m_major, this->m_minor, this->m_subminor, 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_subminor, this->m_patch)
            < std::tie(other.m_major, other.m_minor, other.m_subminor, 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_subminor << '.' << 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.subminor, version.patch)
    {}
 
    explicit operator detail::c_type_of_t<Version>() const
    {
        return { this->GetMajor(), this->GetMinor(), this->GetSubminor(), this->GetPatch() };
    }
 
    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 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