304 lines
8.7 KiB
C++
304 lines
8.7 KiB
C++
/*
|
|
* Copyright (c) 2025. MadVoxel AG
|
|
* All rights reserved.
|
|
*/
|
|
|
|
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <vector>
|
|
#include <span>
|
|
#include <optional>
|
|
#include <memory>
|
|
|
|
namespace OpenVulkano
|
|
{
|
|
struct VersionDataCompact
|
|
{
|
|
std::array<uint32_t, 4> m_versionComponents;
|
|
|
|
VersionDataCompact() = default;
|
|
|
|
VersionDataCompact(const uint32_t major, const uint32_t minor, const uint32_t patch, const uint32_t build)
|
|
: m_versionComponents({major, minor, patch, build})
|
|
{}
|
|
|
|
[[nodiscard]] uint32_t GetComponent(const size_t compId) const
|
|
{
|
|
if (m_versionComponents.size() < compId + 1) return 0u;
|
|
return m_versionComponents[compId];
|
|
}
|
|
};
|
|
|
|
struct VersionDataExtendedData
|
|
{
|
|
std::vector<uint32_t> m_versionComponents;
|
|
std::vector<std::string> m_tagComponents;
|
|
uint64_t m_timestamp = 0, m_buildNumber = 0;
|
|
|
|
VersionDataExtendedData() = default;
|
|
VersionDataExtendedData(const std::string_view& versionString, bool ignoreTags);
|
|
|
|
[[nodiscard]] uint32_t GetComponent(const size_t compId) const
|
|
{
|
|
if (m_versionComponents.size() < compId + 1) return 0u;
|
|
return m_versionComponents[compId];
|
|
}
|
|
|
|
std::optional<VersionDataCompact> GetCompactVersion(const bool force = false) const
|
|
{
|
|
if (!force)
|
|
{
|
|
if (m_versionComponents.size() > 3 && m_buildNumber != 0) return {};
|
|
if (m_versionComponents.size() > 4 || !m_tagComponents.empty()) return {};
|
|
}
|
|
return VersionDataCompact(GetComponent(0), GetComponent(1), GetComponent(2), m_buildNumber ? m_buildNumber : GetComponent(3));
|
|
}
|
|
};
|
|
|
|
struct VersionDataExtended
|
|
{
|
|
std::array<uint32_t, 2> m_leadComponents;
|
|
std::unique_ptr<VersionDataExtendedData> m_data;
|
|
|
|
VersionDataExtended() : m_leadComponents({ UINT32_MAX, UINT32_MAX }), m_data(std::make_unique<VersionDataExtendedData>())
|
|
{}
|
|
|
|
VersionDataExtended(const VersionDataExtended& o) : m_leadComponents(o.m_leadComponents), m_data(std::make_unique<VersionDataExtendedData>(*o.m_data))
|
|
{}
|
|
|
|
VersionDataExtended(VersionDataExtended&& o) noexcept
|
|
: m_leadComponents(o.m_leadComponents), m_data(std::move(o.m_data))
|
|
{
|
|
o.m_leadComponents = { 0, 0 };
|
|
}
|
|
|
|
[[maybe_unused]] VersionDataExtended(VersionDataExtendedData&& data) :
|
|
m_leadComponents({ UINT32_MAX, UINT32_MAX }), m_data(std::make_unique<VersionDataExtendedData>(std::move(data)))
|
|
{}
|
|
|
|
VersionDataExtended& operator=(VersionDataExtended&& o) noexcept
|
|
{
|
|
m_leadComponents = std::move(o.m_leadComponents);
|
|
m_data = std::move(o.m_data);
|
|
o.m_data = nullptr;
|
|
o.m_leadComponents = { 0, 0 };
|
|
return *this;
|
|
}
|
|
|
|
VersionDataExtended& operator=(const VersionDataExtended& o)
|
|
{
|
|
m_leadComponents = o.m_leadComponents;
|
|
m_data = std::make_unique<VersionDataExtendedData>(*o.m_data);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
union VersionData
|
|
{
|
|
VersionDataCompact compact;
|
|
VersionDataExtended extended;
|
|
|
|
VersionData() { new (&compact)VersionDataCompact(); }
|
|
|
|
VersionData(VersionData&& o) noexcept
|
|
{
|
|
if (o.IsExtended())
|
|
{
|
|
new (&extended) VersionDataExtended(std::move(o.extended));
|
|
}
|
|
else compact = o.compact;
|
|
}
|
|
|
|
VersionData(const VersionData& o)
|
|
{
|
|
if (o.IsExtended()) new (&extended)VersionDataExtended(o.extended);
|
|
else compact = o.compact;
|
|
}
|
|
|
|
[[maybe_unused]] VersionData(const VersionDataCompact& other) { new (&compact)VersionDataCompact(other); }
|
|
|
|
VersionData(VersionDataCompact&& other) { new (&compact) VersionDataCompact(std::move(other)); }
|
|
|
|
[[maybe_unused]] VersionData(const VersionDataExtended& other)
|
|
{
|
|
new (&extended)VersionDataExtended(other);
|
|
}
|
|
|
|
[[maybe_unused]] VersionData(VersionDataExtended&& other) { new (&extended) VersionDataExtended(std::move(other)); }
|
|
|
|
~VersionData()
|
|
{
|
|
if (IsExtended())
|
|
{
|
|
extended.~VersionDataExtended();
|
|
}
|
|
}
|
|
|
|
VersionData& operator =(const VersionDataCompact& other)
|
|
{
|
|
compact = other;
|
|
return *this;
|
|
}
|
|
|
|
VersionData& operator =(VersionDataExtendedData&& other)
|
|
{
|
|
extended.m_leadComponents = { UINT32_MAX, UINT32_MAX };
|
|
extended.m_data = std::make_unique<VersionDataExtendedData>(std::move(other));
|
|
return *this;
|
|
}
|
|
|
|
VersionData& operator =(VersionData&& other) noexcept
|
|
{
|
|
Clear();
|
|
if (other.IsExtended())
|
|
{
|
|
extended.m_leadComponents = { UINT32_MAX, UINT32_MAX };
|
|
extended.m_data = std::move(other.extended.m_data);
|
|
}
|
|
else
|
|
{
|
|
compact = other.compact;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
VersionData& operator =(const VersionData& other)
|
|
{
|
|
Clear();
|
|
if (other.IsExtended())
|
|
extended = other.extended;
|
|
else
|
|
compact = other.compact;
|
|
return *this;
|
|
}
|
|
|
|
bool IsExtended() const
|
|
{
|
|
return compact.m_versionComponents[0] > INT32_MAX;
|
|
}
|
|
|
|
uint64_t GetTimestamp() const
|
|
{
|
|
if (IsExtended()) return extended.m_data->m_timestamp;
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
void Clear()
|
|
{
|
|
if (IsExtended())
|
|
{
|
|
extended.~VersionDataExtended();
|
|
}
|
|
new (&compact)VersionDataCompact();
|
|
}
|
|
};
|
|
|
|
class Version
|
|
{
|
|
VersionData m_data;
|
|
std::string m_versionString;
|
|
|
|
bool IsExtendedData() const
|
|
{
|
|
return m_data.compact.m_versionComponents[0] > INT32_MAX;
|
|
}
|
|
|
|
public:
|
|
Version() : Version(0, 0) {}
|
|
|
|
template<typename T>
|
|
explicit Version(T major) requires std::is_integral_v<T>
|
|
: Version(major, 0) {}
|
|
|
|
Version(uint32_t major, uint32_t minor, uint32_t patch = 0, uint32_t build = 0);
|
|
|
|
Version(std::string_view versionString, bool ignoreTags = false);
|
|
|
|
explicit Version(double version);
|
|
|
|
Version(const Version& other) = default;
|
|
Version(Version&& other) = default;
|
|
Version& operator =(const Version& other) = default;
|
|
Version& operator=(Version&& other) = default;
|
|
|
|
[[nodiscard]] uint32_t GetComponent(const size_t compId) const
|
|
{
|
|
if (IsExtendedData())
|
|
return m_data.extended.m_data->GetComponent(compId);
|
|
return m_data.compact.GetComponent(compId);
|
|
}
|
|
|
|
[[nodiscard]] uint32_t Major() const { return GetComponent(0); }
|
|
|
|
[[nodiscard]] uint32_t Minor() const { return GetComponent(1); }
|
|
|
|
[[nodiscard]] uint32_t Patch() const { return GetComponent(2); }
|
|
|
|
[[nodiscard]] uint64_t Build() const
|
|
{
|
|
if (IsExtendedData()) return m_data.extended.m_data->m_buildNumber;
|
|
return m_data.compact.m_versionComponents[3];
|
|
}
|
|
|
|
[[nodiscard]] uint64_t Timestamp() const
|
|
{
|
|
return m_data.GetTimestamp();
|
|
}
|
|
|
|
//[[nodiscard]] bool IsPreRelease() const { return m_preRelease; }
|
|
|
|
[[nodiscard]] std::span<const std::string> GetTags() const
|
|
{
|
|
if (IsExtendedData())
|
|
return m_data.extended.m_data->m_tagComponents;
|
|
return {};
|
|
}
|
|
|
|
[[nodiscard]] std::span<const uint32_t> GetVersionComponents() const
|
|
{
|
|
if (IsExtendedData()) return m_data.extended.m_data->m_versionComponents;
|
|
return m_data.compact.m_versionComponents;
|
|
}
|
|
|
|
//region Conversion operators
|
|
[[nodiscard]] explicit operator uint32_t() const { return (Major() << 20) | ((Minor() & 0x3FF) << 10) | (Patch() & 0x3FF); }
|
|
|
|
[[nodiscard]] operator const std::string&() const { return m_versionString; }
|
|
|
|
[[nodiscard]] const std::string& String() const { return m_versionString; }
|
|
//endregion
|
|
|
|
//region Comparison operators
|
|
[[nodiscard]] bool operator ==(const Version& rhs) const { return Compare(rhs) == 0; }
|
|
[[nodiscard]] bool operator !=(const Version& rhs) const { return Compare(rhs); }
|
|
[[nodiscard]] bool operator < (const Version& rhs) const { return Compare(rhs) < 0; }
|
|
[[nodiscard]] bool operator <=(const Version& rhs) const { return Compare(rhs) < 1; }
|
|
[[nodiscard]] bool operator > (const Version& rhs) const { return Compare(rhs) > 0; }
|
|
[[nodiscard]] bool operator >=(const Version& rhs) const { return Compare(rhs) > -1; }
|
|
//endregion
|
|
|
|
private:
|
|
[[nodiscard]] int Compare(const Version& other) const;
|
|
[[nodiscard]] int CompareBuildNr(const Version& other) const;
|
|
[[nodiscard]] int CompareTimestamp(const Version& other) const;
|
|
[[nodiscard]] int CompareComponents(const Version& other) const;
|
|
};
|
|
|
|
[[nodiscard]] [[maybe_unused]] static Version operator""_v(const char* str) { return { str }; }
|
|
[[nodiscard]] [[maybe_unused]] static Version operator""_v(const char* str, size_t c) { return { std::string_view(str, c) }; }
|
|
[[nodiscard]] [[maybe_unused]] static Version operator""_version(const char* str) { return { str }; }
|
|
[[nodiscard]] [[maybe_unused]] static Version operator""_version(const char* str, size_t c) { return { std::string_view(str, c) }; }
|
|
[[nodiscard]] [[maybe_unused]] static Version operator""_v(const long double val) { return Version(static_cast<double>(val)); }
|
|
[[nodiscard]] [[maybe_unused]] static Version operator""_version(const long double val) { return Version(static_cast<double>(val)); }
|
|
}
|