peak_version.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 <cstdint>
#include <sstream>
#include <string>


namespace peak
{
namespace core
{

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

    std::string ToString() const;
    uint32_t Major() const;
    uint32_t Minor() const;
    uint32_t Subminor() const;

private:
    uint32_t m_major;
    uint32_t m_minor;
    uint32_t m_subminor;
};

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 subminor)
    : m_major(major)
    , m_minor(minor)
    , m_subminor(subminor)
{}

inline std::string Version::ToString() const
{
    std::stringstream strStream;

    strStream << Major() << '.' << Minor() << '.' << Subminor();

    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 m_subminor;
}

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.Subminor() < rhs.Subminor())
    {
        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 */